class CharacterMeta(type):
 """角色元类，自动注册角色类型"""

 def __new__(cls, name, bases, attrs):
 new_class = super().__new__(cls, name, bases, attrs)
 if not hasattr(cls, 'registry'):
 cls.registry = {}
 cls.registry[name.lower()] = new_class
 return new_class

class GameCharacter(metaclass=CharacterMeta):
 """游戏角色基类"""

 def __init__(self, name, level=1):
 self.name = name
 self.level = level
 self._health = 100
 self._mana = 50
 self._experience = 0

 @property
 def health(self):
 return self._health

 @health.setter
 def health(self, value):
 self._health = max(0, min(value, self.max_health))

 @property
 def mana(self):
 return self._mana

 @mana.setter
 def mana(self, value):
 self._mana = max(0, min(value, self.max_mana))

 @property
 def max_health(self):
 return 100 + self.level * 10

 @property
 def max_mana(self):
 return 50 + self.level * 5

 def __str__(self):
 return f"{self.__class__.__name__}: {self.name} (等级{self.level})"

 def __repr__(self):
 return f"{self.__class__.__name__}('{self.name}', {self.level})"

class Warrior(GameCharacter):
 def __init__(self, name, level=1):
 super().__init__(name, level)
 self.strength = 15 + level * 3
 self.defense = 12 + level * 2

 def attack(self):
 return f"{self.name} 使用剑击造成 {self.strength} 点伤害"

class Mage(GameCharacter):
 def __init__(self, name, level=1):
 super().__init__(name, level)
 self.intelligence = 18 + level * 4
 self.mana *= 1.5

 def cast_spell(self):
 if self.mana >= 20:
 self.mana -= 20
 return f"{self.name} 释放火球术造成 {self.intelligence * 1.5} 点魔法伤害"
 return f"{self.name} 魔力不足，无法施法"

class Archer(GameCharacter):
 def __init__(self, name, level=1):
 super().__init__(name, level)
 self.agility = 16 + level * 3.5
 self.critical_chance = 0.2 + level * 0.02

 def shoot_arrow(self):
 damage = self.agility * 1.2
 if random.random() < self.critical_chance:
 damage *= 2
 return f"{self.name} 射出暴击箭造成 {damage} 点伤害！"
 return f"{self.name} 射出箭矢造成 {damage} 点伤害"

# 使用示例
warrior = Warrior("亚瑟", 5)
mage = Mage("梅林", 4)
archer = Archer("罗宾", 3)

print(warrior)
print(mage)
print(archer)

print(CharacterMeta.registry)
# 查看所有注册的角色类型

class EquipmentMeta(type):
 """装备元类，管理装备类型"""

 def __new__(cls, name, bases, attrs):
 new_class = super().__new__(cls, name, bases, attrs)
 if not hasattr(cls, 'equipment_types'):
 cls.equipment_types = {}
 cls.equipment_types[name.lower()] = new_class
 return new_class

class Equipment(metaclass=EquipmentMeta):
 """装备基类"""

 def __init__(self, name, rarity="普通"):
 self.name = name
 self.rarity = rarity
 self._enhancement_level = 0

 @property
 def enhancement_level(self):
 return self._enhancement_level

 @enhancement_level.setter
 def enhancement_level(self, value):
 if 0 <= value <= 15:
 self._enhancement_level = value
 else:
 raise ValueError("强化等级必须在0-15之间")

 def __str__(self):
 rarity_colors = {
 "普通": "白色",
 "稀有": "蓝色",
 "史诗": "紫色",
 "传说": "橙色"
 }
 return f"{rarity_colors.get(self.rarity, '未知')} {self.rarity} {self.name} +{self.enhancement_level}"

 def __add__(self, other):
 """装备合成"""
 if isinstance(other, Equipment) and self.__class__ == other.__class__:
 new_name = f"强化{self.name}"
 new_equipment = self.__class__(new_name, self.rarity)
 new_equipment.enhancement_level = min(self.enhancement_level + 1, 15)
 return new_equipment
 raise TypeError("只能合成相同类型的装备")

class Weapon(Equipment):
 def __init__(self, name, attack_power, rarity="普通"):
 super().__init__(name, rarity)
 self.base_attack = attack_power
 self.weapon_type = "武器"

 @property
 def total_attack(self):
 return self.base_attack * (1 + self.enhancement_level * 0.1)

class Armor(Equipment):
 def __init__(self, name, defense_power, rarity="普通"):
 super().__init__(name, rarity)
 self.base_defense = defense_power
 self.armor_type = "防具"

 @property
 def total_defense(self):
 return self.base_defense * (1 + self.enhancement_level * 0.08)

class Accessory(Equipment):
 def __init__(self, name, special_effect, rarity="普通"):
 super().__init__(name, rarity)
 self.special_effect = special_effect
 self.accessory_type = "饰品"

# 使用示例
sword = Weapon("长剑", 100, "史诗")
shield = Armor("圆盾", 50, "稀有")
ring = Accessory("力量戒指", "增加10%攻击力")

print(sword)
print(shield)
print(ring)

# 装备合成
enhanced_sword = sword + sword
print(f"合成后: {enhanced_sword}")
print(f"攻击力: {enhanced_sword.total_attack}")

class SkillSystem:
 """技能系统管理器"""

 def __init__(self):
 self.skills = {}

 def register_skill(self, skill_class):
 """注册技能类"""
 self.skills[skill_class.__name__.lower()] = skill_class

 def create_skill(self, skill_name, *args, **kwargs):
 """创建技能实例"""
 if skill_name.lower() in self.skills:
 return self.skills[skill_name.lower()](*args, **kwargs)
 raise ValueError(f"未知技能: {skill_name}")

class Skill:
 """技能基类"""

 def __init__(self, name, mana_cost, cooldown):
 self.name = name
 self.mana_cost = mana_cost
 self.cooldown = cooldown
 self._current_cooldown = 0

 @property
 def is_ready(self):
 return self._current_cooldown <= 0

 def use(self, caster):
 """使用技能"""
 if not self.is_ready:
 return f"技能 {self.name} 冷却中 ({self._current_cooldown}回合)"

 if caster.mana < self.mana_cost:
 return f"魔力不足，无法使用 {self.name}"

 caster.mana -= self.mana_cost
 self._current_cooldown = self.cooldown
 return self.execute(caster)

 def execute(self, caster):
 """技能执行逻辑（子类实现）"""
 raise NotImplementedError

 def tick(self):
 """每回合更新"""
 if self._current_cooldown > 0:
 self._current_cooldown -= 1

class Fireball(Skill):
 def __init__(self):
 super().__init__("火球术", 20, 2)

 def execute(self, caster):
 damage = caster.intelligence * 1.5
 return f"{caster.name} 释放火球术造成 {damage} 点魔法伤害"

class Heal(Skill):
 def __init__(self):
 super().__init__("治疗术", 15, 3)

 def execute(self, caster):
 heal_amount = caster.intelligence * 2
 caster.health += heal_amount
 return f"{caster.name} 使用治疗术恢复 {heal_amount} 点生命值"

class Shield(Skill):
 def __init__(self):
 super().__init__("护盾术", 10, 4)

 def execute(self, caster):
 shield_amount = caster.defense * 1.2
 return f"{caster.name} 激活护盾，获得 {shield_amount} 点护盾值"

# 使用示例
skill_system = SkillSystem()
skill_system.register_skill(Fireball)
skill_system.register_skill(Heal)
skill_system.register_skill(Shield)

mage = Mage("艾莉娅", 10)
fireball = skill_system.create_skill("fireball")
heal = skill_system.create_skill("heal")

print(fireball.use(mage))
print(heal.use(mage))

# 模拟回合
for i in range(5):
 fireball.tick()
 if i == 2:
 print(fireball.use(mage)) # 冷却结束