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))  # 冷却结束