j147: the 1-tick fire-detection lag is OURS — measure it, then back-date it (TR_FIRE_LAG)
MEASURED LIVE (common_libs/tests/measure_fire_ghost_lag.py, 4 sessions, 1777 matched ghost spawns, both movers): the server dispatches a turn's fire AFTER our go() for that same turn, so a turn-T shot's energy drop first reaches our scan at turn T+1 — and a bullet takes its FIRST step during the turn it is fired, so the true bullet is already one whole bullet step (11-20 px) downrange. Both movers place the ghost at the SCANNED enemy position (where the bullet was born), so the whole ghost trajectory is the true one shifted one turn later and the arrival deadline is a full tick late. MEASURED: detection lag +1 tick on 100% of 1777 matched spawns; ghost-vs- observer displacement 19.06 px mean / 22.00 p90 (tfil) and 16.08 / 21.81 (strafe); arrival-deadline error 0.99 / 0.77 ticks. NOT a rendering artefact: the draw/advance order is correct (advanceBullets -> detectFires -> build). THE FIX: TR_FIRE_LAG (int, default 0 = today byte-for-byte) in the shared fire_tracker, applied by both movers at spawn: x = origin + dir*speed*lag. The deadline needs no separate change — both movers derive it from the ghost's own position, so a correct position gives a correct deadline. WITH IT: displacement 19.06 -> 5.37 px mean (the residue is the enemy's own <=8 px scan staleness) and the deadline error 0.99 -> 0.06 ticks. Guards: test_tfil_commit_env 77 -> 87 checks (default golden parity, exact n-step back-date, deadline shortens by exactly lag, junk/negative degrade to 0, reaped exactly one tick earlier); test_env_report + test_env_dotenv green. TR_FIRE_LAG registered in env_report + knownEnvNames + .env.example + docs/env_reference.md. Live A/B pre-registered in docs/movement_campaign.md (Batch 8) with its MDE stated up front; arms tools/ab/arms_fire_lag.txt. TR_FIRE_DIAG gains a per-round ROUND line (the tick->getTurn anchor) and a per-spawn SPAWN line (the ghost's drawn position).
This commit is contained in:
@@ -848,6 +848,113 @@ when declared(loadTfilCommitEnv):
|
||||
" mean path heat=", meanPathHeat(s).formatFloat(ffDecimal, 2),
|
||||
" >90deg=", pct(s.bigTurn, s.picks)
|
||||
|
||||
## j147: TR_FIRE_LAG back-dates the ghost by the MEASURED detection lag (1
|
||||
## tick live: 1777/1777 matched spawns, `measure_fire_ghost_lag.py`). Default
|
||||
## 0 must be byte-for-byte today's spawn, and lag=n must move the ghost exactly
|
||||
## n bullet steps downrange — which is what shortens the arrival deadline,
|
||||
## because every mover derives the deadline from the ghost's own position.
|
||||
proc testJ147() =
|
||||
let ws = WorldState(enemyX: 0.0, enemyY: 0.0, enemyHeading: 0.0,
|
||||
enemySpeed: 0.0, enemyEnergy: 100.0,
|
||||
selfX: 400.0, selfY: 320.0, selfHeading: 0.0,
|
||||
selfSpeed: 0.0, selfEnergy: 100.0,
|
||||
arenaWidth: ArenaW, arenaHeight: ArenaH, tick: 1,
|
||||
enemies: @[])
|
||||
let ei = EnemyInfo(id: 1, x: 200.0, y: 320.0, heading: 0.0,
|
||||
speed: 0.0, energy: 100.0)
|
||||
const Power = 1.0
|
||||
let speed = 20.0 - 3.0 * Power # 17 px/tick
|
||||
|
||||
proc spawnGhost(): TrackedBullet =
|
||||
var m = initTFIL()
|
||||
discard m.computeMove(ws) # initGrid
|
||||
m.spawnTrackedWave(ws, ei, Power)
|
||||
m.bullets[^1]
|
||||
|
||||
# 1. default parity: unset -> 0, and the ghost is EXACTLY the scanned origin
|
||||
delEnv("TR_FIRE_LAG")
|
||||
loadFireTrackerEnv()
|
||||
check "j147: TR_FIRE_LAG unset -> FireLag 0", FireLag == 0
|
||||
let g0 = spawnGhost()
|
||||
check "j147: default (lag 0) puts the ghost exactly on the scanned enemy",
|
||||
g0.x == ei.x and g0.y == ei.y
|
||||
|
||||
# 2. lag 1 back-dates by EXACTLY one bullet step, on the ghost's own heading
|
||||
putEnv("TR_FIRE_LAG", "1")
|
||||
loadFireTrackerEnv()
|
||||
let g1 = spawnGhost()
|
||||
check "j147: TR_FIRE_LAG=1 places the ghost one bullet step downrange",
|
||||
FireLag == 1 and
|
||||
abs((g1.x - g0.x) - g1.velX) < 1e-9 and
|
||||
abs((g1.y - g0.y) - g1.velY) < 1e-9
|
||||
check "j147: ... and that step is the true bullet speed, not a scaled one",
|
||||
abs(sqrt(g1.velX * g1.velX + g1.velY * g1.velY) - speed) < 1e-9
|
||||
|
||||
# 3. the ARRIVAL DEADLINE shortens by exactly `lag` ticks. The mover's own
|
||||
# arrival proxy is dist(self, ghost) / speed (tfil `heatDecay(along/speed)`,
|
||||
# the `dot < 0` reap); the true bullet is one step further along.
|
||||
let etaGhost = sqrt((ws.selfX - g1.x)^2 + (ws.selfY - g1.y)^2) /
|
||||
sqrt(g1.velX * g1.velX + g1.velY * g1.velY)
|
||||
let etaTrue0 = sqrt((ws.selfX - g0.x)^2 + (ws.selfY - g0.y)^2) / speed
|
||||
let etaTrue1 = sqrt((ws.selfX - (g0.x + g0.velX))^2 +
|
||||
(ws.selfY - (g0.y + g0.velY))^2) / speed
|
||||
check "j147: with lag=1 the mover's deadline equals the TRUE remaining " &
|
||||
"flight (" & etaGhost.formatFloat(ffDecimal, 6) & " vs " &
|
||||
etaTrue1.formatFloat(ffDecimal, 6) & "), the lag-0 deadline being " &
|
||||
etaTrue0.formatFloat(ffDecimal, 6) & " — a full tick late",
|
||||
abs(etaGhost - etaTrue1) < 1e-9 and
|
||||
abs((etaTrue0 - etaTrue1) - 1.0) < 1e-9
|
||||
|
||||
# 4. lag n is n steps, and n=2 shortens the deadline by exactly 2
|
||||
putEnv("TR_FIRE_LAG", "2")
|
||||
loadFireTrackerEnv()
|
||||
let g2 = spawnGhost()
|
||||
check "j147: TR_FIRE_LAG=2 back-dates by two steps",
|
||||
abs((g2.x - g0.x) - 2.0 * g0.velX) < 1e-9 and
|
||||
abs((g2.y - g0.y) - 2.0 * g0.velY) < 1e-9
|
||||
let etaTrue2 = sqrt((ws.selfX - (g0.x + 2.0 * g0.velX))^2 +
|
||||
(ws.selfY - (g0.y + 2.0 * g0.velY))^2) / speed
|
||||
check "j147: ... so the deadline shortens by exactly 2 ticks",
|
||||
abs((etaTrue0 - etaTrue2) - 2.0) < 1e-9
|
||||
|
||||
# 5. a junk value falls back to 0, never to a negative/garbage back-date
|
||||
putEnv("TR_FIRE_LAG", "junk")
|
||||
loadFireTrackerEnv()
|
||||
let gj = spawnGhost()
|
||||
putEnv("TR_FIRE_LAG", "-4")
|
||||
loadFireTrackerEnv()
|
||||
let gn = spawnGhost()
|
||||
check "j147: a junk / negative TR_FIRE_LAG degrades to the shipped lag 0",
|
||||
FireLag == 0 and gj.x == ei.x and gn.x == ei.x
|
||||
|
||||
# 6. the ARRIVAL DEADLINE end-to-end: the ghost is reaped (`dot < 0`, the
|
||||
# geometric arrival) exactly `lag` ticks earlier, because it is `lag`
|
||||
# steps further along. This is the deadline the decision actually uses.
|
||||
proc ticksToReap(): int =
|
||||
var m = initTFIL()
|
||||
randomize(Seed)
|
||||
discard m.computeMove(ws)
|
||||
m.spawnTrackedWave(ws, ei, Power)
|
||||
for t in 1..80:
|
||||
discard m.computeMove(ws)
|
||||
if m.bullets.len == 0: return t
|
||||
99
|
||||
putEnv("TR_FIRE_LAG", "0")
|
||||
loadFireTrackerEnv()
|
||||
let reap0 = ticksToReap()
|
||||
putEnv("TR_FIRE_LAG", "1")
|
||||
loadFireTrackerEnv()
|
||||
let reap1 = ticksToReap()
|
||||
check "j147: the ghost arrives — and is reaped — exactly 1 tick earlier " &
|
||||
"with the back-date (" & $reap0 & " -> " & $reap1 & " ticks)",
|
||||
reap0 > 0 and reap1 > 0 and reap0 - reap1 == 1
|
||||
|
||||
# 7. restore the shipped default for every later check in this process
|
||||
delEnv("TR_FIRE_LAG")
|
||||
loadFireTrackerEnv()
|
||||
check "j147: clearing the knob restores the shipped spawn exactly",
|
||||
FireLag == 0 and spawnGhost().x == ei.x
|
||||
|
||||
# ── driver ───────────────────────────────────────────────────────────────────
|
||||
|
||||
testDefaultParity()
|
||||
@@ -857,6 +964,7 @@ when declared(loadTfilCommitEnv):
|
||||
testJ144()
|
||||
testJ145()
|
||||
testJ146()
|
||||
testJ147()
|
||||
|
||||
if failures > 0:
|
||||
echo "\n", failures, " check(s) FAILED"
|
||||
|
||||
Reference in New Issue
Block a user