from __future__ import annotations import copy import random from typing import Any, Dict import numpy as np from engine.game.effects.choices import queue_select_from_list_choice from engine.game.effects.hand import discard_hand_cards from engine.models.ability import ConditionType, Effect, EffectType, TargetType from engine.models.enums import Group, Unit from engine.models.opcodes import Opcode def _decode_real_value(p: Any, v: int, a: int, s_packed: int) -> int: """Resolve bytecode scaling/dynamic-count semantics into a concrete value.""" real_v = v if (a & 0x40) == 0: return real_v cond_type = ConditionType(v) if cond_type == ConditionType.COUNT_STAGE: raw_count = len([c for c in p.stage if c >= 0]) elif cond_type == ConditionType.COUNT_HAND: raw_count = len(p.hand) elif cond_type == ConditionType.COUNT_DISCARD: raw_count = len(p.discard) elif cond_type == ConditionType.COUNT_ENERGY: raw_count = len(p.energy_zone) elif cond_type == ConditionType.COUNT_SUCCESS_LIVE: raw_count = len(p.success_lives) elif cond_type == ConditionType.COUNT_LIVE_ZONE: raw_count = len(p.live_zone) else: raw_count = 0 if (a & 0x20) != 0: scaling_factor = s_packed >> 4 if scaling_factor > 0: return (s_packed & 0x0F) * (raw_count // scaling_factor) return 0 return raw_count def _append_deck_top_to_discard(game: Any, player: Any, count: int) -> None: for _ in range(count): if not player.main_deck: game._resolve_deck_refresh(player) if player.main_deck: player.discard.append(player.main_deck.pop(0)) def _append_energy_to_discard(player: Any, count: int) -> None: for _ in range(count): if player.energy_zone: player.discard.append(player.energy_zone.pop()) def resolve_effect_opcode(game: Any, opcode: Opcode, seg: Any, context: Dict[str, Any]) -> None: self = game """Execute a single quadruple from bytecode.""" p = self.active_player opp_idx = 1 - p.player_id v = seg[1] a = seg[2] s_packed = seg[3] real_v = _decode_real_value(p, v, a, s_packed) s = s_packed & 0x0F # Condition Check Opcodes (Return/Jump logic usually handled in loop, but we need 'cond' state) # In this Python version, _resolve_pending_effect's loop needs to handle cond. # But for now, we only trigger effects. if self.verbose: print(f"DEBUG_OP: {opcode.name} v={v} a={a} s={s}") if opcode == Opcode.DRAW: self._draw_cards(p, real_v) elif opcode == Opcode.ADD_BLADES: p.continuous_effects.append( { "source_card_id": context.get("source_card_id", context.get("card_id", -1)), "effect": Effect(EffectType.ADD_BLADES, real_v, TargetType.SELF), "target_slot": s if s < 3 else -1, "expiry": "TURN_END", } ) elif opcode == Opcode.ADD_HEARTS: p.continuous_effects.append( { "source_card_id": context.get("source_card_id", context.get("card_id", -1)), "effect": Effect(EffectType.ADD_HEARTS, real_v, TargetType.SELF, {"color": a & 0x3F}), "expiry": "TURN_END", } ) elif opcode == Opcode.GRANT_ABILITY: # Granting an ability (Rule 1.3.1) # a: attribute of granted ability (trigger type) # v: Index into member_db if external, or reference to current # For Sumire: It's usually a predefined ID or a special payload. # In V2 compiler, GRANT_ABILITY often carries a whole Ability object or pre-compiled bytecode. # But here we handle the "Legacy" or "Simple" case for Starters. # If it's "SELF" (s == 0), we apply to current member. source_id = context.get("source_card_id", -1) target_p = p # In Sumire's case, the pseudocode is: # EFFECT: GRANT_ABILITY(SELF, TRIGGER="CONSTANT", CONDITION="IS_ON_STAGE", EFFECT="BOOST_SCORE(1)") # This is compiled into Opcode 60. # For simplicity in this engine version, we convert it to a Continuous Effect # that mimics the granted ability. target_slot = context.get("area", -1) if target_slot == -1 and source_id != -1: # Find where source_id is on stage for i, cid in enumerate(p.stage): if cid == source_id: target_slot = i break if target_slot != -1: # Create a pseudo-effect that matches the granted ability # Sumire grants BOOST_SCORE(1) while on stage. # In basic engine terms, this is just a Score Buff continuous effect. p.continuous_effects.append( { "source_card_id": source_id, "effect": Effect(EffectType.BOOST_SCORE, real_v, TargetType.SELF), "target_slot": target_slot, "expiry": "TURN_END", # Usually until end of turn or permanent? # Starter Sumire is "This turn". } ) elif opcode == Opcode.LOOK_DECK: # Reveal top V cards (Target awareness) target_tp = self.players[opp_idx] if s == 2 else p # s=2 is OPPONENT in TargetType if self.verbose: print(f"DEBUG: LOOK_DECK Target={target_tp.player_id} DeckLen={len(target_tp.main_deck)}") if not target_tp.main_deck: self._resolve_deck_refresh(target_tp) self.looked_cards = [] for _ in range(v): if target_tp.main_deck: self.looked_cards.append(target_tp.main_deck.pop(0)) if self.verbose: print(f"DEBUG: LOOK_DECK Result={self.looked_cards}") elif opcode == Opcode.LOOK_AND_CHOOSE: # Trigger SLIST choice if self.looked_cards: dest = "discard" if (a & 0x0F) == 1 else "hand" target_pid = opp_idx if s == 2 else p.player_id queue_select_from_list_choice( self, { "player_id": p.player_id, "source_card_id": context.get("source_card_id", context.get("card_id", -1)), }, self.looked_cards, real_v, "look_and_choose", "Choose cards from looked list", target_pid, extra_params={"destination": dest}, ) elif opcode == Opcode.TAP_OPPONENT: is_all = (a & 0x80) != 0 requires_selection = (a & 0x20) != 0 # Bit 5 flag cost_max = v blades_max = a & 0x1F # Mask out flags # Dynamic Resolution: If cost_max is 99, try to find context card cost if cost_max == 99: scid = context.get("source_card_id", context.get("card_id", -1)) if scid != -1 and scid in self.member_db: cost_max = self.member_db[scid].cost def passes_filter(slot_id): cid = opp.stage[slot_id] if cid < 0: return False card = self.member_db[int(cid)] # Cost check if cost_max != 99 and card.cost > cost_max: return False # Blades check if blades_max != 99 and card.total_blades > blades_max: return False return True if is_all: for i in range(3): if passes_filter(i): opp.tapped_members[i] = True opp.members_tapped_by_opponent_this_turn.add(opp.stage[i]) else: # Check for interactive selection if requires_selection or (s == 2 and v == 1): # s=2 is OPPONENT, v=1 count choice = context.get("choice_index", -1) if choice == -1: # Pause for selection # Create a pending choice # Valid targets valid_slots = [i for i in range(3) if passes_filter(i) and not opp.tapped_members[i]] if valid_slots: self.pending_choices.append( ( "TARGET_OPPONENT_MEMBER", { "player_id": self.current_player, "valid_slots": valid_slots, "effect": "tap_opponent", "pending_context": context, # Store context to resume # "resume_opcode": opcode, ... (Python engine handles resume differently usually) # Using standard pending_choices format }, ) ) # In Python engine, pending_choices usually halts execution flow implicitly or explicitly? # resolve_bytecode doesn't return status. # We might need to ensure this halts. # But standard python engine relies on pending_choices check in outer loop. pass else: # Apply to chosen slot if 0 <= choice < 3 and passes_filter(choice): opp.tapped_members[choice] = True opp.members_tapped_by_opponent_this_turn.add(opp.stage[choice]) elif s < 3: # Fallback for directed target (if s is actually a fixed slot index) # Note: s=2 (Right Slot) vs s=2 (Opponent TargetType) is ambiguous without flags. # This is why we added the flag. # If flag is NOT set, and s < 3, assume fixed slot? # But previously s=2 tapped right slot. if passes_filter(s): opp.tapped_members[s] = True opp.members_tapped_by_opponent_this_turn.add(opp.stage[s]) elif opcode == Opcode.ACTIVATE_MEMBER: if s < 3: p.tapped_members[s] = False elif opcode == Opcode.REVEAL_CARDS: # s=1 means reveal looking cards (usually for yel animation/trigger) pass elif opcode == Opcode.RECOVER_LIVE: # Trigger interactive selection instead of broken automatic recovery live_cards_in_discard = [cid for cid in p.discard if int(cid) in self.live_db] if live_cards_in_discard: self.pending_choices.append( ( "SELECT_FROM_DISCARD", { "source_card_id": context.get("source_card_id", -1), "cards": live_cards_in_discard, "count": real_v, "filter": "live", "effect": "return_to_hand", "effect_description": "蝗槫庶縺吶ｋ繝ｩ繧､繝悶ｒ驕ｸ繧薙〒縺上□縺輔＞", }, ) ) elif opcode == Opcode.RECOVER_MEMBER: # Trigger interactive selection instead of broken automatic recovery member_cards_in_discard = [cid for cid in p.discard if int(cid) in self.member_db] if member_cards_in_discard: self.pending_choices.append( ( "SELECT_FROM_DISCARD", { "source_card_id": context.get("source_card_id", -1), "cards": member_cards_in_discard, "count": real_v, "filter": "member", "effect": "return_to_hand", "effect_description": "蝗槫庶縺吶ｋ繝｡繝ｳ繝舌・繧帝∈繧薙〒縺上□縺輔＞", }, ) ) elif opcode == Opcode.SWAP_CARDS: # Discard v, then draw v for _ in range(v): if p.hand: cid = p.hand.pop(0) p.hand_added_turn.pop(0) p.discard.append(cid) self._draw_cards(p, v) elif opcode == Opcode.REDUCE_COST: p.continuous_effects.append( { "source_card_id": context.get("source_card_id", context.get("card_id", -1)), "effect": Effect(EffectType.REDUCE_COST, v, TargetType.SELF), "target_slot": s if s < 3 else -1, "expiry": "TURN_END", } ) elif opcode == Opcode.REDUCE_HEART_REQ: p.continuous_effects.append( { "source_card_id": context.get("source_card_id", context.get("card_id", -1)), "effect": Effect(EffectType.REDUCE_HEART_REQ, v, TargetType.SELF), "expiry": "LIVE_END" if context.get("until") == "live_end" else "TURN_END", } ) elif opcode == Opcode.BATON_TOUCH_MOD: p.continuous_effects.append( { "source_card_id": context.get("source_card_id", context.get("card_id", -1)), "effect": Effect(EffectType.BATON_TOUCH_MOD, v, TargetType.SELF), "expiry": "TURN_END", } ) elif opcode == Opcode.META_RULE: # Handle specific meta rules that have engine impact (cheer_mod, etc) rule_type = context.get("type", "") if rule_type == "cheer_mod": p.continuous_effects.append( { "source_card_id": context.get("source_card_id", context.get("card_id", -1)), "effect": Effect(EffectType.META_RULE, v, TargetType.SELF, {"type": "cheer_mod"}), "expiry": "LIVE_END" if context.get("until") == "live_end" else "TURN_END", } ) elif rule_type == "fragment_cleanup": pass # Already handled by parser filter else: p.meta_rules.add(str(rule_type)) elif opcode == Opcode.TRANSFORM_COLOR: target = context.get("target", "base_hearts") p.continuous_effects.append( { "source_card_id": context.get("source_card_id", context.get("card_id", -1)), "effect": Effect(EffectType.TRANSFORM_COLOR, v, TargetType.SELF, {"target": target, "color": a}), "expiry": "LIVE_END" if context.get("until") == "live_end" else "TURN_END", } ) elif opcode == Opcode.PLAY_MEMBER_FROM_HAND: # v = count, a = source_attr (e.g. Group) # From hand is standard, but if context says discard: source_zone = context.get("from", "hand") self.pending_choices.append( ( "TARGET_MEMBER_SLOT", { **context, "player_id": p.player_id, "effect": "place_member", "source_zone": source_zone, "count": v, "filter_group": a if a != 0 else None, }, ) ) elif opcode == Opcode.FLAVOR_ACTION: # Trigger modal choice "What do you like?" self.pending_choices.append( ( "MODAL_CHOICE", { **context, "player_id": opp_idx, "title": "What do you like?", "options": [ "Choco Mint", "Strawberry Flavor", "Cookies & Cream", "You", "Anything else", ], "reason": "flavor_action", }, ) ) elif opcode == Opcode.ADD_TO_HAND: # v = count, a = source (0=looked, 1=discard, 2=deck) if a == 0 and self.looked_cards: for _ in range(v): if self.looked_cards: cid = self.looked_cards.pop(0) p.hand.append(cid) p.hand_added_turn.append(self.turn_number) elif a == 1: # Handled by RECOVER_LIVE/MEMBER usually, but for generic: for _ in range(v): if p.discard: cid = p.discard.pop() p.hand.append(cid) p.hand_added_turn.append(self.turn_number) elif a == 2: self._draw_cards(p, v) elif opcode == Opcode.BOOST_SCORE: p.live_score_bonus += v elif opcode == Opcode.ENERGY_CHARGE: count = v for _ in range(count): if p.main_deck: cid = p.main_deck.pop(0) p.energy_zone.append(cid) p.tapped_energy[len(p.energy_zone) - 1] = False elif p.discard: self._resolve_deck_refresh(p) if p.main_deck: cid = p.main_deck.pop(0) p.energy_zone.append(cid) p.tapped_energy[len(p.energy_zone) - 1] = False elif opcode == Opcode.MOVE_MEMBER: dest = context.get("target_slot", -1) if 0 <= s < 3 and 0 <= dest < 3: self._move_member(p, s, dest) elif opcode == Opcode.MOVE_TO_DISCARD: # v = count, a = source (1=deck_top, 2=hand, 3=energy), s = target_slot if a == 1: # From Deck Top _append_deck_top_to_discard(self, p, v) elif a == 2: # From Hand discard_hand_cards(p, v) elif a == 3: # From Energy _append_energy_to_discard(p, v) elif s == 0: # Target SELF (Member on stage) scid = context.get("source_card_id", context.get("card_id", -1)) for i in range(3): if p.stage[i] == scid: p.stage[i] = -1 p.tapped_members[i] = False p.discard.append(scid) break elif opcode == Opcode.JUMP_IF_FALSE: # This requires a more complex loop in _resolve_pending_effect # For now, standard step() might not use jumps heavily in Python mode pass __all__ = ["resolve_effect_opcode"]