393 lines
14 KiB
Python
393 lines
14 KiB
Python
"""Deterministic combat engine: attacks, crits, DR, hp states, initiative, rounds.
|
|
|
|
Phase 0 documented deviations from PF1e (conventions):
|
|
- One action per turn: move OR attack (no move+attack, no AoO, no flanking).
|
|
- A weapon with `count` > 1 ("2x Talons") resolves `count` independent attacks
|
|
in one attack action; remaining swings are lost once the target drops
|
|
(down or dead) mid-routine. BAB iterative attacks are not modeled.
|
|
- Natural 1 always misses; natural 20 always hits and threatens a crit.
|
|
- A confirmed crit multiplies the total damage (dice + flat bonus) by crit_mult.
|
|
- DR applies once, after crit multiplication; any bypassing type defeats DR.
|
|
- Death when hp < min(-10, -CON); hp <= 0 cannot act.
|
|
- Initiative ties: higher initiative_mod first, then list order (no re-roll).
|
|
- Movement: one step per move action toward the nearest enemy, following the
|
|
true shortest path (Dijkstra cost field from the target); ties keep delta order.
|
|
- Line of effect gates all attacks: a target fully behind blocking terrain
|
|
cannot be attacked, and the policy moves to gain sight instead.
|
|
- Cover (corner rule) grants +4 AC on hit and crit-confirm rolls; melee and
|
|
ranged reuse the same corner rule. Soft cover: active creatures between
|
|
attacker and target also grant +4 AC on ranged attacks (CRB soft cover);
|
|
melee attacks ignore creatures.
|
|
- Ranged: cumulative -2 per full range increment beyond the first, up to 10
|
|
range increments; the penalty applies to attack and crit-confirm rolls.
|
|
Thrown weapons (5 increments max) are not distinguished.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Callable
|
|
from dataclasses import asdict, dataclass
|
|
from typing import TYPE_CHECKING
|
|
|
|
if TYPE_CHECKING:
|
|
from typing import Literal
|
|
|
|
from pf1e_simulator.grid import Grid
|
|
from pf1e_simulator.map import Pos
|
|
from pf1e_simulator.models import AttackSpec, Combatant, DamageReduction
|
|
from pf1e_simulator.rng import Rng
|
|
|
|
from pf1e_simulator.los import has_cover, has_line_of_effect
|
|
|
|
_SQUARE_FT = 5 # Phase 0 maps use 5-ft squares
|
|
_DEATH_FLOOR = -10 # PF1e: dead when hp < -10 or -CON, whichever is lower
|
|
_NATURAL_ONE = 1 # PF1e: natural 1 always misses
|
|
_NATURAL_TWENTY = 20 # PF1e: natural 20 always hits and threatens
|
|
_COVER_AC_BONUS = 4 # PF1e: partial cover grants +4 AC
|
|
_RANGE_INCREMENT_PENALTY = 2 # PF1e: -2 per full range increment beyond the first
|
|
_MAX_RANGE_INCREMENTS = 10 # PF1e: projectile weapons shoot up to 10 increments
|
|
|
|
_STEP_DELTAS: tuple[Pos, ...] = (
|
|
(-1, -1),
|
|
(-1, 0),
|
|
(-1, 1),
|
|
(0, -1),
|
|
(0, 1),
|
|
(1, -1),
|
|
(1, 0),
|
|
(1, 1),
|
|
)
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class CombatantStats:
|
|
"""Aggregated outcomes for one combatant over a battle."""
|
|
|
|
hits: int = 0
|
|
crits: int = 0
|
|
damage_dealt: int = 0
|
|
damage_taken: int = 0
|
|
|
|
|
|
@dataclass
|
|
class CombatantState:
|
|
"""Mutable runtime state of one combatant on the grid."""
|
|
|
|
combatant: Combatant
|
|
side: str
|
|
pos: Pos
|
|
hp: int
|
|
|
|
@property
|
|
def active(self) -> bool:
|
|
return self.hp > 0
|
|
|
|
@property
|
|
def dead(self) -> bool:
|
|
return self.hp < self.death_threshold
|
|
|
|
@property
|
|
def death_threshold(self) -> int:
|
|
return min(_DEATH_FLOOR, -self.combatant.abilities.con_score)
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class AttackResult:
|
|
"""Outcome of one attack roll, including the raw rolls for the log."""
|
|
|
|
hit: bool
|
|
crit: bool
|
|
damage: int
|
|
roll: int
|
|
total: int
|
|
ac: int
|
|
penalty: int = 0
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Action:
|
|
"""What a policy wants a combatant to do this turn."""
|
|
|
|
kind: Literal["attack", "move", "wait"]
|
|
target_id: str | None = None
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class CombatResult:
|
|
"""Outcome of a full battle: winner, rounds, log, and per-combatant stats."""
|
|
|
|
winner: str | None
|
|
rounds: int
|
|
transcript: tuple[str, ...]
|
|
stats: dict[str, CombatantStats]
|
|
|
|
|
|
@dataclass
|
|
class _LiveStats:
|
|
hits: int = 0
|
|
crits: int = 0
|
|
damage_dealt: int = 0
|
|
damage_taken: int = 0
|
|
|
|
|
|
class CombatEngine:
|
|
"""Runs one battle to completion on a grid with a single RNG stream."""
|
|
|
|
def __init__(
|
|
self,
|
|
rng: Rng,
|
|
grid: Grid,
|
|
states: list[CombatantState],
|
|
*,
|
|
round_cap: int = 100,
|
|
policy: Policy | None = None,
|
|
) -> None:
|
|
self._rng = rng
|
|
self._grid = grid
|
|
self._states = states
|
|
self._round_cap = round_cap
|
|
self._policy = policy if policy is not None else default_policy
|
|
self._transcript: list[str] = []
|
|
self._stats: dict[str, _LiveStats] = {s.combatant.id: _LiveStats() for s in states}
|
|
|
|
def run(self) -> CombatResult:
|
|
"""Run the battle and return the final result and transcript."""
|
|
order = self._roll_initiative()
|
|
round_no = 1
|
|
while round_no <= self._round_cap:
|
|
for state in order:
|
|
if not state.active:
|
|
continue
|
|
action = self._policy(self, state)
|
|
self._execute(state, action, round_no)
|
|
if self._winner_side() is not None:
|
|
break
|
|
if self._winner_side() is not None:
|
|
break
|
|
round_no += 1
|
|
winner = self._winner_side()
|
|
if winner is not None:
|
|
self._log(f"battle over: {winner} win in {round_no} rounds")
|
|
else:
|
|
self._log(f"battle over: draw after {self._round_cap} rounds")
|
|
stats = {cid: CombatantStats(**asdict(live)) for cid, live in self._stats.items()}
|
|
return CombatResult(
|
|
winner=winner,
|
|
rounds=round_no if winner is not None else self._round_cap,
|
|
transcript=tuple(self._transcript),
|
|
stats=stats,
|
|
)
|
|
|
|
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]
|
|
if not enemies:
|
|
return None
|
|
return min(
|
|
enemies,
|
|
key=lambda s: (self._grid.distance(state.pos, s.pos), 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):
|
|
return None
|
|
dist_ft = self._grid.distance(attacker.pos, target.pos) * _SQUARE_FT
|
|
for weapon in attacker.combatant.attacks:
|
|
if weapon.kind in ("melee", "touch") and dist_ft <= weapon.reach_ft:
|
|
return weapon
|
|
if (
|
|
weapon.kind == "ranged"
|
|
and weapon.range_increment_ft is not None
|
|
and dist_ft <= weapon.range_increment_ft * _MAX_RANGE_INCREMENTS
|
|
):
|
|
return weapon
|
|
return None
|
|
|
|
def range_penalty(self, weapon: AttackSpec, dist_ft: int) -> int:
|
|
"""PF1e: -2 per full range increment beyond the first, zero within it."""
|
|
if weapon.kind != "ranged" or weapon.range_increment_ft is None:
|
|
return 0
|
|
increments = dist_ft // weapon.range_increment_ft
|
|
if dist_ft % weapon.range_increment_ft != 0:
|
|
increments += 1
|
|
return -_RANGE_INCREMENT_PENALTY * max(0, increments - 1)
|
|
|
|
def resolve_attack(
|
|
self, attacker: CombatantState, target: CombatantState, weapon: AttackSpec
|
|
) -> 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
|
|
penalty = self.range_penalty(weapon, dist_ft)
|
|
total = roll + weapon.attack_bonus + penalty
|
|
ac = target.combatant.ac.total
|
|
occupied = frozenset(
|
|
s.pos for s in self._states if s.active and s is not attacker and s is not target
|
|
)
|
|
if has_cover(
|
|
self._grid,
|
|
attacker.pos,
|
|
target.pos,
|
|
ranged=weapon.kind == "ranged",
|
|
occupied=occupied,
|
|
):
|
|
ac += _COVER_AC_BONUS
|
|
hit = roll == _NATURAL_TWENTY or (roll != _NATURAL_ONE and total >= ac)
|
|
crit = False
|
|
damage = 0
|
|
if hit:
|
|
if roll != _NATURAL_ONE and roll >= weapon.crit_range:
|
|
confirm = self._rng.d20()
|
|
crit = confirm != _NATURAL_ONE and confirm + weapon.attack_bonus + penalty >= ac
|
|
damage = sum(c.formula.roll(self._rng) for c in weapon.damage) + weapon.damage_bonus
|
|
if crit:
|
|
damage *= weapon.crit_mult
|
|
damage = self._apply_dr(damage, weapon, target)
|
|
target.hp -= damage
|
|
return AttackResult(
|
|
hit=hit, crit=crit, damage=damage, roll=roll, total=total, ac=ac, penalty=penalty
|
|
)
|
|
|
|
def _apply_dr(self, damage: int, weapon: AttackSpec, target: CombatantState) -> int:
|
|
dr: DamageReduction | None = target.combatant.dr
|
|
if dr is None:
|
|
return damage
|
|
types = {t for component in weapon.damage for t in component.types}
|
|
if types & dr.bypass:
|
|
return damage
|
|
return max(0, damage - dr.amount)
|
|
|
|
def _roll_initiative(self) -> list[CombatantState]:
|
|
rolls: dict[str, tuple[int, int]] = {}
|
|
for state in self._states:
|
|
roll = self._rng.d20()
|
|
rolls[state.combatant.id] = (roll, roll + state.combatant.initiative_mod)
|
|
order = sorted(
|
|
self._states,
|
|
key=lambda s: (
|
|
rolls[s.combatant.id][1],
|
|
s.combatant.initiative_mod,
|
|
self._states.index(s),
|
|
),
|
|
reverse=True,
|
|
)
|
|
for state in order:
|
|
roll, total = rolls[state.combatant.id]
|
|
self._log(
|
|
f"initiative: {state.combatant.id} "
|
|
f"d20={roll}+{state.combatant.initiative_mod}={total}"
|
|
)
|
|
return order
|
|
|
|
def _winner_side(self) -> str | None:
|
|
active_sides = {s.side for s in self._states if s.active}
|
|
if len(active_sides) == 1:
|
|
return active_sides.pop()
|
|
return None
|
|
|
|
def _execute(self, state: CombatantState, action: Action, round_no: int) -> None:
|
|
target = next((s for s in self._states if s.combatant.id == action.target_id), None)
|
|
if action.kind == "attack":
|
|
if target is None or not target.active:
|
|
self._log(f"round {round_no} {state.combatant.id}: wait")
|
|
return
|
|
weapon = self.weapon_for(state, target)
|
|
if weapon is None:
|
|
self._log(f"round {round_no} {state.combatant.id}: wait")
|
|
return
|
|
self._attack(state, target, weapon, round_no)
|
|
elif action.kind == "move":
|
|
if target is None:
|
|
self._log(f"round {round_no} {state.combatant.id}: wait")
|
|
return
|
|
self._move(state, target, round_no)
|
|
else:
|
|
self._log(f"round {round_no} {state.combatant.id}: wait")
|
|
|
|
def _attack(
|
|
self, attacker: CombatantState, target: CombatantState, weapon: AttackSpec, round_no: int
|
|
) -> None:
|
|
live = self._stats[attacker.combatant.id]
|
|
target_live = self._stats[target.combatant.id]
|
|
for swing in range(1, weapon.count + 1):
|
|
hp_before = target.hp
|
|
result = self.resolve_attack(attacker, target, weapon)
|
|
live.hits += int(result.hit)
|
|
live.crits += int(result.crit)
|
|
live.damage_dealt += result.damage
|
|
target_live.damage_taken += result.damage
|
|
outcome = "CRIT" if result.crit else "HIT" if result.hit else "MISS"
|
|
label = weapon.name if weapon.count == 1 else f"{weapon.name} #{swing}"
|
|
bonus = (
|
|
f"{weapon.attack_bonus}{result.penalty:+d}"
|
|
if result.penalty
|
|
else f"{weapon.attack_bonus}"
|
|
)
|
|
line = (
|
|
f"round {round_no} {attacker.combatant.id}: {label} vs {target.combatant.id} "
|
|
f"d20={result.roll}+{bonus}={result.total} "
|
|
f"AC {result.ac} -> {outcome}"
|
|
)
|
|
if result.hit:
|
|
line += f" {result.damage} damage ({hp_before}->{target.hp})"
|
|
self._log(line)
|
|
if target.dead:
|
|
self._log(f"round {round_no} {attacker.combatant.id}: {target.combatant.id} dead")
|
|
return
|
|
if not target.active:
|
|
self._log(f"round {round_no} {attacker.combatant.id}: {target.combatant.id} down")
|
|
return
|
|
|
|
def _move(self, state: CombatantState, target: CombatantState, round_no: int) -> None:
|
|
step = self._step_toward(state, target)
|
|
if step is None:
|
|
self._log(f"round {round_no} {state.combatant.id}: wait")
|
|
return
|
|
self._log(
|
|
f"round {round_no} {state.combatant.id}: move "
|
|
f"({state.pos[0]},{state.pos[1]})->({step[0]},{step[1]})"
|
|
)
|
|
state.pos = step
|
|
|
|
def _step_toward(self, state: CombatantState, target: CombatantState) -> Pos | None:
|
|
speed_cells = state.combatant.speed_land_ft // _SQUARE_FT
|
|
if speed_cells <= 0:
|
|
return None
|
|
blocked = frozenset(s.pos for s in self._states if s is not state and s.active)
|
|
to_target = self._grid.reachable(target.pos, None, blocked)
|
|
if state.pos not in to_target:
|
|
return None
|
|
best: tuple[int, Pos] | None = None
|
|
row, col = state.pos
|
|
for d_row, d_col in _STEP_DELTAS:
|
|
nxt = (row + d_row, col + d_col)
|
|
cost = to_target.get(nxt)
|
|
if cost is None:
|
|
continue
|
|
step = self._grid.step_cost(state.pos, nxt, 0)
|
|
if step > speed_cells:
|
|
continue
|
|
score = step + cost
|
|
if best is None or score < best[0]:
|
|
best = (score, nxt)
|
|
if best is None:
|
|
return None
|
|
return best[1]
|
|
|
|
def _log(self, line: str) -> None:
|
|
self._transcript.append(line)
|
|
|
|
|
|
Policy = Callable[[CombatEngine, CombatantState], Action]
|
|
|
|
|
|
def default_policy(engine: CombatEngine, state: CombatantState) -> Action:
|
|
"""Attack the nearest active enemy when a weapon is in range, else approach."""
|
|
target = engine.nearest_enemy(state)
|
|
if target is None:
|
|
return Action(kind="wait")
|
|
if engine.weapon_for(state, target) is not None:
|
|
return Action(kind="attack", target_id=target.combatant.id)
|
|
return Action(kind="move", target_id=target.combatant.id)
|