""" 能力系统 实现KARDS中的各种单位能力 """ from abc import ABC, abstractmethod from typing import Any, Dict, List, Optional, TYPE_CHECKING from enum import Enum from .keywords import TriggerTiming if TYPE_CHECKING: from ..units.unit import Unit from ..battlefield.battlefield import Battlefield class AbilityType(Enum): """能力类型枚举""" DEPLOY = "deploy" # 部署能力 TRIGGERED = "triggered" # 触发能力 STATIC = "static" # 静态能力（光环） ACTIVATED = "activated" # 激活能力 DEATH = "death" # 死亡能力 class TargetType(Enum): """目标类型枚举""" SELF = "self" # 自己 FRIENDLY_UNIT = "friendly_unit" # 友方单位 ENEMY_UNIT = "enemy_unit" # 敌方单位 ANY_UNIT = "any_unit" # 任意单位 FRIENDLY_HQ = "friendly_hq" # 友方HQ ENEMY_HQ = "enemy_hq" # 敌方HQ ALL_FRIENDLY = "all_friendly" # 所有友方单位 ALL_ENEMY = "all_enemy" # 所有敌方单位 ADJACENT_FRIENDLY = "adjacent_friendly" # 相邻友方单位 NO_TARGET = "no_target" # 无目标 class Ability(ABC): """能力基类""" def __init__(self, name: str, ability_type: AbilityType, description: str = ""): self.name = name self.ability_type = ability_type self.description = description self.is_used = False # 是否已使用（某些能力只能使用一次） @abstractmethod def can_activate(self, owner: 'Unit', battlefield: 'Battlefield', timing: TriggerTiming, context: Dict[str, Any]) -> bool: """检查能力是否可以激活""" pass @abstractmethod def get_valid_targets(self, owner: 'Unit', battlefield: 'Battlefield') -> List[Any]: """获取有效目标列表""" pass @abstractmethod def execute(self, owner: 'Unit', battlefield: 'Battlefield', target: Any = None, context: Dict[str, Any] = None) -> Dict[str, Any]: """执行能力，返回执行结果""" pass def get_trigger_timings(self) -> List[TriggerTiming]: """获取能力触发时机""" timing_map = { AbilityType.DEPLOY: [TriggerTiming.ON_DEPLOY], AbilityType.TRIGGERED: [], # 子类指定 AbilityType.STATIC: [TriggerTiming.PASSIVE], AbilityType.ACTIVATED: [], # 主动激活，无固定时机 AbilityType.DEATH: [TriggerTiming.ON_DEATH] } return timing_map.get(self.ability_type, []) def reset(self) -> None: """重置能力状态""" self.is_used = False def __str__(self) -> str: return f"{self.name} ({self.ability_type.value}): {self.description}" class DeployAbility(Ability): """部署能力基类""" def __init__(self, name: str, description: str = ""): super().__init__(name, AbilityType.DEPLOY, description) def can_activate(self, owner: 'Unit', battlefield: 'Battlefield', timing: TriggerTiming, context: Dict[str, Any]) -> bool: return timing == TriggerTiming.ON_DEPLOY and not self.is_used class TriggeredAbility(Ability): """触发能力基类""" def __init__(self, name: str, trigger_timing: TriggerTiming, trigger_condition: callable = None, description: str = ""): super().__init__(name, AbilityType.TRIGGERED, description) self.trigger_timing = trigger_timing self.trigger_condition = trigger_condition or (lambda *args: True) def can_activate(self, owner: 'Unit', battlefield: 'Battlefield', timing: TriggerTiming, context: Dict[str, Any]) -> bool: return (timing == self.trigger_timing and self.trigger_condition(owner, battlefield, context)) def get_trigger_timings(self) -> List[TriggerTiming]: return [self.trigger_timing] class StaticAbility(Ability): """静态能力（光环效果）基类""" def __init__(self, name: str, description: str = ""): super().__init__(name, AbilityType.STATIC, description) def can_activate(self, owner: 'Unit', battlefield: 'Battlefield', timing: TriggerTiming, context: Dict[str, Any]) -> bool: return timing == TriggerTiming.PASSIVE @abstractmethod def apply_static_effect(self, owner: 'Unit', battlefield: 'Battlefield') -> None: """应用静态效果""" pass def execute(self, owner: 'Unit', battlefield: 'Battlefield', target: Any = None, context: Dict[str, Any] = None) -> Dict[str, Any]: self.apply_static_effect(owner, battlefield) return {"success": True, "effect_type": "static"} class ActivatedAbility(Ability): """激活能力（主动使用）基类""" def __init__(self, name: str, cost: int = 0, uses_per_turn: int = 1, description: str = ""): super().__init__(name, AbilityType.ACTIVATED, description) self.cost = cost # 使用成本（如果有） self.uses_per_turn = uses_per_turn self.uses_this_turn = 0 def can_activate(self, owner: 'Unit', battlefield: 'Battlefield', timing: TriggerTiming, context: Dict[str, Any]) -> bool: return self.uses_this_turn < self.uses_per_turn def reset_turn(self) -> None: """回合重置""" self.uses_this_turn = 0 class DeathAbility(Ability): """死亡能力基类""" def __init__(self, name: str, description: str = ""): super().__init__(name, AbilityType.DEATH, description) def can_activate(self, owner: 'Unit', battlefield: 'Battlefield', timing: TriggerTiming, context: Dict[str, Any]) -> bool: return timing == TriggerTiming.ON_DEATH and not self.is_used # 具体能力实现示例 class DealDamageOnDeploy(DeployAbility): """部署时造成伤害""" def __init__(self, damage: int, target_type: TargetType = TargetType.ENEMY_UNIT): super().__init__("DEPLOY_DAMAGE", f"部署时对{target_type.value}造成{damage}点伤害") self.damage = damage self.target_type = target_type def get_valid_targets(self, owner: 'Unit', battlefield: 'Battlefield') -> List['Unit']: from ..effects.target_selectors import TargetSelector selector = TargetSelector() return selector.get_targets_by_type(owner, battlefield, self.target_type) def execute(self, owner: 'Unit', battlefield: 'Battlefield', target: 'Unit' = None, context: Dict[str, Any] = None) -> Dict[str, Any]: if not target: return {"success": False, "reason": "No target specified"} actual_damage = target.stats.take_damage(self.damage) self.is_used = True result = { "success": True, "effect_type": "damage", "target": target.id, "damage_dealt": actual_damage, "target_destroyed": not target.stats.is_alive() } # 如果目标被摧毁，从战场移除 if not target.stats.is_alive(): battlefield.remove_unit(target) return result class BuffAlliesStatic(StaticAbility): """静态增益友方单位""" def __init__(self, attack_bonus: int = 0, defense_bonus: int = 0): description = f"友方单位获得+{attack_bonus}/+{defense_bonus}" super().__init__("BUFF_ALLIES", description) self.attack_bonus = attack_bonus self.defense_bonus = defense_bonus def get_valid_targets(self, owner: 'Unit', battlefield: 'Battlefield') -> List['Unit']: return battlefield.get_all_units(owner.owner) def apply_static_effect(self, owner: 'Unit', battlefield: 'Battlefield') -> None: # 静态效果在战斗计算时动态应用，这里仅做标记 pass def get_buff_values(self, target: 'Unit', owner: 'Unit') -> tuple: """获取对目标的增益值""" if target.owner == owner.owner and target.id != owner.id: return (self.attack_bonus, self.defense_bonus) return (0, 0) class SacrificeForDamage(ActivatedAbility): """牺牲自己造成伤害""" def __init__(self, damage: int): super().__init__("SACRIFICE_DAMAGE", 0, 1, f"牺牲自己对敌方单位造成{damage}点伤害") self.damage = damage def get_valid_targets(self, owner: 'Unit', battlefield: 'Battlefield') -> List['Unit']: enemy_id = battlefield.get_enemy_player_id(owner.owner) return battlefield.get_all_units(enemy_id) if enemy_id else [] def execute(self, owner: 'Unit', battlefield: 'Battlefield', target: 'Unit' = None, context: Dict[str, Any] = None) -> Dict[str, Any]: if not target: return {"success": False, "reason": "No target specified"} # 造成伤害 actual_damage = target.stats.take_damage(self.damage) # 牺牲自己 owner.stats.current_defense = 0 battlefield.remove_unit(owner) self.uses_this_turn += 1 result = { "success": True, "effect_type": "sacrifice_damage", "target": target.id, "damage_dealt": actual_damage, "target_destroyed": not target.stats.is_alive(), "owner_sacrificed": True } # 如果目标也被摧毁，从战场移除 if not target.stats.is_alive(): battlefield.remove_unit(target) return result class HealOnDeath(DeathAbility): """死亡时治疗友方单位""" def __init__(self, heal_amount: int): super().__init__("DEATH_HEAL", f"死亡时治疗所有友方单位{heal_amount}点") self.heal_amount = heal_amount def get_valid_targets(self, owner: 'Unit', battlefield: 'Battlefield') -> List['Unit']: return battlefield.get_all_units(owner.owner) def execute(self, owner: 'Unit', battlefield: 'Battlefield', target: Any = None, context: Dict[str, Any] = None) -> Dict[str, Any]: friendly_units = self.get_valid_targets(owner, battlefield) healed_units = [] for unit in friendly_units: if unit.id != owner.id: # 不治疗自己（已死亡） heal_amount = unit.stats.heal(self.heal_amount) if heal_amount > 0: healed_units.append({ "unit_id": unit.id, "heal_amount": heal_amount }) self.is_used = True return { "success": True, "effect_type": "death_heal", "healed_units": healed_units } class AbilityManager: """能力管理器，负责处理能力的触发和执行""" def __init__(self): self.pending_abilities = [] # 待处理的能力 def trigger_abilities(self, owner: 'Unit', battlefield: 'Battlefield', timing: TriggerTiming, context: Dict[str, Any]) -> List[Dict[str, Any]]: """触发单位的能力""" results = [] for ability in owner.abilities: if ability.can_activate(owner, battlefield, timing, context): # 获取目标 valid_targets = ability.get_valid_targets(owner, battlefield) if ability.ability_type == AbilityType.STATIC: # 静态能力直接执行 result = ability.execute(owner, battlefield, context=context) results.append(result) elif valid_targets or ability.get_valid_targets(owner, battlefield) == []: # 有有效目标或无需目标的能力 if len(valid_targets) == 1: # 单一目标自动选择 target = valid_targets[0] result = ability.execute(owner, battlefield, target, context) results.append(result) elif len(valid_targets) == 0 and ability.ability_type in [AbilityType.DEPLOY, AbilityType.DEATH]: # 无目标能力（如群体效果） result = ability.execute(owner, battlefield, context=context) results.append(result) else: # 多目标需要外部选择，添加到待处理列表 self.pending_abilities.append({ "owner": owner, "ability": ability, "battlefield": battlefield, "valid_targets": valid_targets, "context": context }) return results def execute_pending_ability(self, ability_index: int, target_index: int) -> Optional[Dict[str, Any]]: """执行待处理的能力""" if 0 <= ability_index < len(self.pending_abilities): pending = self.pending_abilities[ability_index] valid_targets = pending["valid_targets"] if 0 <= target_index < len(valid_targets): target = valid_targets[target_index] result = pending["ability"].execute( pending["owner"], pending["battlefield"], target, pending["context"] ) # 移除已处理的能力 self.pending_abilities.pop(ability_index) return result return None def clear_pending(self) -> None: """清除所有待处理的能力""" self.pending_abilities.clear()