diff --git a/ModularBot_garage/src/ModularBot.nim b/ModularBot_garage/src/ModularBot.nim index e55f8a2..919f503 100644 --- a/ModularBot_garage/src/ModularBot.nim +++ b/ModularBot_garage/src/ModularBot.nim @@ -1,5 +1,5 @@ ## ModularBot — plugin gun architecture tracer bullet. -## Guns: HeadOnGun (0), LinearGun (1), TsetlinGun (2), CircularGun (3), GFGun (4), PatternMatcherGun (5), WallBounceGun (6), AccelGun (7), StopShotGun (8), DisplacementGun (9), AveragedLeadGun (10), DecayGFGun (11), KNNGun (12), TmSelectorGun (13), TmPatternGun (14), TmHorizonGun (15) via GunHarness. +## Guns: HeadOnGun (0), LinearGun (1), TsetlinGun (2), CircularGun (3), GFGun (4), PatternMatcherGun (5), WallBounceGun (6), AccelGun (7), StopShotGun (8), DisplacementGun (9), AveragedLeadGun (10), DecayGFGun (11), KNNGun (12), TmSelectorGun (13), TmPatternGun (14), TmHorizonGun (15), BitBrainGun (16) via GunHarness. ## Radar: RadarLockModule (1v1) / AdaptiveMeleeRadarModule (2+ enemies), auto-switched per tick. ## Movement: OscillatorModule (perpendicular strafing). @@ -27,6 +27,7 @@ import guns/knn_gun import guns/tm_selector import guns/tm_pattern import guns/tm_horizon +import guns/bitbrain_gun import movements/phantom_meteor import movements/rammer import movements/ram_decision @@ -121,7 +122,7 @@ let ShotLogPath = getEnv("GUN_SHOTLOG_PATH", "/tmp/shot_log.jsonl") ## shows why the cap moved. The policy itself lives in the shared gun harness ## (`applyPowerPolicy`), so both live and offline paths see the same rule. let PowerLog = existsEnv("TR_POWER_LOG") -const GunNames = ["HeadOn", "Linear", "Tsetlin", "Circular", "GuessFactor", "Pattern", "WallBounce", "Accel", "StopShot", "Displace", "AvgLead", "DecayGF", "KNN", "TMSelect", "TMPattern", "TMHorizon"] +const GunNames = ["HeadOn", "Linear", "Tsetlin", "Circular", "GuessFactor", "Pattern", "WallBounce", "Accel", "StopShot", "Displace", "AvgLead", "DecayGF", "KNN", "TMSelect", "TMPattern", "TMHorizon", "BitBrain"] ## Rack id of the new TM pattern gun. It defaults to `TR_RACK_TMPATTERN=off`; ## unlike the other guns, its virtual-bullet spawn is gated on rack admission @@ -136,6 +137,12 @@ const TmPatternId = 14 ## head — hence every other gun's learning order — is byte-for-byte unchanged. const TmHorizonId = 15 +## Rack id of the BitBrain ADE+SBC fine-grained aim corrector. It defaults to +## `TR_RACK_BITBRAIN=off` and its virtual-bullet spawn is gated on rack +## admission, so the shipped default never spawns it and the shared tracker ring +## head — hence every other gun's learning order — is byte-for-byte unchanged. +const BitBrainId = 16 + const CLR_GUN = "\e[33m" # yellow CLR_MOVE = "\e[36m" # cyan @@ -183,6 +190,7 @@ type tmSelector: TmSelectorGun tmPattern: TmPatternGun tmHorizon: TmHorizonGun + bitbrain: BitBrainGun mover: TFILModule ringMover: TFILRingModule rammer: RammerModule @@ -208,18 +216,18 @@ type roundNumber: int realShotsFired: int realHits: int - gunRealShots: array[16, int] - gunRealHits: array[16, int] + gunRealShots: array[17, int] + gunRealHits: array[17, int] # Same real-shot accounting split by the rack in force at fire time, so a # later data-driven pass can rank guns per mode (1v1 vs melee). - gunRealShotsByMode: array[vb.RackMode, array[16, int]] - gunRealHitsByMode: array[vb.RackMode, array[16, int]] + gunRealShotsByMode: array[vb.RackMode, array[17, int]] + gunRealHitsByMode: array[vb.RackMode, array[17, int]] pendingFires: seq[PendingShot] ## FIFO of fired shots awaiting onBulletFired bulletId stamp bulletGun: Table[int, int] ## bulletId -> gun id, filled on onBulletFired, drained on resolution bulletMode: Table[int, vb.RackMode] ## bulletId -> rack at fire time bulletShot: Table[int, PendingShot] ## bulletId -> shot metadata (Task A shot log) pendingHitBullets: HashSet[int] ## hit bulletIds seen before their onBulletFired stamp - gunSelectionCount: array[16, int] + gunSelectionCount: array[17, int] lastPowerLogKey: string ## change detector for the TR_POWER_LOG line lastKnownTargetId: int ## persists through death, used for round-end stats # Radar measurement instrumentation (only touched when RadarScanLog is set). @@ -589,7 +597,7 @@ method onRoundEnded*(bot: ModularBot, e: RoundEndedEventForBot) = let fit = bot.tracker.fitnessFor(targetId) var gunsArr = newJArray() - for gid in 0..<16: + for gid in 0..<17: var totalShots = 0 var totalHits = 0 for binIdx in 0..= 0: bot.lastKnownTargetId = bot.currentTargetId @@ -1028,6 +1043,7 @@ method run*(bot: ModularBot) = var tmselPreds: array[len(PowerBins), GunPrediction] var tmpPreds: array[len(PowerBins), GunPrediction] var tmhPreds: array[len(PowerBins), GunPrediction] + var bbPreds: array[len(PowerBins), GunPrediction] # ── TR_VBULLET_ADMIT_ONLY gate ────────────────────────────────────── # Rack membership used to filter only SELECTION, so every unselected gun # still ran predict()+spawnBullets() each tick to feed a fitness table the @@ -1039,11 +1055,11 @@ method run*(bot: ModularBot) = # owning gun's onResult, so attribution survives a mid-round rack change. # TMPATTERN and TMHORIZON keep their own admission gate even when the knob # is 0, so TR_VBULLET_ADMIT_ONLY=0 reproduces the exact pre-change rack. - var admit: array[16, bool] - for gi in 0..<16: + var admit: array[17, bool] + for gi in 0..<17: admit[gi] = vBulletAdmitted(gi, bot.rackMode, ActiveRackMembership, VBulletAdmitOnly or gi == TmPatternId or - gi == TmHorizonId) + gi == TmHorizonId or gi == BitBrainId) for i in 0..` value. Empty / unknown values fall back to the diff --git a/common_libs/guns/bitbrain_gun.nim b/common_libs/guns/bitbrain_gun.nim new file mode 100644 index 0000000..701550b --- /dev/null +++ b/common_libs/guns/bitbrain_gun.nim @@ -0,0 +1,536 @@ +## bitbrain_gun.nim — BitBrain (ADE + SBC) FINE-GRAINED AIM CORRECTOR. +## +## THE BRIEF THIS IMPLEMENTS (from the offline gate test, docs/bitbrain_gate_test.md): +## * BASE — the shipped Pattern gun's prediction (`guns/pattern_matcher`). +## BitBrain supplies only a small ANGULAR CORRECTION on top of it, +## exactly the shape the gate test measured and the shape TMHorizon +## uses. That keeps the comparison against Pattern/TMHorizon +## apples-to-apples. +## * INPUT — the SAME 53 bits TMHorizon uses: the 49-bit draft spec +## (`tmhBaseBits`) PLUS a 4-bit horizon one-hot (`tmhLits`). These are +## reused from `guns/tm_horizon.nim`, not re-derived. +## * OUTPUT — a fine-grained angular-correction CLASS over ±`TR_BITBRAIN_RANGE` +## degrees (`TR_BITBRAIN_N` bins, default 32). The readout is the +## ARGMAX class centre (the gate test MEASURED that argmax is the +## winning readout; the count-weighted mean is a shrinkage predictor +## that lowers the hit rate). Zero correction when there is no +## evidence. +## * LABEL — the +h-tick FACT from our OWN observation ring (the ring the +## embedded TmHorizonGun maintains): `h = round(dist/speed)`, +## `speed = 20 - 3*power`, clamped to [10, 50]. Never crosses a round +## boundary (pending samples are dropped on a round reset). +## * TRAIN — ONLINE / PREQUENTIAL: predict, then learn the resolved fact when +## it becomes due `h` ticks later. +## * AD LAYER — synthesised for OUR data. The MNIST weights are useless. +## center = 0 (the inputs are BINARY; the reference 127 would collapse +## the code to a polarity count). Thresholds start from a small +## heuristic that fires ~1 % from the first ticks, are then calibrated +## from a running score histogram to the paper's ~1 % operating point +## (the gate test's percentile init, made online), and are nudged by +## the library's deterministic `adaptThresholds` homeostasis. +## +## MEMORY MODES (`TR_BITBRAIN_MEM`): +## perRound (DEFAULT) — wipe the SBCs every round. The gate test measured this +## as the WINNING regime. +## retained — accumulate across the whole battle/enemy and wipe only +## on a target change / new battle. This is what the user +## asked for, and the gate test measured it as the WEAKEST +## regime: the idempotent SBC only ADDS, so it saturates. +## decay — retained PLUS a periodic partial wipe of the SBC +## tensors (TR_BITBRAIN_DECAY every N samples, a fraction +## TR_BITBRAIN_DECAY_FRAC of words zeroed). This is the one +## mechanism with a measured diagnosis behind it: the SBC +## saturates and a bounded/decaying memory should help. +## +## DEFAULT OFF / PARITY: this gun is admitted ONLY when `TR_RACK_BITBRAIN` says so +## (default `off`) AND it never runs its network until `predict` is first called +## (`ensureInit`). With the shipped rack the live loop never calls `predict`, so +## no network is built, no RNG is touched and the shipped bot is unchanged. + +import std/[math, os, strutils, strformat, random] +import gun_harness/gun_interface +import guns/tm_horizon +import guns/pattern_matcher +import bitbrain/bitbrain + +const + ## ── env knobs (all resolved once at gun construction) ───────────────────── + BB_MEM_ENV* = "TR_BITBRAIN_MEM" ## perRound|retained|decay + BB_N_ENV* = "TR_BITBRAIN_N" ## correction classes + BB_NADE_ENV* = "TR_BITBRAIN_NADE" ## ADEs per address decoder + BB_RANGE_ENV* = "TR_BITBRAIN_RANGE" ## class half-range, degrees + BB_LOG_ENV* = "TR_BITBRAIN_LOG" ## 1 = per-change [bb] log + BB_MIN_OBS_ENV* = "TR_BITBRAIN_MIN_OBS" ## resolved samples before correction + BB_WARMUP_ENV* = "TR_BITBRAIN_WARMUP" ## samples before percentile init + BB_ADAPT_ENV* = "TR_BITBRAIN_ADAPT" ## homeostasis interval (samples) + BB_CALIB_ENV* = "TR_BITBRAIN_CALIB" ## percentile recalibration interval + BB_DECAY_ENV* = "TR_BITBRAIN_DECAY" ## decay interval (samples) + BB_DECAY_FRAC_ENV* = "TR_BITBRAIN_DECAY_FRAC" ## fraction of words zeroed per decay + BB_SEED_ENV* = "TR_BITBRAIN_SEED" ## deterministic AD/decay seed + BB_RESET_ON_TARGET_ENV* = "TR_BITBRAIN_RESET_ON_TARGET" + ## ── fixed geometry ──────────────────────────────────────────────────────── + BB_WIDTHS* = [6, 8, 10, 12] ## the paper's multi-width ADs + BB_TARGET_RATE* = 0.01 ## the paper's ~1 % firing target + BB_PENDING_CAP* = 512 ## deferred-label queue (>= 4 buckets x 50 ticks) + ## ── shipped defaults ────────────────────────────────────────────────────── + BB_N_DEF = 32 + BB_NADE_DEF = 256 + BB_RANGE_DEF = 40.0 + BB_MIN_OBS_DEF = 8 + BB_WARMUP_DEF = 400 + BB_ADAPT_DEF = 32 + BB_CALIB_DEF = 512 + BB_DECAY_DEF = 250 + BB_DECAY_FRAC_DEF = 0.02 + BB_SEED_DEF = 20240921 + BB_RESET_ON_TARGET_DEF = true + +type + BitMemMode* = enum + bmPerRound, bmRetained, bmDecay + + BbPending = object + ## One deferred training sample. `lits` is the exact literal vector the ADs + ## saw at fire time; the label is resolved `horizon` ticks later. + fireTick: int + horizon: int + selfX*, selfY: float + baseBearing: float + lits: array[TMH_NLITS, uint8] + + BitBrainGun* = object + tmh: TmHorizonGun + bb: BitBrain + initialized: bool + # ── resolved config ────────────────────────────────────────────────────── + nClasses*: int + maxDeg*: float + nAde*: int + memMode*: BitMemMode + logEnabled*: bool + minObs*: int + warmupN*: int + adaptEvery*: int + calibEvery*: int + decayEvery*: int + decayFrac*: float + seed*: int64 + resetOnTarget*: bool + # ── AD calibration state ───────────────────────────────────────────────── + rng: Rand + hist: seq[seq[int32]] ## per-AD raw-score histogram (bins 2w+1) + histTotal: int + sampleCount*: int + sinceAdapt: int + sinceCalib: int + sinceDecay: int + decays*: int + # ── scratch (avoid per-sample allocation) ──────────────────────────────── + scratch: seq[seq[int32]] + counts: seq[int] + # ── deferred labels ────────────────────────────────────────────────────── + pending: array[BB_PENDING_CAP, BbPending] + pendingCount*: int + pendingDropped*: int + # ── per-tick caches ────────────────────────────────────────────────────── + lastTick: int + lastEnqTick: int + lastEnqBucket: int + cachedBits: array[TMH_N_BASE, uint8] + cachedBitsTick: int + bitsValid: bool + # ── accounting / logging ───────────────────────────────────────────────── + trained*: int + lastBest: int + lastShift*: float + corrections*: int + lastLogKey: string + lastLogTick: int + observedTargetId*: int + +# ── small pure helpers ─────────────────────────────────────────────────────── + +proc wrapRadBB(r: float): float {.inline.} = + result = r + while result > PI: result -= 2.0 * PI + while result < -PI: result += 2.0 * PI + +proc memModeName*(m: BitMemMode): string = + case m + of bmPerRound: "perRound" + of bmRetained: "retained" + of bmDecay: "decay" + +proc parseMemMode*(value: string): BitMemMode = + ## Empty / unknown values fall back to the shipped `perRound` (the measured + ## winning regime), so a typo cannot silently select another regime. + case value.strip().toLowerAscii() + of "retained", "retain", "accum", "accumulate": bmRetained + of "decay", "forget", "age": bmDecay + else: bmPerRound + +proc envFloatBB(name: string, default: float): float = + let v = getEnv(name, "") + if v.len == 0: return default + try: parseFloat(v.strip()) except ValueError: default + +proc envIntBB(name: string, default: int): int = + let v = getEnv(name, "") + if v.len == 0: return default + try: parseInt(v.strip()) except ValueError: default + +proc envBoolBB(name: string, default: bool): bool = + case getEnv(name, "").strip().toLowerAscii() + of "1", "true", "yes", "on": true + of "0", "false", "no", "off": false + else: default + +proc bbCenterDeg*(k, nClasses: int, maxDeg: float): float = + ## Centre (degrees) of correction class `k` over ±maxDeg. + let w = 2.0 * maxDeg / float(nClasses) + -maxDeg + (float(k) + 0.5) * w + +proc bbClassOf*(errRad: float, nClasses: int, maxDeg: float): int = + ## Bin a signed angular error (radians) into one of `nClasses` bins over + ## [−maxDeg, +maxDeg] (the gate test's `binOf`). + let x = radToDeg(errRad) + var k = int((x + maxDeg) / (2.0 * maxDeg) * float(nClasses)) + if k < 0: k = 0 + if k >= nClasses: k = nClasses - 1 + k + +# ── construction / lazy network build ──────────────────────────────────────── + +proc initBitBrainGun*(): BitBrainGun = + result.nClasses = clamp(envIntBB(BB_N_ENV, BB_N_DEF), 2, 512) + result.nAde = clamp(envIntBB(BB_NADE_ENV, BB_NADE_DEF), 8, 4096) + result.maxDeg = clamp(envFloatBB(BB_RANGE_ENV, BB_RANGE_DEF), 1.0, 180.0) + result.memMode = parseMemMode(getEnv(BB_MEM_ENV, "")) + result.logEnabled = envBoolBB(BB_LOG_ENV, false) + result.minObs = max(1, envIntBB(BB_MIN_OBS_ENV, BB_MIN_OBS_DEF)) + result.warmupN = max(0, envIntBB(BB_WARMUP_ENV, BB_WARMUP_DEF)) + result.adaptEvery = max(1, envIntBB(BB_ADAPT_ENV, BB_ADAPT_DEF)) + result.calibEvery = max(1, envIntBB(BB_CALIB_ENV, BB_CALIB_DEF)) + result.decayEvery = max(1, envIntBB(BB_DECAY_ENV, BB_DECAY_DEF)) + result.decayFrac = clamp(envFloatBB(BB_DECAY_FRAC_ENV, BB_DECAY_FRAC_DEF), 0.0, 1.0) + result.seed = int64(envIntBB(BB_SEED_ENV, BB_SEED_DEF)) + result.resetOnTarget = envBoolBB(BB_RESET_ON_TARGET_ENV, BB_RESET_ON_TARGET_DEF) + result.lastTick = -1 + result.lastEnqTick = -1 + result.lastEnqBucket = -1 + result.observedTargetId = -1 + result.rng = initRand(result.seed + 991) + +proc resetThresholdsHeuristic(g: var BitBrainGun) = + ## Cold-start thresholds: a small multiple of the raw-score standard deviation + ## puts every ADE near the paper's ~1 % firing rate from the FIRST ticks, so + ## the SBCs see a useful (sparse) coincidence set immediately and inference + ## never degenerates into an O(nAde^2) dense scan. The running-histogram + ## percentile calibration replaces these once warmup has passed. + for a in 0..= t` is CLOSEST to + ## `BB_TARGET_RATE * total` — the gate test's percentile init, run online over + ## the running histogram. This is what pins the realised firing rate near 1 %. + if g.histTotal <= 0: return + let target = BB_TARGET_RATE * float(g.histTotal) + for a in 0.. g.warmupN: + inc g.sinceAdapt + inc g.sinceCalib + if g.sinceAdapt >= g.adaptEvery: + for a in 0..= g.calibEvery: + g.calibrate() + g.sinceCalib = 0 + +# ── one AD pass: firing counts + histogram + inference ─────────────────────── + +proc bbObserve(g: var BitBrainGun, lits: array[TMH_NLITS, uint8]) = + ## Drive every ADE: update its firing accumulator and the score histogram, + ## collect the active list, then infer the class counts into `g.counts`. + for a in 0.. 0'i32: int(c) - 1 else: int(-c) - 1 + let pol = if c > 0'i32: 1 else: -1 + raw += pol * int(lits[idx]) + inc g.hist[a][raw + w] + if raw * sc >= int(g.bb.ades[a].thresholds[e]): + g.scratch[a].add int32(e) + inc g.bb.ades[a].fireCounts[e] + inc g.histTotal + for k in 0.. 0'i32: int(c) - 1 else: int(-c) - 1 + let pol = if c > 0'i32: 1 else: -1 + raw += pol * int(lits[idx]) + if raw * sc >= int(g.bb.ades[a].thresholds[e]): + g.scratch[a].add int32(e) + for sl in 0.. state.tick: + g.pending[w] = p + inc w + elif due == state.tick: + let obs = tmhObservedAt(g.tmh, state.tick, p.selfX, p.selfY) + if obs.ok and (state.tick - obs.lastSeenTick) <= TMH_STALE_MAX: + let err = wrapRadBB(obs.bearing - p.baseBearing) + let cls = bbClassOf(err, g.nClasses, g.maxDeg) + g.bbLearn(p.lits, cls) + inc g.trained + inc g.sinceDecay + if g.memMode == bmDecay and g.sinceDecay >= g.decayEvery: + g.applyDecay() + g.sinceDecay = 0 + else: + inc g.pendingDropped + else: + inc g.pendingDropped + g.pendingCount = w + +# ── logging ────────────────────────────────────────────────────────────────── + +proc bbLog(g: var BitBrainGun, state: WorldState, h, bucket, total, best: int) = + ## ONE change-gated `[bb]` line (behind TR_BITBRAIN_LOG=1) so the user tailing + ## the GUI log sees what the corrector is thinking, not one line per tick. + if not g.logEnabled: return + let shift = bbCenterDeg(best, g.nClasses, g.maxDeg) + let key = fmt"{best}|{shift:.1f}" + if key == g.lastLogKey: return + if state.tick == g.lastLogTick: return + g.lastLogKey = key + g.lastLogTick = state.tick + var nz = 0 + for k in 0.. 0: inc nz + echo fmt"[bb] t={state.tick} h={h} bucket={bucket} cls={best}/{g.nClasses} " & + fmt"shift={shift:+.1f}deg cnt={g.counts[best]}/{total} nz={nz} " & + fmt"trained={g.trained} samples={g.sampleCount} pend={g.pendingCount} " & + fmt"mode={memModeName(g.memMode)} warm={(if g.trained >= g.minObs: 1 else: 0)}" + +# ── reset hooks (mirroring TmHorizonGun) ───────────────────────────────────── + +proc resetRound(g: var BitBrainGun) = + ## PER-ROUND wipe. Always clear the observation ring, deferred labels and + ## per-tick caches (the bots teleport between rounds). In `perRound` mode the + ## SBCs are wiped too; `retained`/`decay` keep them across the round. + g.tmh.resetRoundState() + g.pendingCount = 0 + g.lastTick = -1 + g.lastEnqTick = -1 + g.lastEnqBucket = -1 + g.bitsValid = false + g.lastLogKey = "" + g.lastLogTick = -1 + if g.memMode == bmPerRound: + g.bb.resetLearning() + g.trained = 0 + +proc resetRoundState*(g: var BitBrainGun) = + if not g.initialized: return + g.resetRound() + +proc resetLearning*(g: var BitBrainGun, reason = "") = + ## PER-BATTLE / PER-ENEMY wipe: SBCs, AD thresholds, histograms and counters. + if not g.initialized: return + g.bb.resetLearning() + g.resetThresholdsHeuristic() + for a in 0.. 0 and g.logEnabled: + echo fmt"[bb-reset] reason={reason}" + +proc targetChanged*(g: var BitBrainGun, enemyId: int): bool = + ## Per-ENEMY reset: wipe when the target changes to a different bot id. First + ## acquisition never wipes, so the round-start pick does not cold-start us. + if not g.resetOnTarget: return false + if enemyId < 0: return false + if g.observedTargetId >= 0 and enemyId != g.observedTargetId: + g.resetLearning("target_change") + g.observedTargetId = enemyId + return true + g.observedTargetId = enemyId + false + +# ── Gun interface ──────────────────────────────────────────────────────────── + +proc isWarmedUp*(g: BitBrainGun): bool {.inline.} = true + +proc networkBytes*(g: BitBrainGun): int = + ## Bytes held by the AD/SBC network (0 until the network is built). + if g.initialized: g.bb.memoryBytes else: 0 + +proc predict*(g: var BitBrainGun, state: WorldState, + bulletSpeed: float): GunPrediction = + g.ensureInit() + + # Round boundary: a tick regression means a new round. + if state.tick < g.lastTick: g.resetRound() + + # Once per tick: observe the world, then resolve any labels now due. + if state.tick != g.lastTick: + tmhUpdateHistory(g.tmh, state) + g.resolvePending(state) + g.lastTick = state.tick + g.bitsValid = false + + # The base prediction is Pattern; BitBrain only corrects its bearing. + let base = g.tmh.pattern.predict(state, bulletSpeed) + if bulletSpeed <= 0.0: return base + + let dist = hypot(state.enemyX - state.selfX, state.enemyY - state.selfY) + let h = tmhHorizonFor(dist, bulletSpeed) + let bucket = tmhHorizonBucket(h) + + if not g.bitsValid or g.cachedBitsTick != state.tick: + g.cachedBits = tmhBaseBits(g.tmh, state) + g.cachedBitsTick = state.tick + g.bitsValid = true + let lits = tmhLits(g.cachedBits, bucket) + + # Observe this input (AD pass + inference) and advance the calibration clock. + g.bbObserve(lits) + g.afterSample() + + # Enqueue one deferred sample per (tick, bucket): predict runs once per power + # bin, so all four horizons contribute evidence. + if g.lastEnqTick != state.tick or g.lastEnqBucket != bucket: + if g.pendingCount < BB_PENDING_CAP: + g.pending[g.pendingCount] = BbPending( + fireTick: state.tick, horizon: h, + selfX: state.selfX, selfY: state.selfY, + baseBearing: arctan2(base.y - state.selfY, base.x - state.selfX), + lits: lits) + inc g.pendingCount + else: + inc g.pendingDropped + g.lastEnqTick = state.tick + g.lastEnqBucket = bucket + + # Readout: argmax class centre, zero correction with no evidence / cold. + var shiftDeg = 0.0 + if g.trained >= g.minObs: + var total = 0 + for k in 0.. 0: + var best = 0 + for k in 1.. g.counts[best]: best = k + shiftDeg = bbCenterDeg(best, g.nClasses, g.maxDeg) + g.lastBest = best + g.lastShift = shiftDeg + inc g.corrections + g.bbLog(state, h, bucket, total, best) + + if shiftDeg == 0.0: return base + tmhApplyShift(state.selfX, state.selfY, base.x, base.y, shiftDeg) + +proc onResult*(g: var BitBrainGun, e: FeedbackEvent) = + ## Labels come from our own observation ring, not from virtual-bullet + ## feedback, so there is nothing to do here. The hook exists for the rack. + discard diff --git a/common_libs/guns/tm_horizon.nim b/common_libs/guns/tm_horizon.nim index 7cc5613..7c6e8be 100644 --- a/common_libs/guns/tm_horizon.nim +++ b/common_libs/guns/tm_horizon.nim @@ -546,6 +546,19 @@ proc ringValidCount*(g: TmHorizonGun): int = for i in 0.. 0: + echo "\n", failures, " check(s) FAILED" + quit(1) +echo "\nAll BitBrain registration checks passed." diff --git a/common_libs/tests/test_rack_membership.nim b/common_libs/tests/test_rack_membership.nim index 38a1369..d40a628 100644 --- a/common_libs/tests/test_rack_membership.nim +++ b/common_libs/tests/test_rack_membership.nim @@ -158,14 +158,14 @@ proc testDefaultsOnlyPattern() = DefaultRackMembership[12] == rmOff and DefaultRackMembership[13] == rmOff and DefaultRackMembership[14] == rmOff check "defaults: the default rack admits ONLY Pattern in 1v1", - admittedGuns(15, rm1v1, DefaultRackMembership) == @[PatternId] + admittedGuns(17, rm1v1, DefaultRackMembership) == @[PatternId] check "defaults: the default rack admits ONLY Pattern in melee", - admittedGuns(15, rmMelee, DefaultRackMembership) == @[PatternId] + admittedGuns(17, rmMelee, DefaultRackMembership) == @[PatternId] let loaded = loadRackMembership() check "defaults: with a clean environment loadRackMembership() == shipped table", loaded == DefaultRackMembership - check "defaults: RackGunNames covers the shipped 16-gun rack", - RackGunNames.len == 16 and DefaultRackMembership.len == 16 + check "defaults: RackGunNames covers the shipped 17-gun rack", + RackGunNames.len == 17 and DefaultRackMembership.len == 17 proc testFloorRespectsAdmission() = ## The FLOOR path (`bestRate <= 0` or below the floor rate) historically fell @@ -212,8 +212,8 @@ proc testRevertOverrideRestoresFullRack() = let want = if i == 14: rmOff else: rmBoth if m[i] != want: full = false check "revert: the documented one-liner restores the all-`both` full rack", full - check "revert: 1v1 rack admits every gun again (all 14, TMPATTERN excluded)", - admittedGuns(15, rm1v1, m) == @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] + check "revert: 1v1 rack admits every gun again (TMPATTERN excluded)", + admittedGuns(17, rm1v1, m) == @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16] clearRackEnv() proc testEnvOverrides() = diff --git a/common_libs/tests/test_tm_pattern_registration.nim b/common_libs/tests/test_tm_pattern_registration.nim index f447059..db1a824 100644 --- a/common_libs/tests/test_tm_pattern_registration.nim +++ b/common_libs/tests/test_tm_pattern_registration.nim @@ -62,7 +62,7 @@ proc seedOldRack(t: var VirtualTracker, targetId: int) = # ── registration table ──────────────────────────────────────────────────────── proc testTable() = - check "rack: RackGunNames has 16 entries", RackGunNames.len == 16 + check "rack: RackGunNames has 17 entries", RackGunNames.len == 17 check "rack: the new gun is named TMPATTERN at id 14", RackGunNames[TmPatternId] == "TMPATTERN" check "rack: the new gun defaults to `off`", @@ -82,9 +82,9 @@ proc oldRackMembership(): array[15, RackMembership] = proc testDefaultAdmitsOnlyPattern() = check "default membership admits only PATTERN (1v1)", - admittedGuns(15, rm1v1, DefaultRackMembership) == @[PatternId] + admittedGuns(17, rm1v1, DefaultRackMembership) == @[PatternId] check "default membership admits only PATTERN (melee)", - admittedGuns(15, rmMelee, DefaultRackMembership) == @[PatternId] + admittedGuns(17, rmMelee, DefaultRackMembership) == @[PatternId] proc testEnvOverride() = for name in RackGunNames: delEnv("TR_RACK_" & name)