跳至主要內容

5. 升级与出售

EVOCOSMOS2026/4/14大约 11 分钟

5. 保卫萝卜——升级与出售

为什么要升级和出售？

想象你开了一家小店：

  • 升级就像给店面装修、扩充——花更多的钱让小店变得更强（攻击更高、射程更远）
  • 出售就像把不想要的家具二手卖掉——虽然不能全额退款，但能回收一部分钱来买更好的东西

在塔防游戏中，这两个操作让玩家的策略选择更加丰富：

操作好处代价
升级强化已有塔，节省空间需要额外金币
出售回收金币，腾出位置只能返还 60%

升级系统设计

升级规则

规则说明
等级上限最多升到 3 级
费用递增越高级越贵（升2级便宜，升3级贵）
效果递增攻击力、射程随等级提升
视觉变化每次升级外观有变化，让玩家一眼看出等级

升级费用和效果表

以瓶子塔为例：

等级攻击力射程升级费用累计投入
1 级（初始）151500100
2 级2017080180
3 级30200150330

设计思路：3 级瓶子塔（攻击 30）比买两个 1 级瓶子塔（攻击 15x2=30）更强，因为还额外增加了射程。但价格也更贵（330 vs 200），这就需要玩家做出选择。

升级管理器

升级和出售操作需要一个"交互控制器"来管理——当玩家点击一个已放置的塔时，显示升级/出售选项。

C
using Godot;

/// <summary>
/// 塔交互控制器 —— 管理塔的选中、升级、出售交互
/// 就像"塔的服务台"，玩家点击塔后弹出的操作面板
/// </summary>
public partial class TowerInteractionController : Node
{
    // ===== 信号 =====

    /// <summary>塔被选中时发送</summary>
    [Signal]
    public delegate void TowerSelectedEventHandler(Tower tower);

    /// <summary>取消选中时发送</summary>
    [Signal]
    public delegate void TowerDeselectedEventHandler();

    // ===== 状态 =====

    private Tower _selectedTower;

    /// <summary>当前选中的塔</summary>
    public Tower SelectedTower => _selectedTower;

    /// <summary>是否有塔被选中</summary>
    public bool HasSelection => _selectedTower != null;

    public override void _Ready()
    {
        // 监听输入事件
        // 注意：实际的输入处理在 _Input 中
    }

    public override void _Input(InputEvent @event)
    {
        // 鼠标右键或 Escape 取消选中
        if (@event is InputEventMouseButton mb
            && mb.ButtonIndex == MouseButton.Right
            && mb.Pressed)
        {
            DeselectTower();
        }

        if (@event is InputEventKey key
            && key.Keycode == Key.Escape
            && key.Pressed)
        {
            DeselectTower();
        }
    }

    /// <summary>
    /// 选中一个塔
    /// </summary>
    public void SelectTower(Tower tower)
    {
        // 先取消之前的选中
        if (_selectedTower != null && _selectedTower != tower)
        {
            _selectedTower.SetSelected(false);
        }

        _selectedTower = tower;
        tower.SetSelected(true);

        EmitSignal(SignalName.TowerSelected, tower);
    }

    /// <summary>
    /// 取消选中
    /// </summary>
    public void DeselectTower()
    {
        if (_selectedTower != null)
        {
            _selectedTower.SetSelected(false);
            _selectedTower = null;
        }

        EmitSignal(SignalName.TowerDeselected);
    }

    /// <summary>
    /// 升级选中的塔
    /// </summary>
    /// <returns>是否升级成功</returns>
    public bool UpgradeSelectedTower()
    {
        if (_selectedTower == null) return false;

        // 获取升级费用
        int cost = GetUpgradeCost(_selectedTower);

        if (cost <= 0)
        {
            GD.Print("塔已满级，无法升级");
            return false;
        }

        return _selectedTower.Upgrade(cost);
    }

    /// <summary>
    /// 出售选中的塔
    /// </summary>
    public void SellSelectedTower()
    {
        if (_selectedTower == null) return;

        var tower = _selectedTower;
        DeselectTower();
        tower.Sell();
    }

    /// <summary>
    /// 获取升级费用
    /// </summary>
    public int GetUpgradeCost(Tower tower)
    {
        if (tower.CurrentLevel >= tower.MaxLevel)
            return 0; // 已满级

        // 从塔数据中获取对应等级的升级费用
        int levelIndex = tower.CurrentLevel - 1;
        // 简化处理：费用随等级递增
        return tower.PurchaseCost * (tower.CurrentLevel + 1) / 2;
    }

    /// <summary>
    /// 获取出售返还金额
    /// </summary>
    public int GetSellRefund(Tower tower)
    {
        return Mathf.FloorToInt(
            tower.TotalInvested * GameConstants.SellRefundRate);
    }
}

塔的点击检测

玩家需要能够通过点击来选中已放置的塔。我们给每个塔添加一个可点击区域。

C
using Godot;

/// <summary>
/// 塔的可点击区域组件
/// 挂载在每个塔场景上，处理鼠标点击选中逻辑
/// </summary>
public partial class TowerClickArea : Area2D
{
    /// <summary>所属的塔</summary>
    private Tower _parentTower;

    public override void _Ready()
    {
        _parentTower = GetParent<Tower>();

        // 连接鼠标点击信号
        InputEvent += OnInputEvent;

        // 设置碰撞层：只在第2层（Tower层）检测
        CollisionLayer = 0;
        CollisionMask = 0;
    }

    /// <summary>
    /// 鼠标点击事件处理
    /// </summary>
    private void OnInputEvent(Node viewport, InputEvent @event, int shapeIdx)
    {
        if (@event is InputEventMouseButton mb
            && mb.ButtonIndex == MouseButton.Left
            && mb.Pressed)
        {
            // 通知交互控制器选中此塔
            var controller = GetTree()
                .Root.FindChild("TowerInteractionController", true, false);

            if (controller is TowerInteractionController tic)
            {
                tic.SelectTower(_parentTower);
            }
        }
    }

    /// <summary>
    /// 鼠标悬停效果
    /// </summary>
    public override void _Process(double delta)
    {
        // 鼠标悬停时改变光标
        var mousePos = GetGlobalMousePosition();
        bool isHovering = GetNode<CollisionShape2D>("CollisionShape2D")
            .Shape.GetRect().HasPoint(ToLocal(mousePos));

        if (isHovering)
        {
            Input.DefaultCursorShape = Input.CursorShape.PointingHand;
        }
    }
}

升级动画效果

升级时应该有明显的视觉反馈，让玩家感受到"变强了"。

C
using Godot;

/// <summary>
/// 塔升级动画控制器
/// 提供丰富的升级视觉反馈
/// </summary>
public partial class TowerUpgradeEffect : Node2D
{
    /// <summary>
    /// 播放升级动画
    /// </summary>
    public void PlayUpgradeAnimation(
        Sprite2D towerSprite,
        int newLevel)
    {
        // 1. 放大再缩回
        var tween = CreateTween();
        tween.TweenProperty(towerSprite, "scale",
            new Vector2(1.4f, 1.4f), 0.15f)
            .SetTrans(Tween.TransitionType.Back);
        tween.TweenProperty(towerSprite, "scale",
            new Vector2(1.0f, 1.0f), 0.15f);

        // 2. 金色闪光
        var flashOverlay = new ColorRect
        {
            Color = new Color(1, 0.84f, 0, 0.5f) // 金色半透明
        };

        // 3. 上升的金色粒子
        var particles = new GpuParticles2D
        {
            Amount = 15,
            OneShot = true,
            Emitting = true,
            Lifetime = 1.0f,
            Direction = new Vector2(0, -1), // 向上飘
            Spread = 45.0f,
            Gravity = new Vector2(0, -20),
        };

        AddChild(particles);

        // 4. 显示升级文字
        ShowLevelUpText(towerSprite, newLevel);
    }

    /// <summary>
    /// 显示 "Lv.2" 这样的升级文字
    /// </summary>
    private void ShowLevelUpText(Sprite2D parent, int level)
    {
        var label = new Label
        {
            Text = $"Lv.{level}",
            HorizontalAlignment = HorizontalAlignment.Center
        };

        label.Position = new Vector2(-20, -40);
        label.AddThemeFontSizeOverride(
            "font_size", 18);
        label.AddThemeColorOverride(
            "font_color", Colors.Gold);

        parent.AddChild(label);

        // 文字向上飘并淡出
        var tween = CreateTween();
        tween.TweenProperty(label, "position",
            new Vector2(-20, -70), 1.0f);
        tween.Parallel().TweenProperty(label, "modulate",
            new Color(1, 0.84f, 0, 0), 1.0f);
        tween.TweenCallback(Callable.From(() => label.QueueFree()));
    }
}

建造系统

升级和出售是针对已放置的塔的操作，但"放置"本身也需要一个系统来管理。

C
using Godot;

/// <summary>
/// 建造控制器 —— 管理放置新塔的逻辑
/// 就像"施工队队长"，负责把塔放到正确的位置
/// </summary>
public partial class BuildController : Node
{
    [Signal]
    public delegate void BuildModeChangedEventHandler(
        bool isBuilding, TowerData towerData);

    [Signal]
    public delegate void TowerBuiltEventHandler(Tower tower);

    /// <summary>塔容器</summary>
    [Export] public Node2D TowersContainer { get; set; }

    /// <summary>可建造区域地图</summary>
    [Export] public TileMapLayer BuildableMap { get; set; }

    /// <summary>所有塔类型的数据</summary>
    [Export] public TowerData[] AvailableTowers { get; set; }

    private bool _isBuildingMode = false;
    private TowerData _selectedTowerData;
    private Node2D _previewTower; // 放置预览（半透明）

    public bool IsBuildingMode => _isBuildingMode;

    /// <summary>
    /// 进入建造模式
    /// </summary>
    public void EnterBuildMode(TowerData data)
    {
        // 检查金币是否足够
        if (GameManager.Instance.Gold < data.Cost)
        {
            GD.Print($"金币不足！需要 {data.Cost}，当前 {GameManager.Instance.Gold}");
            return;
        }

        _isBuildingMode = true;
        _selectedTowerData = data;

        // 创建预览塔（半透明显示）
        CreatePreview(data);

        EmitSignal(SignalName.BuildModeChanged, true, data);
    }

    /// <summary>
    /// 退出建造模式
    /// </summary>
    public void ExitBuildMode()
    {
        _isBuildingMode = false;
        _selectedTowerData = null;

        // 移除预览
        if (_previewTower != null)
        {
            _previewTower.QueueFree();
            _previewTower = null;
        }

        EmitSignal(SignalName.BuildModeChanged, false, null);
    }

    public override void _Process(double delta)
    {
        if (!_isBuildingMode || _previewTower == null) return;

        // 预览塔跟随鼠标
        _previewTower.GlobalPosition = SnapToGrid(GetGlobalMousePosition());
    }

    public override void _Input(InputEvent @event)
    {
        if (!_isBuildingMode) return;

        // 左键放置
        if (@event is InputEventMouseButton mb
            && mb.ButtonIndex == MouseButton.Left
            && mb.Pressed)
        {
            TryPlaceTower();
        }

        // 右键取消
        if (@event is InputEventMouseButton mb
            && mb.ButtonIndex == MouseButton.Right
            && mb.Pressed)
        {
            ExitBuildMode();
        }

        if (@event is InputEventKey key
            && key.Keycode == Key.Escape
            && key.Pressed)
        {
            ExitBuildMode();
        }
    }

    /// <summary>
    /// 尝试在鼠标位置放置塔
    /// </summary>
    private void TryPlaceTower()
    {
        Vector2 gridPos = SnapToGrid(GetGlobalMousePosition());

        // 检查该位置是否可以建造
        if (!CanBuildAt(gridPos))
        {
            GD.Print("该位置无法建造！");
            return;
        }

        // 扣除金币
        if (!GameManager.Instance.SpendGold(_selectedTowerData.Cost))
        {
            GD.Print("金币不足！");
            ExitBuildMode();
            return;
        }

        // 创建塔
        var tower = _selectedTowerData.TowerScene
            .Instantiate<Tower>();
        tower.GlobalPosition = gridPos;
        TowersContainer.AddChild(tower);

        // 标记该格子为已占用
        MarkGridCell(gridPos, true);

        // 添加到 monsters 组（用于目标检测）
        // 这里用 towers 组
        tower.AddToGroup("towers");

        EmitSignal(SignalName.TowerBuilt, tower);

        // 放置成功后退出建造模式
        // （如果玩家想连续放置，可以不退出）
        ExitBuildMode();
    }

    /// <summary>
    /// 将位置对齐到网格
    /// </summary>
    private Vector2 SnapToGrid(Vector2 position)
    {
        float halfGrid = GameConstants.GridSize / 2.0f;
        return new Vector2(
            Mathf.Round(position.X / GameConstants.GridSize) * GameConstants.GridSize + halfGrid,
            Mathf.Round(position.Y / GameConstants.GridSize) * GameConstants.GridSize + halfGrid
        );
    }

    /// <summary>
    /// 检查某位置是否可以建造
    /// </summary>
    private bool CanBuildAt(Vector2 position)
    {
        // 检查是否已有塔
        var towers = GetTree().GetNodesInGroup("towers");
        foreach (var node in towers)
        {
            if (node is Tower t)
            {
                float dist = position.DistanceTo(t.GlobalPosition);
                if (dist < GameConstants.GridSize * 0.8f)
                    return false;
            }
        }

        return true;
    }

    /// <summary>
    /// 创建放置预览
    /// </summary>
    private void CreatePreview(TowerData data)
    {
        _previewTower = data.TowerScene.Instantiate<Node2D>();
        _previewTower.Modulate = new Color(1, 1, 1, 0.5f); // 半透明
        GetTree().Root.AddChild(_previewTower);
    }

    /// <summary>
    /// 标记网格格子为已占用/已清空
    /// </summary>
    private void MarkGridCell(Vector2 position, bool occupied)
    {
        // 通过 TileMap 来标记
        // 简化处理：实际项目中可以用一个二维数组
    }
}

出售确认

出售是一个不可逆的操作，所以最好加一个确认步骤，防止玩家误操作。

C
/// <summary>
/// 出售确认弹窗
/// 显示返还金额，让玩家确认后再出售
/// </summary>
public partial class SellConfirmDialog : AcceptDialog
{
    private int _refundAmount;
    private Tower _targetTower;

    public void ShowConfirm(Tower tower, int refund)
    {
        _targetTower = tower;
        _refundAmount = refund;

        DialogText = $"确定要出售此塔吗？\n将返还 {_refundAmount} 金币";
        Title = "出售确认";

        // 连接确认按钮
        Confirmed += OnConfirmed;

        PopupCentered();
    }

    private void OnConfirmed()
    {
        if (_targetTower != null && IsInstanceValid(_targetTower))
        {
            _targetTower.Sell();
        }

        Confirmed -= OnConfirmed;
    }
}

本节小结

功能说明
升级提升攻击力和射程，最多3级，费用递增
出售返还总投入的60%，不可逆操作
选中交互点击塔显示攻击范围和操作选项
建造模式选择塔类型后鼠标跟随预览，点击放置
升级动画放大缩回、金色闪光、等级文字上飘
出售确认弹窗确认，防止误操作

升级与出售系统让游戏有了更丰富的策略深度——玩家不仅要想"放什么塔"，还要想"该升级还是该卖掉买新的"。下一节我们将实现波次系统，让怪物一波一波地出现。

最近更新:
贡献者: zefeng.peng,bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS