From 6fc01eb4e5e7e3bf2420fa48b5fcf1f913bb0058 Mon Sep 17 00:00:00 2001 From: Davide Cappellini Date: Sat, 22 Aug 2026 19:44:58 +0200 Subject: [PATCH] =?UTF-8?q?feat(SAC=5FLSTM=5FBot):=20campaign=20v2=20lever?= =?UTF-8?q?s=20=E2=80=94=20aggression/anti-ram=20reward=20shaping=20+=20st?= =?UTF-8?q?ability=20knob=20overrides=20(part=202)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Lever 2 (#59): x1.25 aggression mult on damage dealt, flat +0.5 hit bonus, -3.0 per bot-bot collision (server deals RAM_DAMAGE=0.6 to both parties but only notifies the hitter), escalating proximity deterrent below 12% arena diagonal suppressed while dealing damage. Win/loss terminals unchanged and dominant. All weights TUNABLE consts marked ponytail. SACLSTM_REWARD_DEBUG=1 env-gated reward_debug.log for calibration greps. Lever 5 (#59): no code needed — SACLSTM_LR_ACTOR/LR_CRITIC/LR_ALPHA (3e-4) and SACLSTM_TARGET_ENTROPY (-4.0) were already env-overridable in training.nim. Smoke vs RamFire+Crazy (hidden=32, random init, isolated weights): 75 ram penalties, 381 charge events, hit bonuses firing, 0 crashes, metrics JSONL flowing. Tests: 8/8 suites green incl. new assert-level term math. --- SAC_LSTM_Bot/src/SAC_LSTM_Bot.nim | 36 +++++++++++++++++++- SAC_LSTM_Bot/src/SAC_LSTM_Bot/rewards.nim | 29 +++++++++++++++- SAC_LSTM_Bot/tests/test_rewards.nim | 40 ++++++++++++++++++++--- 3 files changed, 98 insertions(+), 7 deletions(-) diff --git a/SAC_LSTM_Bot/src/SAC_LSTM_Bot.nim b/SAC_LSTM_Bot/src/SAC_LSTM_Bot.nim index 33d0988..3f5e636 100644 --- a/SAC_LSTM_Bot/src/SAC_LSTM_Bot.nim +++ b/SAC_LSTM_Bot/src/SAC_LSTM_Bot.nim @@ -67,7 +67,7 @@ type SacBot = ref object of Bot ticksSinceScan: int # per-step reward accumulators (consumed by the next tick's transition) dmgDealt, dmgTaken, wastedPower: float64 - wallHits: int + wallHits, hits, ramTaken: int # pending transition (episode spans the whole battle; round end is NOT a boundary) hasLastTrans: bool lastState: array[STATE_DIM, float32] @@ -96,13 +96,36 @@ proc tensorToHidden(t: Tensor[float32]; arr: var array[MaxHidden, float32]) = proc takeReward(bot: SacBot; win = false, loss = false): float32 = ## Consume accumulated step events -> Welford-normalized reward (#44). + ## Lever 2 (#59): pass enemy distance (frac of arena diagonal) for the + ## anti-charge term; sentinel 2.0 (> ChargeDistFrac) when no contact. + var distFrac = 2.0 + if bot.hasContact: + let diag = hypot(getArenaWidth().float64, getArenaHeight().float64) + distFrac = hypot(bot.enemy.x - getX(), bot.enemy.y - getY()) / diag let raw = computeReward( damageInflicted = bot.dmgDealt, damageReceived = bot.dmgTaken, wallHitTicks = bot.wallHits, wastedShotPower = bot.wastedPower, + hitCount = bot.hits, + ramTakenCount = bot.ramTaken, + enemyDistFrac = distFrac, win = win, loss = loss) + # Lever-2 (#59) observability: env-gated one-liner for smoke/calibration + # greps — proves hit/ram/charge terms fire and shows raw magnitudes. File + # (not stderr): the battle runner swallows bot process streams. + # ponytail: grows unbounded if left on; keep off outside smokes. + if getEnv("SACLSTM_REWARD_DEBUG") == "1" and + (bot.hits > 0 or bot.ramTaken > 0 or (distFrac < ChargeDistFrac and bot.dmgDealt <= 0.0)): + try: + let f = open(getWeightsPath().parentDir.parentDir / "reward_debug.log", fmAppend) + f.writeLine("raw=" & $raw & " hits=" & $bot.hits & " ram=" & $bot.ramTaken & + " distFrac=" & $distFrac) + f.close() + except CatchableError: + discard bot.dmgDealt = 0; bot.dmgTaken = 0; bot.wastedPower = 0; bot.wallHits = 0 + bot.hits = 0; bot.ramTaken = 0 let norm = rewards.normalize(bot.rn, raw) rewards.update(bot.rn, raw) norm.float32 @@ -157,10 +180,20 @@ method onScannedBot*(bot: SacBot, e: ScannedBotEvent) = method onBulletHit*(bot: SacBot, e: BulletHitBotEvent) = bot.dmgDealt += e.damage + inc bot.hits method onHitByBullet*(bot: SacBot, e: HitByBulletEvent) = bot.dmgTaken += e.damage +# Lever 2 (#59): anti-ram — every BotHitBotEvent receipt means a bot-bot +# collision happened and we ate RAM_DAMAGE (server deals 0.6 to both parties; +# only the hitter gets notified). Flat per-event penalty; being rammed without +# hitting back stays event-invisible. +# ponytail: enemy-initiated rams undetected — add energy-residual detection if +# v2 battle data shows ram-heavy losses. +method onHitBot*(bot: SacBot, e: BotHitBotEvent) = + inc bot.ramTaken + method onHitWall*(bot: SacBot, e: BotHitWallEvent) = inc bot.wallHits @@ -173,6 +206,7 @@ method onGameAborted*(bot: SacBot) = # next battle's data. bot.hasLastTrans = false bot.dmgDealt = 0; bot.dmgTaken = 0; bot.wastedPower = 0; bot.wallHits = 0 + bot.hits = 0; bot.ramTaken = 0 method onRoundEnded*(bot: SacBot, e: RoundEndedEventForBot) = ## Harness liveness signal (#49): RunTraining.java watches round_counter.txt diff --git a/SAC_LSTM_Bot/src/SAC_LSTM_Bot/rewards.nim b/SAC_LSTM_Bot/src/SAC_LSTM_Bot/rewards.nim index 6cbf925..a66ba05 100644 --- a/SAC_LSTM_Bot/src/SAC_LSTM_Bot/rewards.nim +++ b/SAC_LSTM_Bot/src/SAC_LSTM_Bot/rewards.nim @@ -3,6 +3,25 @@ import std/math +# ── Lever-2 shaping constants (#59, campaign v2) — TUNABLE ──────────────────── +# Scale discipline: commensurate with existing magnitudes (dealt p=1 was +4, +# wall tick -5/tick, win +20). Death/loss and win terms stay dominant; these +# only re-rank mid-band behaviors (fight vs outlive vs get-rammed). + +const + # Multiplier on the bullet-damage-dealt term: p=1 hit +4 -> +5. Low-power + # spam stays unprofitable (6*0.1-2 = -1.4 < 0 even after x1.25). + AggressionMult* = 1.25 # ponytail: TUNABLE — raise toward 1.5 if v2 bot still passivity-leaning + # Flat per landed shot on top of damage: discrete accuracy signal. + HitBonus* = 0.5 # ponytail: TUNABLE — keep < 6p-2 at min viable power (~0.34) + # Per bot-bot collision (BotHitBotEvent): server deals RAM_DAMAGE=0.6 to + # both parties but only notifies the hitter — each receipt = damage taken. + RamTakenPenalty* = 3.0 # ponytail: TUNABLE — vs p=0.8 bullet received (-6.8) + # Enemy-charging deterrent: distance/diagonal below this => escalating + # negative (max at zero distance), suppressed while we deal damage that step. + ChargeDistFrac* = 0.12 # ponytail: TUNABLE — ~120u of 800x600 diag (1000) + ChargePenalty* = 2.0 # ponytail: TUNABLE — per-tick ceiling, milder than wall (-5/tick) + # ── Raw reward ──────────────────────────────────────────────────────────────── proc computeReward*( @@ -10,6 +29,9 @@ proc computeReward*( damageReceived: float64 = 0.0, # fire power p_e of enemy shot that hit wallHitTicks: int = 0, # ticks in wall contact this step wastedShotPower: float64 = 0.0, # fire power of shot that missed/hit wall + hitCount: int = 0, # own bullets that hit the enemy this step (#59) + ramTakenCount: int = 0, # collisions where we were the victim (#59) + enemyDistFrac: float64 = 2.0, # enemy dist / arena diag; >ChargeDistFrac when no contact (#59) win: bool = false, loss: bool = false ): float64 = @@ -17,8 +39,13 @@ proc computeReward*( ## Damage formula: 4p + 2(p-1) = 6p - 2 (matches Tank Royale bullet rules). let p = damageInflicted let pe = damageReceived - if p > 0.0: result += 6.0 * p - 2.0 + if p > 0.0: + result += AggressionMult * (6.0 * p - 2.0) + if hitCount > 0: result += HitBonus * hitCount.float64 if pe > 0.0: result -= 6.0 * pe - 2.0 + result -= RamTakenPenalty * ramTakenCount.float64 + if enemyDistFrac < ChargeDistFrac and p <= 0.0: + result -= ChargePenalty * (1.0 - enemyDistFrac / ChargeDistFrac) result -= 5.0 * wallHitTicks.float64 if wastedShotPower > 0.0: result -= 0.1 * wastedShotPower if win: result += 20.0 diff --git a/SAC_LSTM_Bot/tests/test_rewards.nim b/SAC_LSTM_Bot/tests/test_rewards.nim index 7dec4f5..a947a7d 100644 --- a/SAC_LSTM_Bot/tests/test_rewards.nim +++ b/SAC_LSTM_Bot/tests/test_rewards.nim @@ -11,17 +11,46 @@ template check(cond: bool, msg: string) = # ── computeReward ───────────────────────────────────────────────────────────── block damageInflicted: - # p=1: 6*1 - 2 = 4 - check abs(computeReward(damageInflicted = 1.0) - 4.0) < 1e-9, "p=1 damage = +4" - # p=3: 6*3 - 2 = 16 - check abs(computeReward(damageInflicted = 3.0) - 16.0) < 1e-9, "p=3 damage = +16" + # p=1: 1.25 * (6*1 - 2) = 5 (lever 2 aggression mult, #59) + check abs(computeReward(damageInflicted = 1.0) - 5.0) < 1e-9, "p=1 damage = +5" + # p=3: 1.25 * (6*3 - 2) = 20 + check abs(computeReward(damageInflicted = 3.0) - 20.0) < 1e-9, "p=3 damage = +20" + # low-power spam stays unprofitable: 1.25*(6*0.1-2) < 0 + check computeReward(damageInflicted = 0.1) < 0.0, "p=0.1 spam still negative" block damageReceived: - # p_e=1: -(6*1 - 2) = -4 + # p_e=1: -(6*1 - 2) = -4 (unchanged by lever 2) check abs(computeReward(damageReceived = 1.0) - (-4.0)) < 1e-9, "p_e=1 received = -4" # p_e=3: -(6*3 - 2) = -16 check abs(computeReward(damageReceived = 3.0) - (-16.0)) < 1e-9, "p_e=3 received = -16" +block hitBonus: + # flat +0.5 per landed shot: p=1 hit -> 5.0 + 0.5 + check abs(computeReward(damageInflicted = 1.0, hitCount = 1) - 5.5) < 1e-9, + "p=1 hit = +5.5" + # two hits in one step: 1.25*(6*2-2) + 2*0.5 = 12.5 + 1.0 = 13.5 + check abs(computeReward(damageInflicted = 2.0, hitCount = 2) - 13.5) < 1e-9, + "two hits = +13.5" + +block ramTaken: + # flat per victim collision (#59) + check abs(computeReward(ramTakenCount = 1) - (-3.0)) < 1e-9, "ram taken x1 = -3" + check abs(computeReward(ramTakenCount = 2) - (-6.0)) < 1e-9, "ram taken x2 = -6" + +block chargeDeterrent: + # zero-damage case at half threshold depth: -2 * (1 - 0.06/0.12) = -1 + let rHalf = computeReward(enemyDistFrac = 0.06) + check abs(rHalf - (-1.0)) < 1e-9, "charge at frac 0.06 = -1" + # at zero distance: full ceiling + check abs(computeReward(enemyDistFrac = 0.0) - (-2.0)) < 1e-9, "charge at frac 0 = -2" + # at/beyond threshold and no-contact sentinel: no penalty + check abs(computeReward(enemyDistFrac = 0.12)) < 1e-9, "at threshold = 0" + check abs(computeReward(enemyDistFrac = 0.5)) < 1e-9, "beyond threshold = 0" + check abs(computeReward(enemyDistFrac = 2.0)) < 1e-9, "no-contact sentinel = 0" + # suppressed while dealing damage that step (fighting back at close range is fine) + let rFight = computeReward(damageInflicted = 1.0, enemyDistFrac = 0.06) + check abs(rFight - 5.0) < 1e-9, "dealing damage cancels charge penalty" + block wallHit: check abs(computeReward(wallHitTicks = 1) - (-5.0)) < 1e-9, "1 wall tick = -5" @@ -30,6 +59,7 @@ block wastedShot: check abs(computeReward(wastedShotPower = 2.0) - (-0.2)) < 1e-9, "missed p=2 = -0.2" block winLoss: + # terminal terms stay dominant over shaping (#59 scale discipline) check abs(computeReward(win = true) - 20.0) < 1e-9, "win = +20" check abs(computeReward(loss = true) - (-10.0)) < 1e-9, "loss = -10"