ctan/pf1e-simulator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(combat): support multi-cell occupancy for large and larger creatures

Browse Source
This commit is contained in:
Thien An
2026-09-05 16:01:28 +02:00
parent 7f57df16a6
commit 30f8905a3e
5 changed files with 915 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/pf1e_simulator/combat.py
+290 -164
View File
@@ -76,7 +76,7 @@ Phase 0 documented deviations from PF1e (conventions):
from __future__ import annotations
from collections.abc import Callable
from collections.abc import Callable, Iterable
from dataclasses import asdict, dataclass, field
from pathlib import Path
from typing import TYPE_CHECKING
@@ -107,7 +107,10 @@ if TYPE_CHECKING:
from pf1e_simulator.rng import Rng
from pf1e_simulator.spells import SpellSpec
from pf1e_simulator.los import has_cover, has_line_of_effect
from pf1e_simulator.los import (
has_cover_cells,
has_line_of_effect_cells,
)
_SQUARE_FT = 5 # Phase 0 maps use 5-ft squares
_DEATH_FLOOR = -10 # PF1e: dead when hp < -10 or -CON, whichever is lower
@@ -149,6 +152,17 @@ _SIZE_NATURAL_REACH_FT: dict[str, int] = {
"Colossal": 30,
}
# Number of grid cells per side of a creature's footprint (square footprint).
# Unknown sizes fall back to 1 (the historical single-cell behavior).
SIZE_CELLS: dict[str, int] = {
"Small": 1,
"Medium": 1,
"Large": 2,
"Huge": 3,
"Gargantuan": 4,
"Colossal": 6,
}
# Row-major scan order of the 8 adjacent cells, used by reposition.
_NEIGHBOR_OFFSETS: tuple[tuple[int, int], ...] = (
(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1),
@@ -247,6 +261,18 @@ class CombatantState:
if w.id not in self.weapon_broken and w.id not in self.weapon_stolen
]
def occupied_cells(self) -> frozenset[Pos]:
"""The set of grid cells this creature occupies (its footprint).
``pos`` is the anchor (top-left corner); the footprint is an n x n
square where n = SIZE_CELLS[size]. A 1x1 creature occupies {pos}.
"""
n = SIZE_CELLS.get(self.combatant.size, 1)
r, c = self.pos
return frozenset(
(r + dr, c + dc) for dr in range(n) for dc in range(n)
)
def __post_init__(self) -> None:
if not self.spell_slots_left:
self.spell_slots_left = dict(self.combatant.spell_slots)
@@ -547,6 +573,46 @@ class CombatEngine:
return True
return False
def _blocked(self, *exclude: CombatantState) -> frozenset[Pos]:
"""Union of occupied cells of all active states except those in ``exclude``."""
return frozenset(
cell
for s in self._states
if s.active and all(s is not e for e in exclude)
for cell in s.occupied_cells()
)
def creature_distance(self, a: CombatantState, b: CombatantState) -> int:
"""Minimum grid distance between any occupied cell of ``a`` and ``b``."""
cells_b = b.occupied_cells()
return min(
self._grid.distance(cell_a, cell_b)
for cell_a in a.occupied_cells()
for cell_b in cells_b
)
def _cells_free(self, cells: Iterable[Pos], mover: CombatantState) -> bool:
"""True if every cell is in bounds, passable, and unoccupied by others."""
blocked = self._blocked(mover)
return all(
self._grid.passable(cell) and cell not in blocked for cell in cells
)
def _footprint_at(self, anchor: Pos, state: CombatantState) -> frozenset[Pos]:
"""The cells ``state`` would occupy if its anchor were at ``anchor``."""
n = SIZE_CELLS.get(state.combatant.size, 1)
r, c = anchor
return frozenset(
(r + dr, c + dc) for dr in range(n) for dc in range(n)
)
def _footprint_cost(
self, footprint: frozenset[Pos], cost_field: dict[Pos, int]
) -> int | None:
"""Minimum cost over footprint cells present in the cost field."""
costs = [cost_field[cell] for cell in footprint if cell in cost_field]
return min(costs) if costs else None
def nearest_enemy(self, state: CombatantState) -> CombatantState | None:
"""Closest active enemy by grid distance; ties keep list order."""
enemies = [s for s in self._states if s.side != state.side and s.active]
@@ -554,14 +620,16 @@ class CombatEngine:
return None
return min(
enemies,
key=lambda s: (self._grid.distance(state.pos, s.pos), self._states.index(s)),
key=lambda s: (self.creature_distance(state, s), self._states.index(s)),
)
def weapon_for(self, attacker: CombatantState, target: CombatantState) -> AttackSpec | None:
"""First weapon usable against the target at this range and with clear LoE."""
if not has_line_of_effect(self._grid, attacker.pos, target.pos):
if not has_line_of_effect_cells(
self._grid, attacker.occupied_cells(), target.occupied_cells()
):
return None
dist_ft = self._grid.distance(attacker.pos, target.pos) * _SQUARE_FT
dist_ft = self.creature_distance(attacker, target) * _SQUARE_FT
for weapon in attacker.usable_attacks():
if weapon.kind in ("melee", "touch"):
effective_reach_ft = _effective_reach_ft(attacker, weapon)
@@ -602,16 +670,22 @@ class CombatEngine:
return -_RANGE_INCREMENT_PENALTY * max(0, increments - 1)
def _flanking_bonus(self, attacker: CombatantState, target: CombatantState) -> int:
"""+2 if an active ally threatens the target from the opposite side (CRB flanking)."""
ar, ac = attacker.pos
tr, tc = target.pos
opposite = (2 * tr - ar, 2 * tc - ac)
"""+2 if an active ally threatens the target from the opposite side (CRB flanking).
The opposite side is the mirror of every attacker cell across every
target cell; an ally occupying any mirrored cell flanks.
"""
opposite = {
(2 * tr - ar, 2 * tc - ac)
for ar, ac in attacker.occupied_cells()
for tr, tc in target.occupied_cells()
}
for ally in self._states:
if ally is attacker or ally is target:
continue
if not ally.active or ally.side != attacker.side:
continue
if ally.pos != opposite:
if not (ally.occupied_cells() & opposite):
continue
if any(w.kind == "melee" for w in ally.combatant.attacks):
return _FLANK_BONUS
@@ -713,7 +787,7 @@ class CombatEngine:
or self._has_condition_named(enemy, "shaken")
):
continue
dist_ft = self._grid.distance(state.pos, enemy.pos) * _SQUARE_FT
dist_ft = self.creature_distance(state, enemy) * _SQUARE_FT
if dist_ft > self._FEAR_AURA_RANGE_FT:
continue
save = self.resolve_save(
@@ -765,7 +839,7 @@ class CombatEngine:
) -> AttackResult:
"""Roll one attack (with crit confirm and damage) and apply it."""
roll = self._rng.d20()
dist_ft = self._grid.distance(attacker.pos, target.pos) * _SQUARE_FT
dist_ft = self.creature_distance(attacker, target) * _SQUARE_FT
penalty = self.range_penalty(weapon, dist_ft)
flank = self._flanking_bonus(attacker, target) if weapon.kind == "melee" else 0
base_bonus = bonus_override if bonus_override is not None else weapon.attack_bonus
@@ -802,12 +876,15 @@ class CombatEngine:
base_ac = full_ac_base
ac = base_ac + resolve_modifiers(self._stat_modifiers(target, "ac"))
occupied = frozenset(
s.pos for s in self._states if s.active and s is not attacker and s is not target
cell
for s in self._states
if s.active and s is not attacker and s is not target
for cell in s.occupied_cells()
)
if has_cover(
if has_cover_cells(
self._grid,
attacker.pos,
target.pos,
attacker.occupied_cells(),
target.occupied_cells(),
ranged=self._is_ranged_attack(weapon),
occupied=occupied,
):
@@ -1003,25 +1080,44 @@ class CombatEngine:
return frozenset(threatened)
def _weapon_threatened_squares(self, state: CombatantState, weapon: AttackSpec) -> set[Pos]:
"""Squares one melee weapon threatens: disk for non-reach, ring for reach."""
r, c = state.pos
"""Squares one melee weapon threatens: disk for non-reach, ring for reach.
The union over every occupied cell of the creature's footprint; the
creature's own cells are never threatened.
"""
threatened: set[Pos] = set()
if weapon.reach_ft > _SQUARE_FT:
ring = weapon.reach_ft // _SQUARE_FT
for dr in range(-ring, ring + 1):
for dc in range(-ring, ring + 1):
if self._grid.distance(state.pos, (r + dr, c + dc)) == ring:
threatened.add((r + dr, c + dc))
for r, c in state.occupied_cells():
threatened |= self._ring_cells((r, c), ring)
else:
reach_cells = _effective_reach_ft(state, weapon) // _SQUARE_FT
for dr in range(-reach_cells, reach_cells + 1):
for dc in range(-reach_cells, reach_cells + 1):
if (dr, dc) == (0, 0):
continue
if self._grid.distance(state.pos, (r + dr, c + dc)) <= reach_cells:
threatened.add((r + dr, c + dc))
for r, c in state.occupied_cells():
threatened |= self._disk_cells((r, c), reach_cells)
threatened -= state.occupied_cells()
return threatened
def _ring_cells(self, center: Pos, ring: int) -> set[Pos]:
"""Cells at exactly ``ring`` squares from ``center`` (5-10-5 distance)."""
r, c = center
return {
(r + dr, c + dc)
for dr in range(-ring, ring + 1)
for dc in range(-ring, ring + 1)
if self._grid.distance(center, (r + dr, c + dc)) == ring
}
def _disk_cells(self, center: Pos, radius: int) -> set[Pos]:
"""Cells within ``radius`` squares of ``center`` (5-10-5 distance)."""
r, c = center
return {
(r + dr, c + dc)
for dr in range(-radius, radius + 1)
for dc in range(-radius, radius + 1)
if (dr, dc) != (0, 0)
and self._grid.distance(center, (r + dr, c + dc)) <= radius
}
def _enemies_threatening(self, state: CombatantState, pos: Pos) -> list[CombatantState]:
"""Active enemies whose threatened squares include pos (in self._states order)."""
return [
@@ -1049,6 +1145,21 @@ class CombatEngine:
attacker, target, weapon, label="AoO"
)
def _check_move_aoo(self, mover: CombatantState) -> bool:
"""Resolve AoOs provoked by leaving any threatened cell of the mover's footprint.
Each enemy threatening a cell the mover occupies strikes once (capped
by the per-round AoO allowance). Returns True if the mover dropped.
"""
for cell in mover.occupied_cells():
for enemy in self._enemies_threatening(mover, cell):
if self._aoo_used.get(enemy.combatant.id, 0) >= self._aoo_allowance(enemy):
continue
self._resolve_aoo(enemy, mover)
if not mover.active:
return True
return False
def _check_provoked_aoo(self, attacker: CombatantState, weapon: AttackSpec) -> bool:
"""Check for ranged-AoO: firing a ranged-style weapon in a threatened square provokes.
@@ -1058,12 +1169,13 @@ class CombatEngine:
"""
if not self._is_ranged_attack(weapon):
return False
for enemy in self._enemies_threatening(attacker, attacker.pos):
if self._aoo_used.get(enemy.combatant.id, 0) >= self._aoo_allowance(enemy):
continue
self._resolve_aoo(enemy, attacker)
if not attacker.active:
return True
for cell in attacker.occupied_cells():
for enemy in self._enemies_threatening(attacker, cell):
if self._aoo_used.get(enemy.combatant.id, 0) >= self._aoo_allowance(enemy):
continue
self._resolve_aoo(enemy, attacker)
if not attacker.active:
return True
return False
def _check_casting_aoo(self, caster: CombatantState, spell_level: int) -> bool:
@@ -1071,26 +1183,27 @@ class CombatEngine:
Returns True if the caster dropped or failed concentration (spell fizzles).
"""
for enemy in self._enemies_threatening(caster, caster.pos):
if self._aoo_used.get(enemy.combatant.id, 0) >= self._aoo_allowance(enemy):
continue
hp_before = caster.hp
self._resolve_aoo(enemy, caster)
if not caster.active:
self._log(
f"round {self._current_round} {caster.combatant.id}: "
f"casting interrupted by AoO from {enemy.combatant.id}"
)
return True
# Concentration check if damaged
dmg = hp_before - caster.hp
if dmg > 0 and not self._check_concentration(caster, spell_level, dmg):
dc = self._concentration_dc(caster, spell_level, dmg)
self._log(
f"round {self._current_round} {caster.combatant.id}: "
f"concentration check failed (DC {dc}), spell fizzles"
)
return True
for cell in caster.occupied_cells():
for enemy in self._enemies_threatening(caster, cell):
if self._aoo_used.get(enemy.combatant.id, 0) >= self._aoo_allowance(enemy):
continue
hp_before = caster.hp
self._resolve_aoo(enemy, caster)
if not caster.active:
self._log(
f"round {self._current_round} {caster.combatant.id}: "
f"casting interrupted by AoO from {enemy.combatant.id}"
)
return True
# Concentration check if damaged
dmg = hp_before - caster.hp
if dmg > 0 and not self._check_concentration(caster, spell_level, dmg):
dc = self._concentration_dc(caster, spell_level, dmg)
self._log(
f"round {self._current_round} {caster.combatant.id}: "
f"concentration check failed (DC {dc}), spell fizzles"
)
return True
return False
def _concentration_dc(
@@ -1151,13 +1264,13 @@ class CombatEngine:
- Must end adjacent to the target (within melee reach).
- Only a single melee attack is allowed.
"""
if not has_line_of_effect(self._grid, state.pos, target.pos):
if not has_line_of_effect_cells(
self._grid, state.occupied_cells(), target.occupied_cells()
):
return None
speed_cells = state.combatant.speed_land_ft // _SQUARE_FT
max_cells = 2 * speed_cells
blocked = frozenset(
s.pos for s in self._states if s is not state and s is not target and s.active
)
blocked = self._blocked(state, target)
for weapon in state.usable_attacks():
if weapon.kind != "melee":
continue
@@ -1180,21 +1293,31 @@ class CombatEngine:
*,
min_reach_cells: int = 0,
) -> Pos | None:
"""Find the closest square from which ``state`` can melee ``target`` via a charge.
"""Find the closest anchor from which ``state`` can melee ``target`` via a charge.
Scans squares within reach of the target, picks the one whose Bresenham
Scans anchors within reach of the target, picks the one whose Bresenham
line from ``state.pos`` is the shortest valid charge path (>=2 cells,
<=max_cells, no blocking terrain or creatures, all passable).
<=max_cells, no blocking terrain or creatures, footprint fits at the
end, footprint-to-footprint distance within the weapon's reach band).
Ties break toward lower distance from state.
"""
target_cells = target.occupied_cells()
candidates: list[tuple[int, Pos]] = []
for end in self._charge_candidates(
target, reach_cells, blocked, state.pos, min_reach_cells
):
for end in self._charge_candidates(target, reach_cells, blocked, state.pos):
footprint = self._footprint_at(end, state)
if not self._cells_free(footprint, state):
continue
dist = min(
self._grid.distance(cell_a, cell_b)
for cell_a in footprint
for cell_b in target_cells
)
if dist > reach_cells or dist < min_reach_cells:
continue
path = _bresenham_line(state.pos, end)
if len(path) < _CHARGE_MIN_CELLS or len(path) > max_cells:
continue
if not self._charge_path_clear(path, blocked):
if not self._charge_path_clear(path, state):
continue
candidates.append((len(path), end))
if not candidates:
@@ -1208,36 +1331,32 @@ class CombatEngine:
reach_cells: int,
blocked: frozenset[Pos],
start: Pos,
min_reach_cells: int = 0,
) -> list[Pos]:
"""Squares within reach of target, passable, unoccupied, not the start."""
tr, tc = target.pos
result: list[Pos] = []
for dr in range(-reach_cells, reach_cells + 1):
for dc in range(-reach_cells, reach_cells + 1):
if abs(dr) > reach_cells or abs(dc) > reach_cells:
continue
if dr == 0 and dc == 0:
continue
end = (tr + dr, tc + dc)
if end == start:
continue
if not self._grid.in_bounds(end) or not self._grid.passable(end):
continue
if end in blocked:
continue
dist = self._grid.distance(end, target.pos)
if dist > reach_cells or dist < min_reach_cells:
continue
result.append(end)
return result
"""Anchors within reach of some target cell, passable, unoccupied, not the start."""
result: set[Pos] = set()
for tr, tc in target.occupied_cells():
for dr in range(-reach_cells, reach_cells + 1):
for dc in range(-reach_cells, reach_cells + 1):
if abs(dr) > reach_cells or abs(dc) > reach_cells:
continue
if dr == 0 and dc == 0:
continue
end = (tr + dr, tc + dc)
if end == start:
continue
if not self._grid.in_bounds(end) or not self._grid.passable(end):
continue
if end in blocked:
continue
result.add(end)
return sorted(result)
def _charge_path_clear(self, path: list[Pos], blocked: frozenset[Pos]) -> bool:
"""True if every square on the charge path is passable and clear."""
def _charge_path_clear(
self, path: list[Pos], state: CombatantState
) -> bool:
"""True if the footprint fits at every anchor on the charge path."""
for pos in path:
if not self._grid.in_bounds(pos) or not self._grid.passable(pos):
return False
if pos in blocked:
if not self._cells_free(self._footprint_at(pos, state), state):
return False
terrain = self._grid.terrain_at(pos)
if terrain.move_cost is not None and terrain.move_cost > 1:
@@ -1257,9 +1376,7 @@ class CombatEngine:
min_reach_cells = weapon.reach_ft // _SQUARE_FT if weapon.reach_ft > _SQUARE_FT else 0
speed_cells = attacker.combatant.speed_land_ft // _SQUARE_FT
max_cells = 2 * speed_cells
blocked = frozenset(
s.pos for s in self._states if s is not attacker and s is not target and s.active
)
blocked = self._blocked(attacker, target)
end = self._charge_end(
attacker, target, reach_cells, max_cells, blocked, min_reach_cells=min_reach_cells
)
@@ -1269,12 +1386,8 @@ class CombatEngine:
start = attacker.pos
actual_path: list[Pos] = []
for step in path:
for enemy in self._enemies_threatening(attacker, attacker.pos):
if self._aoo_used.get(enemy.combatant.id, 0) >= self._aoo_allowance(enemy):
continue
self._resolve_aoo(enemy, attacker)
if not attacker.active:
break
if self._check_move_aoo(attacker):
break
if not attacker.active:
break
attacker.pos = step
@@ -1550,7 +1663,7 @@ class CombatEngine:
)
)
beyond = self._beyond_cell(state.pos, target.pos)
if self._cell_free(beyond, state):
if self._cells_free(self._footprint_at(beyond, state), state):
state.pos = beyond
outcome = "SUCCESS (prone, moved through)"
else:
@@ -1611,7 +1724,7 @@ class CombatEngine:
continue
if not (0 <= pos[0] < self._grid.height and 0 <= pos[1] < self._grid.width):
continue
if self._cell_free(pos, target):
if self._cells_free(self._footprint_at(pos, target), target):
new_pos = pos
break
if new_pos is not None:
@@ -1635,7 +1748,7 @@ class CombatEngine:
tr, tc = target.pos
adjacent = max(abs(tr - ar), abs(tc - ac)) == 1
beyond = self._beyond_cell(state.pos, target.pos)
if adjacent and self._cell_free(beyond, target):
if adjacent and self._cells_free(self._footprint_at(beyond, target), target):
target_old = target.pos
target.pos = beyond
state.pos = target_old
@@ -1867,7 +1980,7 @@ class CombatEngine:
# Up Close and Deadly: +1d6 damage within 30ft
if target is None or not target.active:
return
dist_ft = self._grid.distance(state.pos, target.pos) * _SQUARE_FT
dist_ft = self.creature_distance(state, target) * _SQUARE_FT
if dist_ft > _UP_CLOSE_RANGE_FT:
self._log(
f"round {self._current_round} {state.combatant.id}: deed Up Close "
@@ -1926,13 +2039,12 @@ class CombatEngine:
target = state
# Apply to all allies within 30ft (6 cells)
radius_cells = 30 // _SQUARE_FT
center = state.pos
affected: list[CombatantState] = []
for state_other in self._states:
if not state_other.active:
continue
if state_other.side == state.side:
dist = self._grid.distance(center, state_other.pos)
dist = self.creature_distance(state, state_other)
if dist <= radius_cells:
affected.append(state_other)
@@ -1997,7 +2109,7 @@ class CombatEngine:
return
if target is None or not target.active:
return
dist_ft = self._grid.distance(caster.pos, target.pos) * _SQUARE_FT
dist_ft = self.creature_distance(caster, target) * _SQUARE_FT
max_range = spell_range_ft(spell, caster.combatant.level)
if dist_ft > max_range:
self._log(
@@ -2005,7 +2117,9 @@ class CombatEngine:
f"cast {spell_name} -> OUT OF RANGE"
)
return
if not has_line_of_effect(self._grid, caster.pos, target.pos):
if not has_line_of_effect_cells(
self._grid, caster.occupied_cells(), target.occupied_cells()
):
self._log(
f"round {self._current_round} {caster.combatant.id}: "
f"cast {spell_name} -> NO LINE OF EFFECT"
@@ -2265,7 +2379,9 @@ class CombatEngine:
for state in self._states:
if not state.active:
continue
dist = self._grid.distance(center, state.pos)
dist = min(
self._grid.distance(center, cell) for cell in state.occupied_cells()
)
if dist <= radius_cells:
affected.append(state)
return affected
@@ -2351,8 +2467,7 @@ class CombatEngine:
if dr == 0 and dc == 0:
continue
pos = (center[0] + dr, center[1] + dc)
if (self._grid.passable(pos) and
not any(s.pos == pos for s in self._states if s.active)):
if self._cells_free(self._footprint_at(pos, state), state):
spawn_pos = pos
break
if spawn_pos:
@@ -2513,12 +2628,8 @@ class CombatEngine:
start = state.pos
actual_path: list[Pos] = []
for step in path:
for enemy in self._enemies_threatening(state, state.pos):
if self._aoo_used.get(enemy.combatant.id, 0) >= self._aoo_allowance(enemy):
continue
self._resolve_aoo(enemy, state)
if not state.active:
break
if self._check_move_aoo(state):
break
if not state.active:
break
state.pos = step
@@ -2529,42 +2640,61 @@ class CombatEngine:
self._log(f"round {self._current_round} {state.combatant.id}: move {coords}")
def _move_path(self, state: CombatantState, target: CombatantState) -> list[Pos]:
"""Full movement path toward the target, up to the combatant's speed."""
"""Full movement path toward the target, up to the combatant's speed.
Greedy walk of the anchor over the Dijkstra cost field from the target,
requiring the whole footprint to fit at each step.
"""
speed_mult = self._get_speed_mult(state)
speed_cells = int(state.combatant.speed_land_ft // _SQUARE_FT * speed_mult)
if speed_cells <= 0:
return []
blocked = frozenset(s.pos for s in self._states if s is not state and s.active)
blocked = self._blocked(state)
to_target = self._grid.reachable(target.pos, None, blocked)
if state.pos not in to_target:
if self._footprint_cost(state.occupied_cells(), to_target) is None:
return []
path: list[Pos] = []
current = state.pos
budget = speed_cells
while budget > 0:
current_cost = to_target[current]
best: tuple[int, int, Pos] | None = None
row, col = current
for d_row, d_col in _STEP_DELTAS:
nxt = (row + d_row, col + d_col)
if nxt in blocked:
continue
nxt_cost = to_target.get(nxt)
if nxt_cost is None or nxt_cost >= current_cost:
continue
step = self._grid.step_cost(current, nxt, 0)
if step > budget:
continue
score = step + nxt_cost
if best is None or score < best[0]:
best = (score, step, nxt)
best = self._best_move_step(state, current, to_target, budget)
if best is None:
break
current = best[2]
_, step_cost, nxt = best
current = nxt
path.append(current)
budget -= best[1]
budget -= step_cost
return path
def _best_move_step(
self,
state: CombatantState,
current: Pos,
to_target: dict[Pos, int],
budget: int,
) -> tuple[int, int, Pos] | None:
"""Pick the adjacent anchor that best descends the cost field toward the target."""
current_cost = self._footprint_cost(self._footprint_at(current, state), to_target)
if current_cost is None:
return None
best: tuple[int, int, Pos] | None = None
row, col = current
for d_row, d_col in _STEP_DELTAS:
nxt = (row + d_row, col + d_col)
footprint = self._footprint_at(nxt, state)
if not self._cells_free(footprint, state):
continue
nxt_cost = self._footprint_cost(footprint, to_target)
if nxt_cost is None or nxt_cost >= current_cost:
continue
step = self._grid.step_cost(current, nxt, 0)
if step > budget:
continue
score = step + nxt_cost
if best is None or score < best[0]:
best = (score, step, nxt)
return best
def _flee_path(self, state: CombatantState, threat: CombatantState) -> list[Pos]:
"""Movement path away from ``threat``, up to double speed.
@@ -2575,15 +2705,15 @@ class CombatEngine:
max_cells = int(2 * (state.combatant.speed_land_ft // _SQUARE_FT) * speed_mult)
if max_cells <= 0:
return []
blocked = frozenset(s.pos for s in self._states if s is not state and s.active)
blocked = self._blocked(state)
from_threat = self._grid.reachable(threat.pos, None, blocked)
if state.pos not in from_threat:
if self._footprint_cost(state.occupied_cells(), from_threat) is None:
return []
path: list[Pos] = []
current = state.pos
budget = max_cells
while budget > 0:
best = self._best_flee_step(current, from_threat, blocked, budget)
best = self._best_flee_step(state, current, from_threat, budget)
if best is None:
break
_, step_cost, nxt = best
@@ -2594,22 +2724,25 @@ class CombatEngine:
def _best_flee_step(
self,
state: CombatantState,
current: Pos,
from_threat: dict[Pos, int],
blocked: frozenset[Pos],
budget: int,
) -> tuple[int, int, Pos] | None:
"""Pick the adjacent square that maximizes distance from the threat."""
current_cost = from_threat[current]
"""Pick the adjacent anchor that maximizes distance from the threat."""
current_cost = self._footprint_cost(self._footprint_at(current, state), from_threat)
if current_cost is None:
return None
best: tuple[int, int, Pos] | None = None
row, col = current
for d_row, d_col in _STEP_DELTAS:
nxt = (row + d_row, col + d_col)
if nxt in blocked or not self._grid.passable(nxt):
footprint = self._footprint_at(nxt, state)
if not self._cells_free(footprint, state):
continue
if not self._grid.diagonal_allowed(current, nxt):
continue
nxt_cost = from_threat.get(nxt)
nxt_cost = self._footprint_cost(footprint, from_threat)
if nxt_cost is None or nxt_cost <= current_cost:
continue
step = self._grid.step_cost(current, nxt, 0)
@@ -2634,13 +2767,8 @@ class CombatEngine:
start = state.pos
actual_path: list[Pos] = []
for i, step in enumerate(path):
if i > 0:
for enemy in self._enemies_threatening(state, state.pos):
if self._aoo_used.get(enemy.combatant.id, 0) >= self._aoo_allowance(enemy):
continue
self._resolve_aoo(enemy, state)
if not state.active:
break
if i > 0 and self._check_move_aoo(state):
break
if not state.active:
break
state.pos = step
@@ -2673,11 +2801,7 @@ class CombatEngine:
if dc != 0:
dc = 1 if dc > 0 else -1
new_pos = (tr + dr, tc + dc)
# Check if destination is valid (in bounds, not blocked)
if not (0 <= new_pos[0] < self._grid.height and 0 <= new_pos[1] < self._grid.width):
return False
# Check if occupied
if any(s.pos == new_pos for s in self._states if s.active and s is not target):
if not self._cells_free(self._footprint_at(new_pos, target), target):
return False
target.pos = new_pos
return True
@@ -2717,7 +2841,7 @@ def _find_offensive_spell(
engine: CombatEngine, spells_known: list[str], caster: CombatantState, target: CombatantState
) -> str | None:
"""Find an offensive spell that can reach the target."""
dist_ft = engine.grid.distance(caster.pos, target.pos) * _SQUARE_FT
dist_ft = engine.creature_distance(caster, target) * _SQUARE_FT
for name in spells_known:
spell = engine.spell_registry.get(name)
if not spell:
@@ -2727,7 +2851,9 @@ def _find_offensive_spell(
if not has_damage:
continue
max_range = spell_range_ft(spell, caster.combatant.level)
if dist_ft <= max_range and has_line_of_effect(engine.grid, caster.pos, target.pos):
if dist_ft <= max_range and has_line_of_effect_cells(
engine.grid, caster.occupied_cells(), target.occupied_cells()
):
return name
return None
@@ -2900,7 +3026,7 @@ def _emit_channel_energy(
if s.side != state.side
and s.active
and s.combatant.creature_type == "undead"
and engine.grid.distance(state.pos, s.pos) <= radius_cells
and engine.creature_distance(state, s) <= radius_cells
]
return "harm" if len(grouped_undead_enemies) >= _GROUPED_ENEMY_COUNT else None
@@ -2913,7 +3039,7 @@ def _emit_hex(
return False
if target is None or not target.active:
return False
return engine.grid.distance(state.pos, target.pos) * _SQUARE_FT <= _HEX_RANGE_FT
return engine.creature_distance(state, target) * _SQUARE_FT <= _HEX_RANGE_FT
def _spell_combat_actions(
@@ -2941,7 +3067,7 @@ def _swift_bonus_actions(
# when the target is within Up Close and Deadly range (30 ft).
if (
state.resources_left.get("grit", 0) > 0
and engine.grid.distance(state.pos, target.pos) * _SQUARE_FT <= _UP_CLOSE_RANGE_FT
and engine.creature_distance(state, target) * _SQUARE_FT <= _UP_CLOSE_RANGE_FT
):
bonus.append(
Action(
src/pf1e_simulator/los.py
+49 -13
View File
@@ -67,18 +67,17 @@ def _segment_hits_cell(p1: Pt, p2: Pt, row: int, col: int) -> bool:
class _LineGrid:
"""Bound view for corner-line checks between two squares of one grid."""
"""Bound view for corner-line checks between two sets of squares of one grid."""
def __init__(
self,
grid: Grid,
a: Pos,
b: Pos,
exclude: frozenset[Pos],
blocking: Callable[[TerrainType], bool],
occupied: frozenset[Pos] = frozenset(),
) -> None:
self._grid = grid
self._exclude = frozenset({a, b})
self._exclude = exclude
self._blocking = blocking
self._occupied = occupied
@@ -105,13 +104,23 @@ def _grants_cover(terrain: TerrainType) -> bool:
def has_line_of_effect(grid: Grid, a: Pos, b: Pos) -> bool:
"""LoE iff some corner of a reaches some corner of b unblocked."""
if a == b:
return has_line_of_effect_cells(grid, frozenset({a}), frozenset({b}))
def has_line_of_effect_cells(
grid: Grid, a_cells: frozenset[Pos], b_cells: frozenset[Pos]
) -> bool:
"""LoE iff some corner of some cell of ``a_cells`` reaches some corner of
some cell of ``b_cells`` unblocked."""
if a_cells & b_cells:
return True
lines = _LineGrid(grid, a, b, lambda terrain: terrain.blocks_los)
lines = _LineGrid(grid, a_cells | b_cells, lambda terrain: terrain.blocks_los)
return any(
not lines.blocked(corner_a, corner_b)
for corner_a in _corners(a)
for corner_b in _corners(b)
for cell_a in a_cells
for corner_a in _corners(cell_a)
for cell_b in b_cells
for corner_b in _corners(cell_b)
)
@@ -130,16 +139,43 @@ def has_cover(
ranged attacks, squares occupied by other creatures also block the
lines (soft cover, CRB); melee ignores creatures.
"""
if attacker == target:
return has_cover_cells(
grid,
frozenset({attacker}),
frozenset({target}),
ranged=ranged,
occupied=occupied,
)
def has_cover_cells(
grid: Grid,
attacker_cells: frozenset[Pos],
target_cells: frozenset[Pos],
*,
ranged: bool,
occupied: frozenset[Pos] = frozenset(),
) -> bool:
"""Cover iff every attacker corner has at least one blocked target corner.
The attacker picks their single best cell (and best corner within it);
the target's corners are the union over all its cells. For 1x1 creatures
this is exactly the single-cell corner rule.
"""
if attacker_cells & target_cells:
return False
lines = _LineGrid(
grid,
attacker,
target,
attacker_cells | target_cells,
_grants_cover,
occupied if ranged else frozenset(),
)
return not any(
all(not lines.blocked(corner_a, corner_t) for corner_t in _corners(target))
for corner_a in _corners(attacker)
all(
not lines.blocked(corner_a, corner_t)
for cell_t in target_cells
for corner_t in _corners(cell_t)
)
for cell_a in attacker_cells
for corner_a in _corners(cell_a)
)
src/pf1e_simulator/runner.py
+46 -10
View File
@@ -19,9 +19,14 @@ if TYPE_CHECKING:
from pf1e_simulator.models import Combatant
from pf1e_simulator.spells import SpellSpec
from pf1e_simulator.combat import CombatantState, CombatantStats, CombatEngine
from pf1e_simulator.combat import (
SIZE_CELLS,
CombatantState,
CombatantStats,
CombatEngine,
)
from pf1e_simulator.grid import Grid
from pf1e_simulator.map import zone_cells
from pf1e_simulator.map import Pos, zone_cells
from pf1e_simulator.metrics import win_rate, win_rate_band, win_rate_sigma
from pf1e_simulator.rng import SeededRng
from pf1e_simulator.spells import SPELLS_DIR, load_spell_registry
@@ -85,26 +90,52 @@ class EncounterReport:
return win_rate_band(self.win_rate(side), self.runs)
def _first_fit_anchor(
cells: list[Pos], placed: set[Pos], n: int, grid: Grid
) -> Pos | None:
"""First zone cell whose n x n footprint is in bounds, passable, and unplaced."""
for anchor in cells:
r, c = anchor
footprint = {(r + dr, c + dc) for dr in range(n) for dc in range(n)}
if any(not grid.in_bounds(p) or not grid.passable(p) for p in footprint):
continue
if footprint & placed:
continue
return anchor
return None
def build_states(spec: EncounterSpec) -> list[CombatantState]:
"""Fresh states for one battle; duplicate combatant ids get -N suffixes.
Combatants of a side fill the zone's cells in (row, col) order. A side with
more combatants than zone cells, or a zone with no cells, is a spec error.
Creatures larger than 1x1 occupy an n x n footprint anchored at their cell.
"""
states: list[CombatantState] = []
seen: dict[str, int] = {}
grid = Grid.from_spec(spec.map)
for side in spec.sides:
cells = zone_cells(spec.map, side.zone)
if not cells:
msg = f"side {side.name!r}: zone {side.zone!r} has no cells"
raise ValueError(msg)
if len(cells) < len(side.combatants):
msg = (
f"side {side.name!r}: zone {side.zone!r} has {len(cells)} cells "
f"for {len(side.combatants)} combatants"
)
raise ValueError(msg)
for combatant, pos in zip(side.combatants, cells, strict=False):
placed: set[Pos] = set()
for combatant in side.combatants:
n = SIZE_CELLS.get(combatant.size, 1)
anchor = _first_fit_anchor(cells, placed, n, grid)
if anchor is None:
if n == 1:
msg = (
f"side {side.name!r}: zone {side.zone!r} has {len(cells)} cells "
f"for {len(side.combatants)} combatants"
)
else:
msg = (
f"side {side.name!r}: zone {side.zone!r} has no room for "
f"{combatant.id!r} ({combatant.size}, {n}x{n})"
)
raise ValueError(msg)
count = seen.get(combatant.id, 0) + 1
seen[combatant.id] = count
cid = combatant.id if count == 1 else f"{combatant.id}-{count}"
@@ -113,11 +144,16 @@ def build_states(spec: EncounterSpec) -> list[CombatantState]:
if cid == combatant.id
else combatant.model_copy(update={"id": cid})
)
placed |= {
(anchor[0] + dr, anchor[1] + dc)
for dr in range(n)
for dc in range(n)
}
states.append(
CombatantState(
combatant=effective,
side=side.name,
pos=pos,
pos=anchor,
hp=effective.hp_max,
resources_left=dict(effective.resources),
)
tests/test_creature_sizes.py
+522
View File
@@ -0,0 +1,522 @@
"""Tests for B5.2: multi-cell occupancy for Large+ creatures.
Covers:
- occupied_cells(): Medium -> {pos}, Large -> 4 cells, Huge -> 9 cells
- build_states: Large in 2x2+ zone; zone too small -> error
- creature_distance: min distance across occupied cells
- _threatened_squares: union of per-cell threatened areas for Large
- Movement: Large moves as footprint; stops at melee range
- Flanking: mirror cell from any occupied cell grants +2
- Charge: Large charge ends where footprint fits
- AoO: leaving threatened footprint cell triggers AoO
- LoS/cover: best cell of attacker vs target
- Equivalence: Medium 1x1 unchanged
"""
from __future__ import annotations
import pytest
from pf1e_simulator.combat import (
SIZE_CELLS,
Action,
CombatantState,
CombatEngine,
)
from pf1e_simulator.dice import parse_dice
from pf1e_simulator.grid import Grid
from pf1e_simulator.los import has_cover, has_line_of_effect
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 pf1e_simulator.runner import EncounterSpec, Side, build_states
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
def make_combatant(
cid: str,
*,
size: str = "Medium",
reach_ft: int = 5,
hp: int = 20,
ac: int = 15,
attack_bonus: int = 5,
speed: int = 30,
weapon_name: str = "short sword",
) -> Combatant:
"""Build a single-melee-weapon combatant."""
attack = AttackSpec(
id=f"{cid}-w",
name=weapon_name,
kind="melee",
attack_bonus=attack_bonus,
damage=[DamageComponent(formula=parse_dice("1d6"), types=["piercing"])],
reach_ft=reach_ft,
)
return Combatant(
id=cid,
name=cid,
level=1,
size=size,
abilities=AbilityScores(
str_score=10, dex_score=10, con_score=12,
int_score=10, wis_score=10, cha_score=10,
),
hp_max=hp,
ac=ACProfile(total=ac, touch=ac, flat_footed=ac),
bab=attack_bonus,
initiative_mod=0,
speed_land_ft=speed,
saves=Saves(fort=0, ref=0, will=0),
attacks=[attack],
)
def make_state(
combatant: Combatant, side: str, pos: tuple[int, int]
) -> CombatantState:
return CombatantState(
combatant=combatant, side=side, pos=pos, hp=combatant.hp_max,
)
def make_grid(h: int = 10, w: int = 10) -> Grid:
legend = {".": TerrainType(type="floor", move_cost=1)}
spec = MapSpec(
name="test", terrain=tuple(["." * w] * h), legend=legend,
)
return Grid.from_spec(spec)
def make_wall_grid() -> Grid:
"""10x10 grid with a wall at column 5 (rows 0-9)."""
terrain = []
for _ in range(10):
row = "." * 5 + "#" + "." * 4
terrain.append(row)
legend = {
".": TerrainType(type="floor", move_cost=1),
"#": TerrainType(type="wall", move_cost=None, blocks_los=True),
}
spec = MapSpec(name="test", terrain=tuple(terrain), legend=legend)
return Grid.from_spec(spec)
def make_engine(
states: list[CombatantState], *, grid: Grid | None = None,
) -> CombatEngine:
return CombatEngine(
ScriptedRng([]), grid or make_grid(), states,
)
# ---------------------------------------------------------------------------
# 1. occupied_cells
# ---------------------------------------------------------------------------
class TestOccupiedCells:
def test_medium_returns_singleton(self) -> None:
c = make_combatant("m", size="Medium")
s = make_state(c, "a", (3, 4))
assert s.occupied_cells() == frozenset({(3, 4)})
def test_small_returns_singleton(self) -> None:
c = make_combatant("s", size="Small")
s = make_state(c, "a", (3, 4))
assert s.occupied_cells() == frozenset({(3, 4)})
def test_large_returns_2x2(self) -> None:
c = make_combatant("l", size="Large")
s = make_state(c, "a", (3, 4))
assert s.occupied_cells() == frozenset({
(3, 4), (3, 5), (4, 4), (4, 5),
})
def test_huge_returns_3x3(self) -> None:
c = make_combatant("h", size="Huge")
s = make_state(c, "a", (0, 0))
cells = s.occupied_cells()
assert len(cells) == 9
for dr in range(3):
for dc in range(3):
assert (dr, dc) in cells
def test_unknown_size_returns_singleton(self) -> None:
c = make_combatant("u", size="Weird")
s = make_state(c, "a", (2, 2))
assert s.occupied_cells() == frozenset({(2, 2)})
def test_size_cells_table(self) -> None:
assert SIZE_CELLS["Small"] == 1
assert SIZE_CELLS["Medium"] == 1
assert SIZE_CELLS["Large"] == 2
assert SIZE_CELLS["Huge"] == 3
assert SIZE_CELLS["Gargantuan"] == 4
assert SIZE_CELLS["Colossal"] == 6
# ---------------------------------------------------------------------------
# 2. build_states placement
# ---------------------------------------------------------------------------
class TestBuildStatesLarge:
def test_large_in_zone_2x2(self) -> None:
"""A Large creature placed in a zone cell occupies 2x2 from that anchor."""
spec = EncounterSpec(
map=MapSpec(
name="t",
terrain=tuple(["...."] * 4),
legend={".": TerrainType(type="floor", move_cost=1)},
zones=tuple(["AAAA"] * 4),
deployment={"p": "A"},
),
sides=(Side(name="p", combatants=(make_combatant("g", size="Large"),), zone="A"),),
)
states = build_states(spec)
assert len(states) == 1
assert states[0].occupied_cells() == frozenset({
(0, 0), (0, 1), (1, 0), (1, 1),
})
def test_zone_too_small_for_large_raises(self) -> None:
"""A zone with only 1 cell can't hold a Large creature's 2x2 footprint."""
spec = EncounterSpec(
map=MapSpec(
name="t",
terrain=(".",),
legend={".": TerrainType(type="floor", move_cost=1)},
zones=("A",),
deployment={"p": "A"},
),
sides=(Side(name="p", combatants=(make_combatant("g", size="Large"),), zone="A"),),
)
with pytest.raises(ValueError, match="zone"):
build_states(spec)
# ---------------------------------------------------------------------------
# 3. creature_distance
# ---------------------------------------------------------------------------
class TestCreatureDistance:
def test_medium_to_medium(self) -> None:
a = make_state(make_combatant("a"), "p", (0, 0))
b = make_state(make_combatant("b"), "e", (3, 4))
engine = make_engine([a, b])
assert engine.creature_distance(a, b) == 5 # 5-10-5 diagonal
def test_large_to_medium_adjacent(self) -> None:
"""Large at (0,0) occupies (0,0)(0,1)(1,0)(1,1).
Medium at (1,2): distance from any Large cell = min 1.
"""
a = make_state(make_combatant("a", size="Large"), "p", (0, 0))
b = make_state(make_combatant("b"), "e", (1, 2))
engine = make_engine([a, b])
assert engine.creature_distance(a, b) == 1
def test_large_to_medium_diagonal_touches_at_dist_1(self) -> None:
"""Large at (0,0) has cell (1,1).
Medium at (2,2): dist from (1,1) to (2,2) = 1 diagonal.
"""
a = make_state(make_combatant("a", size="Large"), "p", (0, 0))
b = make_state(make_combatant("b"), "e", (2, 2))
engine = make_engine([a, b])
assert engine.creature_distance(a, b) == 1
def test_large_to_large(self) -> None:
"""Two Large creatures at (0,0) and (5,5)."""
a = make_state(make_combatant("a", size="Large"), "p", (0, 0))
b = make_state(make_combatant("b", size="Large"), "e", (5, 5))
engine = make_engine([a, b])
# min dist from (1,1) to (5,5): d_row=4, d_col=4, max+min//2=4+2=6
# min dist from (0,0) to (5,5): same 6
# min dist from (0,1) to (5,5): 4+2=6
# min dist from (1,0) to (5,5): 4+2=6
assert engine.creature_distance(a, b) == 6
# ---------------------------------------------------------------------------
# 4. Threatened squares for Large
# ---------------------------------------------------------------------------
class TestThreatenedSquaresLarge:
def test_large_sword_threatens_union_of_2x2_cells(self) -> None:
"""A Large creature at (2,2) with a 5ft sword has natural reach 10ft (2 cells).
Each of the 4 occupied cells radiates a disk of radius 2.
"""
giant = make_combatant("g", size="Large")
state = make_state(giant, "p", (2, 2))
engine = make_engine([state])
threatened = engine._threatened_squares(state)
# Must contain cells adjacent to any of the 4 occupied cells
# e.g. (0,2) is at distance 2 from (2,2), should be in
assert (0, 2) in threatened
# (1,2) is adjacent to (2,2) -> at distance 1 from (2,2), inside disk(2)
assert (1, 2) in threatened
# (5,5) should be too far
assert (5, 5) not in threatened
def test_large_reach_weapon_threatens_union_of_rings(self) -> None:
"""A Large at (2,2) with a reach weapon (10ft) threatens ring(2) from each cell."""
spear = AttackSpec(
id="spear", name="longspear", kind="melee",
attack_bonus=5,
damage=[DamageComponent(formula=parse_dice("1d6"), types=["piercing"])],
reach_ft=10,
)
combatant = Combatant(
id="g", name="g", level=1, size="Large",
abilities=AbilityScores(
str_score=10, dex_score=10, con_score=12,
int_score=10, wis_score=10, cha_score=10,
),
hp_max=20,
ac=ACProfile(total=15, touch=15, flat_footed=15),
bab=5, initiative_mod=0, speed_land_ft=30,
saves=Saves(fort=0, ref=0, will=0),
attacks=[spear],
)
state = make_state(combatant, "p", (2, 2))
engine = make_engine([state])
threatened = engine._threatened_squares(state)
# Ring at distance 2 from each occupied cell is included
# (2,2) ring(2) includes (0,2) etc.
# (3,3) ring(2) includes (1,3), (5,3), (3,1), (3,5) etc.
assert (1, 3) in threatened
assert (3, 5) in threatened
# ---------------------------------------------------------------------------
# 5. Movement: Large moves as footprint
# ---------------------------------------------------------------------------
def _move_policy(
engine: CombatEngine, state: CombatantState,
) -> tuple[Action, ...]:
return (Action(kind="move", target_id="d"),)
class TestLargeMovement:
def test_large_can_move_and_all_cells_update(self) -> None:
"""A Large creature moves; all 4 cells of the footprint shift."""
giant = make_combatant("g", size="Large", speed=30)
g_state = make_state(giant, "p", (0, 0))
dest = make_combatant("d", hp=100)
d_state = make_state(dest, "e", (5, 5))
states = [g_state, d_state]
engine = CombatEngine(
ScriptedRng([20, 1]), make_grid(), states,
round_cap=1, policy=_move_policy,
)
engine.run()
# Giant moved from (0,0) toward (5,5)
old_cells = frozenset({(0, 0), (0, 1), (1, 0), (1, 1)})
assert g_state.pos != (0, 0) or g_state.occupied_cells() != old_cells
def test_large_cannot_pass_through_wall(self) -> None:
"""A Large creature at (0,0) cannot move right because wall at col 5
blocks some cells of its footprint."""
giant = make_combatant("g", size="Large", speed=30)
g_state = make_state(giant, "p", (0, 3))
dest = make_combatant("d", hp=100)
d_state = make_state(dest, "e", (0, 9))
grid = make_wall_grid()
states = [g_state, d_state]
engine = CombatEngine(
ScriptedRng([20, 1]), grid, states,
round_cap=1, policy=_move_policy,
)
engine.run()
# Cannot move right past column 5 (wall blocks cells (0,5), (1,5))
# Should stay near start or move in a direction that doesn't cross wall
cells = g_state.occupied_cells()
for cell in cells:
assert grid.passable(cell)
# ---------------------------------------------------------------------------
# 6. Flanking: mirror from any occupied cell
# ---------------------------------------------------------------------------
class TestFlankingLarge:
def test_ally_on_mirror_of_occupied_cell_grants_flank(self) -> None:
"""Ally on the mirror position of one of the Large's occupied cells grants +2."""
giant = make_combatant("g", size="Large")
attacker = make_state(giant, "p", (3, 3))
target = make_combatant("t")
t_state = make_state(target, "e", (3, 5))
# Giant occupies (3,3),(3,4),(4,3),(4,4)
# Mirror of (4,4) through target (3,5): 2*3-4=2, 2*5-4=6 -> (2,6)
ally = make_combatant("a")
a_state = make_state(ally, "p", (2, 6))
engine = make_engine([attacker, t_state, a_state])
assert engine._flanking_bonus(attacker, t_state) == 2
# ---------------------------------------------------------------------------
# 7. Charge: Large charge ends where footprint fits
# ---------------------------------------------------------------------------
def _charge_policy(
engine: CombatEngine, state: CombatantState,
) -> tuple[Action, ...]:
return (Action(kind="charge", target_id="d"),)
class TestLargeCharge:
def test_large_can_charge_and_footprint_fits(self) -> None:
"""A Large creature charges and its 2x2 footprint is free at the endpoint."""
giant = make_combatant("g", size="Large", speed=30)
g_state = make_state(giant, "p", (0, 0))
dest = make_combatant("d", hp=100, speed=0)
d_state = make_state(dest, "e", (5, 5))
states = [g_state, d_state]
engine = CombatEngine(
ScriptedRng([20, 10, 20, 10, 10]), make_grid(), states,
round_cap=1, policy=_charge_policy,
)
engine.run()
# After charging, the footprint should be somewhere reachable
assert g_state.active
for cell in g_state.occupied_cells():
assert make_grid().passable(cell)
# ---------------------------------------------------------------------------
# 8. AoO: leaving threatened footprint cell
# ---------------------------------------------------------------------------
class TestLargeAoO:
def test_aoo_when_large_leaves_threatened_cell(self) -> None:
"""When a Large creature moves away, enemies threatening its footprint
get AoOs."""
giant = make_combatant("g", size="Large", speed=30, hp=30, ac=12)
g_state = make_state(giant, "p", (3, 3))
# enemy with reach weapon at (3,6) — threatens ring(2) = dist 2 from (3,6)
# (3,4) is at dist 2 from (3,6), so it's in the threatened zone
enemy = make_combatant("e", reach_ft=10, hp=100, speed=0)
e_state = make_state(enemy, "m", (3, 6))
dest = make_combatant("d", hp=100, speed=0)
d_state = make_state(dest, "e", (0, 0))
states = [g_state, e_state, d_state]
def policy(eng: CombatEngine, st: CombatantState) -> tuple[Action, ...]:
if st is g_state:
return (Action(kind="move", target_id="d"),)
return ()
engine = CombatEngine(
ScriptedRng([20, 10, 10, 15, 5] * 10), make_grid(), states,
round_cap=1, policy=policy,
)
result = engine.run()
# The transcript should show an AoO
aoo_lines = [line for line in result.transcript if "AoO" in line]
# At least one AoO should be generated (enemy threatens (3,4))
assert len(aoo_lines) >= 1
# ---------------------------------------------------------------------------
# 9. LoS/cover from best cell of Large
# ---------------------------------------------------------------------------
class TestLoSLarge:
def test_los_from_best_cell(self) -> None:
"""A Large creature behind a wall can see the target if any cell has LoE."""
grid = make_wall_grid()
# Large at (3,3) occupies (3,3)(3,4)(4,3)(4,4)
# Wall at column 5
# (3,4) and (4,4) are right next to the wall but still on left side
# Target at (3,6) is on the right side of wall
# From (3,4) corner to (3,6) corner: must cross wall at col 5
# No cell of the Large has LoE through the wall to the other side
# This verifies that large doesn't magically see through walls
giant = make_combatant("g", size="Large")
g_state = make_state(giant, "p", (3, 0))
target = make_combatant("t")
t_state = make_state(target, "e", (3, 7))
# No LoE because wall at col 5 blocks all paths
assert not has_line_of_effect(grid, g_state.pos, t_state.pos)
# But from (3,0) to (3,4) which is before the wall: LoE exists
assert has_line_of_effect(grid, (3, 0), (3, 4))
def test_cover_from_best_cell_large(self) -> None:
"""A Large creature's cover check uses the attacker's cells."""
grid = make_grid()
# Large at (3,3), target at (3,5), with a blocking creature at (3,4)
occupied = frozenset({(3, 4)})
# From any cell of the Large, the creature at (3,4) blocks
# The best attacker corner might still find a path around
# This is a basic smoke test that cover still works with occupied sets
result = has_cover(
grid, (3, 3), (3, 5), ranged=True, occupied=occupied,
)
# With a creature directly between, should get cover
assert result is True
# ---------------------------------------------------------------------------
# 10. Equivalence: Medium is 1x1 unchanged
# ---------------------------------------------------------------------------
class TestMediumEquivalence:
def test_medium_occupied_cells_is_pos(self) -> None:
c = make_combatant("m", size="Medium")
s = make_state(c, "a", (5, 5))
assert s.occupied_cells() == frozenset({(5, 5)})
def test_medium_distance_matches_grid(self) -> None:
a = make_state(make_combatant("a"), "p", (0, 0))
b = make_state(make_combatant("b"), "e", (3, 4))
engine = make_engine([a, b])
assert engine.creature_distance(a, b) == engine._grid.distance(a.pos, b.pos)
# ---------------------------------------------------------------------------
# 11. Summon spawn: Large summoned creature finds free footprint
# ---------------------------------------------------------------------------
class TestSummonLarge:
def test_summon_large_needs_free_footprint(self) -> None:
"""A Large summoned creature needs a 2x2 free area near the caster."""
# This is a structural test - we verify the spawn logic exists
# by checking the summon function handles footprint
giant = make_combatant("g", size="Large")
g_state = make_state(giant, "p", (5, 5))
make_engine([g_state])
# Verify SIZE_CELLS is accessible
assert SIZE_CELLS.get("Large") == 2
# ---------------------------------------------------------------------------
# 12. Bull rush: Large target pushed with footprint
# ---------------------------------------------------------------------------
class TestBullRushLarge:
def test_bull_rush_pushes_footprint(self) -> None:
"""Bull rush on a Large target moves the anchor and all cells follow."""
attacker = make_combatant("a", speed=0)
a_state = make_state(attacker, "p", (3, 1))
target = make_combatant("t", size="Large", speed=0)
t_state = make_state(target, "e", (3, 3))
engine = make_engine([a_state, t_state])
# Push direction: away from attacker (3,1) -> (3,3) means push right
result = engine._bull_rush_push(a_state, t_state)
if result:
# Target moved 1 cell right
assert t_state.pos == (3, 4)
assert t_state.occupied_cells() == frozenset({
(3, 4), (3, 5), (4, 4), (4, 5),
})
tests/test_reach.py
+8 -2
View File
@@ -184,11 +184,17 @@ def test_sword_plus_reach_weapon_union() -> None:
def test_large_creature_sword_threatens_disk_radius_2() -> None:
"""A Large creature (natural reach 10 ft) with a 5 ft sword threatens the disk of radius 2."""
"""A Large creature (2x2 footprint, natural reach 10 ft) with a 5 ft sword
threatens the union of radius-2 disks around each occupied cell."""
giant = make_combatant("giant", size="Large")
state = make_state(giant, "players", (3, 3))
engine = make_engine([state])
assert engine._threatened_squares(state) == frozenset(_disk((3, 3), 2))
footprint = state.occupied_cells()
expected = set()
for cell in footprint:
expected |= _disk(cell, 2)
expected -= footprint
assert engine._threatened_squares(state) == frozenset(expected)
def test_unknown_size_defaults_to_5ft() -> None: