fix(scenario): def-counter-battery — recalibrate after engine movement fixes

openra_bench/scenarios/packs/def-counter-battery.yaml

@@ -48,13 +48,21 @@
 #     reached (the run ends the moment the fact falls, capping the
 #     kill count well below K) → LOSS.
 #
-#   • intended counter-battery strike (drive the tanks straight to
-#     the artillery, destroy ALL the guns FIRST, THEN mop up the
-#     infantry screen): the guns die in ~1-2 decision turns of
-#     concentrated tank fire (arty hp75 vs ~88-132 tank dps); once
-#     the battery is silent the fact stops taking damage and
-#     survives, and the strike force has the rest of the budget to
-#     clear the screen for the kill bar → WIN.
+#   • intended counter-battery strike (drive the tanks straight
+#     THROUGH the screen to the artillery, destroy ALL the guns
+#     FIRST, THEN mop up the infantry screen): post the engine
+#     movement fix, `attack_unit` no longer teleport-chases an
+#     out-of-sight target — it closes at the tank's real Mobile
+#     speed, identical to a plain `move`. The strike therefore has
+#     to PUSH THROUGH the passive screen with a straight move
+#     order; the moment the guns come into sight, concentrated
+#     tank fire silences the fragile battery (arty hp75) in ~1-2
+#     decision turns. Once the battery is silent the fact stops
+#     taking damage and survives, and the strike force spends the
+#     rest of the budget clearing the screen for the kill bar →
+#     WIN. A strike that STOPS to trade with the screen en route
+#     (an `attack_unit` on a screen rifleman) never reaches the
+#     guns in time — the artillery razes the fact first.
 #
 # WHY THE SPEC WORKS (engine combat sheet, per CLAUDE.md / prompt_v2):
 #   - `arty` = artillery: $600 hp75 rng7c dps45 sight5c. Range 7c
@@ -75,7 +83,12 @@
 #   - `2tnk` = medium tank: hp400 rng4.75c dps22. Four to six tanks
 #     concentrate enough fire to one-shot-class the fragile arty;
 #     infantry cannot meaningfully block tank movement, so the
-#     strike can drive through the screen to reach the guns.
+#     strike can drive THROUGH the screen to reach the guns — but
+#     only with a plain `move` order. Since the engine movement fix
+#     a moving tank fires opportunistically en route yet does NOT
+#     abandon its move, so the straight drive is not delayed by the
+#     passive screen; an explicit `attack_unit` on a screen unit,
+#     by contrast, halts the tanks to grind it.
 #   - The kill bar K is set ABOVE the number of kills a screen-first
 #     policy can rack up before the fact falls (the run ends on the
 #     fact's destruction), but BELOW the full enemy roster — the

tests/test_def_counter_battery.py

@@ -254,10 +254,21 @@ def _screen_first(rs, Command):
 
 
 def _counter_battery_strike(rs, Command):
-    """The intended play — drive the tanks toward the artillery and
-    attack_unit the guns FIRST (highest-impact threat); only once the
-    battery is silent mop up the infantry screen. Saving the fact
-    leaves the rest of the budget to clear the kill bar → WIN."""
+    """The intended play — drive the tanks PAST the infantry screen to
+    the rear battery and attack_unit the guns FIRST (highest-impact
+    threat); only once the battery is silent mop up the infantry
+    screen for the kill bar. Saving the fact leaves the rest of the
+    budget to clear the kill bar → WIN.
+
+    Post engine-movement-fix: `attack_unit` no longer teleport-chases
+    an out-of-sight target — it closes distance at the tank's real
+    Mobile speed. The strike must therefore PUSH THROUGH the screen
+    with `move_units` (a plain move, which the engine still resolves
+    at full speed) rather than `attack_unit`-ing a screen rifleman
+    en route — stopping to trade with the screen lets the artillery
+    raze the fact before the guns are reached. Only once the tanks
+    are deep east (past the screen column) and the guns are silenced
+    does the policy pivot to mopping the screen."""
     ts = _tanks(rs)
     if not ts:
         return [Command.observe()]
@@ -265,12 +276,31 @@ def _counter_battery_strike(rs, Command):
     ids = [str(t["id"]) for t in ts]
     artys = [e for e in es if str(e.get("type", "")).lower() == "arty"]
     if artys:
+        # Guns in sight — kill the battery FIRST, concentrated fire.
         return [Command.attack_unit(ids, str(artys[0]["id"]))]
+    ax = sum(t.get("cell_x", 0) for t in ts) / len(ts)
+    ay = int(sum(t["cell_y"] for t in ts) / len(ts))
+    if ax < 26:
+        # Still closing on the battery — drive STRAIGHT through the
+        # screen toward the rear (a plain move, not an attack order,
+        # so the tanks don't stop to grind the passive picket line).
+        return [Command.move_units(ids, 29, ay)]
+    # Deep east with no gun in sight — the battery is dead; mop the
+    # infantry screen for the kill bar.
     e1s = [e for e in es if str(e.get("type", "")).lower() == "e1"]
     if e1s:
         return [Command.attack_unit(ids, str(e1s[0]["id"]))]
+    return [Command.observe()]
+
+
+def _wrong_path(rs, Command):
+    """Wrong route — drive the tanks AWAY from the battery (back west).
+    The guns are never engaged; the artillery razes the fact → LOSS."""
+    ts = _tanks(rs)
+    if not ts:
+        return [Command.observe()]
     ay = int(sum(t["cell_y"] for t in ts) / len(ts))
-    return [Command.move_units(ids, 27, ay)]
+    return [Command.move_units([str(t["id"]) for t in ts], 8, ay)]
 
 
 @pytest.mark.parametrize("level", ["easy", "medium", "hard"])
@@ -333,3 +363,21 @@ def test_screen_first_loses(level, seed):
         f"razes the fact before the screen is cleared), got "
         f"{r.outcome} (kills={r.signals.units_killed})"
     )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+@pytest.mark.parametrize("seed", [1, 2, 3, 4])
+def test_wrong_path_loses(level, seed):
+    """The wrong-route play — driving the tanks away from the battery
+    instead of toward it — must LOSE on every level and seed: the guns
+    are never engaged and the artillery razes the fact."""
+    pytest.importorskip("openra_train")
+    from openra_bench.eval_core import run_level
+
+    c = compile_level(load_pack(PACK_PATH), level)
+    r = run_level(c, _wrong_path, seed=seed)
+    assert r.outcome == "loss", (
+        f"{level} seed={seed}: wrong-path must LOSE (the artillery "
+        f"razes the fact while the tanks drive the wrong way), got "
+        f"{r.outcome} (kills={r.signals.units_killed})"
+    )