SirStone
0f5cfe37b2
common_libs/movements/wave_surfer.nim was written in an early session and
never wired to the bot. This connects it exactly like tfil/strafe and fixes
the defects a full read found:
1. the dodge direction was INVERTED: the perpendicular was built from the
bot->enemy bearing while GF lives in the enemy->bot frame, so the bot
moved toward MORE danger. Now built from the wave's origin->bot bearing:
+90 provably increases GF.
2. the danger histogram was never reset (resetRound cleared waves only), so
it was a battle-long static average. Now reset to the uniform prior each
round.
3. fire detection tracked only the current target's energy via one scalar;
now per-enemy (seq[(id,energy)]) so melee target switches cannot invent
or hide waves.
4. the wall penalty projected a point from the wave origin, not from the
bot, making the wall test meaningless. Now projects the bot->candidate
direction.
Wave speed uses the actual firepower (the one-tick energy drop IS the
firepower, so speed = 20 - 3*drop is exact). Adds TR_SURF_* knobs and
registers them in the env report. Shipped TR_MOVEMENT=tfil default untouched
(test_tfil_commit_env: 30/30 pass; test_env_report: pass).
341 lines
14 KiB
Nim
341 lines
14 KiB
Nim
## wave_surfer.nim — Wave-surfing movement module.
|
|
##
|
|
## Detects enemy fire via energy drops, maintains a per-round danger histogram
|
|
## of the GuessFactor (GF) each resolved wave arrived at, and steers toward the
|
|
## lowest-danger reachable GF on the nearest approaching wave. All angles in
|
|
## radians internally; output degrees for the bot API.
|
|
##
|
|
## ── What was broken and what was fixed (j115) ───────────────────────────────
|
|
## The module was written in an early session, never wired to the bot and never
|
|
## tested. A full read found four real defects; all are fixed here:
|
|
##
|
|
## 1. **The dodge was INVERTED.** The perpendicular direction was built from
|
|
## the bot→enemy bearing (`arctan2(enemyY-botY, enemyX-botX)`), while the
|
|
## GF is measured in the enemy→bot frame. Rotating the bot→enemy bearing by
|
|
## +90 deg points the OPPOSITE way from rotating the enemy→bot bearing by
|
|
## +90 deg, so when the safest bin was at a higher GF the bot moved toward
|
|
## a LOWER GF, i.e. toward MORE danger. Fixed by building the perpendicular
|
|
## from the ORIGIN→bot bearing (the wave's own frame): `perp = toBot ± 90`,
|
|
## where `toBot = arctan2(botY-originY, botX-originX)`. `+90` now provably
|
|
## increases GF (d(theta)/ds is maximal there).
|
|
## 2. **The histogram was never reset.** `resetRound` cleared the waves but
|
|
## left `bins` accumulating for the WHOLE battle, so it became a global
|
|
## static average. It is now reset to the uniform prior every round (it is
|
|
## per-round-resettable, as required).
|
|
## 3. **Fire detection tracked only the CURRENT TARGET's energy** via a single
|
|
## scalar `prevEnergy` (init 100.0). In melee a target switch silently
|
|
## compared two different bots' energies, inventing/hiding waves. It is now
|
|
## per-enemy (`seq[(id, energy)]`, exactly like the STRAFE mover), a new
|
|
## enemy id is seeded without emitting a wave, and a vanished enemy keeps
|
|
## its last value until it reappears.
|
|
## 4. **The wall penalty projected the wrong future point.** It placed the
|
|
## future position at `bot + (wave-bearing + gf*MEA)` — the direction from
|
|
## the wave ORIGIN, not from the bot — so the wall test was meaningless. It
|
|
## now projects the point on the wave circle at the candidate GF and takes
|
|
## the direction from the BOT to it.
|
|
##
|
|
## Wave geometry uses the ACTUAL fired power: the one-tick energy drop IS the
|
|
## firepower (energy cost == firepower), so `speed = 20 - 3*drop` is exact, not
|
|
## an assumption. Wave resolution fires when the wave radius reaches the bot's
|
|
## distance from the origin, and the GF is normalised by that power's maximum
|
|
## escape angle `arcsin(8/speed)`.
|
|
##
|
|
## KNOWN LIMITATION (measured, not hidden): a low-power hit ON the enemy (our
|
|
## bullet doing <= 3.0 energy of damage) is indistinguishable from a small
|
|
## firepower in the energy drop. Those shots can spawn a false wave. High-power
|
|
## hits (damage > 3.0) are correctly rejected by the drop window. This is the
|
|
## standard energy-drop ambiguity; the single 1v1 A/B cannot separate it.
|
|
|
|
import std/[math, os]
|
|
from std/strutils import parseFloat, strip, toLowerAscii
|
|
import gun_harness/gun_interface
|
|
import movement_harness/movement_interface
|
|
|
|
const
|
|
WS_BINS = 31
|
|
DodgeTicks = 15.0 ## approximate ticks to reach the dodge position
|
|
MaxBotSpeed = 8.0 ## Tank Royale max forward/backward speed (px/tick)
|
|
|
|
## ── env knobs (all read once at module init) ────────────────────────────────
|
|
const
|
|
SurfPrefDistEnv* = "TR_SURF_PREF_DIST"
|
|
SurfDistBandEnv* = "TR_SURF_DIST_BAND"
|
|
SurfWallMarginEnv* = "TR_SURF_WALL_MARGIN"
|
|
SurfRadialFracEnv* = "TR_SURF_RADIAL_FRAC"
|
|
SurfLogEnv* = "TR_SURF_LOG"
|
|
|
|
const
|
|
DefaultPrefDist = 400.0 ## optimal engagement distance (px)
|
|
DefaultDistBand = 50.0 ## deadband: pure strafe within ±band of pref dist
|
|
DefaultWallMargin = 48.0 ## px; > bot radius 18, plus braking room
|
|
DefaultRadialFrac = 0.35 ## radial blend fraction (0=pure strafe, 1=radial)
|
|
|
|
var
|
|
SurfPrefDist* = DefaultPrefDist
|
|
SurfDistBand* = DefaultDistBand
|
|
SurfWallMargin* = DefaultWallMargin
|
|
SurfRadialFrac* = DefaultRadialFrac
|
|
SurfLog* = false
|
|
|
|
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 loadSurfEnv*() =
|
|
## Read the surfer knobs; callable again after `putEnv` so a gate can
|
|
## exercise arms in one process.
|
|
SurfPrefDist = max(1.0, getEnvFloat(SurfPrefDistEnv, DefaultPrefDist))
|
|
SurfDistBand = max(0.0, getEnvFloat(SurfDistBandEnv, DefaultDistBand))
|
|
SurfWallMargin = max(0.0, getEnvFloat(SurfWallMarginEnv, DefaultWallMargin))
|
|
SurfRadialFrac = clamp(getEnvFloat(SurfRadialFracEnv, DefaultRadialFrac), 0.0, 1.0)
|
|
SurfLog = existsEnv(SurfLogEnv)
|
|
|
|
loadSurfEnv()
|
|
|
|
type
|
|
WSWave = object
|
|
originX, originY: float64
|
|
bearing: float64 ## direction from enemy to us at fire time (rad)
|
|
speed: float64
|
|
radius: float64
|
|
startDist: float64
|
|
power: float64
|
|
|
|
WaveSurferModule* = object
|
|
bins: array[WS_BINS, float64]
|
|
waves: seq[WSWave]
|
|
prevEnergy: seq[tuple[id: int, energy: float]]
|
|
strafeDir: float64 ## +1.0 or -1.0
|
|
debugGraphics*: bool
|
|
|
|
proc resetRound*(m: var WaveSurferModule) =
|
|
## Wipe per-round state. The danger histogram IS reset here (defect 2): it is
|
|
## a per-round learner, not a battle-long static average.
|
|
m.waves = @[]
|
|
m.prevEnergy = @[]
|
|
m.strafeDir = 1.0
|
|
for i in 0..<WS_BINS: m.bins[i] = 1.0
|
|
|
|
proc initWaveSurfer*(): WaveSurferModule =
|
|
var m = WaveSurferModule(debugGraphics: false)
|
|
m.resetRound()
|
|
m
|
|
|
|
proc clearGraphics*(m: var WaveSurferModule) {.inline.} =
|
|
## No-op: the SVG buffer is a framework global cleared after every go().
|
|
## Exists so callers can signal "the surfer is inactive".
|
|
discard
|
|
|
|
proc removeBulletNear*(m: var WaveSurferModule, x, y: float) {.inline.} =
|
|
## No-op: the surfer tracks WAVES (energy drops), not bullet bodies.
|
|
discard
|
|
|
|
proc prevEnergyGet(m: WaveSurferModule, id: int): float =
|
|
for e in m.prevEnergy:
|
|
if e.id == id: return e.energy
|
|
100.0
|
|
|
|
proc prevEnergySet(m: var WaveSurferModule, id: int, energy: float) =
|
|
for i in 0..<m.prevEnergy.len:
|
|
if m.prevEnergy[i].id == id:
|
|
m.prevEnergy[i].energy = energy
|
|
return
|
|
m.prevEnergy.add((id: id, energy: energy))
|
|
|
|
proc gfToBin(gf: float64): int {.inline.} =
|
|
clamp(int(round((gf.clamp(-1.0, 1.0) + 1.0) * 0.5 * float64(WS_BINS - 1))),
|
|
0, WS_BINS - 1)
|
|
|
|
proc binToGF(idx: int): float64 {.inline.} =
|
|
float64(idx) / float64(WS_BINS - 1) * 2.0 - 1.0
|
|
|
|
proc mea(speed: float64): float64 {.inline.} =
|
|
## Maximum escape angle for a bot moving at max speed relative to a bullet of
|
|
## the given speed.
|
|
if speed <= 1e-9: return 0.0
|
|
arcsin(min(MaxBotSpeed / speed, 1.0))
|
|
|
|
proc wrapPi(x: float64): float64 {.inline.} =
|
|
result = x
|
|
while result > PI: result -= 2.0*PI
|
|
while result < -PI: result += 2.0*PI
|
|
|
|
proc nearestWave(m: WaveSurferModule, botX, botY: float64): int =
|
|
## Index of the wave closest to reaching us (largest radius relative to the
|
|
## current distance). -1 when there is no live wave.
|
|
result = -1
|
|
var bestRatio = -1.0
|
|
for i in 0..<m.waves.len:
|
|
let d = max(1e-6, hypot(botX - m.waves[i].originX, botY - m.waves[i].originY))
|
|
let ratio = m.waves[i].radius / d
|
|
if ratio > bestRatio:
|
|
bestRatio = ratio
|
|
result = i
|
|
|
|
proc detectFire(m: var WaveSurferModule, id: int, ex, ey, eenergy,
|
|
botX, botY: float64) =
|
|
## One enemy's energy sample: emit a wave iff its energy dropped by a
|
|
## plausible firepower in one tick. `drop` is the firepower exactly.
|
|
let prev = m.prevEnergyGet(id)
|
|
let drop = prev - eenergy
|
|
m.prevEnergySet(id, eenergy)
|
|
if drop >= 0.1 and drop <= 3.0:
|
|
let bspeed = 20.0 - 3.0 * drop
|
|
let bearing = arctan2(botY - ey, botX - ex)
|
|
let d = hypot(botX - ex, botY - ey)
|
|
m.waves.add WSWave(
|
|
originX: ex, originY: ey,
|
|
bearing: bearing,
|
|
speed: bspeed,
|
|
radius: 0.0,
|
|
startDist: d,
|
|
power: drop,
|
|
)
|
|
|
|
proc computeMove*(m: var WaveSurferModule, ws: WorldState): MoveCommand =
|
|
let botX = ws.selfX
|
|
let botY = ws.selfY
|
|
|
|
# ── Fire detection: EVERY alive enemy, per-enemy energy (defect 3) ─────────
|
|
var seen = 0
|
|
for ei in ws.enemies:
|
|
inc seen
|
|
m.detectFire(ei.id, ei.x, ei.y, ei.energy, botX, botY)
|
|
if seen == 0 and (ws.enemyX != 0.0 or ws.enemyY != 0.0):
|
|
# Fallback to the tracked target when `enemies` is empty.
|
|
m.detectFire(-1, ws.enemyX, ws.enemyY, ws.enemyEnergy, botX, botY)
|
|
|
|
# ── Advance waves; record the GF of each wave that reaches us ─────────────
|
|
var i = 0
|
|
while i < m.waves.len:
|
|
m.waves[i].radius += m.waves[i].speed
|
|
let d = hypot(botX - m.waves[i].originX, botY - m.waves[i].originY)
|
|
if m.waves[i].radius >= d:
|
|
let toBot = arctan2(botY - m.waves[i].originY, botX - m.waves[i].originX)
|
|
let off = wrapPi(toBot - m.waves[i].bearing)
|
|
let maxA = mea(m.waves[i].speed)
|
|
if maxA >= 1e-9:
|
|
let gf = clamp(off / maxA, -1.0, 1.0)
|
|
m.bins[gfToBin(gf)] += 1.0
|
|
m.waves.del(i)
|
|
else:
|
|
inc i
|
|
|
|
# ── Dodge logic: pick the safest reachable GF on the nearest wave ─────────
|
|
var perpAngle = 0.0
|
|
var havePerp = false
|
|
let nearest = m.nearestWave(botX, botY)
|
|
if nearest >= 0:
|
|
let w = m.waves[nearest]
|
|
let dx = botX - w.originX
|
|
let dy = botY - w.originY
|
|
let d = max(1.0, hypot(dx, dy))
|
|
let toBot = arctan2(dy, dx) # origin -> bot (the GF frame)
|
|
let off = wrapPi(toBot - w.bearing)
|
|
let maxA = mea(w.speed)
|
|
let curGF = if maxA >= 1e-9: clamp(off / maxA, -1.0, 1.0) else: 0.0
|
|
let curBin = gfToBin(curGF)
|
|
|
|
# Danger = per-bin average; the current bin is the danger baseline.
|
|
var total = 0.0
|
|
for b in m.bins: total += b
|
|
let avg = total / float64(WS_BINS)
|
|
|
|
if m.bins[curBin] > avg:
|
|
# Find the least-dangerous reachable GF, penalising wall-bound moves.
|
|
let dodgeDist = max(MaxBotSpeed, ws.selfSpeed) * DodgeTicks
|
|
var bestBin = curBin
|
|
var bestDanger = Inf
|
|
for j in 0..<WS_BINS:
|
|
let gfJ = binToGF(j)
|
|
let angleJ = w.bearing + gfJ * maxA
|
|
# Point on the wave circle at this GF, then the DIRECTION FROM THE BOT.
|
|
let px = w.originX + cos(angleJ) * d
|
|
let py = w.originY + sin(angleJ) * d
|
|
var ux = px - botX
|
|
var uy = py - botY
|
|
let ul = hypot(ux, uy)
|
|
if ul < 1e-6:
|
|
ux = 0.0; uy = 0.0
|
|
else:
|
|
ux /= ul; uy /= ul
|
|
let futureX = botX + ux * dodgeDist
|
|
let futureY = botY + uy * dodgeDist
|
|
let wallHit = futureX < SurfWallMargin or futureX > ws.arenaWidth - SurfWallMargin or
|
|
futureY < SurfWallMargin or futureY > ws.arenaHeight - SurfWallMargin
|
|
var danger = m.bins[j]
|
|
if wallHit: danger *= 5.0
|
|
danger += 0.01 * abs(gfJ - curGF) # mild preference for less travel
|
|
if danger < bestDanger:
|
|
bestDanger = danger
|
|
bestBin = j
|
|
let bestGF = binToGF(bestBin)
|
|
m.strafeDir = if bestGF >= curGF: 1.0 else: -1.0
|
|
if SurfLog:
|
|
echo "[surf] wave d=", d.int, " curGF=", (curGF * 100.0).int,
|
|
" bestGF=", (bestGF * 100.0).int, " dir=", m.strafeDir.int,
|
|
" curDanger=", m.bins[curBin].int
|
|
# Perpendicular in the wave's own frame: +90 deg from origin->bot provably
|
|
# INCREASES the GF (CCW); -90 decreases it (defect 1).
|
|
perpAngle = if m.strafeDir >= 0.0: toBot + PI * 0.5
|
|
else: toBot - PI * 0.5
|
|
havePerp = true
|
|
else:
|
|
# No live wave: hold the perpendicular of the current threat bearing.
|
|
if ws.enemyX != 0.0 or ws.enemyY != 0.0:
|
|
let toBot = arctan2(botY - ws.enemyY, botX - ws.enemyX)
|
|
perpAngle = if m.strafeDir >= 0.0: toBot + PI * 0.5
|
|
else: toBot - PI * 0.5
|
|
havePerp = true
|
|
else:
|
|
perpAngle = degToRad(ws.selfHeading)
|
|
|
|
# ── Hard wall escape: never drive into a wall ─────────────────────────────
|
|
let nearLeft = botX < SurfWallMargin
|
|
let nearRight = botX > ws.arenaWidth - SurfWallMargin
|
|
let nearBottom = botY < SurfWallMargin
|
|
let nearTop = botY > ws.arenaHeight - SurfWallMargin
|
|
if nearLeft or nearRight or nearBottom or nearTop:
|
|
let px = cos(perpAngle)
|
|
let py = sin(perpAngle)
|
|
if (nearLeft and px < 0.0) or (nearRight and px > 0.0) or
|
|
(nearBottom and py < 0.0) or (nearTop and py > 0.0):
|
|
# Flip to the opposite perpendicular (same as the other strafe side).
|
|
m.strafeDir = -m.strafeDir
|
|
perpAngle = perpAngle + PI
|
|
# Blend 50% toward the arena centre.
|
|
let escapeAngle = arctan2(ws.arenaHeight * 0.5 - botY, ws.arenaWidth * 0.5 - botX)
|
|
let ex = cos(escapeAngle) + cos(perpAngle)
|
|
let ey = sin(escapeAngle) + sin(perpAngle)
|
|
perpAngle = arctan2(ey, ex)
|
|
|
|
# ── Distance control: a radial component outside the deadband ────────────
|
|
let enemyDist = hypot(ws.enemyX - botX, ws.enemyY - botY)
|
|
let distErr = enemyDist - SurfPrefDist
|
|
let radialFrac =
|
|
if distErr > SurfDistBand: SurfRadialFrac # too far -> approach
|
|
elif distErr < -SurfDistBand: -SurfRadialFrac # too close -> retreat
|
|
else: 0.0
|
|
if abs(radialFrac) > 1e-9:
|
|
let radialAngle = arctan2(ws.enemyY - botY, ws.enemyX - botX) +
|
|
(if radialFrac < 0.0: PI else: 0.0)
|
|
let rx = cos(perpAngle) * (1.0 - abs(radialFrac)) + cos(radialAngle) * abs(radialFrac)
|
|
let ry = sin(perpAngle) * (1.0 - abs(radialFrac)) + sin(radialAngle) * abs(radialFrac)
|
|
perpAngle = arctan2(ry, rx)
|
|
|
|
# ── Turn the body toward the desired heading; move at full speed ─────────
|
|
let desiredDeg = radToDeg(perpAngle)
|
|
|
|
var delta = desiredDeg - ws.selfHeading
|
|
while delta > 180.0: delta -= 360.0
|
|
while delta < -180.0: delta += 360.0
|
|
|
|
let goForward = abs(delta) <= 90.0
|
|
if not goForward:
|
|
delta = if delta >= 0.0: delta - 180.0 else: delta + 180.0
|
|
|
|
(speed: if goForward: 8.0 else: -8.0,
|
|
turnRate: delta.clamp(-10.0, 10.0))
|