跳至主要內容

7. 回合系统与经济

EVOCOSMOS2026/4/14大约 8 分钟

回合系统与经济

回合制是 CS 区别于其他射击游戏的标志性特征。每一回合都是一个独立的"小战役"——有开始（买枪）、有过程（战斗）、有结局（胜负判定），回合之间的经济传承又让每回合不是孤立的。这一章我们实现回合管理器和经济系统。

回合管理器

回合管理器是整个游戏的"裁判"——它控制回合的流程、计时、胜负判定，以及半场换边。

回合流程

比赛开始
  │
  ├── 上半场（最多12回合，先到13分结束）
  │     │
  │     ├─① 购买阶段（15秒）─── 买枪时间
  │     │    │
  │     ├─② 战斗阶段（115秒）── 正式战斗
  │     │    ├─ T 全灭 → CT 赢
  │     │    ├─ CT 全灭 → T 赢
  │     │    ├─ 炸弹爆炸 → T 赢
  │     │    ├─ 炸弹拆除 → CT 赢
  │     │    └─ 时间耗尽且炸弹未安放 → CT 赢
  │     │
  │     ├─③ 回合结算（5秒）
  │     │    ├─ 发放金钱奖励
  │     │    ├─ 更新比分
  │     │    └─ 重生所有角色
  │     │
  │     └─ 回到①
  │
  ├── 半场休息（15秒）── 双方换边
  │
  └── 下半场（最多12回合）

回合管理器实现

C#
// Scripts/Systems/RoundManager.cs
using Godot;

public enum RoundPhase
{
    BuyPhase,       // 购买阶段
    PlayPhase,      // 战斗阶段
    RoundEnd,       // 回合结算
    HalfTime,       // 半场休息
    MatchOver       // 比赛结束
}

/// <summary>
/// 回合管理器。控制回合流程、计时和胜负判定。
/// </summary>
public partial class RoundManager : Node
{
    [Export] public float BuyPhaseDuration { get; set; } = 15f;
    [Export] public float PlayPhaseDuration { get; set; } = 115f;
    [Export] public float RoundEndDuration { get; set; } = 5f;
    [Export] public float HalfTimeDuration { get; set; } = 15f;
    [Export] public int WinsNeeded { get; set; } = 13;

    private RoundPhase _phase;
    private float _phaseTimer;
    private int _ctScore;
    private int _tScore;
    private int _roundNumber;
    private bool _bombPlanted;
    private bool _isFirstHalf = true;

    // 回合内状态追踪
    private int _aliveCT;
    private int _aliveT;

    public override void _Ready()
    {
        var gameEvents = GetNode<GameEvents>("/root/GameEvents");

        gameEvents.PlayerDied += OnPlayerDied;
        gameEvents.BombPlanted += OnBombPlanted;
        gameEvents.BombDefused += OnBombDefused;
        gameEvents.BombExploded += OnBombExploded;
    }

    /// <summary>
    /// 开始新回合。
    /// </summary>
    public void StartRound()
    {
        _roundNumber++;
        _bombPlanted = false;
        _phase = RoundPhase.BuyPhase;
        _phaseTimer = BuyPhaseDuration;

        // 统计存活人数
        _aliveCT = GetTree().GetNodesInGroup("counter_terrorist").Count;
        _aliveT = GetTree().GetNodesInGroup("terrorist").Count;

        var gameEvents = GetNode<GameEvents>("/root/GameEvents");
        gameEvents.EmitSignal(GameEvents.SignalName.RoundStarted, _roundNumber);
    }

    public override void _Process(double delta)
    {
        if (_phase == RoundPhase.MatchOver) return;

        _phaseTimer -= (float)delta;

        switch (_phase)
        {
            case RoundPhase.BuyPhase:
                if (_phaseTimer <= 0)
                {
                    _phase = RoundPhase.PlayPhase;
                    _phaseTimer = PlayPhaseDuration;
                }
                break;

            case RoundPhase.PlayPhase:
                // 时间耗尽
                if (_phaseTimer <= 0 && !_bombPlanted)
                {
                    // CT 赢（T 没能在时间内安放炸弹）
                    EndRound("CT");
                }
                break;

            case RoundPhase.RoundEnd:
                if (_phaseTimer <= 0)
                {
                    // 检查是否需要换边
                    if (_roundNumber >= 12 && _isFirstHalf)
                    {
                        _phase = RoundPhase.HalfTime;
                        _phaseTimer = HalfTimeDuration;
                    }
                    else if (_ctScore >= WinsNeeded || _tScore >= WinsNeeded)
                    {
                        _phase = RoundPhase.MatchOver;
                    }
                    else
                    {
                        StartRound();
                    }
                }
                break;

            case RoundPhase.HalfTime:
                if (_phaseTimer <= 0)
                {
                    _isFirstHalf = false;
                    // 交换双方阵营和分数
                    (_ctScore, _tScore) = (_tScore, _ctScore);
                    StartRound();
                }
                break;
        }
    }

    private void EndRound(string winner)
    {
        _phase = RoundPhase.RoundEnd;
        _phaseTimer = RoundEndDuration;

        if (winner == "CT") _ctScore++;
        else _tScore++;

        var gameEvents = GetNode<GameEvents>("/root/GameEvents");
        gameEvents.EmitSignal(GameEvents.SignalName.RoundEnded, winner);

        // 通知经济系统
        var economy = GetNode<EconomyManager>("/root/EconomyManager");
        economy.ProcessRoundEnd(winner);
    }

    // 事件处理
    private void OnPlayerDied(Node3D player, Node3D killer)
    {
        if (player.IsInGroup("counter_terrorist")) _aliveCT--;
        else if (player.IsInGroup("terrorist")) _aliveT--;

        // 检查是否有一方全灭
        if (_phase == RoundPhase.PlayPhase)
        {
            if (_aliveCT <= 0) EndRound("T");
            else if (_aliveT <= 0) EndRound("CT");
        }
    }

    private void OnBombPlanted(Vector3 position)
    {
        _bombPlanted = true;
    }

    private void OnBombDefused()
    {
        EndRound("CT");
    }

    private void OnBombExploded()
    {
        EndRound("T");
    }

    // 公开查询接口
    public RoundPhase GetPhase() => _phase;
    public float GetPhaseTimeRemaining() => _phaseTimer;
    public (int ct, int t) GetScore() => (_ctScore, _tScore);
    public int GetRoundNumber() => _roundNumber;
}

经济系统

经济系统是 CS 的另一个标志性机制——每一回合赚到的钱可以用来买下一回合的武器，让每回合之间存在"传承"关系。

金钱规则

C#
// Scripts/Systems/EconomyManager.cs
using Godot;

/// <summary>
/// 经济管理器。追踪每个玩家的金钱，处理回合结算时的金钱发放。
///
/// CS 经济系统的核心规则：
/// - 赢了回合 → 每人得 $3250
/// - 输了回合 → 基础 $1400，连续输递增
/// - 击杀奖励：步枪 $300，霰弹枪 $900，AWP $100
/// - 安放炸弹：$300（无论输赢）
/// </summary>
public partial class EconomyManager : Node
{
    private int _consecutiveLosses;
    private const int MaxMoney = 16000;

    // 每个玩家的金钱（用 playerId 作为 key）
    private Godot.Collections.Dictionary<int, int> _playerMoney = new();

    public override void _Ready()
    {
        var gameEvents = GetNode<GameEvents>("/root/GameEvents");
        gameEvents.WeaponPurchased += OnWeaponPurchased;
    }

    /// <summary>
    /// 初始化一个玩家的金钱（开局 $800）
    /// </summary>
    public void InitPlayer(int playerId)
    {
        _playerMoney[playerId] = 800;  // CS 的初始金钱
    }

    /// <summary>
    /// 回合结束时调用。根据胜负发放金钱。
    /// </summary>
    public void ProcessRoundEnd(string winningTeam)
    {
        // 计算胜方和败方的奖金
        int winReward = 3250;
        int lossReward = CalculateLossReward();

        if (winningTeam == "CT")
        {
            _consecutiveLosses = 0;  // CT 赢了，CT 的连败清零
        }
        else
        {
            _consecutiveLosses++;    // CT 输了，连败计数+1
        }

        // 给所有玩家发钱
        foreach (var (playerId, currentMoney) in _playerMoney)
        {
            // 判断这个玩家属于哪方（简化处理）
            int reward = IsCTPlayer(playerId) ?
                (winningTeam == "CT" ? winReward : lossReward) :
                (winningTeam == "T" ? winReward : lossReward);

            _playerMoney[playerId] = Mathf.Min(currentMoney + reward, MaxMoney);
        }

        // 通知 UI 更新
        EmitMoneyChanged();
    }

    /// <summary>
    /// 计算连败递增奖励。
    /// 连续输的次数越多，每回合的安慰金越高。
    /// </summary>
    private int CalculateLossReward()
    {
        return _consecutiveLosses switch
        {
            0 => 1400,
            1 => 1900,
            2 => 2400,
            _ => 2900  // 连续输 3 次及以上都是 2900
        };
    }

    /// <summary>
    /// 玩家购买武器。
    /// </summary>
    public bool TryPurchase(int playerId, int cost)
    {
        if (!_playerMoney.ContainsKey(playerId)) return false;

        var currentMoney = _playerMoney[playerId];
        if (currentMoney < cost) return false;

        _playerMoney[playerId] = currentMoney - cost;

        var gameEvents = GetNode<GameEvents>("/root/GameEvents");
        gameEvents.EmitSignal(GameEvents.SignalName.MoneyChanged, playerId, _playerMoney[playerId]);

        return true;
    }

    /// <summary>
    /// 击杀奖励。
    /// </summary>
    public void AwardKillReward(int playerId, string weaponType)
    {
        int reward = weaponType switch
        {
            "Rifle" => 300,
            "Pistol" => 300,
            "Shotgun" => 900,
            "Sniper" => 100,
            "SMG" => 600,
            _ => 300
        };

        if (_playerMoney.ContainsKey(playerId))
        {
            _playerMoney[playerId] = Mathf.Min(
                _playerMoney[playerId] + reward,
                MaxMoney
            );
        }
    }

    private void OnWeaponPurchased(int playerId, string weaponName)
    {
        // UI 发来的购买请求会在这里处理
    }

    private bool IsCTPlayer(int playerId)
    {
        // 简化处理，实际应根据玩家数据判断
        return playerId % 2 == 0;
    }

    public int GetMoney(int playerId)
    {
        return _playerMoney.GetValueOrDefault(playerId, 0);
    }

    private void EmitMoneyChanged()
    {
        var gameEvents = GetNode<GameEvents>("/root/GameEvents");
        foreach (var (playerId, money) in _playerMoney)
        {
            gameEvents.EmitSignal(GameEvents.SignalName.MoneyChanged, playerId, money);
        }
    }
}

买枪菜单

买枪菜单只在购买阶段显示，提供一个简单的界面让玩家选择武器。

C#
// Scripts/UI/BuyMenuController.cs
using Godot;

/// <summary>
/// 买枪菜单控制器。在购买阶段按 B 键打开。
///
/// 显示可购买的武器列表和价格，
/// 点击购买后扣钱、装备武器、关闭菜单。
/// </summary>
public partial class BuyMenuController : CanvasLayer
{
    private bool _isVisible;
    private int _playerId;

    public override void _Ready()
    {
        Visible = false;
    }

    public override void _UnhandledInput(InputEvent @event)
    {
        if (@event.IsActionPressed("buy_menu"))
        {
            var roundManager = GetParent().GetNode<RoundManager>("RoundManager");
            if (roundManager.GetPhase() == RoundPhase.BuyPhase)
            {
                ToggleMenu();
            }
        }
    }

    private void ToggleMenu()
    {
        _isVisible = !_isVisible;
        Visible = _isVisible;

        if (_isVisible)
        {
            Input.MouseMode = Input.MouseModeEnum.Visible;
        }
        else
        {
            Input.MouseMode = Input.MouseModeEnum.Captured;
        }
    }

    /// <summary>
    /// 购买武器（由 UI 按钮调用）
    /// </summary>
    public void OnPurchaseButtonPressed(string weaponName, int cost)
    {
        var economy = GetNode<EconomyManager>("/root/EconomyManager");
        if (economy.TryPurchase(_playerId, cost))
        {
            var gameEvents = GetNode<GameEvents>("/root/GameEvents");
            gameEvents.EmitSignal(GameEvents.SignalName.WeaponPurchased, _playerId, weaponName);

            // 关闭菜单
            ToggleMenu();
        }
    }
}

小结

这一章实现了 CS 的回合系统与经济：

  1. 回合管理器：控制购买/战斗/结算三个阶段，判定六种胜负条件
  2. 经济系统：回合奖金、连败递增、击杀奖励、最大金钱上限
  3. 买枪菜单：购买阶段按 B 打开，花钱买武器

关键设计：

  • 用事件总线（信号）解耦回合管理器和其他系统
  • 连败递增机制让落后方有机会翻盘
  • 金钱上限（$16000）防止一方无限积累财富

下一章我们实现 HUD 界面和炸弹系统。

最近更新:
贡献者: bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS