714 lines
26 KiB
Python
714 lines
26 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
facts.py -- compute hard facts in code so Jev never has to.
|
||
|
||
Why this module exists
|
||
----------------------
|
||
Measured against jev-1.13.0: given energy 3, hand Strike(1c/6dmg) x3 plus
|
||
Bash(2c/8dmg), and a target on 19 HP, Jev bucketed the max damage as
|
||
"18_to_23" (correct) but answered "is lethal available?" as 0.79 YES
|
||
(wrong -- the true max is 18). It reported 0.79 confidence on that wrong
|
||
answer, so confidence gating cannot catch arithmetic errors.
|
||
|
||
Conclusion: every comparison, sum, and threshold is computed here. Jev is
|
||
handed conclusions ("lethal_available": true) and is only ever asked about
|
||
preference, priority, and semantics.
|
||
|
||
Damage model and its limits
|
||
---------------------------
|
||
Hand descriptions from STS2MCP already include attacker modifiers such as
|
||
Strength and Weak. Never apply those modifiers to the displayed damage again.
|
||
Pile descriptions have a different display context and are not damage inputs.
|
||
|
||
The direct-damage search supports fixed energy costs and plain damage text.
|
||
It excludes compound/conditional cards, star costs, and unsupported powers.
|
||
Target Vulnerable is applied per hit; enemy block is absorbed once per line.
|
||
The search does not simulate relic hooks, card ordering effects, or shared
|
||
resources across enemies. `lethal_available` is None for multi-enemy combat
|
||
and unsupported power contexts. Other results describe this limited model,
|
||
not a full game simulation. Fight duration and future damage are estimates.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import itertools
|
||
import json
|
||
import re
|
||
from dataclasses import dataclass, field
|
||
from typing import Any
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Thresholds -- all policy lives here, not in the prompt
|
||
# --------------------------------------------------------------------------
|
||
|
||
THREAT_NONE = "none"
|
||
THREAT_CHIP = "chip" # <= 15% of current HP
|
||
THREAT_HEAVY = "heavy" # <= 40% of current HP
|
||
THREAT_SEVERE = "severe" # <= 70% of current HP
|
||
THREAT_LETHAL = "lethal" # >= current HP
|
||
|
||
HP_HEALTHY = "healthy" # > 60%
|
||
HP_WOUNDED = "wounded" # 30-60%
|
||
HP_CRITICAL = "critical" # < 30%
|
||
|
||
DAMAGE_RE = re.compile(
|
||
r"Deal\s+(\d+)\s+damage(?:\s+(\d+)\s+times)?(?:\s+to\s+ALL\s+enemies)?",
|
||
re.IGNORECASE,
|
||
)
|
||
AOE_RE = re.compile(r"to\s+ALL\s+enemies", re.IGNORECASE)
|
||
BLOCK_RE = re.compile(r"Gain\s+(\d+)\s+Block", re.IGNORECASE)
|
||
|
||
|
||
def _as_int(value: Any, default: int = 0) -> int:
|
||
"""Card costs arrive as strings ('1', '2', sometimes 'X')."""
|
||
try:
|
||
return int(str(value).strip())
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
|
||
def power_amount(statuses: list | None, name: str) -> int:
|
||
"""Read a power amount by display name, e.g. 'Strength'."""
|
||
total = 0
|
||
for entry in statuses or []:
|
||
if not isinstance(entry, dict):
|
||
continue
|
||
if str(entry.get("name", "")).lower() == name.lower():
|
||
total += _as_int(entry.get("amount"), 0)
|
||
return total
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Card damage
|
||
# --------------------------------------------------------------------------
|
||
|
||
@dataclass(frozen=True)
|
||
class CardDamage:
|
||
base: int # displayed damage per hit, not the card's unmodified base value
|
||
hits: int
|
||
is_aoe: bool
|
||
|
||
@property
|
||
def raw_total(self) -> int:
|
||
return self.base * self.hits
|
||
|
||
|
||
def block_value(card: dict) -> int:
|
||
"""Displayed immediate block; do not treat conditional triggers as block now."""
|
||
match = BLOCK_RE.match((card.get("description") or "").strip())
|
||
return int(match.group(1)) if match else 0
|
||
|
||
|
||
def parse_card_damage(card: dict) -> CardDamage:
|
||
match = DAMAGE_RE.search(card.get("description") or "")
|
||
if not match:
|
||
return CardDamage(base=0, hits=0, is_aoe=False)
|
||
base = int(match.group(1))
|
||
hits = int(match.group(2)) if match.group(2) else 1
|
||
return CardDamage(
|
||
base=base,
|
||
hits=hits,
|
||
is_aoe=bool(AOE_RE.search(card.get("description") or "")),
|
||
)
|
||
|
||
|
||
def damage_to_target(
|
||
card: dict,
|
||
attacker_status: list | None,
|
||
target_status: list | None,
|
||
target_block: int = 0,
|
||
) -> int:
|
||
"""Estimate damage from HAND text, with target Vulnerable and block.
|
||
|
||
`attacker_status` remains accepted for callers, but its modifiers are
|
||
already included in the displayed value. This is not a base-card API.
|
||
Other target powers and relic hooks are outside this calculation.
|
||
"""
|
||
dmg = parse_card_damage(card)
|
||
per_hit = dmg.base
|
||
if power_amount(target_status, "Vulnerable"):
|
||
per_hit = per_hit * 3 // 2
|
||
return max(0, per_hit * dmg.hits - max(0, target_block))
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Enemy facts
|
||
# --------------------------------------------------------------------------
|
||
|
||
@dataclass
|
||
class EnemyFact:
|
||
entity_id: str
|
||
name: str
|
||
hp: int
|
||
max_hp: int
|
||
block: int
|
||
incoming_damage: int
|
||
intent_kinds: list[str] = field(default_factory=list)
|
||
intent_text: list[str] = field(default_factory=list)
|
||
statuses: list[str] = field(default_factory=list)
|
||
status_amounts: list[dict] = field(default_factory=list)
|
||
is_minion: bool = False
|
||
|
||
@property
|
||
def effective_hp(self) -> int:
|
||
return self.hp + self.block
|
||
|
||
@property
|
||
def hp_pct(self) -> float:
|
||
return self.hp / self.max_hp if self.max_hp else 0.0
|
||
|
||
def to_state(self) -> dict:
|
||
return {
|
||
"id": self.entity_id,
|
||
"name": self.name,
|
||
"hp_state": _hp_bucket(self.hp_pct, self.hp),
|
||
"incoming": self.incoming_damage,
|
||
"intends": ", ".join(self.intent_text) or "unknown",
|
||
# Names AND amounts: an enemy at Strength 6 and Strength 1 used to
|
||
# look identical to Jev. Amounts are context, not a comparison, so
|
||
# no arithmetic crosses the boundary.
|
||
"statuses": self.status_amounts or "none",
|
||
}
|
||
|
||
|
||
def _hp_bucket(pct: float, hp: int | None = None) -> str:
|
||
"""
|
||
Bucket health by percentage, but never call very low ABSOLUTE HP healthy.
|
||
|
||
Measured: an event option set the player's max HP to 1. At 1/1 the
|
||
percentage is 100% and this returned "healthy", so the bot walked into a
|
||
normal fight at 1 HP and died. A percentage is meaningless once max HP
|
||
itself is tiny.
|
||
"""
|
||
if hp is not None and hp <= 5:
|
||
return HP_CRITICAL
|
||
if pct > 0.6:
|
||
return HP_HEALTHY
|
||
if pct >= 0.3:
|
||
return HP_WOUNDED
|
||
return HP_CRITICAL
|
||
|
||
|
||
def _intent_damage(intent: dict) -> int:
|
||
"""
|
||
Intent damage. `label` is the authoritative number the game shows,
|
||
e.g. '12' or '12x2'. Fall back to parsing the description.
|
||
"""
|
||
if intent.get("type") != "Attack":
|
||
return 0
|
||
label = str(intent.get("label") or "").strip()
|
||
multi = re.match(r"^(\d+)\s*[xX×]\s*(\d+)$", label)
|
||
if multi:
|
||
return int(multi.group(1)) * int(multi.group(2))
|
||
if label.isdigit():
|
||
return int(label)
|
||
found = re.search(r"(\d+)", label)
|
||
if found:
|
||
return int(found.group(1))
|
||
desc = intent.get("description") or ""
|
||
found = re.search(r"(\d+)\s*damage", desc, re.IGNORECASE)
|
||
return int(found.group(1)) if found else 0
|
||
|
||
|
||
def enemy_facts(enemy: dict) -> EnemyFact:
|
||
statuses = enemy.get("status") or []
|
||
intents = enemy.get("intents") or []
|
||
|
||
names = [str(s.get("name")) for s in statuses if isinstance(s, dict) and s.get("name")]
|
||
amounts = [
|
||
{"name": str(s.get("name")), "amount": _as_int(s.get("amount"))}
|
||
for s in statuses
|
||
if isinstance(s, dict) and s.get("name")
|
||
]
|
||
|
||
return EnemyFact(
|
||
entity_id=str(enemy.get("entity_id") or "?"),
|
||
name=str(enemy.get("name") or "?"),
|
||
hp=_as_int(enemy.get("hp")),
|
||
max_hp=_as_int(enemy.get("max_hp")),
|
||
block=_as_int(enemy.get("block")),
|
||
incoming_damage=sum(_intent_damage(i) for i in intents if isinstance(i, dict)),
|
||
intent_kinds=[str(i.get("type")) for i in intents if isinstance(i, dict)],
|
||
intent_text=[
|
||
str(i.get("description") or i.get("title") or i.get("type"))
|
||
for i in intents
|
||
if isinstance(i, dict)
|
||
],
|
||
statuses=names,
|
||
status_amounts=amounts,
|
||
)
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Small-hand calculations. Unknown costs never become free cards.
|
||
# --------------------------------------------------------------------------
|
||
|
||
def fixed_energy_cost(card: dict) -> int | None:
|
||
"""A supported fixed cost, or None for unknown/X costs and star spending."""
|
||
if card.get("star_cost") not in (None, 0, "0"):
|
||
return None
|
||
text = str(card.get("cost", "")).strip()
|
||
return int(text) if text.isdecimal() else None
|
||
|
||
|
||
def best_block_line(playable: list[dict], energy: int) -> list[dict]:
|
||
"""Maximize displayed immediate block with fixed costs, using each card once.
|
||
|
||
This ignores draw outcomes and other side effects. Ties use less energy,
|
||
then fewer cards. The returned list is a plan, not a queued action list.
|
||
"""
|
||
plans: dict[int, tuple[int, list[dict]]] = {0: (0, [])}
|
||
for card in playable:
|
||
cost = fixed_energy_cost(card)
|
||
value = block_value(card)
|
||
if cost is None or cost > energy or value <= 0:
|
||
continue
|
||
for spent, (total, line) in list(plans.items()):
|
||
new_spent = spent + cost
|
||
if new_spent > energy:
|
||
continue
|
||
candidate = (total + value, line + [card])
|
||
old = plans.get(new_spent)
|
||
if old is None or (candidate[0], -len(candidate[1])) > (old[0], -len(old[1])):
|
||
plans[new_spent] = candidate
|
||
_, (_, line) = max(plans.items(), key=lambda item: (item[1][0], -item[0], -len(item[1][1])))
|
||
return line
|
||
|
||
|
||
def damage_context_supported(attacker_status: list, enemy: EnemyFact) -> bool:
|
||
"""Reject power contexts outside the limited direct-damage calculation."""
|
||
known = {"strength", "weak", "vulnerable", "dexterity", "frail"}
|
||
names = [str(s.get("name", "")).lower() for s in attacker_status if isinstance(s, dict)]
|
||
return all(n in known for n in names + [n.lower() for n in enemy.statuses])
|
||
|
||
|
||
def damage_subsets(playable: list[dict], energy: int, attacker_status: list, enemy: EnemyFact):
|
||
"""Yield (cards, raw damage) for supported subsets, shortest first.
|
||
|
||
Only plain direct attacks are modeled. A matching phrase inside a
|
||
conditional or a card with additional effects is not a supported attack.
|
||
"""
|
||
if not damage_context_supported(attacker_status, enemy):
|
||
return
|
||
candidates = [
|
||
c for c in playable
|
||
if c.get("type") == "Attack"
|
||
and c.get("target_type") in ("AnyEnemy", "AllEnemies")
|
||
and fixed_energy_cost(c) is not None
|
||
and DAMAGE_RE.fullmatch((c.get("description") or "").strip().rstrip("."))
|
||
][:12]
|
||
for count in range(1, len(candidates) + 1):
|
||
for subset in itertools.combinations(candidates, count):
|
||
if sum(fixed_energy_cost(c) for c in subset) > energy:
|
||
continue
|
||
total = sum(damage_to_target(c, attacker_status, enemy_status_names(enemy)) for c in subset)
|
||
yield list(subset), total
|
||
|
||
|
||
def lethal_line(playable: list[dict], energy: int, attacker_status: list,
|
||
enemy: EnemyFact) -> list[dict] | None:
|
||
"""Shortest supported direct-damage line against one enemy, if found."""
|
||
if enemy.hp <= 0:
|
||
return None
|
||
for cards, total in damage_subsets(playable, energy, attacker_status, enemy):
|
||
if total >= enemy.effective_hp:
|
||
return sorted(cards, key=lambda c: -parse_card_damage(c).raw_total)
|
||
return None
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# Combat facts
|
||
# --------------------------------------------------------------------------
|
||
|
||
@dataclass
|
||
class CombatFacts:
|
||
round: int
|
||
in_play_phase: bool
|
||
turn: str
|
||
energy: int
|
||
max_energy: int
|
||
hp: int
|
||
max_hp: int
|
||
block: int
|
||
incoming_damage: int
|
||
enemies: list[EnemyFact]
|
||
hand: list[dict]
|
||
playable: list[dict]
|
||
potions: list[dict]
|
||
player_status: list
|
||
lethal_available: bool | None
|
||
killable: list[str]
|
||
deck_counts: dict
|
||
deck_summary: dict
|
||
draw_pile_count: int
|
||
discard_pile_count: int
|
||
exhaust_pile_count: int
|
||
|
||
@property
|
||
def hp_pct(self) -> float:
|
||
return self.hp / self.max_hp if self.max_hp else 0.0
|
||
|
||
@property
|
||
def hp_bucket(self) -> str:
|
||
return _hp_bucket(self.hp_pct, self.hp)
|
||
|
||
@property
|
||
def unblocked_damage(self) -> int:
|
||
return max(0, self.incoming_damage - self.block)
|
||
|
||
@property
|
||
def threat(self) -> str:
|
||
incoming = self.unblocked_damage
|
||
if incoming <= 0:
|
||
return THREAT_NONE
|
||
if incoming >= self.hp:
|
||
return THREAT_LETHAL
|
||
if incoming <= self.max_hp * 0.15:
|
||
return THREAT_CHIP
|
||
if incoming <= self.max_hp * 0.40:
|
||
return THREAT_HEAVY
|
||
return THREAT_SEVERE
|
||
|
||
@property
|
||
def total_enemy_hp(self) -> int:
|
||
return sum(e.effective_hp for e in self.enemies)
|
||
|
||
@property
|
||
def max_block_available(self) -> int:
|
||
"""Maximum displayed immediate block in the fixed-cost model."""
|
||
return sum(block_value(c) for c in best_block_line(self.playable, self.energy))
|
||
|
||
@property
|
||
def survives_with_cards(self) -> bool:
|
||
"""
|
||
Estimate survival after known incoming attacks and the block plan.
|
||
Survival can include HP loss. Card side effects are not simulated.
|
||
"""
|
||
remaining = max(0, self.incoming_damage - self.block - self.max_block_available)
|
||
return remaining < self.hp
|
||
|
||
# ---------------------------------------------------------------------
|
||
# Fight-length projection.
|
||
#
|
||
# The old model asked "is THIS turn's hit big?" (see `threat`). That is
|
||
# myopic and it lost 9 runs to THE_KIN_BOSS: at 80 max HP a hit of <=12 is
|
||
# classed CHIP, so the bot attacked through the boss's main attack, took
|
||
# ~10-13 a turn, and died in 5-10 turns having dealt 44-80 damage to
|
||
# itself. The quantity that decides whether to block is the TOTAL damage
|
||
# the rest of the fight will cost, not one turn of it.
|
||
# ---------------------------------------------------------------------
|
||
|
||
@property
|
||
def attack_power(self) -> int:
|
||
"""Greedy damage estimate, ignoring targets, ordering, and unknown costs."""
|
||
energy = self.energy
|
||
total = 0
|
||
for card in sorted(self.playable, key=lambda x: -parse_card_damage(x).raw_total):
|
||
dmg = parse_card_damage(card).raw_total
|
||
if dmg <= 0:
|
||
continue
|
||
cost = fixed_energy_cost(card)
|
||
if cost is not None and cost <= energy:
|
||
total += dmg
|
||
energy -= cost
|
||
return total
|
||
|
||
@property
|
||
def turns_to_kill(self) -> int:
|
||
"""
|
||
Estimate remaining turns by assuming later hands resemble this hand.
|
||
|
||
This ignores future draws and effects. A block-only hand produces a
|
||
large estimate; it does not establish the actual fight duration.
|
||
"""
|
||
power = self.attack_power
|
||
if power <= 0:
|
||
return 20
|
||
return max(1, -(-self.total_enemy_hp // power))
|
||
|
||
@property
|
||
def projected_incoming(self) -> int:
|
||
"""Total damage the rest of this fight is likely to deal us."""
|
||
return self.turns_to_kill * self.incoming_damage
|
||
|
||
@property
|
||
def affordable_loss(self) -> int:
|
||
"""
|
||
HP we can spend on this fight and still enter the next one healthy.
|
||
|
||
HP is a resource (it carries across the act), so we do not want to
|
||
leave a fight at 1 HP. Keep a floor of 30% of max HP.
|
||
"""
|
||
return max(0, self.hp - int(self.max_hp * 0.30))
|
||
|
||
@property
|
||
def must_block(self) -> bool:
|
||
"""
|
||
Request current block when estimated future damage exceeds the HP budget.
|
||
|
||
This is a heuristic. It must stop requesting block once the current
|
||
incoming damage is covered; ordinary block does not cover future turns.
|
||
"""
|
||
if self.unblocked_damage <= 0:
|
||
return False
|
||
return self.projected_incoming > self.affordable_loss
|
||
|
||
@property
|
||
def block_urgent(self) -> bool:
|
||
"""
|
||
Block now even at the cost of tempo: this turn alone is dangerous.
|
||
Separate from `must_block` because it also covers the case where the
|
||
current hit is lethal-ish regardless of how long the fight lasts.
|
||
"""
|
||
if self.unblocked_damage <= 0:
|
||
return False
|
||
return (
|
||
self.threat in (THREAT_SEVERE, THREAT_LETHAL)
|
||
or self.hp_bucket in (HP_WOUNDED, HP_CRITICAL)
|
||
or self.must_block
|
||
)
|
||
|
||
def to_state(self) -> dict:
|
||
"""
|
||
The compact, semantic state handed to Jev.
|
||
|
||
Include computed comparisons so Jev need not perform arithmetic.
|
||
Preserve displayed costs, including X. Lethal can be unknown (None).
|
||
"""
|
||
return {
|
||
"combat": {
|
||
"round": self.round,
|
||
"your_turn": self.in_play_phase,
|
||
"energy": self.energy,
|
||
"your_health": self.hp_bucket,
|
||
"your_statuses": [
|
||
{"name": str(s.get("name")), "amount": _as_int(s.get("amount"))}
|
||
for s in self.player_status
|
||
if isinstance(s, dict) and s.get("name")
|
||
] or "none",
|
||
"incoming_threat": self.threat,
|
||
# The fight-length view. `threat` alone is myopic: at 80 max HP
|
||
# a 12-damage hit reads as "chip" even when the fight will run
|
||
# 10 more turns and kill us. These expose the accumulated view
|
||
# without handing Jev any arithmetic to do.
|
||
"fight_is_grinding": self.must_block,
|
||
"this_turn_is_dangerous": self.block_urgent,
|
||
"lethal_available": self.lethal_available,
|
||
"can_survive_with_cards": self.survives_with_cards,
|
||
"enemies_you_can_kill_now": self.killable or "none",
|
||
"enemies": [e.to_state() for e in self.enemies],
|
||
"hand": [
|
||
{
|
||
"index": c.get("index"),
|
||
"name": c.get("name"),
|
||
"cost": c.get("cost"),
|
||
"type": c.get("type"),
|
||
"targets": c.get("target_type"),
|
||
"text": c.get("description"),
|
||
}
|
||
for c in self.hand
|
||
],
|
||
# Potions cost no energy, so they are always an alternative.
|
||
# `slot` is the index use_potion expects, NOT the list position.
|
||
"potions": [
|
||
{
|
||
"slot": p.get("slot"),
|
||
"name": p.get("name"),
|
||
"targets": p.get("target_type"),
|
||
"text": p.get("description"),
|
||
}
|
||
for p in self.potions
|
||
],
|
||
"cannot_play": [
|
||
{"index": c.get("index"), "name": c.get("name"),
|
||
"why": c.get("unplayable_reason")}
|
||
for c in self.hand
|
||
if not c.get("can_play")
|
||
],
|
||
}
|
||
}
|
||
|
||
def describe(self) -> str:
|
||
lines = [
|
||
f"round={self.round} turn={self.turn} play_phase={self.in_play_phase}",
|
||
f"energy={self.energy}/{self.max_energy} hand={len(self.hand)} playable={len(self.playable)}",
|
||
f"hp={self.hp}/{self.max_hp} ({self.hp_bucket}) block={self.block}",
|
||
f"incoming={self.incoming_damage} unblocked={self.unblocked_damage} threat={self.threat}",
|
||
f"lethal_available={self.lethal_available} killable={self.killable}",
|
||
f"block_available={self.max_block_available} survives_with_cards={self.survives_with_cards}",
|
||
f"potions={[p.get('name') for p in self.potions]}",
|
||
f"piles: draw={self.draw_pile_count} discard={self.discard_pile_count} exhaust={self.exhaust_pile_count}",
|
||
f"deck: {self.deck_counts}",
|
||
]
|
||
for e in self.enemies:
|
||
lines.append(
|
||
f" enemy {e.entity_id}: {e.name} {e.hp}/{e.max_hp} block={e.block} "
|
||
f"incoming={e.incoming_damage} intents={e.intent_kinds}"
|
||
)
|
||
return "\n".join(lines)
|
||
|
||
|
||
def combat_facts(observation: dict) -> CombatFacts:
|
||
battle = observation.get("battle") or {}
|
||
player = observation.get("player") or {}
|
||
|
||
enemies = [enemy_facts(e) for e in (battle.get("enemies") or [])]
|
||
|
||
hand = list(player.get("hand") or [])
|
||
energy = _as_int(player.get("energy"))
|
||
player_status = player.get("status") or []
|
||
|
||
playable = [c for c in hand if c.get("can_play")]
|
||
|
||
# A card is playable only if we can also afford it.
|
||
affordable = [c for c in playable
|
||
if fixed_energy_cost(c) is None or fixed_energy_cost(c) <= energy]
|
||
|
||
killable: list[str] = []
|
||
for enemy in enemies:
|
||
best = _subset_damage(affordable, energy, player_status, enemy)
|
||
if enemy.hp > 0 and best >= enemy.effective_hp:
|
||
killable.append(enemy.entity_id)
|
||
|
||
# Individually killable enemies may require the SAME cards and energy.
|
||
# Do not claim joint lethal without a shared-resource search.
|
||
lethal = bool(killable) if len(enemies) == 1 else None
|
||
if len(enemies) == 1 and not damage_context_supported(player_status, enemies[0]):
|
||
lethal = None
|
||
|
||
# draw/discard/exhaust piles expose only {name, cost, star_cost, description}
|
||
# with no `type`, so composition is counted by card name for every pile.
|
||
deck_counts: dict[str, int] = {}
|
||
for pile in ("hand", "draw_pile", "discard_pile", "exhaust_pile"):
|
||
for card in player.get(pile) or []:
|
||
key = str(card.get("name") or "?")
|
||
deck_counts[key] = deck_counts.get(key, 0) + 1
|
||
|
||
return CombatFacts(
|
||
round=_as_int(battle.get("round")),
|
||
in_play_phase=bool(battle.get("is_play_phase")),
|
||
turn=str(battle.get("turn") or "?"),
|
||
energy=energy,
|
||
max_energy=_as_int(player.get("max_energy")),
|
||
hp=_as_int(player.get("hp")),
|
||
max_hp=_as_int(player.get("max_hp")),
|
||
block=_as_int(player.get("block")),
|
||
incoming_damage=sum(e.incoming_damage for e in enemies),
|
||
enemies=enemies,
|
||
hand=hand,
|
||
playable=affordable,
|
||
potions=[p for p in (player.get("potions") or []) if isinstance(p, dict)],
|
||
player_status=player_status,
|
||
lethal_available=lethal,
|
||
killable=killable,
|
||
deck_counts=deck_counts,
|
||
deck_summary=deck_summary(player),
|
||
draw_pile_count=_as_int(player.get("draw_pile_count")),
|
||
discard_pile_count=_as_int(player.get("discard_pile_count")),
|
||
exhaust_pile_count=_as_int(player.get("exhaust_pile_count")),
|
||
)
|
||
|
||
|
||
def _subset_damage(playable: list[dict], energy: int, attacker_status: list, enemy: EnemyFact) -> int:
|
||
"""Maximum supported raw damage; compare with HP + block exactly once."""
|
||
return max((total for _, total in damage_subsets(playable, energy, attacker_status, enemy)), default=0)
|
||
|
||
|
||
def enemy_status_names(enemy: EnemyFact) -> list:
|
||
"""Preserve observed amounts; accept legacy name-only EnemyFact values."""
|
||
return enemy.status_amounts or [{"name": n, "amount": 1} for n in enemy.statuses]
|
||
|
||
|
||
def deck_summary(player: dict) -> dict:
|
||
"""
|
||
Stable aggregates over ALL FOUR PILES, for macro decisions.
|
||
|
||
The reward, shop and map states do NOT expose the deck, so this travels with
|
||
the composition snapshot taken during combat. It is deliberately a
|
||
*supplement* to the name->count map, never a replacement: card identities
|
||
are the signal for synergy, redundancy and upgrades, and only counts can
|
||
carry them. These aggregates are the part that is arithmetic, so it is
|
||
computed here and never asked of the model.
|
||
|
||
Every field is computed over the whole deck and is stable across snapshots
|
||
of the same deck. There is deliberately no cost aggregate: the state does
|
||
not expose a card's BASE cost, and a temporary in-combat cost modifier
|
||
applies to the copy in hand. Measured over 600 captures, one Strike read
|
||
`cost: "0"` in hand while the same Strike read `cost: "1"` in the draw pile,
|
||
so an average cost would differ between two snapshots of an identical deck.
|
||
"""
|
||
names: list[str] = []
|
||
attacks = blocks = other = upgraded = 0
|
||
for pile in ("hand", "draw_pile", "discard_pile", "exhaust_pile"):
|
||
for card in player.get(pile) or []:
|
||
if not isinstance(card, dict):
|
||
continue
|
||
name = str(card.get("name") or "?")
|
||
names.append(name)
|
||
if name.endswith("+"):
|
||
upgraded += 1
|
||
text = card.get("description") or ""
|
||
if DAMAGE_RE.search(text):
|
||
attacks += 1
|
||
elif BLOCK_RE.search(text):
|
||
blocks += 1
|
||
else:
|
||
other += 1
|
||
|
||
if not names:
|
||
return {}
|
||
|
||
return {
|
||
"size": len(names),
|
||
"attacks": attacks,
|
||
"block_cards": blocks,
|
||
"other_cards": other,
|
||
"upgraded": upgraded,
|
||
}
|
||
|
||
|
||
def deck_context(deck: Any) -> Any:
|
||
"""
|
||
What a macro question receives as deck context: the full name->count map
|
||
(card identities, which carry the synergy and redundancy signal) plus the
|
||
stable aggregates. Tolerates a legacy flat name->count snapshot.
|
||
"""
|
||
if not deck:
|
||
return "unknown"
|
||
if isinstance(deck, dict) and "counts" in deck:
|
||
counts = deck.get("counts") or {}
|
||
if not counts:
|
||
return "unknown"
|
||
return {"cards": counts, **({"summary": deck["summary"]}
|
||
if deck.get("summary") else {})}
|
||
if isinstance(deck, dict):
|
||
return {"cards": deck}
|
||
return deck
|
||
|
||
|
||
# --------------------------------------------------------------------------
|
||
# CLI
|
||
# --------------------------------------------------------------------------
|
||
|
||
def main() -> int:
|
||
import sys
|
||
import pathlib
|
||
|
||
path = sys.argv[1] if len(sys.argv) > 1 else "capture/09_now.json"
|
||
obs = json.loads(pathlib.Path(path).read_text())
|
||
|
||
if obs.get("state_type") not in ("monster", "elite", "boss"):
|
||
print(f"not a combat state: state_type={obs.get('state_type')!r}")
|
||
return 1
|
||
|
||
facts = combat_facts(obs)
|
||
print("=== FACTS ===")
|
||
print(facts.describe())
|
||
print()
|
||
print("=== SEMANTIC STATE FOR JEV ===")
|
||
print(json.dumps(facts.to_state(), indent=2))
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|