feat(combat): add aid another and run actions
This commit is contained in:
@@ -0,0 +1,517 @@
|
||||
"""The PF1e aid another and run actions (optional Package U5e).
|
||||
|
||||
``aid_another`` is a standard action: the aider (which must have a usable
|
||||
melee weapon) makes an attack roll — d20 + its first usable melee weapon's
|
||||
bonus — against AC 10 (natural 20 always succeeds, natural 1 always fails);
|
||||
on success the target stacks +2 on its next attack roll (``aid_mode``
|
||||
"attack"/None, consumed one-shot by ``resolve_attack``) or +2 AC against the
|
||||
next attack targeting it (``aid_mode`` "ac"). ``run`` is a full-round action
|
||||
moving up to 4x speed toward ``target_id`` or an explicit ``destination``,
|
||||
reusing the move machinery (Dijkstra descent, step-by-step AoO walk); it
|
||||
sets ``running``, which lasts until the runner's next turn and denies the
|
||||
runner its Dexterity bonus to AC (the flat-footed path). Both kinds are
|
||||
exposed through the U1 feedback contract (``missing_target`` when neither a
|
||||
target nor a destination is given) and the three runtime fields are additive
|
||||
snapshot keys. The transcript of a combat that uses neither is unchanged.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Callable
|
||||
|
||||
from pf1e_simulator.combat import (
|
||||
Action,
|
||||
ActionResult,
|
||||
CombatantState,
|
||||
CombatEngine,
|
||||
)
|
||||
from pf1e_simulator.dice import parse_dice
|
||||
from pf1e_simulator.grid import Grid
|
||||
from pf1e_simulator.map import MapSpec, TerrainType
|
||||
from pf1e_simulator.models import (
|
||||
AbilityScores,
|
||||
ACProfile,
|
||||
AttackSpec,
|
||||
Combatant,
|
||||
DamageComponent,
|
||||
Saves,
|
||||
)
|
||||
from pf1e_simulator.rng import ScriptedRng
|
||||
from tests.test_observation_enriched import _snapshot, make_grid, make_state
|
||||
|
||||
|
||||
def _combatant(
|
||||
id_: str,
|
||||
*,
|
||||
initiative_mod: int = 0,
|
||||
ac: int = 10,
|
||||
flat_ac: int | None = None,
|
||||
dex: int = 10,
|
||||
speed: int = 30,
|
||||
attack_bonus: int = 5,
|
||||
ranged: bool = False,
|
||||
) -> Combatant:
|
||||
weapon = AttackSpec(
|
||||
id=f"{id_}-{'bow' if ranged else 'sword'}",
|
||||
name="short bow" if ranged else "short sword",
|
||||
kind="ranged" if ranged else "melee",
|
||||
attack_bonus=attack_bonus,
|
||||
damage=[DamageComponent(formula=parse_dice("1d6"), types=["piercing"]
|
||||
if ranged else ["slashing"])],
|
||||
range_increment_ft=60 if ranged else None,
|
||||
)
|
||||
return Combatant(
|
||||
id=id_,
|
||||
name=id_,
|
||||
level=1,
|
||||
abilities=AbilityScores(
|
||||
str_score=10, dex_score=dex, con_score=10,
|
||||
int_score=10, wis_score=10, cha_score=10,
|
||||
),
|
||||
ac=ACProfile(total=ac, touch=ac, flat_footed=flat_ac if flat_ac is not None else ac),
|
||||
bab=1,
|
||||
initiative_mod=initiative_mod,
|
||||
speed_land_ft=speed,
|
||||
hp_max=100,
|
||||
saves=Saves(fort=0, ref=0, will=0),
|
||||
attacks=[weapon],
|
||||
)
|
||||
|
||||
|
||||
PolicyFn = Callable[[CombatEngine, CombatantState], tuple[Action, ...]]
|
||||
|
||||
_WAIT: tuple[Action, ...] = (Action(kind="wait"),)
|
||||
|
||||
|
||||
def _trio(
|
||||
policy: PolicyFn, rng: list[int], round_cap: int,
|
||||
) -> CombatEngine:
|
||||
"""hero (0,0) acts first, ally (3,3) second, foe (0,1) adjacent last."""
|
||||
hero = make_state(_combatant("hero", initiative_mod=2), "players", (0, 0))
|
||||
ally = make_state(_combatant("ally", initiative_mod=1), "players", (3, 3))
|
||||
foe = make_state(_combatant("foe"), "monsters", (0, 1))
|
||||
return CombatEngine(
|
||||
ScriptedRng(rng), make_grid(), [hero, ally, foe],
|
||||
policy=policy, round_cap=round_cap,
|
||||
)
|
||||
|
||||
|
||||
def _duo(
|
||||
policy: PolicyFn, rng: list[int], round_cap: int, *,
|
||||
hero: CombatantState | None = None,
|
||||
foe: CombatantState | None = None,
|
||||
grid: Grid | None = None,
|
||||
) -> CombatEngine:
|
||||
hero = hero or make_state(_combatant("hero", initiative_mod=2), "players", (0, 0))
|
||||
foe = foe or make_state(_combatant("foe"), "monsters", (0, 1))
|
||||
return CombatEngine(
|
||||
ScriptedRng(rng), grid or make_grid(), [hero, foe],
|
||||
policy=policy, round_cap=round_cap,
|
||||
)
|
||||
|
||||
|
||||
def _open_grid(size: int = 16) -> Grid:
|
||||
legend = {".": TerrainType(type="floor", move_cost=1)}
|
||||
spec = MapSpec(
|
||||
name="open", terrain=tuple(["." * size] * size), legend=legend,
|
||||
)
|
||||
return Grid.from_spec(spec)
|
||||
|
||||
|
||||
# ── (a) aid (attack): +2 on the ally's next attack, consumed one-shot ────────
|
||||
|
||||
|
||||
def test_aid_attack_bonus_grants_two_and_is_consumed() -> None:
|
||||
calls: dict[str, int] = {}
|
||||
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
cid = state.combatant.id
|
||||
n = calls.get(cid, 0)
|
||||
calls[cid] = n + 1
|
||||
if cid == "hero":
|
||||
if n == 0:
|
||||
return (Action(
|
||||
kind="ready", target_id="foe",
|
||||
ready_trigger="enemy_attacks",
|
||||
),)
|
||||
return (Action(kind="attack", target_id="foe"),)
|
||||
if cid == "ally":
|
||||
if n == 0:
|
||||
return (Action(
|
||||
kind="aid_another", target_id="hero", aid_mode="attack",
|
||||
),)
|
||||
return _WAIT
|
||||
if n == 0:
|
||||
return (Action(kind="attack", target_id="hero"),)
|
||||
return _WAIT
|
||||
|
||||
# Rolls: 3 initiatives; aid d20=10 (10+5=15 >= 10 success); foe attack
|
||||
# d20=4 (9 vs AC 10, miss); readied hero attack d20=3 (3+5+2=10, hit) +
|
||||
# d6=3; round-2 hero attack d20=3 (3+5=8, miss — bonus consumed); the
|
||||
# ally and the foe both wait in round 2 (no rolls).
|
||||
eng = _trio(policy, [10, 10, 10, 10, 4, 3, 3, 3], round_cap=2)
|
||||
t = eng.run().transcript
|
||||
|
||||
assert (
|
||||
"round 1 ally: aid another hero (attack) d20=10+5=15 vs AC 10 -> success"
|
||||
in t
|
||||
)
|
||||
assert "round 1 hero: ready fires (enemy_attacks)" in t
|
||||
# The readied attack that would miss by 2 (d20 3 + 5 = 8) hits with the +2.
|
||||
assert (
|
||||
"round 1 hero: short sword vs foe d20=3+5=10 AC 10 -> HIT 3 damage (100->97)"
|
||||
in t
|
||||
)
|
||||
hero = eng._states[0]
|
||||
assert hero.aid_attack_bonus == 0 # consumed by the readied attack
|
||||
# The second attack (round 2, same scripted d20) does not get the bonus.
|
||||
assert "round 2 hero: short sword vs foe d20=3+5=8 AC 10 -> MISS" in t
|
||||
assert eng._states[2].hp == 97
|
||||
assert hero.hp == 100
|
||||
|
||||
|
||||
def test_aid_attack_control_without_aid_misses() -> None:
|
||||
calls: dict[str, int] = {}
|
||||
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
cid = state.combatant.id
|
||||
n = calls.get(cid, 0)
|
||||
calls[cid] = n + 1
|
||||
if cid == "hero" and n == 0:
|
||||
return (Action(
|
||||
kind="ready", target_id="foe", ready_trigger="enemy_attacks",
|
||||
),)
|
||||
if cid == "foe" and n == 0:
|
||||
return (Action(kind="attack", target_id="hero"),)
|
||||
return _WAIT
|
||||
|
||||
# Same geometry, no aid: the readied d20=3+5=8 misses AC 10.
|
||||
eng = _trio(policy, [10, 10, 10, 4, 3], round_cap=1)
|
||||
t = eng.run().transcript
|
||||
assert "round 1 hero: short sword vs foe d20=3+5=8 AC 10 -> MISS" in t
|
||||
assert eng._states[0].aid_attack_bonus == 0
|
||||
assert eng._states[2].hp == 100
|
||||
|
||||
|
||||
# ── (b) aid (ac): +2 AC against the next attack targeting the ally ───────────
|
||||
|
||||
|
||||
def test_aid_ac_bonus_raises_ally_ac() -> None:
|
||||
calls: dict[str, int] = {}
|
||||
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
cid = state.combatant.id
|
||||
n = calls.get(cid, 0)
|
||||
calls[cid] = n + 1
|
||||
if cid == "ally" and n == 0:
|
||||
return (Action(kind="aid_another", target_id="hero", aid_mode="ac"),)
|
||||
if cid == "foe":
|
||||
return (Action(kind="attack", target_id="hero"),)
|
||||
return _WAIT
|
||||
|
||||
# Aid d20=10 success; foe attack d20=5+5=10 vs AC 10+2=12 -> MISS.
|
||||
eng = _trio(policy, [10, 10, 10, 10, 5], round_cap=1)
|
||||
t = eng.run().transcript
|
||||
assert (
|
||||
"round 1 ally: aid another hero (ac) d20=10+5=15 vs AC 10 -> success"
|
||||
in t
|
||||
)
|
||||
assert "round 1 foe: short sword vs hero d20=5+5=10 AC 12 -> MISS" in t
|
||||
hero = eng._states[0]
|
||||
assert hero.aid_ac_bonus == 2
|
||||
assert hero.aid_attack_bonus == 0
|
||||
assert hero.hp == 100
|
||||
|
||||
|
||||
def test_aid_ac_control_without_aid_hits() -> None:
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
if state.combatant.id == "foe":
|
||||
return (Action(kind="attack", target_id="hero"),)
|
||||
return _WAIT
|
||||
|
||||
eng = _trio(policy, [10, 10, 10, 5, 3], round_cap=1)
|
||||
t = eng.run().transcript
|
||||
assert (
|
||||
"round 1 foe: short sword vs hero d20=5+5=10 AC 10 -> HIT 3 damage (100->97)"
|
||||
in t
|
||||
)
|
||||
|
||||
|
||||
# ── (c) a failed aid roll grants nothing ─────────────────────────────────────
|
||||
|
||||
|
||||
def test_failed_aid_grants_nothing() -> None:
|
||||
calls: dict[str, int] = {}
|
||||
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
cid = state.combatant.id
|
||||
n = calls.get(cid, 0)
|
||||
calls[cid] = n + 1
|
||||
if cid == "ally" and n == 0:
|
||||
return (Action(kind="aid_another", target_id="hero", aid_mode="ac"),)
|
||||
if cid == "foe":
|
||||
return (Action(kind="attack", target_id="hero"),)
|
||||
return _WAIT
|
||||
|
||||
# Aid d20=2 + 5 = 7 < 10 -> fail; the foe's d20=5+5=10 then hits plain AC 10.
|
||||
eng = _trio(policy, [10, 10, 10, 2, 5, 3], round_cap=1)
|
||||
t = eng.run().transcript
|
||||
assert (
|
||||
"round 1 ally: aid another hero (ac) d20=2+5=7 vs AC 10 -> fail" in t
|
||||
)
|
||||
hero = eng._states[0]
|
||||
assert hero.aid_ac_bonus == 0
|
||||
assert hero.aid_attack_bonus == 0
|
||||
assert "round 1 foe: short sword vs hero d20=5+5=10 AC 10 -> HIT 3 damage (100->97)" in t
|
||||
assert hero.hp == 97
|
||||
|
||||
|
||||
# ── (d) run moves up to 4x speed (destination and target), sets running ──────
|
||||
|
||||
|
||||
def test_run_reaches_destination_beyond_normal_move() -> None:
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
if state.combatant.id == "hero":
|
||||
return (Action(kind="run", destination=(7, 7)),)
|
||||
return _WAIT
|
||||
|
||||
# Speed 30 ft = 6 cells; run = 24 cells; (0,0)->(7,7) costs 7 diagonals.
|
||||
# The foe sits at (7,0), far off the diagonal path — no AoO provokes.
|
||||
foe = make_state(_combatant("foe"), "monsters", (7, 0))
|
||||
eng = _duo(policy, [10, 5], round_cap=1, foe=foe)
|
||||
t = eng.run().transcript
|
||||
hero = eng._states[0]
|
||||
assert hero.pos == (7, 7)
|
||||
assert hero.running is True
|
||||
assert "round 1 hero: run" in t
|
||||
assert hero.last_action_results == [ActionResult(kind="run", ok=True, reason="ok")]
|
||||
|
||||
|
||||
def test_normal_move_cannot_reach_the_same_destination() -> None:
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
if state.combatant.id == "hero":
|
||||
return (Action(kind="move", destination=(7, 7)),)
|
||||
return _WAIT
|
||||
|
||||
eng = _duo(policy, [10, 5], round_cap=1)
|
||||
t = eng.run().transcript
|
||||
hero = eng._states[0]
|
||||
assert hero.pos == (0, 0) # 7 cells > the 6-cell speed budget
|
||||
assert "round 1 hero: move rejected (unreachable_destination)" in t
|
||||
assert hero.running is False
|
||||
# The run got strictly farther than the normal move.
|
||||
assert make_grid().distance((7, 7), (0, 0)) > make_grid().distance(hero.pos, (0, 0))
|
||||
|
||||
|
||||
def test_run_toward_target_outreaches_normal_move() -> None:
|
||||
grid = _open_grid(16)
|
||||
hero = make_state(_combatant("hero", initiative_mod=2), "players", (0, 0))
|
||||
foe = make_state(_combatant("foe"), "monsters", (15, 15))
|
||||
eng = _duo(
|
||||
lambda _e, s: (
|
||||
(Action(kind="run", target_id="foe"),)
|
||||
if s.combatant.id == "hero" else _WAIT
|
||||
),
|
||||
[10, 5], round_cap=1, hero=hero, foe=foe, grid=grid,
|
||||
)
|
||||
t = eng.run().transcript
|
||||
run_hero = eng._states[0]
|
||||
assert run_hero.pos == (14, 14) # stopped adjacent to the foe
|
||||
assert run_hero.running is True
|
||||
assert "round 1 hero: run" in t
|
||||
|
||||
hero2 = make_state(_combatant("hero", initiative_mod=2), "players", (0, 0))
|
||||
foe2 = make_state(_combatant("foe"), "monsters", (15, 15))
|
||||
eng2 = _duo(
|
||||
lambda _e, s: (
|
||||
(Action(kind="move", target_id="foe"),)
|
||||
if s.combatant.id == "hero" else _WAIT
|
||||
),
|
||||
[10, 5], round_cap=1, hero=hero2, foe=foe2, grid=grid,
|
||||
)
|
||||
eng2.run()
|
||||
move_hero = eng2._states[0]
|
||||
assert move_hero.pos == (6, 6) # only 6 cells of the 15-cell path
|
||||
assert grid.distance(run_hero.pos, foe.pos) < grid.distance(move_hero.pos, foe2.pos)
|
||||
|
||||
|
||||
# ── (e) a running combatant loses its Dex bonus to AC ────────────────────────
|
||||
|
||||
|
||||
def test_running_combatant_is_denied_dex_to_ac() -> None:
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
if state.combatant.id == "hero":
|
||||
return (Action(kind="run", destination=(0, 1)),)
|
||||
return (Action(kind="attack", target_id="hero"),)
|
||||
|
||||
# Hero: AC 14 (Dex +4) but flat-footed 10. Running denies the Dex bonus:
|
||||
# the foe's d20=5+5=10 hits AC 10 (the flat-footed value).
|
||||
hero = make_state(
|
||||
_combatant("hero", initiative_mod=2, ac=14, flat_ac=10, dex=18),
|
||||
"players", (0, 0),
|
||||
)
|
||||
foe = make_state(_combatant("foe"), "monsters", (0, 2))
|
||||
eng = _duo(policy, [10, 10, 5, 3], round_cap=1, hero=hero, foe=foe)
|
||||
t = eng.run().transcript
|
||||
assert "round 1 hero: run" in t
|
||||
assert (
|
||||
"round 1 foe: short sword vs hero d20=5+5=10 AC 10 -> HIT 3 damage (100->97)"
|
||||
in t
|
||||
)
|
||||
assert eng._states[0].hp == 97
|
||||
|
||||
|
||||
def test_not_running_combatant_keeps_dex_to_ac() -> None:
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
if state.combatant.id == "hero":
|
||||
return (Action(kind="move", destination=(0, 1)),)
|
||||
return (Action(kind="attack", target_id="hero"),)
|
||||
|
||||
# Same geometry, plain move (not running): the same roll misses AC 14.
|
||||
hero = make_state(
|
||||
_combatant("hero", initiative_mod=2, ac=14, flat_ac=10, dex=18),
|
||||
"players", (0, 0),
|
||||
)
|
||||
foe = make_state(_combatant("foe"), "monsters", (0, 2))
|
||||
eng = _duo(policy, [10, 10, 5], round_cap=1, hero=hero, foe=foe)
|
||||
t = eng.run().transcript
|
||||
assert "round 1 foe: short sword vs hero d20=5+5=10 AC 14 -> MISS" in t
|
||||
assert eng._states[0].hp == 100
|
||||
|
||||
|
||||
# ── (f) the snapshot exposes the three keys ──────────────────────────────────
|
||||
|
||||
|
||||
def test_snapshot_exposes_aid_and_run_keys() -> None:
|
||||
hero_snaps: list[dict[str, object]] = []
|
||||
first_hero_snap: dict[str, object] = {}
|
||||
|
||||
def policy(engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
cid = state.combatant.id
|
||||
if cid == "hero":
|
||||
obs = _snapshot(engine, state)
|
||||
mine = next(c for c in obs["combatants"] if c["id"] == "hero")
|
||||
first_hero_snap.update(mine)
|
||||
return (Action(kind="run", destination=(1, 0)),)
|
||||
if cid == "ally":
|
||||
return (Action(kind="aid_another", target_id="hero"),)
|
||||
obs = _snapshot(engine, state)
|
||||
hero_snaps.append(
|
||||
next(c for c in obs["combatants"] if c["id"] == "hero")
|
||||
)
|
||||
return _WAIT
|
||||
|
||||
hero = make_state(_combatant("hero", initiative_mod=2), "players", (0, 0))
|
||||
ally = make_state(_combatant("ally", initiative_mod=1), "players", (3, 3))
|
||||
foe = make_state(_combatant("foe"), "monsters", (0, 4))
|
||||
eng = CombatEngine(
|
||||
ScriptedRng([10, 10, 10, 10]), make_grid(), [hero, ally, foe],
|
||||
policy=policy, round_cap=1,
|
||||
)
|
||||
eng.run()
|
||||
|
||||
# Before any aid/run: the three keys exist with neutral defaults.
|
||||
assert first_hero_snap["aid_attack_bonus"] == 0
|
||||
assert first_hero_snap["aid_ac_bonus"] == 0
|
||||
assert first_hero_snap["running"] is False
|
||||
# After hero ran and the ally aided (default mode = attack): live values.
|
||||
assert len(hero_snaps) == 1
|
||||
assert hero_snaps[0]["aid_attack_bonus"] == 2
|
||||
assert hero_snaps[0]["aid_ac_bonus"] == 0
|
||||
assert hero_snaps[0]["running"] is True
|
||||
# A combatant that never used either keeps neutral values.
|
||||
foe_snap = _snapshot(eng, eng._states[2])
|
||||
foe_mine = next(c for c in foe_snap["combatants"] if c["id"] == "foe")
|
||||
assert foe_mine["aid_attack_bonus"] == 0
|
||||
assert foe_mine["aid_ac_bonus"] == 0
|
||||
assert foe_mine["running"] is False
|
||||
|
||||
|
||||
# ── (g) missing target/destination rejections (U1 path) ──────────────────────
|
||||
|
||||
|
||||
def test_run_and_aid_without_target_are_rejected() -> None:
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
if state.combatant.id == "hero":
|
||||
return (Action(kind="run"), Action(kind="aid_another"))
|
||||
return _WAIT
|
||||
|
||||
eng = _duo(policy, [10, 5], round_cap=1)
|
||||
t = eng.run().transcript
|
||||
hero = eng._states[0]
|
||||
assert hero.last_action_results == [
|
||||
ActionResult(kind="run", ok=False, reason="missing_target"),
|
||||
ActionResult(kind="aid_another", ok=False, reason="missing_target"),
|
||||
]
|
||||
assert "round 1 hero: run rejected (missing_target)" in t
|
||||
assert "round 1 hero: aid_another rejected (missing_target)" in t
|
||||
assert hero.pos == (0, 0)
|
||||
assert hero.running is False
|
||||
|
||||
|
||||
# ── (h) multiple aids stack (add, never replace) ─────────────────────────────
|
||||
|
||||
|
||||
def test_multiple_aids_stack() -> None:
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
if state.combatant.id in ("ally-1", "ally-2"):
|
||||
return (Action(kind="aid_another", target_id="hero"),)
|
||||
return _WAIT
|
||||
|
||||
hero = make_state(_combatant("hero", initiative_mod=3), "players", (0, 0))
|
||||
ally1 = make_state(_combatant("ally-1", initiative_mod=2), "players", (3, 3))
|
||||
ally2 = make_state(_combatant("ally-2", initiative_mod=1), "players", (4, 4))
|
||||
foe = make_state(_combatant("foe"), "monsters", (0, 1))
|
||||
eng = CombatEngine(
|
||||
ScriptedRng([10, 10, 10, 10, 10, 10]), make_grid(),
|
||||
[hero, ally1, ally2, foe], policy=policy, round_cap=1,
|
||||
)
|
||||
eng.run()
|
||||
assert hero.aid_attack_bonus == 4 # 2 + 2, added not replaced
|
||||
|
||||
|
||||
# ── (i) aid without a usable melee weapon is rejected ────────────────────────
|
||||
|
||||
|
||||
def test_aid_without_melee_weapon_is_rejected() -> None:
|
||||
def policy(_engine: CombatEngine, state: CombatantState) -> tuple[Action, ...]:
|
||||
if state.combatant.id == "helper":
|
||||
return (Action(kind="aid_another", target_id="hero"),)
|
||||
return _WAIT
|
||||
|
||||
hero = make_state(_combatant("hero", initiative_mod=2), "players", (0, 0))
|
||||
helper = make_state(
|
||||
_combatant("helper", ranged=True), "monsters", (3, 3),
|
||||
)
|
||||
# Only the two initiative rolls are consumed — the aid never reaches a d20.
|
||||
eng = _duo(policy, [10, 5], round_cap=1, hero=hero, foe=helper)
|
||||
t = eng.run().transcript
|
||||
assert "round 1 helper: aid_another rejected (no_weapon)" in t
|
||||
assert hero.aid_attack_bonus == 0
|
||||
assert hero.last_action_results == [
|
||||
ActionResult(kind="wait", ok=True, reason="ok")
|
||||
]
|
||||
assert helper.last_action_results == [
|
||||
ActionResult(kind="aid_another", ok=False, reason="no_weapon")
|
||||
]
|
||||
|
||||
|
||||
# ── (j) combats that use neither action are byte-identical ──────────────────
|
||||
|
||||
|
||||
def test_no_aid_or_run_transcript_is_pinned() -> None:
|
||||
eng = _duo(lambda _e, _s: _WAIT, [10, 5], round_cap=2)
|
||||
result = eng.run()
|
||||
|
||||
assert result.transcript == (
|
||||
"initiative: hero d20=10+2=12",
|
||||
"initiative: foe d20=5+0=5",
|
||||
"round 1 hero: wait",
|
||||
"round 1 foe: wait",
|
||||
"round 2 hero: wait",
|
||||
"round 2 foe: wait",
|
||||
"battle over: draw after 2 rounds",
|
||||
)
|
||||
for state in eng._states:
|
||||
assert state.aid_attack_bonus == 0
|
||||
assert state.aid_ac_bonus == 0
|
||||
assert state.running is False
|
||||
Reference in New Issue
Block a user