SirStone
d2005abee9
The owner's live-GUI report was correct on all four counts, and all four are
one bug: the commitment is cancelled by our own tile-boundary crossing
(96.1% of picks, 3793/3946, mean hold 5.06 ticks) while the bot is still
accelerating, and the picker is an unconstrained uniform draw over every
safe tile, so the new target can land in the mirror direction at |speed| < 4.
New knobs, all env-gated and default = today's behaviour (byte-for-byte
default parity guard re-run and green, 51 checks):
TR_TFIL_COMMIT_ARRIVAL hold the committed tile until we are ON it; the
tick knob becomes a MINIMUM dwell. 0 = shipped.
TR_TFIL_COMMIT_MARGIN leave only if the best alternative is at least
this much cooler on the same pathMaxHeat scale.
0 = shipped.
TR_TFIL_NOREV_SPEED while |speed| is below this, a mid-flight switch
may not take a tile >90 deg off the travel
direction. 0 = shipped. norevPool() never returns
an empty pool: with every candidate behind us it
takes the least-bad turn.
Offline gate (recorded DrussGT fixture, 20026 ticks): mean hold 4.1 -> 24.0
ticks, abandoned-before-arrival 92.8% -> 40.5%, committed tile actually
reached 3.3% -> 17.2%, opposite-direction slow mid-flight switches 394 -> 64
(-84%). 'TR_TFIL_TILE_REPLAN=off' alone - what cc11ede's arm B already tried -
only gets the hold to 13.6, which is why that A/B could not find this.
strafe is untouched: it imports only heatDecay/bulletMagScale/Pillar*, none
of which this touches. TR_MOVEMENT default stays strafe. Registered in
env_report.nim + knownEnvNames() + .env.example. Arms pre-registered in
docs/movement_campaign.md and tools/ab/arms_tfil_commit.txt.
1162 lines
50 KiB
Nim
1162 lines
50 KiB
Nim
## TFIL — The Floor Is Lava. Built incrementally.
|
||
|
||
import std/math
|
||
import std/random
|
||
import std/os
|
||
import std/strutils except fromHex # `fromHex` would clash with color.fromHex
|
||
import gun_harness/gun_interface
|
||
import movement_harness/movement_interface
|
||
import movement_harness/fire_tracker
|
||
import robocode_tankroyale_botapi/graphics
|
||
import robocode_tankroyale_botapi/color
|
||
|
||
const GridSize = 36.0
|
||
const MaxSpeed = 8.0
|
||
|
||
const BulletCoreRadiusMin = 9.0 ## core radius at power 0.1
|
||
const BulletCoreRadiusMax = 54.0 ## core radius at power 3.0
|
||
const BulletAuraExtMin = 36.0 ## aura extension at power 3.0 (slow)
|
||
const BulletAuraExtMax = 54.0 ## aura extension at power 0.1 (fast)
|
||
|
||
const BulletCore = 10.0 ## lava accumulation per bullet-overlapping tile
|
||
const BulletAura = 5.0 ## lava accumulation for aura ring tiles
|
||
|
||
const EnemyCoreRadius = 18.0 ## half of 36px body
|
||
const EnemyAuraRadius = 54.0 ## 18 + 36
|
||
|
||
const EnemyCore = 40.0 ## lava per tile overlapping enemy body circle
|
||
const EnemyAura = 10.0 ## lava per tile in enemy aura ring
|
||
|
||
## The shipped heat SHAPE, env-overridable since j119 (the same pattern j106
|
||
## used for the virtual pillar). The DEFAULTS below are the shipped values, so
|
||
## the default path is unchanged; the vars are read once at module init by
|
||
## `loadTfilHeatShapeEnv`. This is what makes the heat axis sweepable on ONE
|
||
## frozen binary (before this it was a Nim `const`, so no env arm could move it).
|
||
## TR_TFIL_CORRIDOR_HEAT default 20.0 lava per corridor-overlapping tile
|
||
## TR_TFIL_WALL_HOTNESS default 30.0 peak wall radiance
|
||
## TR_TFIL_WALL_RADIANCE default 10.0 wall radiance falloff
|
||
const
|
||
DefaultCorridorHeat = 20.0
|
||
DefaultWallHotness = 30.0
|
||
DefaultWallRadiance = 10.0
|
||
|
||
var
|
||
CorridorHeat* = DefaultCorridorHeat
|
||
WallHotness* = DefaultWallHotness
|
||
WallRadiance* = DefaultWallRadiance
|
||
|
||
## The "virtual centre pillar": heat OUR code paints on the arena centre even
|
||
## though the arena has NO physical pillar there. The shipped default is now
|
||
## OFF (0/0) — the bot must not avoid open centre floor for no reason. Set
|
||
## `TR_TFIL_PILLAR_ON=1` to restore the old 30/10 field for A/B (see
|
||
## `loadTfilPillarEnv`). The ring variant already ships 0/0.
|
||
const
|
||
PillarHotnessOn = 30.0
|
||
PillarRadianceOn = 10.0
|
||
var
|
||
PillarHotness* = 0.0
|
||
PillarRadiance* = 0.0
|
||
|
||
const CommitTicks = 15 ## ticks to commit to a dodge point
|
||
const MinCommitTicks = 5 ## must commit for this many ticks before danger replan allowed
|
||
const DangerReplanThreshold = 25.0 ## replan on serious threats only (bullet core), not corridors/auras
|
||
const CoolestLevels = 2 ## how many distinct lava values count as "cool"
|
||
const MaxTrackedBullets = 20 ## hard cap on tracked bullets
|
||
|
||
# ── Commit-behaviour knobs (A/B arms) ────────────────────────────────────────
|
||
#
|
||
# The shipped mover cancels its movement commitment whenever OUR tile changes
|
||
# (`ttrSelf`). With GridSize = 36 and speed up to 8 px/tick the bot crosses a
|
||
# tile boundary every ~5 ticks, so the 15-tick commitment is cancelled by the
|
||
# very motion it commands. `ttrOff` honours the commitment (the danger replan
|
||
# stays the safety valve); `ttrEnemy` keys the cancel to the TARGET's tile
|
||
# displacement, which is what the original comment claimed to do.
|
||
#
|
||
# Every default below reproduces the shipped mover byte-for-byte; see the
|
||
# default-path parity guard in `common_libs/tests/test_tfil_commit_env.nim`.
|
||
type
|
||
TfilTileReplan* = enum
|
||
ttrSelf, ttrOff, ttrEnemy
|
||
|
||
TfilReplanReason* = enum
|
||
rrNone, rrInit, rrTileSelf, rrTileEnemy, rrDanger, rrExpiry,
|
||
rrArrival, rrHyst ## j144: the tile was REACHED / the alternative won by a margin
|
||
|
||
proc tileReplanName*(m: TfilTileReplan): string =
|
||
case m
|
||
of ttrSelf: "self"
|
||
of ttrOff: "off"
|
||
of ttrEnemy: "enemy"
|
||
|
||
proc reasonName*(r: TfilReplanReason): string =
|
||
case r
|
||
of rrNone: "none"
|
||
of rrInit: "init"
|
||
of rrTileSelf: "tile_self"
|
||
of rrTileEnemy: "tile_enemy"
|
||
of rrDanger: "danger"
|
||
of rrExpiry: "expiry"
|
||
of rrArrival: "arrival"
|
||
of rrHyst: "hyst"
|
||
|
||
const
|
||
DefaultTfilCommitTicks = CommitTicks ## 15 — the shipped commitment length
|
||
NoRevForwardWeight = 3 ## forward:backward weight ratio (arm C)
|
||
ArriveRadius = 18.0 ## "we are on the committed tile" — same
|
||
## 18px radius the steering already uses
|
||
## at the bottom of this file
|
||
HullTicks = 50 ## the reachable-hull planning horizon. Past
|
||
## it the committed target is no longer
|
||
## guaranteed reachable, so the arrival
|
||
## commitment must release (stall escape).
|
||
|
||
var
|
||
TfilTileReplanMode*: TfilTileReplan = ttrSelf
|
||
TfilCommitTicks*: int = DefaultTfilCommitTicks
|
||
TfilNoRev*: bool = false
|
||
TfilCommitLogPath*: string = ""
|
||
## j144 — the commitment is held until the tile is REACHED, not for a fixed
|
||
## number of ticks. Every knob below defaults to OFF, so the shipped default
|
||
## path is byte-for-byte unchanged (see `test_tfil_commit_env.nim`).
|
||
## TR_TFIL_COMMIT_ARRIVAL 0/1 hold the committed tile until we are ON it
|
||
## (0 = shipped: fixed 15-tick dwell)
|
||
## TR_TFIL_COMMIT_MARGIN float leave it only if the best alternative tile
|
||
## is at least this much cooler (0 = no margin)
|
||
## TR_TFIL_NOREV_SPEED float while |speed| is below this, a mid-flight
|
||
## switch to the OPPOSITE side is refused
|
||
## (0 = off, today's behaviour)
|
||
TfilCommitArrival*: bool = false
|
||
TfilCommitMargin*: float = 0.0
|
||
TfilNoRevSpeed*: float = 0.0
|
||
## j134: the shared fire-detection correction (`TR_FIRE_FIX`, default on).
|
||
## Off = the shipped `prev - energy` detector byte-for-byte.
|
||
TfilFireFix*: bool = true
|
||
|
||
proc getEnvInt(name: string, default: int): int =
|
||
let s = getEnv(name, "")
|
||
if s.len == 0: return default
|
||
try: result = parseInt(s.strip())
|
||
except ValueError: result = default
|
||
|
||
proc getEnvBool(name: string, default: bool): bool =
|
||
let s = getEnv(name, "").strip().toLowerAscii()
|
||
if s.len == 0: return default
|
||
s in ["1", "true", "on", "yes"]
|
||
|
||
proc getEnvFloat(name: string, default: float): float =
|
||
let s = getEnv(name, "")
|
||
if s.len == 0: return default
|
||
try: result = parseFloat(s.strip())
|
||
except ValueError: result = default
|
||
|
||
proc loadTfilCommitEnv*() =
|
||
## Read the commit knobs. Called once at module init; the guard test calls it
|
||
## again after `putEnv` so the non-default arms can be exercised in one process.
|
||
case getEnv("TR_TFIL_TILE_REPLAN", "self").strip().toLowerAscii()
|
||
of "off", "none", "never", "0", "false": TfilTileReplanMode = ttrOff
|
||
of "enemy", "target": TfilTileReplanMode = ttrEnemy
|
||
else: TfilTileReplanMode = ttrSelf
|
||
TfilCommitTicks = max(1, getEnvInt("TR_TFIL_COMMIT_TICKS", DefaultTfilCommitTicks))
|
||
TfilNoRev = getEnvBool("TR_TFIL_NO_REV", false)
|
||
TfilCommitLogPath = getEnv("TR_TFIL_COMMIT_LOG", "")
|
||
TfilCommitArrival = getEnvBool("TR_TFIL_COMMIT_ARRIVAL", false)
|
||
TfilCommitMargin = max(0.0, getEnvFloat("TR_TFIL_COMMIT_MARGIN", 0.0))
|
||
TfilNoRevSpeed = max(0.0, getEnvFloat("TR_TFIL_NOREV_SPEED", 0.0))
|
||
TfilFireFix = getEnvBool("TR_FIRE_FIX", true)
|
||
|
||
loadTfilCommitEnv()
|
||
|
||
proc loadTfilPillarEnv*() =
|
||
## Read the virtual-centre-pillar knob. OFF by default: the shipped field is
|
||
## the arena with no invented centre hazard. `TR_TFIL_PILLAR_ON=1` restores
|
||
## the pre-change 30/10 field so the two defaults can be A/B-ed offline.
|
||
if getEnvBool("TR_TFIL_PILLAR_ON", false):
|
||
PillarHotness = PillarHotnessOn
|
||
PillarRadiance = PillarRadianceOn
|
||
else:
|
||
PillarHotness = 0.0
|
||
PillarRadiance = 0.0
|
||
|
||
loadTfilPillarEnv()
|
||
|
||
proc loadTfilHeatShapeEnv*() =
|
||
## Read the shipped-mover heat-shape overrides. Called once at module init;
|
||
## callable again after `putEnv` so one process can A/B the fields. The
|
||
## defaults reproduce the shipped `const`s exactly, so the default field is
|
||
## bit-identical. The `TR_TFIL_CORRIDOR_HEAT` / `TR_TFIL_WALL_HOTNESS` names
|
||
## are shared with the ring mover (which reads its own copies with its own
|
||
## retuned defaults); `TR_TFIL_WALL_RADIANCE` is new here.
|
||
CorridorHeat = max(0.0, getEnvFloat("TR_TFIL_CORRIDOR_HEAT", DefaultCorridorHeat))
|
||
WallHotness = max(0.0, getEnvFloat("TR_TFIL_WALL_HOTNESS", DefaultWallHotness))
|
||
WallRadiance = max(0.0, getEnvFloat("TR_TFIL_WALL_RADIANCE", DefaultWallRadiance))
|
||
|
||
loadTfilHeatShapeEnv()
|
||
|
||
# ── Time-indexed bullet heat (TR_TFIL_HEAT_TIME=1, default OFF = shipped) ─────
|
||
#
|
||
# WHY: the flat model gives every bullet-overlapping tile the same heat and
|
||
# paints the bullet's corridor all the way to the arena wall, regardless of how
|
||
# far away or how weak the bullet still is. `CorridorHeat` (20) is twice
|
||
# `PathDangerThreshold` (10), so ONE weak far bullet saturates a 108px-wide
|
||
# swath from its nose to the wall, and a path the bullet will not reach until
|
||
# long after the bot has left it is already marked unsafe.
|
||
#
|
||
# WHAT: heat becomes a function of `dt`, the time (ticks) until the bullet
|
||
# REACHES that cell:
|
||
#
|
||
# dt = along / speed # along = distance from the bullet
|
||
# heat = magnitude(power) * decay(dt)
|
||
#
|
||
# * `decay(dt) = exp(-dt / tau)` is a function of TIME, not pixels. A fixed time
|
||
# constant `tau` therefore projects a PIXEL reach of `speed * tau`: a fast
|
||
# bullet's slope is longer, a slow one's shorter — DERIVED from the physics
|
||
# (`speed = 20 - 3*power`), not hand-tuned per power. `tau` = TR_TFIL_HEAT_TAU.
|
||
# * `magnitude(power)` scales the near-end heat with power from DAMAGE, not from
|
||
# hit chance: server damage is `calcBulletDamage = 4p`, linear in p, and
|
||
# `SCORE_PER_BULLET_DAMAGE = 1.0`, so a stronger bullet costs more when it
|
||
# hits. Hit probability is FLAT across power (docs/env_reference.md), so risk
|
||
# does NOT justify power scaling — the COST of the hit does. Floored at 1.0 so
|
||
# a weak bullet's near end is never LESS dangerous than the flat model.
|
||
# Gain = TR_TFIL_HEAT_POWER_GAIN.
|
||
#
|
||
# TIME-INDEXED PLANNER (NOT implemented, by design): because every source is
|
||
# already expressed as `f(dt)`, evaluating a cell at the tick the bot would
|
||
# ARRIVE there is the one-line change `heatDecay(dt - arrivalDelay)` — heat a
|
||
# later bullet's path by that bullet's lead on the bot's own arrival time, so
|
||
# the bot can use the path and leave before the bullet arrives. This is the real
|
||
# fix for the user's second point; the shipped move is unchanged until then.
|
||
var
|
||
TfilHeatTime*: bool = false
|
||
TfilHeatTau*: float = 9.0 ## decay time constant, ticks
|
||
TfilHeatPowerGain*: float = 1.0 ## extra near-end heat at max power (damage proxy)
|
||
|
||
proc loadTfilHeatEnv*() =
|
||
## Read the heat-model knobs. Called once at module init; also callable after
|
||
## `putEnv` so one process can A/B both models (the offline ruler does this).
|
||
TfilHeatTime = getEnvBool("TR_TFIL_HEAT_TIME", false)
|
||
TfilHeatTau = max(0.05, getEnvFloat("TR_TFIL_HEAT_TAU", 9.0))
|
||
TfilHeatPowerGain = max(0.0, getEnvFloat("TR_TFIL_HEAT_POWER_GAIN", 1.0))
|
||
|
||
loadTfilHeatEnv()
|
||
|
||
proc heatDecay*(dt: float): float =
|
||
## Fraction of a bullet's heat still present `dt` ticks before it arrives.
|
||
## Exactly 1.0 when the time model is off, so the default field is
|
||
## bit-identical to the flat model (multiplying any heat by 1.0 is exact).
|
||
if not TfilHeatTime or dt <= 0.0: return 1.0
|
||
exp(-dt / TfilHeatTau)
|
||
|
||
proc bulletMagScale*(power: float): float =
|
||
## Near-end heat multiplier from the bullet's DAMAGE (4p, linear in power),
|
||
## floored at 1.0. Exactly 1.0 when the time model is off.
|
||
if not TfilHeatTime: return 1.0
|
||
1.0 + TfilHeatPowerGain * (power / 3.0)
|
||
|
||
proc bulletRadii(power: float): tuple[core, aura: float] =
|
||
let t = (power - 0.1) / 2.9
|
||
let core = BulletCoreRadiusMin + t * (BulletCoreRadiusMax - BulletCoreRadiusMin)
|
||
let auraExt = BulletAuraExtMax - t * (BulletAuraExtMax - BulletAuraExtMin)
|
||
(core, core + auraExt)
|
||
|
||
type
|
||
TrackedBullet = object
|
||
originX, originY: float
|
||
x, y: float
|
||
velX, velY: float ## speed * cos(heading), speed * sin(heading)
|
||
power: float
|
||
alive: bool
|
||
age: int ## ticks alive; die if > 200
|
||
|
||
TFILModule* = object
|
||
debugGraphics*: bool
|
||
cols, rows: int
|
||
marginX, marginY: float
|
||
arenaWidth, arenaHeight: float
|
||
lava: seq[float] # flat row-major, index = row*cols + col
|
||
bullets: seq[TrackedBullet]
|
||
fire: FireTracker ## shared energy-drop detector (j134)
|
||
commitTarget: tuple[x, y: float] ## world coords of committed dodge point
|
||
commitTicks: int ## ticks remaining on commitment
|
||
commitAge: int ## total ticks held on the current target
|
||
commitLava: float ## lava at commit time (for spike detection)
|
||
blockedTile: tuple[col, row: int; active: bool] ## excluded from next pick after danger replan
|
||
cachedHull: seq[tuple[x, y: float]]
|
||
cachedInsideTiles: seq[tuple[col, row: int]]
|
||
callCount: int ## computeMove call count; 0 = never called
|
||
lastBotX, lastBotY: float ## bot position at last call; used to detect position jumps
|
||
lastTileCol, lastTileRow: int ## grid tile at last call; used to detect gradual displacement
|
||
lastEnemyTileCol, lastEnemyTileRow: int ## grid tile of the target at last call (arm D)
|
||
replanReason: TfilReplanReason ## why the last commitment ended (log only)
|
||
lastPickCall: int ## callCount at the last pick (log only)
|
||
picks: int ## number of picks this round (log only)
|
||
|
||
proc initTFIL*(): TFILModule = TFILModule(debugGraphics: false, fire: initFireTracker())
|
||
|
||
proc removeBulletNear*(m: var TFILModule, x, y: float) =
|
||
## Mark the tracked bullet closest to (x,y) within GridSize tolerance as dead.
|
||
var bestIdx = -1
|
||
var bestD2 = GridSize * GridSize # tolerance²
|
||
for i, b in m.bullets:
|
||
let d2 = (b.x - x)*(b.x - x) + (b.y - y)*(b.y - y)
|
||
if d2 < bestD2:
|
||
bestD2 = d2
|
||
bestIdx = i
|
||
if bestIdx >= 0:
|
||
m.bullets.del(bestIdx)
|
||
|
||
proc prevEnergyGet(m: TFILModule, id: int): float = m.fire.prevEnergyGet(id)
|
||
|
||
proc prevEnergySet(m: var TFILModule, id: int, energy: float) =
|
||
m.fire.prevEnergySet(id, energy)
|
||
|
||
proc clearGraphics*(m: var TFILModule) =
|
||
## No-op: the SVG buffer is a module-level global cleared by the framework
|
||
## after every go(). Exists so callers can signal "TFIL is inactive this tick".
|
||
discard
|
||
|
||
proc resetRound*(m: var TFILModule) =
|
||
m.bullets = @[]
|
||
m.fire.reset()
|
||
m.commitTicks = 0
|
||
m.commitAge = 0
|
||
m.cachedHull = @[]
|
||
m.cachedInsideTiles = @[]
|
||
m.blockedTile = (col: 0, row: 0, active: false)
|
||
m.callCount = 0
|
||
m.lastBotX = 0.0
|
||
m.lastBotY = 0.0
|
||
m.lastTileCol = 0
|
||
m.lastTileRow = 0
|
||
m.lastEnemyTileCol = -1
|
||
m.lastEnemyTileRow = -1
|
||
m.replanReason = rrNone
|
||
m.lastPickCall = 0
|
||
m.picks = 0
|
||
|
||
# ── Commit diagnostics (TR_TFIL_COMMIT_LOG, off by default) ──────────────────
|
||
# One JSONL line per computeMove call, used by the A/B to prove the treatment
|
||
# actually bit (decision interval, replan reason, reversal rate, speed).
|
||
var
|
||
tfilLogFile: File
|
||
tfilLogOpen = false
|
||
tfilLogPathOpen = ""
|
||
|
||
proc closeTfilCommitLog*() =
|
||
## Close the diagnostics stream. Needed because the log path is a knob: a
|
||
## caller (the A/B, or the guard test) may point it somewhere else mid-process.
|
||
if tfilLogOpen:
|
||
try: tfilLogFile.close()
|
||
except CatchableError: discard
|
||
tfilLogOpen = false
|
||
tfilLogPathOpen = ""
|
||
|
||
proc tfilLogWrite(line: string) =
|
||
if TfilCommitLogPath.len == 0: return
|
||
if tfilLogOpen and tfilLogPathOpen != TfilCommitLogPath: closeTfilCommitLog()
|
||
if not tfilLogOpen:
|
||
try:
|
||
tfilLogFile = open(TfilCommitLogPath, fmAppend)
|
||
tfilLogOpen = true
|
||
tfilLogPathOpen = TfilCommitLogPath
|
||
except CatchableError:
|
||
return
|
||
try:
|
||
tfilLogFile.writeLine(line)
|
||
tfilLogFile.flushFile()
|
||
except CatchableError:
|
||
discard
|
||
|
||
proc initGrid(m: var TFILModule, arenaWidth, arenaHeight: float) =
|
||
m.cols = int(arenaWidth / GridSize)
|
||
m.rows = int(arenaHeight / GridSize)
|
||
m.marginX = (arenaWidth - m.cols.float * GridSize) / 2.0
|
||
m.marginY = (arenaHeight - m.rows.float * GridSize) / 2.0
|
||
m.arenaWidth = arenaWidth
|
||
m.arenaHeight = arenaHeight
|
||
m.lava = newSeq[float](m.cols * m.rows) # all 0.0
|
||
|
||
proc spawnTrackedWave(m: var TFILModule, ws: WorldState, ei: EnemyInfo,
|
||
power: float) =
|
||
## One tracked bullet/wave for a confirmed fire of `power`: linear prediction
|
||
## of our position at arrival becomes the aim heading. (Was inlined in
|
||
## `detectFires`; extracted so the shared split can spawn several.)
|
||
let speed = 20.0 - 3.0 * power
|
||
let dist = sqrt((ws.selfX - ei.x)^2 + (ws.selfY - ei.y)^2)
|
||
let travelTime = dist / speed
|
||
let predX = ws.selfX + ws.selfSpeed * cos(ws.selfHeading * PI / 180.0) * travelTime
|
||
let predY = ws.selfY + ws.selfSpeed * sin(ws.selfHeading * PI / 180.0) * travelTime
|
||
let heading = arctan2(predY - ei.y, predX - ei.x)
|
||
if m.bullets.len >= MaxTrackedBullets:
|
||
m.bullets.del(0) # ponytail: drop oldest; fine for 20-bullet cap
|
||
m.bullets.add TrackedBullet(
|
||
originX: ei.x, originY: ei.y,
|
||
x: ei.x, y: ei.y,
|
||
velX: speed * cos(heading),
|
||
velY: speed * sin(heading),
|
||
power: power,
|
||
alive: true,
|
||
age: 0)
|
||
|
||
proc noteEnemyBulletHit*(m: var TFILModule, power: float) =
|
||
## `onHitByBullet` -> the shooter's `3*power` bonus (no-op when off).
|
||
if TfilFireFix:
|
||
m.fire.noteEnemyBulletHit(power)
|
||
|
||
proc noteDamageDealt*(m: var TFILModule, damage: float) =
|
||
## `onBulletHit` -> our same-tick damage to the enemy (no-op when off).
|
||
if TfilFireFix:
|
||
m.fire.noteDamageDealt(damage)
|
||
|
||
proc detectFires(m: var TFILModule, ws: WorldState) =
|
||
## Check all enemies for energy drops; spawn a tracked bullet per confirmed
|
||
## fire. The shared tracker corrects the delta and splits over-cap drops.
|
||
for ei in ws.enemies:
|
||
for p in m.fire.detect(ei.id, ei.energy, 0.09, 3.01, TfilFireFix):
|
||
m.spawnTrackedWave(ws, ei, p)
|
||
m.fire.endScan()
|
||
|
||
proc advanceBullets(m: var TFILModule, selfX, selfY: float) =
|
||
## Advance positions and reap bullets that are: passed us, out of bounds, or too old.
|
||
var i = 0
|
||
while i < m.bullets.len:
|
||
var b = m.bullets[i]
|
||
b.x += b.velX
|
||
b.y += b.velY
|
||
b.age += 1
|
||
# Death conditions (any triggers removal):
|
||
# 1. Passed us (dot < 0, moving away)
|
||
# 2. Out of arena bounds
|
||
# 3. Too old (>200 ticks)
|
||
let dx = selfX - b.x
|
||
let dy = selfY - b.y
|
||
let dot = b.velX * dx + b.velY * dy
|
||
let outOfBounds = b.x < 0.0 or b.x > m.arenaWidth or b.y < 0.0 or b.y > m.arenaHeight
|
||
if dot < 0.0 or outOfBounds or b.age > 200:
|
||
b.alive = false
|
||
m.bullets[i] = b
|
||
if b.alive: inc i
|
||
else: m.bullets.del(i)
|
||
|
||
type CorridorGeom = object
|
||
dx, dy: float ## unit heading
|
||
px, py: float ## unit perpendicular
|
||
tMin: float ## distance to wall
|
||
bx, by: float ## bullet origin
|
||
|
||
proc corridorGeom(b: TrackedBullet, arenaWidth, arenaHeight: float): CorridorGeom =
|
||
let speed = sqrt(b.velX * b.velX + b.velY * b.velY)
|
||
if speed < 0.001: return
|
||
let dx = b.velX / speed
|
||
let dy = b.velY / speed
|
||
var tMin = Inf
|
||
if dx > 0.0: tMin = min(tMin, (arenaWidth - b.x) / dx)
|
||
elif dx < 0.0: tMin = min(tMin, (0.0 - b.x) / dx)
|
||
if dy > 0.0: tMin = min(tMin, (arenaHeight - b.y) / dy)
|
||
elif dy < 0.0: tMin = min(tMin, (0.0 - b.y) / dy)
|
||
CorridorGeom(dx: dx, dy: dy, px: -dy, py: dx, tMin: tMin, bx: b.x, by: b.y)
|
||
|
||
proc lavaAt(m: TFILModule, col, row: int): float =
|
||
m.lava[row * m.cols + col]
|
||
|
||
proc tileAt(m: TFILModule, wx, wy: float): tuple[col, row: int] =
|
||
(col: clamp(int((wx - m.marginX) / GridSize), 0, m.cols - 1),
|
||
row: clamp(int((wy - m.marginY) / GridSize), 0, m.rows - 1))
|
||
|
||
proc pointInHull(px, py: float, hull: seq[(float, float)]): bool =
|
||
var inside = false
|
||
var j = hull.high
|
||
for i in 0..hull.high:
|
||
if ((hull[i][1] > py) != (hull[j][1] > py)) and
|
||
(px < (hull[j][0] - hull[i][0]) * (py - hull[i][1]) / (hull[j][1] - hull[i][1]) + hull[i][0]):
|
||
inside = not inside
|
||
j = i
|
||
inside
|
||
|
||
proc computeReachableHull(x0, y0, heading0, speed0,
|
||
arenaW, arenaH: float, ticks: int = 50): seq[(float, float)] =
|
||
## Simulate `ticks` ticks at various turn rates / target speeds.
|
||
## Returns convex hull (gift-wrap) of final positions.
|
||
const TargetSpeeds = [8.0, 4.0, -4.0, -8.0]
|
||
const NumRates = 11
|
||
|
||
var pts: seq[(float, float)]
|
||
pts.add (x0, y0) # always reachable: stay
|
||
|
||
for tSpeed in TargetSpeeds:
|
||
# Max turn rate at target speed (approximate; actual varies per tick but close enough)
|
||
let mtr = 10.0 - 0.75 * abs(tSpeed)
|
||
for ri in 0..<NumRates:
|
||
let turnRate = if NumRates == 1: 0.0
|
||
else: -mtr + (2.0 * mtr / (NumRates - 1).float) * ri.float
|
||
var x = x0; var y = y0
|
||
var h = heading0; var spd = speed0
|
||
for _ in 0..<ticks:
|
||
# Accelerate toward target
|
||
if spd < tSpeed: spd = min(spd + 1.0, tSpeed)
|
||
elif spd > tSpeed: spd = max(spd - 1.0, tSpeed)
|
||
spd = clamp(spd, -MaxSpeed, MaxSpeed)
|
||
# Turn (clamp to current max turn rate)
|
||
let curMtr = 10.0 - 0.75 * abs(spd)
|
||
let tr = clamp(turnRate, -curMtr, curMtr)
|
||
h += tr
|
||
let hr = h * PI / 180.0
|
||
x = clamp(x + spd * cos(hr), 0.0, arenaW)
|
||
y = clamp(y + spd * sin(hr), 0.0, arenaH)
|
||
pts.add (x, y)
|
||
|
||
# Gift-wrap convex hull (O(n²), ~45 points — fine)
|
||
# Find leftmost point as start
|
||
var startIdx = 0
|
||
for i in 1..<pts.len:
|
||
if pts[i][0] < pts[startIdx][0] or
|
||
(pts[i][0] == pts[startIdx][0] and pts[i][1] < pts[startIdx][1]):
|
||
startIdx = i
|
||
|
||
var hull: seq[(float, float)]
|
||
var cur = startIdx
|
||
while true:
|
||
hull.add pts[cur]
|
||
var next = 0
|
||
for i in 1..<pts.len:
|
||
if next == cur:
|
||
next = i
|
||
continue
|
||
let ax = pts[next][0] - pts[cur][0]
|
||
let ay = pts[next][1] - pts[cur][1]
|
||
let bx = pts[i][0] - pts[cur][0]
|
||
let by = pts[i][1] - pts[cur][1]
|
||
let cross = ax * by - ay * bx
|
||
if cross < 0.0: # i is more counterclockwise
|
||
next = i
|
||
cur = next
|
||
if cur == startIdx: break
|
||
hull
|
||
|
||
proc noRevWeights*(dirs: openArray[float], travelDeg: float): seq[int] =
|
||
## Soft no-reversal preference (arm C). `dirs` are candidate directions in
|
||
## degrees (world frame). Forward candidates (<=90 deg off the travel
|
||
## direction) get `NoRevForwardWeight`, every other candidate gets 1.
|
||
## A weight is NEVER 0, so the preference can only down-weight, never filter:
|
||
## the candidate pool can never be emptied by it. When no forward candidate
|
||
## exists the caller falls back to a uniform draw (all weights 1 anyway).
|
||
for d in dirs:
|
||
var a = d - travelDeg
|
||
while a > 180.0: a -= 360.0
|
||
while a < -180.0: a += 360.0
|
||
result.add (if abs(a) <= 90.0: NoRevForwardWeight else: 1)
|
||
|
||
proc norevPool*(offs: openArray[float], threshold: float): seq[int] =
|
||
## j144: which candidate tiles may a slow, mid-flight switch take?
|
||
## `offs` are the signed angles (deg) from the travel direction to each
|
||
## candidate, `threshold` is the speed gate (px/tick). Returns the indices
|
||
## that are NOT more than 90 deg off — i.e. the bot does not have to turn
|
||
## around to reach them.
|
||
## IF EVERY candidate is behind us the reversal is unavoidable (boxed in, or
|
||
## the field only offers rearward space), so the single LEAST-bad one is
|
||
## returned: a shallow turn, not a 180 deg flip. The result is NEVER empty,
|
||
## so the pick can never be starved. `threshold <= 0` means the knob is off
|
||
## and every candidate stays.
|
||
if offs.len == 0: return
|
||
if threshold <= 0.0: # the knob is off: no filtering at all
|
||
for i in 0..<offs.len: result.add i
|
||
return
|
||
var keep: seq[int]
|
||
for i, a in offs:
|
||
if abs(a) <= 90.0: keep.add i
|
||
if keep.len > 0: return keep
|
||
var best = 0
|
||
for i, a in offs:
|
||
if abs(a) < abs(offs[best]): best = i
|
||
@[best]
|
||
|
||
proc computeMove*(m: var TFILModule, ws: WorldState): MoveCommand =
|
||
if m.cols == 0:
|
||
m.initGrid(ws.arenaWidth, ws.arenaHeight)
|
||
|
||
# Soft reset: detect gap by position jump (rammer moved us across ticks)
|
||
# 12px threshold: above single-tick max movement (8px) but catches even short ram gaps
|
||
let jumpDist = sqrt((ws.selfX - m.lastBotX)^2 + (ws.selfY - m.lastBotY)^2)
|
||
let jumped = (m.callCount > 0) and (jumpDist > 12.0)
|
||
if jumped:
|
||
m.commitTicks = 0 # force replan — old target invalid
|
||
m.cachedHull = @[] # stale position/heading
|
||
m.cachedInsideTiles = @[]
|
||
m.bullets = @[] # bullet positions are hopelessly stale
|
||
m.blockedTile = (col: 0, row: 0, active: false)
|
||
# Re-snapshot prevEnergy so energy changes during ramming aren't misread as fires
|
||
m.fire.prevEnergy = @[]
|
||
for ei in ws.enemies:
|
||
m.fire.prevEnergySet(ei.id, ei.energy)
|
||
|
||
# Tile-change replan — see the knob rationale at the top of the file.
|
||
# j144: with TR_TFIL_COMMIT_ARRIVAL the SELF-tile crossing is exactly the event
|
||
# that must NOT cancel a commitment: crossing a boundary is the very motion
|
||
# the commitment commands, and it fires every ~5 ticks (GridSize 36, speed 8).
|
||
# Under the shipped default (arrival off) this is the original block verbatim.
|
||
if (not jumped) and (m.callCount > 0) and (m.commitTicks > 0) and
|
||
not (TfilCommitArrival and TfilTileReplanMode == ttrSelf):
|
||
case TfilTileReplanMode
|
||
of ttrSelf:
|
||
let curTileCol = clamp(int((ws.selfX - m.marginX) / GridSize), 0, m.cols - 1)
|
||
let curTileRow = clamp(int((ws.selfY - m.marginY) / GridSize), 0, m.rows - 1)
|
||
if curTileCol != m.lastTileCol or curTileRow != m.lastTileRow:
|
||
m.commitTicks = 0
|
||
m.cachedHull = @[]
|
||
m.cachedInsideTiles = @[]
|
||
m.replanReason = rrTileSelf
|
||
of ttrEnemy:
|
||
# The comment's original intent: replan when the TARGET went stale, not
|
||
# when WE moved. Uses the primary enemy's tile displacement.
|
||
if ws.enemies.len > 0 and m.lastEnemyTileCol >= 0:
|
||
let ec = clamp(int((ws.enemies[0].x - m.marginX) / GridSize), 0, m.cols - 1)
|
||
let er = clamp(int((ws.enemies[0].y - m.marginY) / GridSize), 0, m.rows - 1)
|
||
if ec != m.lastEnemyTileCol or er != m.lastEnemyTileRow:
|
||
m.commitTicks = 0
|
||
m.cachedHull = @[]
|
||
m.cachedInsideTiles = @[]
|
||
m.replanReason = rrTileEnemy
|
||
of ttrOff:
|
||
discard # honour the commitment; the danger replan is the safety valve
|
||
|
||
# Per-tick: advance existing bullets, detect new fires
|
||
m.advanceBullets(ws.selfX, ws.selfY)
|
||
m.detectFires(ws)
|
||
|
||
# Recompute lava from scratch each tick
|
||
for i in 0..<m.lava.len: m.lava[i] = 0.0
|
||
for b in m.bullets:
|
||
let bx = b.x
|
||
let by = b.y
|
||
let (coreR, auraR) = bulletRadii(b.power)
|
||
# Time model: project the tile's nearest point onto the bullet heading. When
|
||
# the model is off these factors are exactly 1.0, so heat is unchanged.
|
||
let bSpeed = sqrt(b.velX * b.velX + b.velY * b.velY)
|
||
let bUx = if bSpeed > 0.0: b.velX / bSpeed else: 0.0
|
||
let bUy = if bSpeed > 0.0: b.velY / bSpeed else: 0.0
|
||
let bMag = bulletMagScale(b.power)
|
||
let colMin = max(0, int(floor((bx - auraR - m.marginX) / GridSize)))
|
||
let colMax = min(m.cols-1, int(floor((bx + auraR - m.marginX) / GridSize)))
|
||
let rowMin = max(0, int(floor((by - auraR - m.marginY) / GridSize)))
|
||
let rowMax = min(m.rows-1, int(floor((by + auraR - m.marginY) / GridSize)))
|
||
for row in rowMin..rowMax:
|
||
for col in colMin..colMax:
|
||
let x0 = m.marginX + col.float * GridSize
|
||
let y0 = m.marginY + row.float * GridSize
|
||
let nearX = clamp(bx, x0, x0 + GridSize)
|
||
let nearY = clamp(by, y0, y0 + GridSize)
|
||
let dx = nearX - bx
|
||
let dy = nearY - by
|
||
let d2 = dx*dx + dy*dy
|
||
if d2 <= coreR * coreR:
|
||
let along = dx * bUx + dy * bUy
|
||
m.lava[row * m.cols + col] += BulletCore * bMag *
|
||
heatDecay(along / bSpeed)
|
||
elif d2 <= auraR * auraR:
|
||
let along = dx * bUx + dy * bUy
|
||
m.lava[row * m.cols + col] += BulletAura * bMag *
|
||
heatDecay(along / bSpeed)
|
||
|
||
# Corridor heat — rotated rectangle from bullet position to arena wall, auraR wide
|
||
for b in m.bullets:
|
||
let cg = corridorGeom(b, m.arenaWidth, m.arenaHeight)
|
||
if cg.tMin == 0.0: continue # zero-speed bullet, skip
|
||
let (_, auraR) = bulletRadii(b.power)
|
||
# Time model: the corridor gradient is `dt = along / speed` (see the heat
|
||
# block above). Off -> exactly 1.0, so the corridor is the flat shipped one.
|
||
let bSpeed = sqrt(b.velX * b.velX + b.velY * b.velY)
|
||
let bMag = bulletMagScale(b.power)
|
||
let wx = cg.bx + cg.dx * cg.tMin
|
||
let wy = cg.by + cg.dy * cg.tMin
|
||
# Bounding box of the 4 corners
|
||
let c0x = cg.bx + cg.px * auraR; let c0y = cg.by + cg.py * auraR
|
||
let c1x = cg.bx - cg.px * auraR; let c1y = cg.by - cg.py * auraR
|
||
let c2x = wx - cg.px * auraR; let c2y = wy - cg.py * auraR
|
||
let c3x = wx + cg.px * auraR; let c3y = wy + cg.py * auraR
|
||
let xMin = min(min(c0x, c1x), min(c2x, c3x))
|
||
let xMax = max(max(c0x, c1x), max(c2x, c3x))
|
||
let yMin = min(min(c0y, c1y), min(c2y, c3y))
|
||
let yMax = max(max(c0y, c1y), max(c2y, c3y))
|
||
let colMin = max(0, int(floor((xMin - m.marginX) / GridSize)))
|
||
let colMax = min(m.cols-1, int(floor((xMax - m.marginX) / GridSize)))
|
||
let rowMin = max(0, int(floor((yMin - m.marginY) / GridSize)))
|
||
let rowMax = min(m.rows-1, int(floor((yMax - m.marginY) / GridSize)))
|
||
for row in rowMin..rowMax:
|
||
for col in colMin..colMax:
|
||
let cx = m.marginX + (col.float + 0.5) * GridSize
|
||
let cy = m.marginY + (row.float + 0.5) * GridSize
|
||
# Project tile center onto heading and perpendicular axes
|
||
let relX = cx - cg.bx
|
||
let relY = cy - cg.by
|
||
let along = relX * cg.dx + relY * cg.dy
|
||
let perp = relX * cg.px + relY * cg.py
|
||
if along >= 0.0 and along <= cg.tMin and perp >= -auraR and perp <= auraR:
|
||
m.lava[row * m.cols + col] += CorridorHeat * bMag *
|
||
heatDecay(along / bSpeed)
|
||
|
||
# Enemy heat auras — core (18px) and aura ring (54px), same pattern as bullets
|
||
for ei in ws.enemies:
|
||
let ex = ei.x
|
||
let ey = ei.y
|
||
let colMin = max(0, int(floor((ex - EnemyAuraRadius - m.marginX) / GridSize)))
|
||
let colMax = min(m.cols-1, int(floor((ex + EnemyAuraRadius - m.marginX) / GridSize)))
|
||
let rowMin = max(0, int(floor((ey - EnemyAuraRadius - m.marginY) / GridSize)))
|
||
let rowMax = min(m.rows-1, int(floor((ey + EnemyAuraRadius - m.marginY) / GridSize)))
|
||
for row in rowMin..rowMax:
|
||
for col in colMin..colMax:
|
||
let x0 = m.marginX + col.float * GridSize
|
||
let y0 = m.marginY + row.float * GridSize
|
||
let nearX = clamp(ex, x0, x0 + GridSize)
|
||
let nearY = clamp(ey, y0, y0 + GridSize)
|
||
let dx = nearX - ex
|
||
let dy = nearY - ey
|
||
let d2 = dx*dx + dy*dy
|
||
if d2 <= EnemyCoreRadius * EnemyCoreRadius:
|
||
m.lava[row * m.cols + col] += EnemyCore
|
||
elif d2 <= EnemyAuraRadius * EnemyAuraRadius:
|
||
m.lava[row * m.cols + col] += EnemyAura
|
||
|
||
# Wall radiance heat — additive with bullet heat
|
||
for row in 0..<m.rows:
|
||
for col in 0..<m.cols:
|
||
let heat = max(0.0, WallHotness - col.float * WallRadiance) +
|
||
max(0.0, WallHotness - (m.cols-1-col).float * WallRadiance) +
|
||
max(0.0, WallHotness - row.float * WallRadiance) +
|
||
max(0.0, WallHotness - (m.rows-1-row).float * WallRadiance)
|
||
m.lava[row * m.cols + col] += heat
|
||
|
||
# Pillar radiance heat — center 1×1, 1×2, 2×1, or 2×2 depending on grid parity
|
||
let pc0 = if m.cols mod 2 == 1: m.cols div 2 else: m.cols div 2 - 1
|
||
let pc1 = m.cols div 2 # same as pc0 when odd, pc0+1 when even
|
||
let pr0 = if m.rows mod 2 == 1: m.rows div 2 else: m.rows div 2 - 1
|
||
let pr1 = m.rows div 2
|
||
for row in 0..<m.rows:
|
||
for col in 0..<m.cols:
|
||
var minDist = int.high
|
||
for pcol in pc0..pc1:
|
||
for prow in pr0..pr1:
|
||
let d = max(abs(col - pcol), abs(row - prow))
|
||
if d < minDist: minDist = d
|
||
m.lava[row * m.cols + col] += max(0.0, PillarHotness - minDist.float * PillarRadiance)
|
||
|
||
if m.debugGraphics:
|
||
# Compute max lava for heat gradient
|
||
var maxLava = 0.0
|
||
for v in m.lava:
|
||
if v > maxLava: maxLava = v
|
||
|
||
# Non-zero tiles: colored border + colored value text (yellow→orange→red)
|
||
setFont("Arial", 10.0)
|
||
for row in 0..<m.rows:
|
||
for col in 0..<m.cols:
|
||
let val = m.lava[row * m.cols + col]
|
||
if val == 0.0: continue
|
||
let t = if maxLava > 0.0: val / maxLava else: 0.0
|
||
let heatColor = fromRgb(255'u8, uint8(255.0 * (1.0 - t)), 0'u8)
|
||
let x0 = m.marginX + col.float * GridSize
|
||
let y0 = m.marginY + row.float * GridSize
|
||
setStrokeColor(heatColor)
|
||
setStrokeWidth(1.0)
|
||
drawRectangle(x0, y0, GridSize, GridSize)
|
||
setFillColor(heatColor)
|
||
drawText($int(val), x0 + 12.0, y0 + 22.0)
|
||
|
||
# Draw tracked bullet circles
|
||
setStrokeColor(RED)
|
||
setStrokeWidth(1.0)
|
||
setFillColor(RED)
|
||
for b in m.bullets:
|
||
let (coreR, auraR) = bulletRadii(b.power)
|
||
drawCircle(b.x, b.y, coreR)
|
||
fillCircle(b.x, b.y, 3.0)
|
||
setStrokeColor(fromHex("#FF8800")) # orange aura
|
||
setStrokeWidth(1.0)
|
||
drawCircle(b.x, b.y, auraR)
|
||
setStrokeColor(RED)
|
||
setStrokeWidth(1.0)
|
||
|
||
# Danger corridor: rotated rectangle projecting each bullet forward to arena wall
|
||
setStrokeColor(fromHex("#AAAAAA"))
|
||
setStrokeWidth(1.0)
|
||
for b in m.bullets:
|
||
let (_, auraR) = bulletRadii(b.power)
|
||
let cg = corridorGeom(b, m.arenaWidth, m.arenaHeight)
|
||
if cg.tMin == 0.0: continue
|
||
# When the time model is on, draw only as far as the corridor still blocks
|
||
# (heat > PathDangerThreshold = 10); otherwise the outline would claim a
|
||
# wall-to-wall threat the field no longer has. Off -> reach = cg.tMin.
|
||
var reach = cg.tMin
|
||
if TfilHeatTime:
|
||
let speed = sqrt(b.velX * b.velX + b.velY * b.velY)
|
||
let near = CorridorHeat * bulletMagScale(b.power)
|
||
reach = if speed > 0.0 and near > 10.0:
|
||
min(reach, -TfilHeatTau * ln(10.0 / near) * speed)
|
||
else: 0.0
|
||
let wx = cg.bx + cg.dx * reach
|
||
let wy = cg.by + cg.dy * reach
|
||
let corners: seq[(float, float)] = @[
|
||
(cg.bx + cg.px * auraR, cg.by + cg.py * auraR),
|
||
(cg.bx - cg.px * auraR, cg.by - cg.py * auraR),
|
||
(wx - cg.px * auraR, wy - cg.py * auraR),
|
||
(wx + cg.px * auraR, wy + cg.py * auraR),
|
||
]
|
||
drawPolygon(corners)
|
||
|
||
# Enemy core (cyan) and aura (green)
|
||
setStrokeColor(fromHex("#00FFFF")) # cyan core
|
||
setStrokeWidth(1.5)
|
||
for ei in ws.enemies:
|
||
drawCircle(ei.x, ei.y, EnemyCoreRadius)
|
||
setStrokeColor(fromHex("#00CC00")) # green aura
|
||
setStrokeWidth(1.0)
|
||
for ei in ws.enemies:
|
||
drawCircle(ei.x, ei.y, EnemyAuraRadius)
|
||
|
||
# ── Tile-based Dodge System ───────────────────────────────────────────────────
|
||
let botCol = clamp(int((ws.selfX - m.marginX) / GridSize), 0, m.cols - 1)
|
||
let botRow = clamp(int((ws.selfY - m.marginY) / GridSize), 0, m.rows - 1)
|
||
|
||
# log-only bookkeeping for this tick
|
||
var pickedThisTick = false
|
||
var pickedRev = false
|
||
var pickedMidFlight = false
|
||
var pickedInterval = 0
|
||
|
||
# Hull + inside-tiles: only recompute on replan tick (commitTicks == 0)
|
||
type TileRef = tuple[col, row: int]
|
||
if m.commitTicks == 0:
|
||
let hull = computeReachableHull(ws.selfX, ws.selfY, ws.selfHeading, ws.selfSpeed,
|
||
m.arenaWidth, m.arenaHeight, HullTicks)
|
||
# store as named-field seq to match cachedHull type
|
||
m.cachedHull = @[]
|
||
for p in hull: m.cachedHull.add (x: p[0], y: p[1])
|
||
m.cachedInsideTiles = @[]
|
||
if hull.len >= 3:
|
||
for row in 0..<m.rows:
|
||
for col in 0..<m.cols:
|
||
let cx = m.marginX + (col.float + 0.5) * GridSize
|
||
let cy = m.marginY + (row.float + 0.5) * GridSize
|
||
if pointInHull(cx, cy, hull):
|
||
m.cachedInsideTiles.add (col: col, row: row)
|
||
|
||
let insideTiles = m.cachedInsideTiles
|
||
|
||
# Find the CoolestLevels distinct lava values among inside-hull tiles
|
||
var distinctVals: seq[float]
|
||
for t in insideTiles:
|
||
let v = m.lavaAt(t.col, t.row)
|
||
var found = false
|
||
for dv in distinctVals:
|
||
if dv == v: found = true; break
|
||
if not found: distinctVals.add v
|
||
# Sort ascending (insertion sort — small N)
|
||
for i in 1..<distinctVals.len:
|
||
let key = distinctVals[i]
|
||
var j = i - 1
|
||
while j >= 0 and distinctVals[j] > key:
|
||
distinctVals[j + 1] = distinctVals[j]
|
||
dec j
|
||
distinctVals[j + 1] = key
|
||
|
||
# Collect tiles matching the CoolestLevels coolest distinct values
|
||
var coolTiles: seq[TileRef]
|
||
let numLevels = min(CoolestLevels, distinctVals.len)
|
||
for t in insideTiles:
|
||
let v = m.lavaAt(t.col, t.row)
|
||
for li in 0..<numLevels:
|
||
if v == distinctVals[li]:
|
||
coolTiles.add t
|
||
break
|
||
|
||
# Score each cool tile by MAX lava on the straight-line path from bot.
|
||
# A single hot tile on the path (corridor, bullet core, enemy aura) makes the whole path unsafe.
|
||
const PathSampleStep = 18.0 # ~half a tile
|
||
const PathDangerThreshold = 10.0 # max lava on path; above this = unsafe
|
||
type ScoredTile = tuple[col, row: int; pathMaxHeat: float]
|
||
|
||
proc pathMaxHeat(m: TFILModule, fx, fy, tx, ty: float): float =
|
||
## MAX lava on the straight-line segment (fx,fy) -> (tx,ty), sampled every
|
||
## ~half a tile. One function so the picker and the j144 hysteresis test
|
||
## score the committed target and the alternatives on the SAME scale.
|
||
let ddx = tx - fx
|
||
let ddy = ty - fy
|
||
let lineDist = sqrt(ddx*ddx + ddy*ddy)
|
||
if lineDist <= 0.1: return 0.0
|
||
let steps = max(1, int(lineDist / PathSampleStep))
|
||
var h = 0.0
|
||
for si in 0..steps:
|
||
let frac = si.float / steps.float
|
||
let (sc, sr) = m.tileAt(fx + ddx * frac, fy + ddy * frac)
|
||
h = max(h, m.lavaAt(sc, sr))
|
||
h
|
||
|
||
proc tileOffTravel(m: TFILModule, col, row: int,
|
||
sx, sy, travelDeg: float): float =
|
||
## Signed angle in degrees from the travel direction to the tile centre,
|
||
## folded into (-180, 180]. Positive = the tile lies counterclockwise.
|
||
let tx = m.marginX + (col.float + 0.5) * GridSize
|
||
let ty = m.marginY + (row.float + 0.5) * GridSize
|
||
result = arctan2(ty - sy, tx - sx) * 180.0 / PI - travelDeg
|
||
while result > 180.0: result -= 360.0
|
||
while result < -180.0: result += 360.0
|
||
|
||
var scoredTiles: seq[ScoredTile]
|
||
for t in coolTiles:
|
||
let tx = m.marginX + (t.col.float + 0.5) * GridSize
|
||
let ty = m.marginY + (t.row.float + 0.5) * GridSize
|
||
scoredTiles.add (col: t.col, row: t.row,
|
||
pathMaxHeat: pathMaxHeat(m, ws.selfX, ws.selfY, tx, ty))
|
||
|
||
# Sort by pathMaxHeat ascending (insertion sort — small N)
|
||
for i in 1..<scoredTiles.len:
|
||
let key = scoredTiles[i]
|
||
var j = i - 1
|
||
while j >= 0 and scoredTiles[j].pathMaxHeat > key.pathMaxHeat:
|
||
scoredTiles[j + 1] = scoredTiles[j]
|
||
dec j
|
||
scoredTiles[j + 1] = key
|
||
|
||
# Absolute threshold filter: safe = path max lava <= PathDangerThreshold.
|
||
# Fallback: if everything is hot, keep the 2 coolest paths anyway.
|
||
var safeTiles: seq[ScoredTile]
|
||
var blockedTiles: seq[ScoredTile]
|
||
for t in scoredTiles:
|
||
if t.pathMaxHeat <= PathDangerThreshold: safeTiles.add t
|
||
else: blockedTiles.add t
|
||
if safeTiles.len < 2:
|
||
# Fallback: promote the least-hot blocked tiles until we have 2
|
||
# ponytail: O(n) scan on already-sorted seq — fine for small N
|
||
let needed = 2 - safeTiles.len
|
||
let promote = min(needed, blockedTiles.len)
|
||
for i in 0..<promote:
|
||
safeTiles.add blockedTiles[i]
|
||
blockedTiles = blockedTiles[promote ..< blockedTiles.len]
|
||
|
||
# Commitment logic. With every j144 knob at its default (all off) this is the
|
||
# original three-way test, unchanged. j144 adds two ways OUT of a commitment
|
||
# that are NOT a tile crossing, and turns the tick counter into a MINIMUM
|
||
# dwell: the target is held until we are actually standing on it.
|
||
let atTarget = (ws.selfX - m.commitTarget.x)^2 + (ws.selfY - m.commitTarget.y)^2 <
|
||
ArriveRadius * ArriveRadius
|
||
var commitEnd = rrNone
|
||
if m.commitTicks > 0:
|
||
inc m.commitAge
|
||
# Only allow a replan after MinCommitTicks have elapsed
|
||
let ticksElapsed = TfilCommitTicks - m.commitTicks
|
||
if ticksElapsed >= MinCommitTicks:
|
||
let (cc, cr) = m.tileAt(m.commitTarget.x, m.commitTarget.y)
|
||
let curLava = m.lavaAt(cc, cr)
|
||
if curLava > m.commitLava + DangerReplanThreshold:
|
||
# GENUINE DANGER: the committed tile got hot. Block it so we don't
|
||
# immediately re-pick it, and replan. This is the safety valve and is
|
||
# deliberately independent of any boundary crossing.
|
||
m.blockedTile = (col: cc, row: cr, active: true)
|
||
commitEnd = rrDanger
|
||
elif TfilCommitArrival:
|
||
if atTarget:
|
||
# Reached. Only now is a new target allowed.
|
||
commitEnd = rrArrival
|
||
elif m.commitAge >= HullTicks:
|
||
# Stall escape: past the planner's own reachability horizon the
|
||
# committed tile is no longer guaranteed reachable (rammed, boxed in).
|
||
commitEnd = rrExpiry
|
||
elif TfilCommitMargin > 0.0:
|
||
# Hysteresis: "the path is still good" must not be able to switch us.
|
||
# Leave only when the best OTHER safe tile is cooler by > margin,
|
||
# measured on the same pathMaxHeat scale the picker uses.
|
||
var altBest = Inf
|
||
for t in safeTiles:
|
||
if t.col == cc and t.row == cr: continue
|
||
altBest = min(altBest, t.pathMaxHeat)
|
||
if altBest < Inf and
|
||
altBest < pathMaxHeat(m, ws.selfX, ws.selfY, m.commitTarget.x,
|
||
m.commitTarget.y) - TfilCommitMargin:
|
||
commitEnd = rrHyst
|
||
if commitEnd == rrNone:
|
||
dec m.commitTicks
|
||
if m.commitTicks == 0:
|
||
if TfilCommitArrival:
|
||
m.commitTicks = TfilCommitTicks # minimum dwell reached: renew, don't abandon
|
||
else:
|
||
m.replanReason = rrExpiry
|
||
else:
|
||
m.commitTicks = 0
|
||
m.replanReason = commitEnd
|
||
|
||
# j144: was the commitment we are about to replace still UNREACHED? A pick that
|
||
# replaces a target we had not yet got to is the owner's failure mode: the bot
|
||
# is still accelerating and the target flips under it. `picks == 0` means this
|
||
# is the first pick of the round, which is not a switch at all.
|
||
let midFlight = m.picks > 0 and not atTarget
|
||
|
||
if m.commitTicks == 0 and safeTiles.len > 0:
|
||
# Filter out the blocked tile from candidates
|
||
var candidates: seq[ScoredTile]
|
||
for t in safeTiles:
|
||
if m.blockedTile.active and t.col == m.blockedTile.col and t.row == m.blockedTile.row:
|
||
continue
|
||
candidates.add t
|
||
if candidates.len == 0: candidates = safeTiles # all blocked → ignore block
|
||
let travelDeg = if ws.selfSpeed < -0.01: ws.selfHeading + 180.0
|
||
else: ws.selfHeading
|
||
# j144, no opposite-direction flip while still accelerating. Below the speed
|
||
# threshold the bot physically cannot complete a reversal before the bullet
|
||
# lands, so a mid-flight switch to the mirror side only destroys the dodge it
|
||
# already has. It is refused outright — and only for a MID-FLIGHT switch: if
|
||
# we are already standing on the committed tile (an arrival pick) the bot is
|
||
# free to go anywhere, and that is exactly the pick that must not be blocked.
|
||
if TfilNoRevSpeed > 0.0 and abs(ws.selfSpeed) < TfilNoRevSpeed and midFlight:
|
||
var offs: seq[float]
|
||
for t in candidates:
|
||
offs.add tileOffTravel(m, t.col, t.row, ws.selfX, ws.selfY, travelDeg)
|
||
let keep = norevPool(offs, TfilNoRevSpeed)
|
||
var narrowed: seq[ScoredTile]
|
||
for i in keep: narrowed.add candidates[i]
|
||
candidates = narrowed
|
||
var chosen = 0
|
||
if TfilNoRev and candidates.len >= 2:
|
||
# Soft no-reversal preference (arm C): down-weight — never filter — tiles
|
||
# that lie >90 deg from the current travel direction.
|
||
var dirs: seq[float]
|
||
for t in candidates:
|
||
let tx = m.marginX + (t.col.float + 0.5) * GridSize
|
||
let ty = m.marginY + (t.row.float + 0.5) * GridSize
|
||
dirs.add arctan2(ty - ws.selfY, tx - ws.selfX) * 180.0 / PI
|
||
let weights = noRevWeights(dirs, travelDeg)
|
||
var total = 0
|
||
var forward = 0
|
||
for w in weights:
|
||
total += w
|
||
if w > 1: inc forward
|
||
if forward == 0:
|
||
# Fallback: no forward tile exists → uniform draw, so the pool can
|
||
# never empty and the pick is identical to the shipped one.
|
||
chosen = rand(candidates.high)
|
||
else:
|
||
let r = rand(total - 1)
|
||
var acc = 0
|
||
chosen = weights.high
|
||
for i in 0..<weights.len:
|
||
acc += weights[i]
|
||
if r < acc:
|
||
chosen = i
|
||
break
|
||
else:
|
||
chosen = rand(candidates.high)
|
||
let ct = candidates[chosen]
|
||
m.commitTarget = (x: m.marginX + (ct.col.float + 0.5) * GridSize,
|
||
y: m.marginY + (ct.row.float + 0.5) * GridSize)
|
||
m.commitTicks = TfilCommitTicks
|
||
m.commitAge = 0
|
||
m.commitLava = m.lavaAt(ct.col, ct.row)
|
||
m.blockedTile.active = false # clear after successful pick
|
||
|
||
# log-only: reversal test against the travel direction
|
||
var rd = arctan2(m.commitTarget.y - ws.selfY, m.commitTarget.x - ws.selfX) *
|
||
180.0 / PI - travelDeg
|
||
while rd > 180.0: rd -= 360.0
|
||
while rd < -180.0: rd += 360.0
|
||
pickedThisTick = true
|
||
pickedRev = abs(rd) > 90.0
|
||
pickedMidFlight = midFlight
|
||
pickedInterval = m.callCount - m.lastPickCall
|
||
m.lastPickCall = m.callCount
|
||
inc m.picks
|
||
|
||
if m.debugGraphics:
|
||
# Reachable hull perimeter (darker blue)
|
||
if m.cachedHull.len >= 3:
|
||
let hullPairs: seq[(float, float)] = block:
|
||
var s: seq[(float, float)]
|
||
for p in m.cachedHull: s.add (p.x, p.y)
|
||
s
|
||
setStrokeColor(fromHex("#336699"))
|
||
setStrokeWidth(1.0)
|
||
drawPolygon(hullPairs)
|
||
|
||
# Dim (dark cyan) for path-blocked cool tiles
|
||
setStrokeColor(fromHex("#006666"))
|
||
setStrokeWidth(1.0)
|
||
for t in blockedTiles:
|
||
let x0 = m.marginX + t.col.float * GridSize
|
||
let y0 = m.marginY + t.row.float * GridSize
|
||
drawRectangle(x0, y0, GridSize, GridSize)
|
||
|
||
# Bright cyan borders on safe-to-reach tiles
|
||
setStrokeColor(fromHex("#00FFFF"))
|
||
setStrokeWidth(2.0)
|
||
for t in safeTiles:
|
||
let x0 = m.marginX + t.col.float * GridSize
|
||
let y0 = m.marginY + t.row.float * GridSize
|
||
drawRectangle(x0, y0, GridSize, GridSize)
|
||
|
||
# Green on chosen tile
|
||
let (chosenCol, chosenRow) = m.tileAt(m.commitTarget.x, m.commitTarget.y)
|
||
let gx0 = m.marginX + chosenCol.float * GridSize
|
||
let gy0 = m.marginY + chosenRow.float * GridSize
|
||
setStrokeColor(fromHex("#00FF00"))
|
||
setStrokeWidth(2.5)
|
||
drawRectangle(gx0, gy0, GridSize, GridSize)
|
||
|
||
# Blue on bot tile
|
||
let bx0 = m.marginX + botCol.float * GridSize
|
||
let by0 = m.marginY + botRow.float * GridSize
|
||
setStrokeColor(fromHex("#0088FF"))
|
||
setStrokeWidth(2.5)
|
||
drawRectangle(bx0, by0, GridSize, GridSize)
|
||
|
||
# Committed target line
|
||
setStrokeColor(fromHex("#00FF00"))
|
||
setStrokeWidth(1.5)
|
||
drawLine(ws.selfX, ws.selfY, m.commitTarget.x, m.commitTarget.y)
|
||
|
||
# Update position snapshot and call counter for next gap detection
|
||
m.lastBotX = ws.selfX
|
||
m.lastBotY = ws.selfY
|
||
m.lastTileCol = clamp(int((ws.selfX - m.marginX) / GridSize), 0, m.cols - 1)
|
||
m.lastTileRow = clamp(int((ws.selfY - m.marginY) / GridSize), 0, m.rows - 1)
|
||
if ws.enemies.len > 0:
|
||
m.lastEnemyTileCol = clamp(int((ws.enemies[0].x - m.marginX) / GridSize), 0, m.cols - 1)
|
||
m.lastEnemyTileRow = clamp(int((ws.enemies[0].y - m.marginY) / GridSize), 0, m.rows - 1)
|
||
else:
|
||
m.lastEnemyTileCol = -1
|
||
m.lastEnemyTileRow = -1
|
||
m.callCount += 1
|
||
|
||
if TfilCommitLogPath.len > 0:
|
||
let reason = if pickedThisTick:
|
||
(if m.replanReason == rrNone: rrInit else: m.replanReason)
|
||
else: rrNone
|
||
tfilLogWrite("{\"tick\":" & $ws.tick & ",\"call\":" & $m.callCount &
|
||
",\"sp\":" & $ws.selfSpeed & ",\"ct\":" & $m.commitTicks &
|
||
",\"pick\":" & (if pickedThisTick: "1" else: "0") &
|
||
",\"reason\":\"" & reasonName(reason) & "\",\"rev\":" &
|
||
(if pickedRev: "1" else: "0") & ",\"mid\":" &
|
||
(if pickedMidFlight: "1" else: "0") & ",\"interval\":" & $pickedInterval &
|
||
",\"picks\":" & $m.picks & "}")
|
||
if pickedThisTick: m.replanReason = rrNone
|
||
|
||
# ── Steering ─────────────────────────────────────────────────────────────────
|
||
let stepDx = m.commitTarget.x - ws.selfX
|
||
let stepDy = m.commitTarget.y - ws.selfY
|
||
let dist2 = stepDx*stepDx + stepDy*stepDy
|
||
if dist2 < 324.0: # already at target (18px radius)
|
||
return (speed: 0.0, turnRate: 0.0)
|
||
|
||
let targetBearing = arctan2(stepDy, stepDx) * 180.0 / PI
|
||
var delta = targetBearing - ws.selfHeading
|
||
while delta > 180.0: delta -= 360.0
|
||
while delta < -180.0: delta += 360.0
|
||
|
||
let maxTurnRate = 10.0 - 0.75 * abs(ws.selfSpeed)
|
||
var speed: float
|
||
var turnRate: float
|
||
if abs(delta) <= 90.0:
|
||
speed = MaxSpeed
|
||
turnRate = clamp(delta, -maxTurnRate, maxTurnRate)
|
||
else:
|
||
let flipped = if delta > 0.0: delta - 180.0 else: delta + 180.0
|
||
speed = -MaxSpeed
|
||
turnRate = clamp(flipped, -maxTurnRate, maxTurnRate)
|
||
|
||
result = (speed: speed, turnRate: turnRate)
|