#!/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 honest limits ---------------------------------- Handled: * base damage parsed from the card description * multi-hit ("Deal 3 damage 2 times.") * area of effect ("... to ALL enemies.") * Strength on the attacker (+ per hit) * Vulnerable on the target (x1.5) * Weak on the attacker (x0.75) * enemy Block Not handled (documented, not guessed): * ordering effects (Bash applying Vulnerable before a later attack) * relics that modify damage * enemy powers that reduce incoming damage * X-cost cards So `lethal_available` is a LOWER bound: true means lethal is genuinely reachable. False may still be reachable in game. That is the safe direction for a bot -- we never claim lethal we cannot deliver. """ 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 hits: int is_aoe: bool @property def raw_total(self) -> int: return self.base * self.hits def block_value(card: dict) -> int: """Block a card grants, parsed from its description.""" match = BLOCK_RE.search(card.get("description") or "") 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: """Damage one card deals to one target after buffs, debuffs, and block.""" dmg = parse_card_damage(card) if dmg.raw_total == 0: return 0 strength = power_amount(attacker_status, "Strength") per_hit = dmg.base + strength if power_amount(attacker_status, "Weak"): per_hit = int(per_hit * 0.75) total = per_hit * dmg.hits if power_amount(target_status, "Vulnerable"): total = int(total * 1.5) return max(0, total - 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, ) # -------------------------------------------------------------------------- # Lethal search # -------------------------------------------------------------------------- # -------------------------------------------------------------------------- # 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 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: """Block obtainable from playable cards within the energy budget.""" energy = self.energy total = 0 for card in sorted(self.playable, key=block_value, reverse=True): value = block_value(card) if value <= 0: continue cost = _as_int(card.get("cost")) if cost <= energy: total += value energy -= cost return total @property def survives_with_cards(self) -> bool: """ True when existing block plus reachable card block covers the incoming damage. Used to decide whether a potion is the ONLY way to survive. """ return self.block + self.max_block_available >= self.incoming_damage # --------------------------------------------------------------------- # 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: """Best single-turn damage the hand can produce, ignoring targets.""" 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 = _as_int(card.get("cost")) if cost <= energy: total += dmg energy -= cost return total @property def turns_to_kill(self) -> int: """ Turns this fight still needs, from this turn's reachable damage. Deliberately pessimistic: it assumes every later turn looks like this one. If the hand is all block, the estimate is huge, which correctly pushes toward "this fight will grind me down". """ 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: """ True when the rest of this fight will cost more HP than we can spare. This is the decision the bot was missing. It fires on the Kin turn (74/80 HP, 12 incoming, ~12 turns to kill -> 144 projected vs 50 affordable) and stays silent on a trivial fight (15 HP enemy, 6 incoming, 2 turns -> 12 projected vs 50 affordable). """ if self.incoming_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.incoming_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. Deliberately contains NO raw numbers that Jev would have to compare. Buckets and booleans only, so arithmetic never crosses the boundary. """ 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": _as_int(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 _as_int(c.get("cost")) <= energy] killable: list[str] = [] for enemy in enemies: best = _subset_damage(affordable, energy, player_status, enemy) if enemy.effective_hp > 0 and best >= enemy.effective_hp: killable.append(enemy.entity_id) lethal = bool(enemies) and len(killable) == len(enemies) # 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: """ Exact max RAW damage over subsets, honouring energy and attacker statuses. Raw means before enemy block: compare the result against `enemy.effective_hp` (hp + block) so the block is subtracted exactly once. Subtracting it here and comparing against `effective_hp` required hp + 2*block, which silently discarded real lethal lines whenever an enemy played Defend. """ best = 0 n = min(len(playable), 12) for r in range(1, n + 1): for combo in itertools.combinations(range(n), r): cost = sum(_as_int(playable[i].get("cost")) for i in combo) if cost > energy: continue total = 0 for i in combo: card = playable[i] dmg = parse_card_damage(card) if dmg.raw_total == 0: continue per_hit = dmg.base + power_amount(attacker_status, "Strength") if power_amount(attacker_status, "Weak"): per_hit = int(per_hit * 0.75) card_total = per_hit * dmg.hits if power_amount(enemy_status_names(enemy), "Vulnerable"): card_total = int(card_total * 1.5) total += card_total if total > best: best = total return best def enemy_status_names(enemy: EnemyFact) -> list: """Adapt the name list back into the shape power_amount expects.""" return [{"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())