fix(guns): per-bin wave queues unbreak GF/DecayGF/KNN learning; fix vbullet drops
Wave queues (guess_factor, decay_gf, knn_gun): predict() stored ONE wave per tick while onResult() popped one per resolved bullet (~4/tick), so the queue drained to empty within a few dozen ticks, ~3 of every 4 resolutions returned without learning, and the survivor paired with a same-tick wave (bearingDelta ~= 0) pinning the histogram at centre. PROOF: GF.vHits == HeadOn.vHits and DecayGF.vHits == HeadOn.vHits byte-for-byte in every one of 50 rounds — the guns had degenerated to HeadOn. Now each gun keeps a per-bin FIFO with an O(1) head cursor. At most one push per (tick, bin) so the fire site's 5th predict() call is a no-op, and onResult pops the oldest wave of its OWN bin via e.bulletPower. Aiming math untouched (it was already correct: 0 deg = East, CCW+). maxBullets 2048 -> 8192: the rack spawns 52 bullets/tick so the ring wrapped every ~39 ticks while a long power-3 shot needs ~90, silently discarding unresolved bullets and biasing every measured hit rate by range. Added a droppedBullets counter so a future overflow is measurable, and wavePushes/ waveStarved counters on the three guns. After the fix: vDropped = 0 and vStarved = 0 across all 48 recorded rounds. fitnessFor is now exported, deterministic (enemies iterated in ascending id order) and shared by the selector and the stats dump, replacing a hand-rolled merge in ModularBot that never advanced its window head. Round lines gain additive keys: vDropped, vStarved.
This commit is contained in:
@@ -1,14 +1,16 @@
|
||||
## Guess-factor gun: statistical targeting via GF histogram.
|
||||
## Bins: 31, ranging GF -1 (max CW escape) to +1 (max CCW escape).
|
||||
## Learns from virtual bullet outcomes; caches wave state per-tick.
|
||||
## Learns from virtual bullet outcomes; queues one wave per (tick, power bin).
|
||||
|
||||
import std/[math, strformat]
|
||||
import gun_harness/gun_interface
|
||||
import gun_harness/virtual_bullets as vb # PowerBins: the four power bins the harness spawns
|
||||
|
||||
const
|
||||
GFBins = 31
|
||||
GFPrior = 0.1
|
||||
DebugGF* = false
|
||||
WaveCompactAt = 64 ## compact a bin's wave seq once this many entries are consumed
|
||||
|
||||
type
|
||||
Wave = object
|
||||
@@ -18,15 +20,20 @@ type
|
||||
|
||||
GFGun* = object
|
||||
bins: array[GFBins, float]
|
||||
waves: seq[Wave] # pending unresolved waves
|
||||
# per-tick cache: store wave only once across multiple power-bin calls
|
||||
cachedTick: int
|
||||
cachedWaveStored: bool
|
||||
# One wave queue per power bin. The owning bin is fixed at push time (from the
|
||||
# bulletSpeed argument) and at pop time (from FeedbackEvent.bulletPower), so a
|
||||
# resolved bullet is always paired with a wave from its own bin.
|
||||
waves: array[len(vb.PowerBins), seq[Wave]]
|
||||
waveHead: array[len(vb.PowerBins), int] # O(1) pop cursor into waves[bin]
|
||||
waveStoredTick: array[len(vb.PowerBins), int] # last tick a wave was queued for this bin
|
||||
wavePushes*: int # total waves enqueued (== one per (tick, bin))
|
||||
waveStarved*: int # onResult found an empty queue for its own bin
|
||||
debugGraphics*: bool
|
||||
|
||||
proc initGFGun*(): GFGun =
|
||||
result.cachedTick = -1
|
||||
result.debugGraphics = false
|
||||
for b in 0..<len(vb.PowerBins):
|
||||
result.waveStoredTick[b] = -1
|
||||
# Seed with a head-on prior: triangular bump at bin 15 (GF=0).
|
||||
# Prevents the cold-start tie-break to GF=-1 (bin 0) that poisons early fitness.
|
||||
let center = (GFBins - 1) div 2 # = 15
|
||||
@@ -47,6 +54,34 @@ proc peakBin(g: GFGun): int =
|
||||
best = i
|
||||
best
|
||||
|
||||
proc binForSpeed(spd: float): int {.inline.} =
|
||||
## Map a virtual-bullet speed back to its power-bin index. All four bin speeds
|
||||
## are exactly representable floats; the epsilon is belt-and-braces only.
|
||||
for i in 0..<len(vb.PowerBins):
|
||||
if abs(spd - bulletSpeed(vb.PowerBins[i])) < 1e-6:
|
||||
return i
|
||||
-1
|
||||
|
||||
proc binForPower(power: float): int {.inline.} =
|
||||
## Map a FeedbackEvent.bulletPower back to its power-bin index.
|
||||
for i in 0..<len(vb.PowerBins):
|
||||
if abs(power - vb.PowerBins[i]) < 1e-6:
|
||||
return i
|
||||
-1
|
||||
|
||||
proc takeOldestWave(g: var GFGun, binIdx: int): (bool, Wave) =
|
||||
## Pop the oldest unresolved wave for this bin (O(1) amortized via waveHead).
|
||||
## Returns (false, default) when the bin's queue is empty.
|
||||
if binIdx < 0 or g.waveHead[binIdx] >= g.waves[binIdx].len:
|
||||
return (false, Wave())
|
||||
result = (true, g.waves[binIdx][g.waveHead[binIdx]])
|
||||
inc g.waveHead[binIdx]
|
||||
# Amortized O(1): drop the consumed prefix once it dominates the queue.
|
||||
if g.waveHead[binIdx] >= WaveCompactAt and
|
||||
g.waveHead[binIdx] * 2 >= g.waves[binIdx].len:
|
||||
g.waves[binIdx] = g.waves[binIdx][g.waveHead[binIdx] .. g.waves[binIdx].high]
|
||||
g.waveHead[binIdx] = 0
|
||||
|
||||
proc predict*(g: var GFGun, state: WorldState, bulletSpeed: float): GunPrediction =
|
||||
if bulletSpeed <= 0.0:
|
||||
return GunPrediction(x: state.enemyX, y: state.enemyY)
|
||||
@@ -57,18 +92,17 @@ proc predict*(g: var GFGun, state: WorldState, bulletSpeed: float): GunPredictio
|
||||
let bearing = arctan2(dy, dx)
|
||||
let mea = arcsin(clamp(8.0 / bulletSpeed, -1.0, 1.0))
|
||||
|
||||
# Store one wave per tick regardless of how many power bins call us
|
||||
if state.tick != g.cachedTick:
|
||||
g.cachedTick = state.tick
|
||||
g.cachedWaveStored = false
|
||||
|
||||
if not g.cachedWaveStored:
|
||||
g.waves.add Wave(
|
||||
# Queue at most one wave per (tick, power bin). The fire site's extra predict()
|
||||
# call for the selected bin lands on the same tick and reuses the queued wave.
|
||||
let binIdx = binForSpeed(bulletSpeed)
|
||||
if binIdx >= 0 and g.waveStoredTick[binIdx] != state.tick:
|
||||
g.waves[binIdx].add Wave(
|
||||
fireX: state.selfX,
|
||||
fireY: state.selfY,
|
||||
fireBearing: bearing,
|
||||
)
|
||||
g.cachedWaveStored = true
|
||||
g.waveStoredTick[binIdx] = state.tick
|
||||
inc g.wavePushes
|
||||
|
||||
let peak = g.peakBin()
|
||||
let peakGF = indexToGF(peak)
|
||||
@@ -78,7 +112,7 @@ proc predict*(g: var GFGun, state: WorldState, bulletSpeed: float): GunPredictio
|
||||
let py = state.selfY + sin(gfAngle) * dist
|
||||
|
||||
when DebugGF:
|
||||
echo fmt"[gf-dbg] predict: peakGF={peakGF:.2f} peakBin={peak} mea={radToDeg(mea):.1f}° aimAngle={radToDeg(gfAngle):.1f}° waves={g.waves.len}"
|
||||
echo fmt"[gf-dbg] predict: peakGF={peakGF:.2f} peakBin={peak} mea={radToDeg(mea):.1f}° aimAngle={radToDeg(gfAngle):.1f}° waves={g.waves[binIdx].len}"
|
||||
|
||||
GunPrediction(
|
||||
x: clamp(px, BotRadius, state.arenaWidth - BotRadius),
|
||||
@@ -86,17 +120,15 @@ proc predict*(g: var GFGun, state: WorldState, bulletSpeed: float): GunPredictio
|
||||
)
|
||||
|
||||
proc onResult*(g: var GFGun, e: FeedbackEvent) =
|
||||
## Called when a virtual bullet resolves. Match the wave by predicted point,
|
||||
## compute actual GF, and increment the histogram with a smoothing kernel.
|
||||
## We don't have the original wave tick here, so we use the prediction coords
|
||||
## to identify and remove the matching wave.
|
||||
## ponytail: O(n) scan over waves; waves list stays tiny (< a dozen at a time)
|
||||
if g.waves.len == 0:
|
||||
return
|
||||
## Called when a virtual bullet resolves. Pop the OLDEST unresolved wave from
|
||||
## this bullet's own power-bin queue, compute the actual GF, and smooth-add it.
|
||||
let binIdx = binForPower(e.bulletPower)
|
||||
if binIdx < 0: return
|
||||
|
||||
# Pop the oldest wave (FIFO matches bullet resolution order)
|
||||
let w = g.waves[0]
|
||||
g.waves.delete(0)
|
||||
let (found, w) = g.takeOldestWave(binIdx)
|
||||
if not found:
|
||||
inc g.waveStarved
|
||||
return
|
||||
|
||||
# Recompute mea from the actual bullet power (correct per-bin, not the cached first-bin mea)
|
||||
let speed = bulletSpeed(e.bulletPower)
|
||||
|
||||
Reference in New Issue
Block a user