import copy import re from dataclasses import dataclass, field, fields from typing import Any, Dict, List, Tuple, Union from engine.models.enums import CHAR_MAP from engine.models.opcodes import Opcode from .ability_ir import SemanticAbility, SemanticCondition, SemanticCost, SemanticEffect from .ability_descriptions import ( EFFECT_DESCRIPTIONS, EFFECT_DESCRIPTIONS_JP, TRIGGER_DESCRIPTIONS, TRIGGER_DESCRIPTIONS_JP, ) from .ability_filter import PackedFilterSpec, explain_filter_attr, format_filter_attr from .structured_instruction_ir import build_structured_instruction_ir from .generated_enums import AbilityCostType, ConditionType, EffectType, TargetType, TriggerType from .generated_metadata import COMPARISONS, COUNT_SOURCES, EXTRA_CONSTANTS, HEART_COLOR_MAP, META_RULE_TYPES, ZONES from .generated_packer import ( pack_a_heart_cost, pack_a_standard, pack_s_standard, pack_v_heart_counts, pack_v_look_choose, pack_v_scalar_dynamic, unpack_a_standard, ) def to_signed_32(x): """Utility to convert an integer to a signed 32-bit integer.""" x = int(x) & 0xFFFFFFFF return x - 0x100000000 if x >= 0x80000000 else x # Original definitions removed, now using generated_enums. @dataclass(slots=True) class Condition: type: ConditionType params: Dict[str, Any] = field(default_factory=dict) is_negated: bool = False # "If NOT X" / "Except X" value: int = 0 attr: int = 0 @dataclass(slots=True) class Effect: effect_type: EffectType value: int = 0 value_cond: ConditionType = ConditionType.NONE target: TargetType = TargetType.SELF params: Dict[str, Any] = field(default_factory=dict) is_optional: bool = False # Optional choice flag modal_options: List[List[Any]] = field(default_factory=list) # For SELECT_MODE runtime_opcode: int = 0 runtime_value: int = 0 runtime_attr: int = 0 runtime_slot: int = 0 @dataclass(slots=True) class ResolvingEffect: """Wrapper for an effect currently being resolved to track its source and progress.""" effect: Effect source_card_id: int step_index: int total_steps: int # Original AbilityCostType removed, now using generated_enums. @dataclass class Cost: type: AbilityCostType value: int = 0 params: Dict[str, Any] = field(default_factory=dict) is_optional: bool = False @property def cost_type(self) -> AbilityCostType: return self.type @dataclass class Ability: raw_text: str trigger: TriggerType effects: List[Effect] conditions: List[Condition] = field(default_factory=list) costs: List[Cost] = field(default_factory=list) modal_options: List[List[Any]] = field(default_factory=list) # For SELECT_MODE is_once_per_turn: bool = False bytecode: List[int] = field(default_factory=list) # Ordered list of operations (Union[Effect, Condition]) for precise execution order instructions: List[Union[Effect, Condition, Cost]] = field(default_factory=list) card_no: str = "" # Metadata for debugging/tracing requires_selection: bool = False choice_flags: int = 0 choice_count: int = 0 pseudocode: str = "" filters: List[Dict[str, Any]] = field(default_factory=list) option_names: List[str] = field(default_factory=list) semantic_form: Dict[str, Any] = field(default_factory=dict) # Human-readable form def build_structured_ir(self) -> Dict[str, Any]: return build_structured_instruction_ir(self).to_dict() def compile(self) -> List[int]: """Compile ability into fixed-width bytecode sequence (groups of 4 ints).""" bytecode = [] self.filters = [] # Reset filters for this compilation self._annotate_effect_runtime_metadata() # CONSTANT abilities are enforced from serialized conditions rather than # condition opcodes in bytecode, so keep their numeric fields hydrated. if self.trigger == TriggerType.CONSTANT: self._normalize_serialized_conditions() # 0. Compile Ordered Instructions (If present - New Parser V2.1) if self.instructions: # Pass 1: Pre-calculate individual instruction sizes instr_bytecodes = [] self._last_counted_zone = None last_emitted_target = None i = 0 while i < len(self.instructions): instr = self.instructions[i] if isinstance(instr, Effect) and instr.params.get("raw_effect") == "COUNT_CARDS": self._last_counted_zone = (instr.params.get("zone") or instr.params.get("ZONE") or "").upper() temp_bc = [] if isinstance(instr, Condition): # CRITICAL FIX: For CONSTANT trigger abilities, do NOT compile conditions into bytecode. # The Rust engine evaluates CONSTANT ability conditions from the 'conditions' array separately # and expects bytecode to contain ONLY effect opcodes. if self.trigger != TriggerType.CONSTANT: self._compile_single_condition(instr, temp_bc) elif isinstance(instr, Effect) and instr.target == TargetType.ALL_PLAYERS: block = [instr] j = i + 1 while ( j < len(self.instructions) and isinstance(self.instructions[j], Effect) and self.instructions[j].target == TargetType.ALL_PLAYERS ): block.append(self.instructions[j]) j += 1 last_emitted_target = self._compile_all_players_block(temp_bc, block, last_emitted_target) instr_bytecodes.append(temp_bc) for _ in range(i + 1, j): instr_bytecodes.append([]) i = j continue elif isinstance(instr, Effect): last_emitted_target = self._compile_effect_with_target_persistence( instr, temp_bc, last_emitted_target ) elif isinstance(instr, Cost): mapping = { AbilityCostType.ENERGY: Opcode.PAY_ENERGY, AbilityCostType.TAP_SELF: Opcode.SET_TAPPED, AbilityCostType.TAP_MEMBER: Opcode.TAP_MEMBER, AbilityCostType.DISCARD_HAND: Opcode.MOVE_TO_DISCARD, AbilityCostType.PLACE_ENERGY_FROM_DECK: Opcode.PLACE_ENERGY_FROM_DECK, AbilityCostType.RETURN_HAND: Opcode.MOVE_MEMBER, AbilityCostType.SACRIFICE_SELF: Opcode.MOVE_TO_DISCARD, AbilityCostType.RETURN_DISCARD_TO_DECK: Opcode.MOVE_TO_DECK, AbilityCostType.NONE: Opcode.SELECT_CARDS, # Fallback for named costs } if ( instr.is_optional or instr.type in mapping or instr.params.get("cost_type_name") in ["CALC_SUM_COST", "SELECT_CARDS", "SELECT_MEMBER", "SELECT_ENERGY"] ): self._compile_single_cost(instr, temp_bc) if instr.is_optional: last_emitted_target = None instr_bytecodes.append(temp_bc) i += 1 # Pass 2: Emit bytecode with accurate jump targets for i, instr in enumerate(self.instructions): bc_chunk = instr_bytecodes[i] bytecode.extend(bc_chunk) if isinstance(instr, Cost) and instr.is_optional: # Calculate jump target based on BYTECODE size, not instruction count # skip_size = sum of lengths of remaining bytecode chunks / 5 remaining_bc_sum = sum(len(c) for c in instr_bytecodes[i + 1 :]) # We jump to the instruction AFTER the remaining ones (the RETURN) skip_count = remaining_bc_sum // 5 bytecode.extend([int(Opcode.JUMP_IF_FALSE), to_signed_32(skip_count), 0, 0, 0]) bytecode.extend([int(Opcode.RETURN), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)]) # Build semantic form for debugging/inspection (before returning) # Note: Only build if explicitly called, not during normal compilation to avoid side effects # self.build_semantic_form() return bytecode # 1. Compile Conditions (Legacy/Split Mode) # CRITICAL FIX: For CONSTANT trigger abilities, do NOT compile conditions into bytecode. # The Rust engine evaluates CONSTANT ability conditions from the 'conditions' array separately # and expects bytecode to contain ONLY effect opcodes (ADD_BLADES, etc). # If conditions are embedded in bytecode, they interfere with effect processing. if self.trigger != TriggerType.CONSTANT: for cond in self.conditions: self._compile_single_condition(cond, bytecode) # 1.5. Compile Costs (Note: Modern engine handles costs via pay_cost shell) # We don't compile costs into bytecode unless they are meant for mid-ability execution. # 2. Compile Effects (with ALL_PLAYERS grouping and target persistence optimization) # TARGET PERSISTENCE: Only emit SET_TARGET if it differs from last_emitted_target. # This reduces redundant target-switching opcodes by ~5 words (1 instruction) per target switch. i = 0 last_emitted_target = None # Track the last SET_TARGET that was emitted while i < len(self.effects): eff = self.effects[i] if eff.target == TargetType.ALL_PLAYERS: # Group consecutive ALL_PLAYERS effects into a single block block = [eff] j = i + 1 while j < len(self.effects) and self.effects[j].target == TargetType.ALL_PLAYERS: block.append(self.effects[j]) j += 1 # Emit block for SELF (only emit SET_TARGET_SELF if needed) if last_emitted_target != TargetType.PLAYER: bytecode.extend( [int(Opcode.SET_TARGET_SELF), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)] ) last_emitted_target = TargetType.PLAYER for e in block: # Create a copy with target=PLAYER (Self) e_self = Effect(e.effect_type, e.value, e.value_cond, TargetType.PLAYER, e.params) e_self.is_optional = e.is_optional self._compile_effect_wrapper(e_self, bytecode) # Emit block for OPPONENT (only emit SET_TARGET_OPPONENT if needed) if last_emitted_target != TargetType.OPPONENT: bytecode.extend( [ int(Opcode.SET_TARGET_OPPONENT), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0), ] ) last_emitted_target = TargetType.OPPONENT for e in block: # Create a copy with target=OPPONENT e_opp = Effect(e.effect_type, e.value, e.value_cond, TargetType.OPPONENT, e.params) e_opp.is_optional = e.is_optional self._compile_effect_wrapper(e_opp, bytecode) # Reset context to SELF for consistency (required for state consistency) # Only emit if the next effect isn't going to emit its own target immediately if j < len(self.effects): # Check if next effect will set its own target next_eff = self.effects[j] if next_eff.target != TargetType.PLAYER and next_eff.target != TargetType.ALL_PLAYERS: # Next effect sets its own target, skip the reset last_emitted_target = None else: # Next is PLAYER or ALL_PLAYERS, emit reset if last_emitted_target != TargetType.PLAYER: bytecode.extend( [int(Opcode.SET_TARGET_SELF), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)] ) last_emitted_target = TargetType.PLAYER else: # End of effects, reset to SELF for cleanliness if last_emitted_target != TargetType.PLAYER: bytecode.extend( [int(Opcode.SET_TARGET_SELF), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)] ) last_emitted_target = TargetType.PLAYER i = j else: # Non-ALL_PLAYERS effect - it will set its own target internally if needed # Reset tracking since this effect handles targeting last_emitted_target = None self._compile_effect_wrapper(eff, bytecode) i += 1 # 3. Add Costs to bytecode if present (Fallback for non-instruction abilities) # DISABLE: Modern engine handles costs via pay_costs_transactional in the trigger/activation shell. # if not self.instructions: # for cost in self.costs: # self._compile_single_cost(cost, bytecode) # Terminator bytecode.extend([int(Opcode.RETURN), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)]) # Build semantic form for debugging/inspection # Note: Only build if explicitly called, not during normal compilation to avoid side effects # self.build_semantic_form() return bytecode def _emit_target_opcode_if_needed(self, bytecode: List[int], target: TargetType, last_emitted_target: TargetType | None): desired_target = None if target in (TargetType.SELF, TargetType.PLAYER): desired_target = TargetType.PLAYER elif target == TargetType.OPPONENT: desired_target = TargetType.OPPONENT if desired_target is None: return None if desired_target == last_emitted_target: return last_emitted_target opcode = Opcode.SET_TARGET_SELF if desired_target == TargetType.PLAYER else Opcode.SET_TARGET_OPPONENT bytecode.extend([int(opcode), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)]) return desired_target def _compile_effect_with_target_persistence( self, eff: Effect, bytecode: List[int], last_emitted_target: TargetType | None ) -> TargetType | None: if eff.target == TargetType.ALL_PLAYERS: return self._compile_all_players_block(bytecode, [eff], last_emitted_target) next_target = None if last_emitted_target is not None and eff.target in (TargetType.SELF, TargetType.PLAYER, TargetType.OPPONENT): next_target = self._emit_target_opcode_if_needed(bytecode, eff.target, last_emitted_target) self._compile_effect_wrapper(eff, bytecode) if last_emitted_target is None: return None if eff.target in (TargetType.SELF, TargetType.PLAYER, TargetType.OPPONENT): return next_target return None def _compile_all_players_block( self, bytecode: List[int], block: List[Effect], last_emitted_target: TargetType | None ) -> TargetType | None: last_emitted_target = self._emit_target_opcode_if_needed(bytecode, TargetType.PLAYER, last_emitted_target) for eff in block: eff_self = Effect(eff.effect_type, eff.value, eff.value_cond, TargetType.PLAYER, eff.params.copy()) eff_self.is_optional = eff.is_optional self._compile_effect_wrapper(eff_self, bytecode) last_emitted_target = self._emit_target_opcode_if_needed(bytecode, TargetType.OPPONENT, last_emitted_target) for eff in block: eff_opp = Effect(eff.effect_type, eff.value, eff.value_cond, TargetType.OPPONENT, eff.params.copy()) eff_opp.is_optional = eff.is_optional self._compile_effect_wrapper(eff_opp, bytecode) return last_emitted_target def _normalize_serialized_conditions(self): for cond in self.conditions: temp_bc: List[int] = [] self._compile_single_condition(cond, temp_bc) def build_semantic_form(self) -> Dict[str, Any]: from .ability_rendering import build_semantic_form return build_semantic_form(self) def _annotate_effect_runtime_metadata(self): for eff in self.effects: self._annotate_single_effect_runtime(eff) def _annotate_single_effect_runtime(self, eff: Effect): eff.runtime_opcode = 0 eff.runtime_value = 0 eff.runtime_attr = 0 eff.runtime_slot = 0 for option in eff.modal_options: for option_item in option: if isinstance(option_item, Effect): self._annotate_single_effect_runtime(option_item) temp_bc: List[int] = [] eff_copy = copy.deepcopy(eff) try: self._compile_single_effect(eff_copy, temp_bc) except Exception: return if len(temp_bc) != 5: return eff.runtime_opcode = int(temp_bc[0]) eff.runtime_value = int(temp_bc[1]) eff.runtime_attr = ((int(temp_bc[3]) & 0xFFFFFFFF) << 32) | (int(temp_bc[2]) & 0xFFFFFFFF) eff.runtime_slot = int(temp_bc[4]) def _compile_single_condition(self, cond: Condition, bytecode: List[int]): # Special handling for BATON condition - must be first since it uses different param keys if cond.type == ConditionType.BATON: # Special handling for BATON condition # Bytecode format: [CHECK_BATON, val, attr, attr_hi, slot] # val: expected baton touch count (0 = any > 0, 2 = exactly 2) # attr: GROUP_ID filter (lower 32 bits) if hasattr(Opcode, "CHECK_BATON"): params_upper = {k.upper(): v for k, v in cond.params.items() if isinstance(k, str)} # Value: expected baton touch count val = 0 count_eq = ( cond.params.get("count_eq") or params_upper.get("COUNT_EQ") or cond.params.get("val") or cond.params.get("value") or params_upper.get("VAL") or params_upper.get("VALUE") ) if count_eq: try: val = int(count_eq) except (ValueError, TypeError): val = 0 # Attr: Standardized packing for filters attr = self._pack_filter_attr(cond) bytecode.extend( [ int(Opcode.CHECK_BATON), to_signed_32(val), to_signed_32(attr & 0xFFFFFFFF), to_signed_32((attr >> 32) & 0xFFFFFFFF), to_signed_32(0), ] ) cond.value = val cond.attr = attr return if cond.type == ConditionType.TYPE_CHECK: if hasattr(Opcode, "CHECK_TYPE_CHECK"): ctype = 1 if str(cond.params.get("card_type", "")).lower() == "live" else 0 bytecode.extend( [ int(Opcode.CHECK_TYPE_CHECK), to_signed_32(ctype), to_signed_32(0), to_signed_32(0), to_signed_32(0), ] ) cond.value = ctype cond.attr = 0 return op_name = f"CHECK_{cond.type.name}" op = getattr(Opcode, op_name, None) if op is None and cond.type == ConditionType.NONE and cond.params: # Systemic Fix: Preserve unknown conditions as Opcode 0 (NOP/UNKNOWN) # This allows the engine to see the params even if it doesn't have a specific opcode. op = 0 if op is not None: # Fixed width: [Opcode, Value, Attr, TargetSlot] # Check multiple potential keys for the value (min, count, value, diff) - case insensitive params_upper = {k.upper(): v for k, v in cond.params.items() if isinstance(k, str)} v_raw = ( cond.params.get("min") or cond.params.get("count") or cond.params.get("value") or cond.params.get("diff") or cond.params.get("GE") or cond.params.get("LE") or cond.params.get("GT") or cond.params.get("LT") or cond.params.get("EQ") or cond.params.get("COUNT_GE") or cond.params.get("COUNT_LE") or cond.params.get("COUNT_GT") or cond.params.get("COUNT_LT") or cond.params.get("COUNT_EQ") or cond.params.get("val") or params_upper.get("MIN") or params_upper.get("COUNT") or params_upper.get("VALUE") or params_upper.get("DIFF") or params_upper.get("GE") or params_upper.get("LE") or params_upper.get("GT") or params_upper.get("LT") or params_upper.get("EQ") or 0 ) try: val = int(v_raw) if v_raw is not None else 0 except (ValueError, TypeError): val = 0 if cond.params.get("ALL") or params_upper.get("ALL"): val |= 0x04 # Unified Filter Packing if op == int(Opcode.CHECK_HAS_KEYWORD): attr = 0 kw = str(cond.params.get("keyword") or "").upper() if "PLAYED_THIS_TURN" in kw: attr |= 1 << 44 elif "YELL_COUNT" in kw: attr |= 1 << 45 elif "HAS_LIVE_SET" in kw: attr |= 1 << 46 elif "ENERGY" in kw: attr |= 1 << 62 attr |= self._pack_filter_attr(cond) elif "MEMBER" in kw: attr |= 1 << 63 attr |= self._pack_filter_attr(cond) else: # Fallback for implicit keywords if cond.type == ConditionType.HAS_KEYWORD: cond.params["keyword"] = "PLAYED_THIS_TURN" attr |= 1 << 44 elif op == int(Opcode.CHECK_HEART_COMPARE): # Heart compare uses raw color index in bits 0-6 from engine.models.enums import HeartColor color_name = str(cond.params.get("color") or "").upper() try: attr = int(HeartColor[color_name]) except (KeyError, TypeError, ValueError): # Fallback: try to extract from filter string if directly missing f_str = str(cond.params.get("filter", "")).upper() if "YELLOW" in f_str: attr = 2 elif "RED" in f_str: attr = 1 elif "PINK" in f_str: attr = 0 elif "BLUE" in f_str: attr = 4 elif "GREEN" in f_str: attr = 3 elif "PURPLE" in f_str: attr = 5 else: attr = 7 # Total count fallback else: attr = self._pack_filter_attr(cond) # Persist back to the Condition object for JSON serialization cond.value = val cond.attr = attr # Comparison and Slot Mapping comp_str = str(cond.params.get("comparison") or params_upper.get("COMPARISON") or "GE").upper() comp_val = COMPARISONS.get(comp_str, 0) slot = 0 zone = str(cond.params.get("zone") or params_upper.get("ZONE") or "").upper() if zone == "LIVE_ZONE": slot = 13 # LIVE_SET elif zone == "STAGE": slot = int(TargetType.MEMBER_SELF) elif zone == "YELL" or zone == "YELL_REVEALED": slot = ZONES.get("YELL", 17) elif str(cond.params.get("context", "")).lower() == "excess": slot = 2 else: slot_raw = cond.params.get("TargetSlot") or params_upper.get("TARGETSLOT") or 0 slot = int(slot_raw) area_val = cond.params.get("area") or params_upper.get("AREA") if area_val: a_str = str(area_val).upper() if "LEFT" in a_str: slot |= 1 << 29 elif "CENTER" in a_str: slot |= 2 << 29 elif "RIGHT" in a_str: slot |= 3 << 29 packed_slot = (slot & 0x0F) | ((comp_val & 0x0F) << 4) | (slot & 0xFFFFFF00) bytecode.extend( [ to_signed_32(int(op) + (1000 if cond.is_negated else 0)), to_signed_32(val), to_signed_32(attr & 0xFFFFFFFF), to_signed_32((attr >> 32) & 0xFFFFFFFF), to_signed_32(packed_slot), ] ) elif cond.type == ConditionType.UNIQUE_NAMES_COUNT: # Map UNIQUE_NAMES_COUNT to CHECK_COUNT_STAGE with FILTER_UNIQUE_NAMES bit (32768) attr = self._pack_filter_attr(cond) attr |= EXTRA_CONSTANTS.get("FILTER_UNIQUE_NAMES", 32768) val = cond.value if val == 0: val = int(cond.params.get("min") or cond.params.get("count") or 0) comp_str = str(cond.params.get("comparison") or "GE").upper() comp_val = COMPARISONS.get(comp_str, 3) # Default GE slot = (int(TargetType.MEMBER_SELF) & 0x0F) | ((comp_val & 0x0F) << 4) # Use CONDITIONS directly to avoid dynamic attribute issues op_code = CONDITIONS.get("COUNT_STAGE", 203) bytecode.extend( [ to_signed_32(op_code), to_signed_32(val), to_signed_32(attr & 0xFFFFFFFF), to_signed_32((attr >> 32) & 0xFFFFFFFF), to_signed_32(slot), ] ) cond.value = val cond.attr = attr else: if cond.type != ConditionType.NONE: print(f"CRITICAL WARNING: No opcode mapping for condition type: {cond.type.name}") def _compile_single_cost(self, cost: Cost, bytecode: List[int]): """Compile a cost into its corresponding opcode.""" mapping = { AbilityCostType.ENERGY: Opcode.PAY_ENERGY, AbilityCostType.TAP_SELF: Opcode.SET_TAPPED, AbilityCostType.TAP_MEMBER: Opcode.TAP_MEMBER, AbilityCostType.DISCARD_HAND: Opcode.MOVE_TO_DISCARD, AbilityCostType.DISCARD_TOP_DECK: Opcode.MOVE_TO_DISCARD, AbilityCostType.PLACE_ENERGY_FROM_DECK: Opcode.PLACE_ENERGY_FROM_DECK, AbilityCostType.RETURN_HAND: Opcode.MOVE_MEMBER, AbilityCostType.SACRIFICE_SELF: Opcode.MOVE_TO_DISCARD, AbilityCostType.RETURN_MEMBER_TO_DECK: Opcode.MOVE_TO_DECK, AbilityCostType.RETURN_LIVE_TO_DECK: Opcode.MOVE_TO_DECK, AbilityCostType.RETURN_DISCARD_TO_DECK: Opcode.MOVE_TO_DECK, AbilityCostType.DISCARD_MEMBER: Opcode.MOVE_TO_DISCARD, AbilityCostType.DISCARD_LIVE: Opcode.MOVE_TO_DISCARD, AbilityCostType.DISCARD_ENERGY: Opcode.MOVE_TO_DISCARD, AbilityCostType.DISCARD_SUCCESS_LIVE: Opcode.MOVE_TO_DISCARD, AbilityCostType.DISCARD_STAGE_ENERGY: Opcode.MOVE_TO_DISCARD, AbilityCostType.REVEAL_HAND: Opcode.REVEAL_CARDS, AbilityCostType.REVEAL_HAND_ALL: Opcode.REVEAL_CARDS, } # Handle Named Costs (e.g. metadata-only costs handled via code) if cost.params.get("cost_type_name") == "CALC_SUM_COST": op = Opcode.CALC_SUM_COST elif cost.params.get("cost_type_name") == "SELECT_CARDS": op = Opcode.SELECT_CARDS elif cost.params.get("cost_type_name") == "SELECT_MEMBER": op = Opcode.SELECT_MEMBER elif cost.params.get("cost_type_name") == "SELECT_ENERGY": op = Opcode.PLACE_ENERGY_UNDER_MEMBER else: op = mapping.get(cost.type) if op is not None: attr = 0 slot_params = { "target_slot": 0, "remainder_zone": 0, "source_zone": 0, "dest_zone": 0, "is_opponent": False, "is_reveal_until_live": False, "is_empty_slot": False, "is_wait": False, "is_dynamic": False, "area_idx": 0, } params_upper = {k.upper(): v for k, v in cost.params.items() if isinstance(k, str)} filter_expr = cost.params.get("filter") or params_upper.get("FILTER") source_name = str(cost.params.get("from") or params_upper.get("FROM") or "").lower() uses_filtered_discard_selection = ( op == Opcode.MOVE_TO_DECK and source_name == "discard" and bool(filter_expr) ) if uses_filtered_discard_selection: select_attr = self._pack_filter_attr(cost) if cost.is_optional: select_attr |= EXTRA_CONSTANTS.get("FILTER_IS_OPTIONAL", 1 << 61) select_slot = pack_s_standard( target_slot=int(TargetType.CARD_DISCARD), remainder_zone=0, source_zone=int(ZONES.get("DISCARD", 7)), dest_zone=int(ZONES.get("DECK", 8)), is_opponent=False, is_reveal_until_live=False, is_empty_slot=False, is_wait=False, is_dynamic=False, area_idx=0, ) value = cost.value count_raw = cost.params.get("count") or params_upper.get("COUNT") if not value and count_raw is not None: value = int(count_raw) bytecode.extend( [ int(Opcode.SELECT_CARDS), to_signed_32(int(value)), to_signed_32(select_attr & 0xFFFFFFFF), to_signed_32((select_attr >> 32) & 0xFFFFFFFF), to_signed_32(select_slot), ] ) return # --- Resolve Slot (Source) --- if cost.type in [ AbilityCostType.DISCARD_HAND, AbilityCostType.RETURN_HAND, AbilityCostType.REVEAL_HAND, AbilityCostType.REVEAL_HAND_ALL, ]: slot_params["target_slot"] = int(TargetType.CARD_HAND) elif cost.type in [AbilityCostType.TAP_SELF, AbilityCostType.TAP_MEMBER, AbilityCostType.SACRIFICE_SELF]: slot_params["target_slot"] = int(TargetType.MEMBER_SELF) elif cost.type == AbilityCostType.DISCARD_ENERGY: slot_params["target_slot"] = int(TargetType.SELF) elif cost.type in [AbilityCostType.RETURN_DISCARD_TO_DECK]: slot_params["target_slot"] = int(TargetType.CARD_DISCARD) elif cost.type == AbilityCostType.DISCARD_TOP_DECK: slot_params["source_zone"] = ZONES.get("DECK_TOP", 1) elif cost.type in [AbilityCostType.RETURN_SUCCESS_LIVE_TO_HAND, AbilityCostType.DISCARD_SUCCESS_LIVE]: slot_params["source_zone"] = ZONES.get("SUCCESS_PILE", 14) elif cost.params.get("cost_type_name") == "SELECT_ENERGY": slot_params["target_slot"] = int(TargetType.SELF) slot_params["source_zone"] = ZONES.get("ENERGY", 3) else: slot_params["target_slot"] = int(TargetType.SELF) # --- Resolve Attr (Params/Destination) --- if op == Opcode.MOVE_TO_DECK: # 0=Discard, 1=Top, 2=Bottom to = str(cost.params.get("to") or params_upper.get("TO") or "top").lower() if to == "bottom": slot_params["remainder_zone"] = int(EXTRA_CONSTANTS.get("DECK_POSITION_BOTTOM", 2)) elif to == "top": slot_params["remainder_zone"] = int(EXTRA_CONSTANTS.get("DECK_POSITION_TOP", 1)) # O_SELECT_MEMBER / O_PLAY_MEMBER_FROM_HAND / MOVE_TO_DISCARD, encode filters into 'attr' (a) # O_SELECT_MEMBER / O_PLAY_MEMBER_FROM_HAND / MOVE_TO_DISCARD, encode filters into 'attr' (a) if op in [ Opcode.SELECT_CARDS, Opcode.SELECT_MEMBER, Opcode.TAP_MEMBER, Opcode.PLAY_MEMBER_FROM_HAND, Opcode.PLAY_MEMBER_FROM_DISCARD, Opcode.MOVE_TO_DISCARD, ]: attr = self._pack_filter_attr(cost) # Value capture flag (Bit 25 of slot) if cost.params.get("destination") == "target_val" or params_upper.get("DESTINATION") == "TARGET_VAL": slot_params["is_reveal_until_live"] = True # Reuse bit 25 for capture if cost.params.get("cost_type_name") == "SELECT_CARDS": source_name = str( cost.params.get("from") or cost.params.get("source") or params_upper.get("FROM") or params_upper.get("SOURCE") or "discard" ).lower() if source_name == "hand": slot_params["source_zone"] = ZONES.get("HAND", 6) slot_params["target_slot"] = int(TargetType.CARD_HAND) elif source_name == "stage": slot_params["source_zone"] = ZONES.get("STAGE", 4) slot_params["target_slot"] = int(TargetType.MEMBER_SELECT) elif source_name in ["deck", "deck_top"]: slot_params["source_zone"] = ZONES.get("DECK_TOP", 1) slot_params["target_slot"] = int(TargetType.CARD_DECK_TOP) else: slot_params["source_zone"] = ZONES.get("DISCARD", 7) slot_params["target_slot"] = int(TargetType.CARD_DISCARD) if cost.is_optional: attr |= EXTRA_CONSTANTS.get("FILTER_IS_OPTIONAL", 1 << 61) # Use value from cost params if available (max/count) value = cost.value count_raw = cost.params.get("count") or params_upper.get("COUNT") if not value and count_raw is not None: value = int(count_raw) # Fix: Default MOVE_TO_DISCARD, SET_TAPPED, and ACTIVATE_MEMBER for members to 1 cur_slot_val = slot_params["target_slot"] if ( op in [Opcode.MOVE_TO_DISCARD, Opcode.SET_TAPPED, Opcode.ACTIVATE_MEMBER] and value == 0 and cur_slot_val in (int(TargetType.MEMBER_SELF), int(TargetType.MEMBER_OTHER), int(TargetType.MEMBER_SELECT)) ): value = 1 slot = pack_s_standard(**slot_params) bytecode.extend( [ int(op), to_signed_32(int(value)), to_signed_32(attr & 0xFFFFFFFF), to_signed_32((attr >> 32) & 0xFFFFFFFF), to_signed_32(slot), ] ) if cost.params.get("cost_type_name") == "SELECT_CARDS": destination = str(cost.params.get("destination") or params_upper.get("DESTINATION") or "").lower() if destination in {"deck_bottom", "deck_top"}: move_slot_params = { "target_slot": 0, "remainder_zone": int( EXTRA_CONSTANTS.get( "DECK_POSITION_BOTTOM" if destination == "deck_bottom" else "DECK_POSITION_TOP", 2 if destination == "deck_bottom" else 1, ) ), "source_zone": 0, "dest_zone": int(ZONES.get("DECK", 8)), "is_opponent": False, "is_reveal_until_live": False, "is_empty_slot": False, "is_wait": False, "is_dynamic": False, "area_idx": 0, } move_slot = pack_s_standard(**move_slot_params) bytecode.extend( [ int(Opcode.MOVE_TO_DECK), to_signed_32(int(value)), to_signed_32(0), to_signed_32(0), to_signed_32(move_slot), ] ) else: if cost.type != AbilityCostType.NONE: # This ensures we don't silently drop costs like we did with TAP_MEMBER print(f"CRITICAL WARNING: No opcode mapping for cost type: {cost.type.name}") def _compile_effect_wrapper(self, eff: Effect, bytecode: List[int]): # Fix: Use name comparison to avoid Enum identity issues from reloading/imports if eff.effect_type.name == "ORDER_DECK": # O_ORDER_DECK requires looking at cards first. # Emit: [O_LOOK_DECK, val, 0, 0] -> [O_ORDER_DECK, val, attr, 0] # attr: 0=Discard, 1=DeckTop, 2=DeckBottom rem = eff.params.get("remainder", "discard").lower() attr = 0 if rem == "deck_top": attr = 1 elif rem == "deck_bottom": attr = 2 bytecode.extend( [int(Opcode.LOOK_DECK), to_signed_32(eff.value), to_signed_32(0), to_signed_32(0), to_signed_32(0)] ) bytecode.extend( [ int(Opcode.ORDER_DECK), to_signed_32(eff.value), to_signed_32(attr & 0xFFFFFFFF), to_signed_32((attr >> 32) & 0xFFFFFFFF), to_signed_32(0), ] ) return # Check for modal options on Effect OR Ability (fallback) modal_opts = eff.modal_options if eff.modal_options else self.modal_options if eff.effect_type == EffectType.SELECT_MODE and modal_opts: # Handle SELECT_MODE with jump table num_options = len(modal_opts) slot = 0 if eff.target == TargetType.OPPONENT: slot |= 1 << 24 # Emit header: [SELECT_MODE, NumOptions, 0, 0, slot] if hasattr(Opcode, "SELECT_MODE"): bytecode.extend( [ int(Opcode.SELECT_MODE), to_signed_32(num_options), to_signed_32(0), to_signed_32(0), to_signed_32(slot), ] ) # Populate descriptive option names for the UI if "options" in eff.params: self.option_names = [str(opt) for opt in eff.params["options"]] # Placeholders for Jump Table jump_table_start_idx = len(bytecode) for _ in range(num_options): bytecode.extend([int(Opcode.JUMP), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)]) # Compile each option and track start/end option_start_offsets = [] end_jumps_locations = [] for opt_instructions in modal_opts: # Record start offset (relative to current instruction pointer) current_idx = len(bytecode) // 5 option_start_offsets.append(current_idx) # Compile option instructions for opt_instr in opt_instructions: if isinstance(opt_instr, Cost): self._compile_single_cost(opt_instr, bytecode) elif isinstance(opt_instr, Condition): self._compile_single_condition(opt_instr, bytecode) else: self._compile_single_effect(opt_instr, bytecode) # Add Jump to End (placeholder) end_jumps_locations.append(len(bytecode)) bytecode.extend([int(Opcode.JUMP), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)]) # Determine End Index end_idx = len(bytecode) // 5 # Patch Jump Table (Start Jumps) for i in range(num_options): jump_instr_idx = (jump_table_start_idx // 5) + i target_idx = option_start_offsets[i] # Fix: Subtract 1 because SELECT_MODE handler in engine_rust adds 1 back unintentionally or # simply because the jump table itself counts as an instruction block in some offsets. # Specifically, the engine jump is handled as current_ip + 1 + offset. offset = target_idx - jump_instr_idx - 1 bytecode[jump_instr_idx * 5 + 1] = offset # Patch End Jumps for loc in end_jumps_locations: jump_instr_idx = loc // 5 offset = end_idx - jump_instr_idx bytecode[loc + 1] = offset else: if eff.target == TargetType.ALL_PLAYERS: # ALL_PLAYERS: Emit sequences for both SELF and OPPONENT # 1. SET_TARGET_SELF bytecode.extend( [int(Opcode.SET_TARGET_SELF), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)] ) # 2. Compile for SELF - COPY params to avoid shared mutations eff_self = Effect(eff.effect_type, eff.value, eff.value_cond, TargetType.PLAYER, eff.params.copy()) eff_self.is_optional = eff.is_optional self._compile_single_effect(eff_self, bytecode) # 3. SET_TARGET_OPPONENT bytecode.extend( [ int(Opcode.SET_TARGET_OPPONENT), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0), ] ) # 4. Compile for OPPONENT - COPY params to avoid shared mutations eff_opp = Effect(eff.effect_type, eff.value, eff.value_cond, TargetType.OPPONENT, eff.params.copy()) eff_opp.is_optional = eff.is_optional self._compile_single_effect(eff_opp, bytecode) # 5. Restore context to SELF (optional safety) bytecode.extend( [int(Opcode.SET_TARGET_SELF), to_signed_32(0), to_signed_32(0), to_signed_32(0), to_signed_32(0)] ) else: self._compile_single_effect(eff, bytecode) def _compile_single_effect(self, eff: Effect, bytecode: List[int]): # Normalize params to lowercase keys for consistent lookups eff.params = {str(k).lower(): v for k, v in eff.params.items()} source_val = 0 if hasattr(Opcode, eff.effect_type.name): op = getattr(Opcode, eff.effect_type.name) move_member_raw_value = str(eff.params.get("raw_val") or "").upper() if eff.effect_type == EffectType.MOVE_MEMBER and ( str(eff.value).upper() in ["ALL", "TARGETS"] or move_member_raw_value in ["ALL", "TARGET", "TARGETS"] ): val = 99 attr = 99 else: try: val = int(eff.value) except (ValueError, TypeError): val = 1 attr = eff.params.get("color", eff.params.get("heart_type", 0)) if not isinstance(attr, int): attr = 0 slot_params = { "target_slot": eff.target.value if hasattr(eff.target, "value") else int(eff.target), "remainder_zone": 0, "source_zone": 0, "dest_zone": 0, "is_opponent": False, "is_reveal_until_live": False, "is_empty_slot": False, "is_wait": False, "area_idx": 0, "is_dynamic": False, } self._resolve_effect_target(eff, slot_params) # --- Systemic Area Packing --- area_raw = eff.params.get("area", "") if not area_raw: f_str = str(eff.params.get("filter", "")).upper() if "AREA=CENTER" in f_str: area_raw = "CENTER" elif "AREA=LEFT" in f_str: area_raw = "LEFT_SIDE" elif "AREA=RIGHT" in f_str: area_raw = "RIGHT_SIDE" if area_raw: a_str = str(area_raw).upper() if "LEFT" in a_str: slot_params["area_idx"] = 1 elif "CENTER" in a_str: slot_params["area_idx"] = 2 elif "RIGHT" in a_str: slot_params["area_idx"] = 3 self._resolve_effect_source_zone(eff, slot_params) # TAP/Interactive selection tap_raw_value = str(eff.params.get("raw_val") or "").upper() if eff.effect_type in (EffectType.TAP_OPPONENT, EffectType.TAP_MEMBER): if eff.effect_type == EffectType.TAP_MEMBER and tap_raw_value in ["TARGET", "TARGETS"]: attr = 0 else: attr = self._pack_filter_attr(eff) if eff.effect_type == EffectType.TAP_MEMBER and tap_raw_value not in ["TARGET", "TARGETS"]: attr |= 0x02 # Bit 1: Selection mode # PLACE_UNDER params if eff.effect_type == EffectType.PLACE_UNDER: source = str(eff.params.get("from") or eff.params.get("source") or "").lower() u_src_val = 0 if source == "energy": u_src_val = ZONES.get("ENERGY", 3) elif source == "discard": u_src_val = ZONES.get("DISCARD", 7) slot_params["source_zone"] = u_src_val # ENERGY_CHARGE params if eff.effect_type == EffectType.ENERGY_CHARGE: if eff.params.get("wait") or eff.params.get("state") == "wait": slot_params["is_wait"] = True # Empty Slot flag dest = str(eff.params.get("destination") or "").lower() if eff.params.get("is_empty_slot") or dest == "stage_empty" or "EMPTY" in dest: slot_params["is_empty_slot"] = True # Specialized Opcode Packing if eff.effect_type == EffectType.SELECT_MEMBER: attr = self._pack_filter_attr(eff) if eff.effect_type == EffectType.MOVE_MEMBER: destination = str(eff.params.get("destination") or "").lower() if destination == "target" or move_member_raw_value in ["TARGET", "TARGETS"]: attr = 99 if eff.effect_type in (EffectType.PLAY_MEMBER_FROM_HAND, EffectType.PLAY_MEMBER_FROM_DISCARD): attr = self._pack_filter_attr(eff) dest_raw = str(eff.params.get("destination") or "").upper() if dest_raw == "STAGE_EMPTY": slot_params["target_slot"] = 4 elif "BATON" in dest_raw: slot_params["is_baton_slot"] = True if eff.effect_type == EffectType.PLAY_LIVE_FROM_DISCARD: attr = self._pack_filter_attr(eff) if eff.effect_type == EffectType.LOOK_AND_CHOOSE: val = self._pack_effect_look_and_choose(eff, val, slot_params) attr |= self._pack_filter_attr(eff) if eff.effect_type in ( EffectType.SELECT_CARDS, EffectType.SELECT_MEMBER, EffectType.SELECT_LIVE, EffectType.MOVE_TO_DISCARD, EffectType.RECOVER_LIVE, EffectType.RECOVER_MEMBER, ): attr = self._pack_filter_attr(eff) src_zone_str = str(eff.params.get("source") or eff.params.get("from") or eff.params.get("zone") or "DECK").upper() if "," not in src_zone_str: if src_zone_str == "HAND": src_val = ZONES.get("HAND", 6) elif src_zone_str == "DISCARD": src_val = ZONES.get("DISCARD", 7) elif src_zone_str in ("YELL", "REVEALED", "CHEER"): src_val = ZONES.get("YELL", 15) elif src_zone_str in ("STAGE", "TARGET_STAGE"): src_val = ZONES.get("STAGE", 4) elif ( src_zone_str == "DECK" and eff.effect_type in (EffectType.SELECT_MEMBER, EffectType.MOVE_TO_DISCARD) ): src_val = ZONES.get("STAGE", 4) else: src_val = ZONES.get("DECK_TOP", 1) slot_params["source_zone"] = src_val rem_val = eff.params.get("remainder_zone", 0) if not rem_val and eff.params.get("raw_val") == "REMAINDER": rem_val = "DISCARD" slot_params["target_slot"] = 0 if isinstance(rem_val, str): rem_map = { "DISCARD": ZONES.get("DISCARD", 7), "DECK": ZONES.get("DECK_TOP", 1), "HAND": ZONES.get("HAND", 6), "DECK_TOP": EXTRA_CONSTANTS.get("DECK_POSITION_TOP", 1), "DECK_BOTTOM": EXTRA_CONSTANTS.get("DECK_POSITION_BOTTOM", 2), } rem_val = rem_map.get(rem_val.upper(), 0) slot_params["remainder_zone"] = rem_val if eff.effect_type == EffectType.MOVE_MEMBER and attr != 99: attr = self._pack_filter_attr(eff) src_zone_str = str(eff.params.get("source") or eff.params.get("from") or eff.params.get("zone") or "DECK").upper() if "," not in src_zone_str: if src_zone_str == "HAND": src_val = ZONES.get("HAND", 6) elif src_zone_str == "DISCARD": src_val = ZONES.get("DISCARD", 7) elif src_zone_str in ("YELL", "REVEALED", "CHEER"): src_val = ZONES.get("YELL", 15) elif src_zone_str in ("STAGE", "TARGET_STAGE"): src_val = ZONES.get("STAGE", 4) else: src_val = ZONES.get("DECK_TOP", 1) slot_params["source_zone"] = src_val rem_val = eff.params.get("remainder_zone", 0) if not rem_val and eff.params.get("raw_val") == "REMAINDER": rem_val = "DISCARD" slot_params["target_slot"] = 0 if isinstance(rem_val, str): rem_map = { "DISCARD": ZONES.get("DISCARD", 7), "DECK": ZONES.get("DECK_TOP", 1), "HAND": ZONES.get("HAND", 6), "DECK_TOP": EXTRA_CONSTANTS.get("DECK_POSITION_TOP", 1), "DECK_BOTTOM": EXTRA_CONSTANTS.get("DECK_POSITION_BOTTOM", 2), } rem_val = rem_map.get(rem_val.upper(), 0) slot_params["remainder_zone"] = rem_val if eff.effect_type == EffectType.MOVE_TO_DISCARD: # REMAINDER handling for LOOK_AND_CHOOSE_ORDER if not rem_val and eff.params.get("raw_val") == "REMAINDER": rem_val = "DISCARD" slot_params["target_slot"] = 0 # For UNTIL_SIZE operations, default source is HAND (not STAGE) # as UNTIL_SIZE is used for hand size checks default_source = "hand" if eff.params.get("operation") == "UNTIL_SIZE" else "stage" src_val = eff.params.get("source", default_source).upper() if src_val == "HAND": src_val = ZONES.get("HAND", 6) elif src_val == "DISCARD": src_val = ZONES.get("DISCARD", 7) elif any(k in src_val for k in ["DECK", "LOOKED"]): src_val = ZONES.get("DECK_TOP", 1) else: src_val = ZONES.get("STAGE", 4) slot_params["source_zone"] = src_val if isinstance(rem_val, str): rem_map = { "DISCARD": ZONES.get("DISCARD", 7), "DECK_TOP": ZONES.get("DECK_TOP", 1), "DECK_BOTTOM": ZONES.get("DECK_BOTTOM", 2), "HAND": ZONES.get("HAND", 6), } slot_params["remainder_zone"] = rem_map.get(rem_val.upper(), 0) slot_params["dest_zone"] = ZONES.get("DISCARD", 7) if eff.effect_type == EffectType.PLACE_UNDER: source = str(eff.params.get("from") or eff.params.get("source") or "").lower() u_src_val = 0 if source == "energy": u_src_val = ZONES.get("ENERGY", 3) elif source == "discard": u_src_val = ZONES.get("DISCARD", 7) slot_params["source_zone"] = u_src_val # ENERGY_CHARGE params if eff.effect_type == EffectType.ENERGY_CHARGE: if eff.params.get("wait") or eff.params.get("state") == "wait": slot_params["is_wait"] = True # Empty Slot flag dest = str(eff.params.get("destination") or "").lower() if eff.params.get("is_empty_slot") or dest == "stage_empty" or "EMPTY" in dest: slot_params["is_empty_slot"] = True # Specialized Opcode Packing if eff.effect_type == EffectType.SELECT_MEMBER: attr = self._pack_filter_attr(eff) if eff.effect_type == EffectType.MOVE_MEMBER: destination = str(eff.params.get("destination") or "").lower() if destination == "target" or move_member_raw_value in ["TARGET", "TARGETS"]: attr = 99 if eff.effect_type in (EffectType.PLAY_MEMBER_FROM_HAND, EffectType.PLAY_MEMBER_FROM_DISCARD): attr = self._pack_filter_attr(eff) dest_raw = str(eff.params.get("destination") or "").upper() if dest_raw == "STAGE_EMPTY": slot_params["target_slot"] = 4 elif "BATON" in dest_raw: slot_params["is_baton_slot"] = True if eff.effect_type == EffectType.PLAY_LIVE_FROM_DISCARD: attr = self._pack_filter_attr(eff) if eff.effect_type == EffectType.LOOK_AND_CHOOSE: val = self._pack_effect_look_and_choose(eff, val, slot_params) attr |= self._pack_filter_attr(eff) if eff.effect_type in ( EffectType.SELECT_CARDS, EffectType.SELECT_MEMBER, EffectType.SELECT_LIVE, EffectType.MOVE_TO_DISCARD, EffectType.RECOVER_LIVE, EffectType.RECOVER_MEMBER, ): attr = self._pack_filter_attr(eff) src_zone_str = str(eff.params.get("source") or eff.params.get("from") or eff.params.get("zone") or "DECK").upper() if "," not in src_zone_str: if src_zone_str == "HAND": src_val = ZONES.get("HAND", 6) elif src_zone_str == "DISCARD": src_val = ZONES.get("DISCARD", 7) elif src_zone_str in ("YELL", "REVEALED", "CHEER"): src_val = ZONES.get("YELL", 15) elif src_zone_str in ("STAGE", "TARGET_STAGE"): src_val = ZONES.get("STAGE", 4) elif ( src_zone_str == "DECK" and eff.effect_type in (EffectType.SELECT_MEMBER, EffectType.MOVE_TO_DISCARD) ): src_val = ZONES.get("STAGE", 4) else: src_val = ZONES.get("DECK_TOP", 1) slot_params["source_zone"] = src_val rem_val = eff.params.get("remainder_zone", 0) if not rem_val and eff.params.get("raw_val") == "REMAINDER": rem_val = "DISCARD" slot_params["target_slot"] = 0 if isinstance(rem_val, str): rem_map = { "DISCARD": ZONES.get("DISCARD", 7), "DECK": ZONES.get("DECK_TOP", 1), "HAND": ZONES.get("HAND", 6), "DECK_TOP": EXTRA_CONSTANTS.get("DECK_POSITION_TOP", 1), "DECK_BOTTOM": EXTRA_CONSTANTS.get("DECK_POSITION_BOTTOM", 2), } rem_val = rem_map.get(rem_val.upper(), 0) slot_params["remainder_zone"] = rem_val if eff.effect_type == EffectType.MOVE_MEMBER and attr != 99: attr = self._pack_filter_attr(eff) src_zone_str = str(eff.params.get("source") or eff.params.get("from") or eff.params.get("zone") or "DECK").upper() if "," not in src_zone_str: if src_zone_str == "HAND": src_val = ZONES.get("HAND", 6) elif src_zone_str == "DISCARD": src_val = ZONES.get("DISCARD", 7) elif src_zone_str in ("YELL", "REVEALED", "CHEER"): src_val = ZONES.get("YELL", 15) elif src_zone_str in ("STAGE", "TARGET_STAGE"): src_val = ZONES.get("STAGE", 4) else: src_val = ZONES.get("DECK_TOP", 1) slot_params["source_zone"] = src_val rem_val = eff.params.get("remainder_zone", 0) if not rem_val and eff.params.get("raw_val") == "REMAINDER": rem_val = "DISCARD" slot_params["target_slot"] = 0 if isinstance(rem_val, str): rem_map = { "DISCARD": ZONES.get("DISCARD", 7), "DECK": ZONES.get("DECK_TOP", 1), "HAND": ZONES.get("HAND", 6), "DECK_TOP": EXTRA_CONSTANTS.get("DECK_POSITION_TOP", 1), "DECK_BOTTOM": EXTRA_CONSTANTS.get("DECK_POSITION_BOTTOM", 2), } rem_val = rem_map.get(rem_val.upper(), 0) slot_params["remainder_zone"] = rem_val if eff.effect_type == EffectType.SET_HEART_COST: val, attr = self._pack_effect_heart_cost(eff, val, attr) if eff.effect_type == EffectType.REVEAL_UNTIL: attr = self._pack_filter_attr(eff) if ( eff.value_cond == ConditionType.TYPE_CHECK and str(eff.params.get("card_type", "")).lower() == "live" ): slot_params["is_reveal_until_live"] = True elif eff.value_cond == ConditionType.COST_CHECK: attr = int(eff.params.get("min", 0)) if eff.effect_type == EffectType.META_RULE: m_type = str(eff.params.get("type", "") or eff.params.get("meta_type", "") or "CHEER_MOD").upper() attr = META_RULE_TYPES.get(m_type, 0) if attr == 1: src = str(eff.params.get("source", "")).lower() if src == "all_blade" or m_type == "ALL_BLADE_AS_ANY_HEART": val = 1 elif src == "blade": val = 2 if eff.effect_type == EffectType.RESTRICTION: restriction_type = str(eff.params.get("type", "")).lower() restriction_map = { "live": 1, "placement": 2, } attr = restriction_map.get(restriction_type, attr) if eff.effect_type in ( EffectType.MOVE_TO_DISCARD, EffectType.COLOR_SELECT, EffectType.TRANSFORM_HEART, EffectType.TRANSFORM_COLOR, ): attr = self._pack_filter_attr(eff) if eff.effect_type == EffectType.MOVE_TO_DISCARD and eff.params.get("operation") == "UNTIL_SIZE": val = (int(val) & 0x7FFFFFFF) | (1 << 31) val, attr = self._resolve_effect_dynamic_multiplier(eff, val, slot_params, attr) # Default to Choice (slot 4) if target is generic is_non_stage_discard = eff.effect_type == EffectType.MOVE_TO_DISCARD and slot_params["source_zone"] in ( ZONES.get("HAND", 6), ZONES.get("DECK", 5), ) if ( eff.target in (TargetType.SELF, TargetType.PLAYER) and not is_non_stage_discard and not slot_params.get("is_dynamic", False) and not (eff.effect_type == EffectType.MOVE_MEMBER and attr == 99) ): slot_params["target_slot"] = 4 # TARGETS usually means "the previously selected player-stage members". # For sweep selectors like SELECT_MEMBER(ALL) {FILTER="PLAYER"} -> TARGETS, # follow-up stage buffs should resolve as a player-wide stage effect. if ( str(eff.params.get("destination") or "").lower() == "targets" and eff.target == TargetType.PLAYER and eff.effect_type in (EffectType.ADD_BLADES, EffectType.ADD_HEARTS, EffectType.BUFF_POWER, EffectType.GRANT_ABILITY) ): slot_params["target_slot"] = int(TargetType.PLAYER) # SYSTEMIC FIX: If this is REDUCE_COST with dynamic multiplier, base value should be 1 if eff.effect_type == EffectType.REDUCE_COST and slot_params.get("is_dynamic"): val = 1 # SYSTEMIC FIX: Set is_wait if wait flow is detected if eff.params.get("wait") or eff.params.get("wait_flow"): slot_params["is_wait"] = True slot = pack_s_standard(**slot_params) # Redundant setting for PREVENT_PLAY_TO_SLOT (relies on slot bit 24) if eff.effect_type == EffectType.PREVENT_PLAY_TO_SLOT: pass # Target opponent bit 24 handles this generically # ENSURE OPTIONAL BIT 61 SET FOR ALL OPCODES if eff.is_optional or eff.params.get("is_optional"): attr |= EXTRA_CONSTANTS.get("FILTER_IS_OPTIONAL", 1 << 61) attr_val = attr if not eff.params.get("all") else (attr | 0x80) # --- SYSTEMIC FIX: Ensure Opcode Mapping for all types --- if eff.effect_type == EffectType.LOOK_REORDER_DISCARD: op = Opcode.LOOK_REORDER_DISCARD v = int(val) bytecode.extend( [ int(op), to_signed_32(v), to_signed_32(attr_val & 0xFFFFFFFF), to_signed_32((attr_val >> 32) & 0xFFFFFFFF), to_signed_32(slot), ] ) elif eff.effect_type == EffectType.DIV_VALUE: op = Opcode.DIV_VALUE v = int(eff.params.get("divisor") or eff.value or 2) bytecode.extend([int(op), to_signed_32(v), 0, 0, 0]) elif eff.effect_type == EffectType.REVEAL_UNTIL: op = Opcode.REVEAL_UNTIL v = int(val) bytecode.extend( [ int(op), to_signed_32(v), to_signed_32(attr_val & 0xFFFFFFFF), to_signed_32((attr_val >> 32) & 0xFFFFFFFF), to_signed_32(slot), ] ) elif eff.effect_type == EffectType.CALC_SUM_COST: op = Opcode.CALC_SUM_COST bytecode.extend( [ int(op), to_signed_32(val), to_signed_32(attr_val & 0xFFFFFFFF), to_signed_32((attr_val >> 32) & 0xFFFFFFFF), to_signed_32(slot), ] ) else: # SYSTEMIC FIX: Ensure filter is packed if present in params for generic effects # This fixes data loss for ADD_BLADES, ADD_HEARTS, BOOST_SCORE etc when they carry a filter. if "filter" in eff.params and attr == 0: attr_val = self._pack_filter_attr(eff) if eff.is_optional or eff.params.get("is_optional"): attr_val |= EXTRA_CONSTANTS.get("FILTER_IS_OPTIONAL", 1 << 61) # Fix: Default MOVE_TO_DISCARD for members to 1 if ( op == Opcode.MOVE_TO_DISCARD and val == 0 and slot in (int(TargetType.MEMBER_SELF), int(TargetType.MEMBER_OTHER), int(TargetType.MEMBER_SELECT)) ): val = 1 bytecode.extend( [ int(op), to_signed_32(val), to_signed_32(attr_val & 0xFFFFFFFF), # a_low to_signed_32((attr_val >> 32) & 0xFFFFFFFF), # a_high to_signed_32(slot), ] ) def _resolve_effect_target(self, eff: Effect, slot_params: Dict[str, Any]): """--- Target Resolution from Params ---""" target_raw = eff.params.get("target") or eff.params.get("to") if target_raw: target_str = str(target_raw).upper() target_map = { "HAND": TargetType.CARD_HAND, "CARD_HAND": TargetType.CARD_HAND, "DISCARD": TargetType.CARD_DISCARD, "CARD_DISCARD": TargetType.CARD_DISCARD, "DECK": TargetType.CARD_DECK_TOP, "CARD_DECK_TOP": TargetType.CARD_DECK_TOP, "PLAYER": TargetType.PLAYER, "SELF": TargetType.SELF, "OPPONENT": TargetType.OPPONENT, "MEMBER_SELF": TargetType.MEMBER_SELF, "MEMBER_SELECT": TargetType.MEMBER_SELECT, } if target_str in target_map: eff.target = target_map[target_str] elif "MEMBER" in target_str: if "OTHER" in target_str: eff.target = TargetType.MEMBER_OTHER else: eff.target = TargetType.MEMBER_SELECT elif eff.effect_type == EffectType.TAP_OPPONENT: eff.target = TargetType.OPPONENT # Update slot_params with the new target slot_params["target_slot"] = eff.target.value if hasattr(eff.target, "value") else int(eff.target) def _resolve_effect_source_zone(self, eff: Effect, slot_params: Dict[str, Any]): """--- Zone Relocation ---""" src_val = 0 if eff.effect_type in ( EffectType.RECOVER_MEMBER, EffectType.RECOVER_LIVE, EffectType.PLAY_MEMBER_FROM_DISCARD, EffectType.PLAY_LIVE_FROM_DISCARD, ): source = str(eff.params.get("source") or eff.params.get("zone") or "discard").lower() src_val = ZONES.get("DISCARD", 7) if source == "discard" else 0 if source == "yell": src_val = ZONES.get("YELL", 15) elif source in ("deck", "deck_top"): src_val = ZONES.get("DECK_TOP", 1) slot_params["source_zone"] = src_val # TAP/Interactive selection also uses source zone if eff.effect_type in (EffectType.TAP_OPPONENT, EffectType.TAP_MEMBER): slot_params["source_zone"] = src_val def _pack_effect_look_and_choose(self, eff: Effect, val: int, slot_params: Dict[str, Any]) -> int: """Special encoding for LOOK_AND_CHOOSE: val = look_count | (pick_count << 8) | (color_mask << 23)""" char_ids = [] # Simple extraction of up to 3 character IDs raw_names = str(eff.params.get("group") or eff.params.get("target_name") or eff.params.get("character") or "") if raw_names: parts = raw_names.replace(",", "/").split("/") for p in parts[:3]: p = p.strip() if p in CHAR_MAP: char_ids.append(CHAR_MAP[p]) look_v = { "count": val, "char_id_1": char_ids[0] if char_ids else 0, "char_id_2": char_ids[1] if len(char_ids) > 1 else 0, "char_id_3": char_ids[2] if len(char_ids) > 2 else 0, "reveal": 1 if eff.params.get("reveal") else 0, "dest_discard": 1 if eff.params.get("destination") == "discard" or eff.params.get("dest_discard") else 0, } val = pack_v_look_choose(**look_v) src = str(eff.params.get("source") or eff.params.get("zone") or "DECK").upper() src_val = ZONES.get("DECK_TOP", 1) if src == "HAND": src_val = ZONES.get("HAND", 6) elif src == "DISCARD": src_val = ZONES.get("DISCARD", 7) elif src in ("YELL", "REVEALED", "CHEER"): src_val = ZONES.get("YELL", 15) elif src == "ENERGY": src_val = ZONES.get("ENERGY", 3) slot_params["source_zone"] = src_val rem_dest_str = str(eff.params.get("remainder") or eff.params.get("destination") or "").upper() rem_val = 0 if rem_dest_str == "DISCARD": rem_val = ZONES.get("DISCARD", 7) elif rem_dest_str == "DECK": rem_val = ZONES.get("DECK_TOP", 1) elif rem_dest_str == "HAND": rem_val = ZONES.get("HAND", 6) elif rem_dest_str == "DECK_TOP": rem_val = EXTRA_CONSTANTS.get("DECK_POSITION_TOP", 1) elif rem_dest_str == "DECK_BOTTOM": rem_val = EXTRA_CONSTANTS.get("DECK_POSITION_BOTTOM", 2) slot_params["remainder_zone"] = rem_val # Parity Fix: Set is_wait if 'wait' parameter is present if eff.params.get("wait") or eff.params.get("wait_flow"): slot_params["is_wait"] = True return val def _pack_effect_heart_cost(self, eff: Effect, val: int, attr: int) -> Tuple[int, int]: """Specialized packing for SET_HEART_COST.""" colors = ["pink", "red", "yellow", "green", "blue", "purple"] v_params = {c: int(eff.params.get(c, 0)) for c in colors} val = pack_v_heart_counts(**v_params) color_map = HEART_COLOR_MAP req_list = [] add_val = eff.params.get("add") if isinstance(add_val, (str, list)): parts = add_val.replace(",", "/").split("/") if isinstance(add_val, str) else add_val req_list = [color_map.get(str(p).strip().upper(), 0) for p in parts[:8]] any_count = int(eff.params.get("any", 0)) for _ in range(any_count): if len(req_list) < 8: req_list.append(HEART_COLOR_MAP.get("ANY", 7)) a_params = {f"req_{i + 1}": req_list[i] if i < len(req_list) else 0 for i in range(8)} unit_val = eff.params.get("unit") if unit_val: try: from engine.models.enums import Unit u_id = int(str(unit_val)) if str(unit_val).isdigit() else int(Unit.from_japanese_name(str(unit_val))) a_params["unit_enabled"] = True a_params["unit_id"] = u_id & 0x7F except (AttributeError, TypeError, ValueError): pass attr = pack_a_heart_cost(**a_params) return val, attr def _resolve_effect_dynamic_multiplier(self, eff: Effect, val: int, slot_params: Dict[str, Any], attr: int) -> Tuple[int, int]: """Resolve dynamic multiplier logic for effects.""" divisor = 1 params = eff.params if not (params.get("per_card") or params.get("per_member") or params.get("has_multiplier") or params.get("per_energy") or params.get("per_energy_paid")): return val, attr # Extract scaling divisor if present divisor = int(params.get("per_energy") or params.get("per_energy_paid") or params.get("per_card_divisor") or 1) count_src = str(params.get("per_card", "")).upper() if count_src == "COUNT" and hasattr(self, "_last_counted_zone") and self._last_counted_zone: count_src = self._last_counted_zone count_op = COUNT_SOURCES.get(count_src, int(ConditionType.COUNT_STAGE)) slot_params["remainder_zone"] = count_op slot_params["is_dynamic"] = True # Ensure multiplier threshold is 1 if not specified if not params.get("value_enabled") and not params.get("cost_ge") and not params.get("cost_le"): params["value_enabled"] = True params["value_threshold"] = 1 # SYSTEMIC FIX: If this is REDUCE_COST, base value should be 1 if eff.effect_type == EffectType.REDUCE_COST: # We can't easily change 'val' here because it's passed by value # But we can update the effect value in place if needed, or caller handles it. pass # Packed value with divisor in high bits packed_val = pack_v_scalar_dynamic(base_value=val, divisor=divisor) # Ensure the DYNAMIC_VALUE bit (bit 60) is set in the attribute for the engine to recognize scaling dynamic_bit = EXTRA_CONSTANTS.get("DYNAMIC_VALUE", 1 << 60) return packed_val, self._pack_filter_attr(eff) | dynamic_bit def _pack_filter_slot(self, area_str: str) -> int: """Helper to pack area strings into slot bits (29-31).""" slot = 0 a_str = area_str.upper() if "LEFT" in a_str: slot |= 1 << 29 elif "CENTER" in a_str: slot |= 2 << 29 elif "RIGHT" in a_str: slot |= 3 << 29 return slot def _pack_filter_attr(self, source: Any) -> int: """ Standardized packing for all filter parameters (Revision 5, 64-bit). 'source' can be an Effect, Condition, or direct Dict params. """ attr = 0 from engine.models.enums import CHAR_MAP, Group, HeartColor, Unit from engine.models.generated_metadata import CHARACTER_IDS # 0. Initialize params from various sources if hasattr(source, "params"): params = source.params elif isinstance(source, dict): params = source else: params = {} params_upper = {str(k).upper(): v for k, v in params.items() if isinstance(k, str)} # Extract filter string and other parameters raw_filter_str = str( params.get("filter") or params_upper.get("FILTER") or params.get("player_center_filter") or params_upper.get("PLAYER_CENTER_FILTER") or params.get("opponent_center_filter") or params_upper.get("OPPONENT_CENTER_FILTER") or "" ) filter_str = raw_filter_str.upper() # Structured object for Phase 3 parity filter_obj = { "target_player": 0, "card_type": 0, "group_enabled": False, "group_id": 0, "is_tapped": False, "has_blade_heart": False, "not_has_blade_heart": False, "unique_names": False, "unit_enabled": False, "unit_id": 0, "value_enabled": False, "value_threshold": 0, "is_le": False, "is_cost_type": False, "color_mask": 0, "char_id_1": 0, "char_id_2": 0, "zone_mask": 0, "special_id": 0, "is_setsuna": False, "compare_accumulated": False, "is_optional": False, "keyword_energy": False, "keyword_member": False, } # Use a separate local variable for filter-specific value thresholding # to avoid 'val' contamination from the parent command (e.g. COUNT_MEMBER(2) shouldn't require 2 hearts) f_val = 0 colors = params.get("colors") or params.get("choices") or ([params.get("color")] if "color" in params else []) sid = params.get("special_id") or params_upper.get("SPECIAL_ID") # 1. Target Player (Bits 0-1) if hasattr(source, "target") and source.target == TargetType.OPPONENT: filter_obj["target_player"] = 2 elif params_upper.get("OPPONENT") or params_upper.get("TARGET_OPPONENT"): filter_obj["target_player"] = 2 elif "OPPONENT" in filter_str: filter_obj["target_player"] = 2 elif hasattr(source, "target") and source.target in (TargetType.PLAYER, TargetType.SELF): filter_obj["target_player"] = 1 else: filter_obj["target_player"] = 0 # Parity Fix: Default to 0 (Unspecified) # Check for ANY_STAGE area parameter which indicates checking both players' stages area_val = params.get("area") or params_upper.get("AREA") if area_val: area_str = str(area_val).upper() if "ANY_STAGE" in area_str: filter_obj["target_player"] = 3 # BOTH players' stages # 2. Card Type (Bits 2-3) ctype = str(params.get("type") or params.get("card_type") or "").lower() if not ctype and "TYPE=" in filter_str: m = re.search(r"TYPE=(\w+)", filter_str) if m: ctype = m.group(1).lower() elif not ctype and "TYPE_" in filter_str: # Handle TYPE_MEMBER, TYPE_LIVE format in filter string m = re.search(r"TYPE_(\w+)", filter_str) if m: ctype = m.group(1).lower() if "live" in ctype: filter_obj["card_type"] = 2 elif "member" in ctype: filter_obj["card_type"] = 1 # 3. Group Filter (Bit 4 + Bits 5-11) group_val = params.get("group") or params.get("group_id") or params_upper.get("GROUP_ID") if not group_val and "GROUP_ID=" in filter_str: m = re.search(r"GROUP_ID=(\d+)", filter_str) if m: group_val = m.group(1) elif not group_val and "GROUP_" in filter_str: m = re.search(r"GROUP_([A-Z]+)", filter_str) if m: group_val = m.group(1) elif not group_val and "NIJIGASAKI" in filter_str: group_val = 2 elif not group_val and "LIELLA" in filter_str: group_val = 3 elif not group_val and "HASUNOSORA" in filter_str: group_val = 4 if group_val: try: g_id = ( int(str(group_val)) if str(group_val).isdigit() else int(Group.from_japanese_name(str(group_val).replace("_", " "))) ) filter_obj["group_enabled"] = True filter_obj["group_id"] = g_id & 0x7F except (AttributeError, TypeError, ValueError): pass # 4. Unit Filter (Bit 16 + Bits 17-23) # NOTE: Some keywords like "UNIT_HASUNOSORA" are actually GROUP constraints, not UNIT constraints. # We must intercept these and treat them as groups instead of trying to resolve them as units. unit_val = params.get("unit") or params.get("unit_id") or params_upper.get("UNIT_ID") if not unit_val and "UNIT_ID=" in filter_str: m = re.search(r"UNIT_ID=(\d+)", filter_str) if m: unit_val = m.group(1) elif not unit_val and "UNIT_" in filter_str: m = re.search(r"UNIT_([A-Z0-9_]+)", filter_str) if m: unit_val = m.group(1) elif not unit_val and "UNIT_BIBI" in filter_str: unit_val = 2 # Check if unit_val is actually a GROUP keyword (HASUNOSORA, LIELLA, NIJIGASAKI, etc.) # If so, treat it as a group constraint instead of a unit constraint if unit_val and isinstance(unit_val, str): unit_val_upper = str(unit_val).upper() # Map group-like keywords that might appear as UNIT_* group_keyword_map = { "HASU": 4, "HASUNOSORA": 4, "LIELLA": 3, "NIJIGASAKI": 2, "AQUOURS": 1, "MUS": 0, } # If this keyword is actually a group, handle it as a group instead if unit_val_upper in group_keyword_map: if not filter_obj.get("group_enabled"): filter_obj["group_enabled"] = True filter_obj["group_id"] = group_keyword_map[unit_val_upper] unit_val = None # Clear so we don't process it as a unit below if unit_val: try: u_id = ( int(str(unit_val)) if str(unit_val).isdigit() else int(Unit.from_japanese_name(str(unit_val).replace("_", " "))) ) filter_obj["unit_enabled"] = True filter_obj["unit_id"] = u_id & 0x7F except (AttributeError, TypeError, ValueError): pass # 5. Cost Filter (Bit 24 + Bits 25-29 + Bit 30=Mode + Bit 31=Type=1) c_min = params.get("cost_ge") # Only check explicit cost GE/LE params c_max = params.get("cost_le") or params.get("total_cost_le") if c_min is None and ("COST_GE=" in filter_str or "COST_GE_" in filter_str): m = re.search(r"COST_GE[=_](\d+)", filter_str) if m: c_min = m.group(1) if c_max is None and ("COST_LE=" in filter_str or "COST_LE_" in filter_str): m = re.search(r"COST_LE[=_](\d+)", filter_str) if m: c_max = m.group(1) if "COST_LT_TARGET_VAL" in filter_str: filter_obj["value_enabled"] = True filter_obj["is_le"] = True filter_obj["compare_accumulated"] = True filter_obj["is_cost_type"] = True elif "COST_EQ=BASE_COST+" in filter_str: m = re.search(r"COST_EQ=BASE_COST\+(\d+)", filter_str) if m: filter_obj["value_enabled"] = True filter_obj["value_threshold"] = int(m.group(1)) & 0x1F filter_obj["compare_accumulated"] = True filter_obj["is_cost_type"] = True filter_obj["special_id"] = 5 elif "COST_EQ_TARGET_PLUS_" in filter_str: m = re.search(r"COST_EQ_TARGET_PLUS_(\d+)", filter_str) if m: filter_obj["value_enabled"] = True filter_obj["value_threshold"] = int(m.group(1)) & 0x1F filter_obj["compare_accumulated"] = True filter_obj["is_cost_type"] = True filter_obj["special_id"] = 5 elif c_min is not None: try: val_c = int(c_min) filter_obj["value_enabled"] = True filter_obj["value_threshold"] = val_c & 0x1F filter_obj["is_cost_type"] = True filter_obj["is_le"] = False except (TypeError, ValueError): pass elif c_max is not None: try: val_c = int(c_max) filter_obj["value_enabled"] = True filter_obj["value_threshold"] = val_c & 0x1F filter_obj["is_cost_type"] = True filter_obj["is_le"] = True except (TypeError, ValueError): pass # 5.1 Heart Sum Support sum_ge = params.get("sum_heart_total_ge") or params_upper.get("SUM_HEART_TOTAL_GE") sum_le = params.get("sum_heart_total_le") or params_upper.get("SUM_HEART_TOTAL_LE") # Also check filter_str for SUM_HEART_TOTAL_GE (e.g. "SUM_HEART_TOTAL_GE=8") if not sum_ge and "SUM_HEART_TOTAL_GE=" in filter_str: m = re.search(r"SUM_HEART_TOTAL_GE=(\d+)", filter_str) if m: sum_ge = m.group(1) if not sum_le and "SUM_HEART_TOTAL_LE=" in filter_str: m = re.search(r"SUM_HEART_TOTAL_LE=(\d+)", filter_str) if m: sum_le = m.group(1) if sum_ge is not None: filter_obj["value_enabled"] = True filter_obj["value_threshold"] = int(sum_ge) & 0x1F filter_obj["is_cost_type"] = False # Must be False for heart sum in engine filter_obj["is_le"] = False elif sum_le is not None: filter_obj["value_enabled"] = True filter_obj["value_threshold"] = int(sum_le) & 0x1F filter_obj["is_cost_type"] = False filter_obj["is_le"] = True # 6. Character Filter (IDs at 39-45, 46-52 in Revision 5) names = params.get("name") or params_upper.get("NAME") if not names and "NAME=" in filter_str: m = re.search(r"NAME=([^,]+)", raw_filter_str, re.IGNORECASE) if m: names = m.group(1) if not names and "NAME_IN=[" in filter_str: names = re.findall(r"'([^']+)'", raw_filter_str) if not names and raw_filter_str and "/" in raw_filter_str and "=" not in raw_filter_str: names = raw_filter_str if names: if isinstance(names, (list, tuple)): n_list = [str(name) for name in names] else: n_list = str(names).split("/") for i, n in enumerate(n_list[:3]): try: n_norm = n.strip().replace(" ", "").replace("驍ｵ・ｲ・つ€", "") c_id = 0 for k, cid in CHAR_MAP.items(): if k.replace(" ", "").replace("驍ｵ・ｲ・つ€", "") == n_norm: c_id = cid break if c_id == 0: c_id = int(CHARACTER_IDS.get(n_norm.upper(), 0)) if c_id > 0: if i < 2: filter_obj[f"char_id_{i + 1}"] = c_id & 0x7F elif not filter_obj["unit_enabled"]: # Standard filter packing only has two dedicated character slots. # Reuse the dormant unit_id bits as a third character-id fallback # when there is no actual unit filter on this selector. filter_obj["unit_id"] = c_id & 0x7F except: pass # 7. Heart Value and Color Filter (Bits 25-29 Threshold + Bit 31=Type=0 + Bits 32-38 Color Mask) if "HAS_HEART_" in filter_str: match = re.search(r"HAS_HEART_(\d+)(?:_X(\d+))?", filter_str) if match: color_code = match.group(1) count = match.group(2) try: c_idx = int(color_code) if not colors: colors = [c_idx] if count: f_val = int(count) except (TypeError, ValueError): pass elif "HAS_COLOR_" in filter_str: match = re.search(r"HAS_COLOR_([A-Z]+)(?:_X(\d+))?", filter_str) if match: color_name = match.group(1).upper() count = match.group(2) try: c_idx = int(HeartColor[color_name]) if not colors: colors = [c_idx] if count: f_val = int(count) except (KeyError, TypeError, ValueError): pass if f_val > 0: filter_obj["value_enabled"] = True filter_obj["value_threshold"] = f_val & 0x1F filter_obj["is_cost_type"] = False if colors or "COLOR=" in filter_str: color_mask = 0 for c in colors if isinstance(colors, list) else [colors]: if c is None: continue try: if isinstance(c, str): if c.isdigit(): c_idx = int(c) else: c_idx = int(HeartColor[c.upper()]) else: c_idx = int(c) color_mask |= 1 << c_idx except (KeyError, TypeError, ValueError): pass if color_mask > 0: filter_obj["color_mask"] = color_mask & 0x7F # 8. Meta Flags and Masks # Zone Mask (Bits 53-55) zone_val = params.get("zone") or params.get("source") or params_upper.get("ZONE") if zone_val: z_str = str(zone_val).upper() z_mask = 0 if "STAGE" in z_str: z_mask = int(EXTRA_CONSTANTS.get("ZONE_MASK_STAGE", 4)) elif "HAND" in z_str: z_mask = int(EXTRA_CONSTANTS.get("ZONE_MASK_HAND", 6)) elif "DISCARD" in z_str: z_mask = int(EXTRA_CONSTANTS.get("ZONE_MASK_DISCARD", 7)) if z_mask > 0: filter_obj["zone_mask"] = z_mask & 0x07 # Special ID (Bits 56-58) if not sid and "NOT_TARGET" in filter_str: sid = 7 elif not sid and "NOT_SELF" in filter_str: sid = 3 elif not sid and "SAME_NAME_AS_REVEALED" in filter_str: sid = 4 elif not sid and "SELECTED_DISCARD" in filter_str: sid = 6 if sid: try: sid_int = int(sid) filter_obj["special_id"] = sid_int & 0x07 except (TypeError, ValueError): pass # Setsuna (Bit 59) if params.get("is_setsuna") or params_upper.get("IS_SETSUNA"): filter_obj["is_setsuna"] = True elif names and "SETSUNA" in str(names).upper(): filter_obj["is_setsuna"] = True # Internal Flags if ( getattr(source, "is_optional", False) or params.get("is_optional") or "(Optional)" in str(params.get("pseudocode", "")) ): filter_obj["is_optional"] = True # Keywords (Bits 62-63) keyword = str(params.get("keyword") or params.get("filter") or "").upper() if params.get("KEYWORD_ENERGY") or "ACTIVATED_ENERGY" in keyword or "DID_ACTIVATE_ENERGY" in keyword: filter_obj["keyword_energy"] = True if params.get("KEYWORD_MEMBER") or "ACTIVATED_MEMBER" in keyword or "DID_ACTIVATE_MEMBER" in keyword: filter_obj["keyword_member"] = True # Legacy flags (Bits 12-15) # Parse STATUS=TAPPED from filter string or params if params.get("is_tapped") or "STATUS=TAPPED" in filter_str or "STATUS=TAP" in filter_str: filter_obj["is_tapped"] = True # Parse HAS_BLADE_HEART / NOT_HAS_BLADE_HEART from filter string or params bh = params.get("has_blade_heart") if bh is True or "HAS_BLADE_HEART" in filter_str: filter_obj["has_blade_heart"] = True elif bh is False or "NOT_HAS_BLADE_HEART" in filter_str: filter_obj["not_has_blade_heart"] = True # Parse UNIQUE_NAMES from filter string or params if params.get("UNIQUE_NAMES") or params_upper.get("UNIQUE_NAMES") or "UNIQUE_NAMES" in filter_str: filter_obj["unique_names"] = True filter_spec = PackedFilterSpec(**filter_obj) self.filters.append(filter_spec.to_debug_dict()) # Use generated packer to ensure bit parity with Rust return filter_spec.pack() def reconstruct_text(self, lang: str = "en") -> str: from .ability_rendering import reconstruct_text return reconstruct_text(self, lang=lang)