6. 咸鱼之王——装备与强化

6.1 什么是装备系统？

想象你给游戏角色穿装备——戴上头盔增加防御，拿上宝剑增加攻击，穿上靴子跑得更快。装备系统就是让英雄通过穿戴装备来变得更强。

在放置游戏中，装备还有一个重要功能：强化。你可以花金币强化装备，让它从+1升到+15，每升一级属性都会增加。就像给汽车改装——换更好的引擎、加涡轮增压器，让它的性能不断提升。

6.2 装备数据结构

C

using Godot;

/// <summary>
/// 装备品质
/// </summary>
public enum EquipQuality
{
    Normal,     // 普通（白色）
    Fine,       // 精良（绿色）
    Rare,       // 稀有（蓝色）
    Epic,       // 史诗（紫色）
    Legend       // 传说（橙色）
}

/// <summary>
/// 装备类型
/// </summary>
public enum EquipSlot
{
    Weapon,     // 武器（增加攻击）
    Armor,      // 防具（增加血量）
    Accessory   // 饰品（增加攻速/技能）
}

/// <summary>
/// 装备数据
/// </summary>
public class EquipmentData
{
    public string Id { get; set; }
    public string Name { get; set; }
    public EquipSlot Slot { get; set; }
    public EquipQuality Quality { get; set; }
    public int EnhanceLevel { get; set; }  // 强化等级 +0 ~ +15

    // 基础属性（强化前）
    public int BaseAttackBonus { get; set; }
    public int BaseHpBonus { get; set; }
    public float BaseSpeedBonus { get; set; }

    /// <summary>
    /// 计算强化后的攻击加成
    /// </summary>
    public int TotalAttackBonus =>
        (int)(BaseAttackBonus * (1f + EnhanceLevel * 0.1f));

    /// <summary>
    /// 计算强化后的血量加成
    /// </summary>
    public int TotalHpBonus =>
        (int)(BaseHpBonus * (1f + EnhanceLevel * 0.1f));

    /// <summary>
    /// 计算强化费用
    /// </summary>
    public int GetEnhanceCost()
    {
        if (EnhanceLevel >= IdleConstants.MaxEnhanceLevel)
            return int.MaxValue;

        // 强化费用随等级递增
        int baseCost = (int)Quality switch
        {
            0 => 20,    // 普通
            1 => 50,    // 精良
            2 => 100,   // 稀有
            3 => 200,   // 史诗
            4 => 500,   // 传说
            _ => 20
        };

        return baseCost * (EnhanceLevel + 1);
    }

    /// <summary>
    /// 计算强化成功率
    /// </summary>
    public float GetEnhanceSuccessRate()
    {
        if (EnhanceLevel < 5) return 1.0f;        // +1~+5: 100%
        if (EnhanceLevel < 10) return 0.8f;       // +6~+10: 80%
        if (EnhanceLevel < 13) return 0.5f;       // +11~+13: 50%
        return 0.3f;                               // +14~+15: 30%
    }

    /// <summary>
    /// 尝试强化
    /// </summary>
    public (bool success, EquipmentData newEquip) TryEnhance()
    {
        if (EnhanceLevel >= IdleConstants.MaxEnhanceLevel)
            return (false, this);

        float rate = GetEnhanceSuccessRate();
        bool success = GD.Randf() < rate;

        var result = new EquipmentData
        {
            Id = Id,
            Name = Name,
            Slot = Slot,
            Quality = Quality,
            EnhanceLevel = success ? EnhanceLevel + 1 : EnhanceLevel,
            BaseAttackBonus = BaseAttackBonus,
            BaseHpBonus = BaseHpBonus,
            BaseSpeedBonus = BaseSpeedBonus
        };

        return (success, result);
    }
}

GDScript

## 装备品质
enum EquipQuality { NORMAL, FINE, RARE, EPIC, LEGEND }
## 装备类型
enum EquipSlot { WEAPON, ARMOR, ACCESSORY }

## 装备数据
class_name EquipmentData

var id: String
var name: String
var slot: EquipSlot
var quality: EquipQuality
var enhance_level: int = 0

# 基础属性
var base_attack_bonus: int = 0
var base_hp_bonus: int = 0
var base_speed_bonus: float = 0.0

## 强化后的攻击加成
func total_attack_bonus() -> int:
    return int(base_attack_bonus * (1.0 + enhance_level * 0.1))

## 强化后的血量加成
func total_hp_bonus() -> int:
    return int(base_hp_bonus * (1.0 + enhance_level * 0.1))

## 计算强化费用
func get_enhance_cost() -> int:
    if enhance_level >= IdleConstants.MAX_ENHANCE_LEVEL:
        return 999999

    var base_cost: int = match quality:
        EquipQuality.NORMAL: 20
        EquipQuality.FINE: 50
        EquipQuality.RARE: 100
        EquipQuality.EPIC: 200
        EquipQuality.LEGEND: 500
        _: 20

    return base_cost * (enhance_level + 1)

## 强化成功率
func get_enhance_success_rate() -> float:
    if enhance_level < 5:
        return 1.0
    if enhance_level < 10:
        return 0.8
    if enhance_level < 13:
        return 0.5
    return 0.3

## 尝试强化
func try_enhance() -> Dictionary:
    if enhance_level >= IdleConstants.MAX_ENHANCE_LEVEL:
        return {"success": false, "equip": self}

    var rate: float = get_enhance_success_rate()
    var success: bool = randf() < rate

    var result = EquipmentData.new()
    result.id = id
    result.name = name
    result.slot = slot
    result.quality = quality
    result.enhance_level = enhance_level + 1 if success else enhance_level
    result.base_attack_bonus = base_attack_bonus
    result.base_hp_bonus = base_hp_bonus
    result.base_speed_bonus = base_speed_bonus

    return {"success": success, "equip": result}

6.3 装备强化概率表

强化不是100%成功的——等级越高，失败概率越大。这增加了游戏的"赌博"刺激感。

强化等级	成功率	失败后果	强化费用倍率
+1 ~ +5	100%	不会失败	1x ~ 5x
+6 ~ +10	80%	失败不降级	6x ~ 10x
+11 ~ +13	50%	失败不降级	11x ~ 13x
+14 ~ +15	30%	失败不降级	14x ~ 15x

6.4 装备管理器

C

using Godot;
using System.Collections.Generic;
using System.Linq;

/// <summary>
/// 装备管理器——管理玩家拥有的装备
/// </summary>
public partial class EquipmentManager : Node
{
    // 背包中的装备
    private List<EquipmentData> _inventory = new();

    // 英雄当前穿戴的装备 {英雄ID: {slot: EquipmentData}}
    private Dictionary<string, Dictionary<EquipSlot, EquipmentData>> _equipped
        = new();

    // 信号
    [Signal] public delegate void EquipmentChangedEventHandler();
    [Signal] public delegate void EnhanceResultEventHandler(
        bool success, int newLevel);

    public override void _Ready()
    {
        GD.Print("装备管理器已初始化");
    }

    /// <summary>
    /// 添加装备到背包
    /// </summary>
    public void AddEquipment(EquipmentData equipment)
    {
        _inventory.Add(equipment);
        EmitSignal(SignalName.EquipmentChanged);
    }

    /// <summary>
    /// 强化装备
    /// </summary>
    public bool EnhanceEquipment(int inventoryIndex)
    {
        if (inventoryIndex < 0 || inventoryIndex >= _inventory.Count)
            return false;

        var equip = _inventory[inventoryIndex];
        int cost = equip.GetEnhanceCost();

        if (!GameManager.Instance.SpendGold(cost))
        {
            GD.Print("金币不足！");
            return false;
        }

        var (success, newEquip) = equip.TryEnhance();
        _inventory[inventoryIndex] = newEquip;

        GD.Print(success
            ? $"强化成功！{equip.Name} → +{newEquip.EnhanceLevel}"
            : $"强化失败！{equip.Name} 仍为 +{equip.EnhanceLevel}");

        EmitSignal(SignalName.EnhanceResult, success, newEquip.EnhanceLevel);
        EmitSignal(SignalName.EquipmentChanged);
        return true;
    }

    /// <summary>
    /// 装备穿戴
    /// </summary>
    public bool EquipItem(int inventoryIndex, string heroId)
    {
        if (inventoryIndex < 0 || inventoryIndex >= _inventory.Count)
            return false;

        var equip = _inventory[inventoryIndex];
        _inventory.RemoveAt(inventoryIndex);

        // 如果该英雄该槽位已有装备，先放回背包
        if (!_equipped.ContainsKey(heroId))
            _equipped[heroId] = new Dictionary<EquipSlot, EquipmentData>();

        if (_equipped[heroId].ContainsKey(equip.Slot))
        {
            var oldEquip = _equipped[heroId][equip.Slot];
            _inventory.Add(oldEquip);
        }

        _equipped[heroId][equip.Slot] = equip;
        EmitSignal(SignalName.EquipmentChanged);
        return true;
    }

    /// <summary>
    /// 计算指定英雄的装备总加成
    /// </summary>
    public (int attackBonus, int hpBonus, float speedBonus)
        GetHeroEquipBonuses(string heroId)
    {
        int attack = 0, hp = 0;
        float speed = 0;

        if (_equipped.TryGetValue(heroId, out var slots))
        {
            foreach (var equip in slots.Values)
            {
                attack += equip.TotalAttackBonus;
                hp += equip.TotalHpBonus;
                speed += equip.BaseSpeedBonus;
            }
        }

        return (attack, hp, speed);
    }

    /// <summary>
    /// 回收装备（换金币）
    /// </summary>
    public int RecycleEquipment(int inventoryIndex)
    {
        if (inventoryIndex < 0 || inventoryIndex >= _inventory.Count)
            return 0;

        var equip = _inventory[inventoryIndex];
        _inventory.RemoveAt(inventoryIndex);

        // 回收价格 = 品质基础价 x 强化等级加成
        int recycleValue = (int)equip.Quality switch
        {
            0 => 10, 1 => 25, 2 => 50, 3 => 100, 4 => 250, _ => 10
        };
        recycleValue += equip.EnhanceLevel * 5;

        GameManager.Instance.AddGold(recycleValue);
        EmitSignal(SignalName.EquipmentChanged);
        return recycleValue;
    }
}

GDScript

extends Node

## 装备管理器——管理玩家拥有的装备

var _inventory: Array = []
var _equipped: Dictionary = {}  # {hero_id: {slot: EquipmentData}}

# 信号
signal equipment_changed
signal enhance_result(success: bool, new_level: int)

func _ready() -> void:
    print("装备管理器已初始化")

## 添加装备
func add_equipment(equip: EquipmentData) -> void:
    _inventory.append(equip)
    equipment_changed.emit()

## 强化装备
func enhance_equipment(inventory_index: int) -> bool:
    if inventory_index < 0 or inventory_index >= _inventory.size():
        return false

    var equip: EquipmentData = _inventory[inventory_index]
    var cost: int = equip.get_enhance_cost()

    if not GameManager.spend_gold(cost):
        print("金币不足！")
        return false

    var result: Dictionary = equip.try_enhance()
    var success: bool = result.success
    var new_equip: EquipmentData = result.equip
    _inventory[inventory_index] = new_equip

    if success:
        print("强化成功！ → +%d" % new_equip.enhance_level)
    else:
        print("强化失败！")

    enhance_result.emit(success, new_equip.enhance_level)
    equipment_changed.emit()
    return true

## 装备穿戴
func equip_item(inventory_index: int, hero_id: String) -> bool:
    if inventory_index < 0 or inventory_index >= _inventory.size():
        return false

    var equip: EquipmentData = _inventory[inventory_index]
    _inventory.remove_at(inventory_index)

    if not _equipped.has(hero_id):
        _equipped[hero_id] = {}

    var slot_key: int = equip.slot
    if _equipped[hero_id].has(slot_key):
        var old_equip = _equipped[hero_id][slot_key]
        _inventory.append(old_equip)

    _equipped[hero_id][slot_key] = equip
    equipment_changed.emit()
    return true

## 计算英雄装备加成
func get_hero_equip_bonuses(hero_id: String) -> Dictionary:
    var attack: int = 0
    var hp: int = 0
    var speed: float = 0.0

    if _equipped.has(hero_id):
        for slot_key in _equipped[hero_id]:
            var eq: EquipmentData = _equipped[hero_id][slot_key]
            attack += eq.total_attack_bonus()
            hp += eq.total_hp_bonus()
            speed += eq.base_speed_bonus

    return {"attack": attack, "hp": hp, "speed": speed}

## 回收装备
func recycle_equipment(inventory_index: int) -> int:
    if inventory_index < 0 or inventory_index >= _inventory.size():
        return 0

    var equip: EquipmentData = _inventory[inventory_index]
    _inventory.remove_at(inventory_index)

    var recycle_value: int = match equip.quality:
        EquipQuality.NORMAL: 10
        EquipQuality.FINE: 25
        EquipQuality.RARE: 50
        EquipQuality.EPIC: 100
        EquipQuality.LEGEND: 250
        _: 10
    recycle_value += equip.enhance_level * 5

    GameManager._gold += recycle_value
    equipment_changed.emit()
    return recycle_value

6.5 装备品质对应颜色

品质	颜色	强化上限	属性倍率
普通	白色 #FFFFFF	+15	1.0x
精良	绿色 #00FF00	+15	1.2x
稀有	蓝色 #00AAFF	+15	1.5x
史诗	紫色 #AA00FF	+15	2.0x
传说	橙色 #FF8800	+15	3.0x

6.6 本章小结

知识点	说明
装备品质	五种品质，品质越高基础属性越强
强化系统	+1到+15，等级越高费用越高成功率越低
装备穿戴	武器/防具/饰品三个槽位，自动替换旧装备
装备加成	强化等级每级增加10%属性
装备回收	不需要的装备可以换金币

下一章我们将实现关卡推进系统。