跳至主要內容

8. HUD 与炸弹系统

EVOCOSMOS2026/4/14大约 9 分钟

HUD 与炸弹系统

HUD（Head-Up Display，抬头显示）是玩家在游戏中看到的界面信息——血量、弹药、金钱、准星、计时器等。炸弹系统是 CS 的核心目标机制——T 安放、CT 拆除。这两个系统让游戏"看得见、玩得着"。

HUD 设计

CS 的 HUD 简洁而信息密集，所有关键信息一目了然：

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│                        [回合信息]                            │
│                    CT 7 : 5 T                               │
│                     01:35                                   │
│                                                             │
│                                                             │
│                          +                                  │  ← 准星
│                                                             │
│                                                             │
│                                                             │
│  [炸弹图标]                              [击杀提示]         │
│  ☢ 0:28                                  你击杀了 Bot01     │
│                                                             │
│                                                             │
│  HP ████████ 100         30/90  AK-47        $4750          │
│  ─────────────          ──────  ─────        ──────         │
│  血量条                  弹药     武器名        金钱          │
└─────────────────────────────────────────────────────────────┘

HUD 场景结构

HUD (CanvasLayer)                       ← 固定在屏幕上的 UI 层
├── TopBar (HBoxContainer)              ← 顶部信息栏
│   ├── CTScore (Label)                 ← CT 比分
│   ├── Timer (Label)                   ← 回合计时器
│   └── TScore (Label)                  ← T 比分
│
├── Crosshair (CenterContainer)         ← 准星（屏幕中央）
│   └── CrosshairLines (Control)        ← 十字准星绘制
│
├── BottomBar (HBoxContainer)           ← 底部信息栏
│   ├── HealthSection (VBoxContainer)
│   │   ├── HealthBar (ProgressBar)     ← 血量条
│   │   └── ArmorIcon (TextureRect)     ← 护甲图标
│   ├── AmmoSection (VBoxContainer)
│   │   ├── CurrentAmmo (Label)         ← 当前弹匣弹药
│   │   └── ReserveAmmo (Label)         ← 备用弹药
│   ├── WeaponName (Label)              ← 武器名称
│   └── MoneySection (VBoxContainer)
│       └── MoneyLabel (Label)          ← 金钱显示
│
├── BombIndicator (HBoxContainer)       ← 炸弹指示器
│   ├── BombIcon (TextureRect)
│   └── BombTimer (Label)
│
├── KillFeed (VBoxContainer)            ← 击杀信息流
│   └── KillNotification (Label)        ← 单条击杀提示
│
└── RoundInfo (Panel)                   ← 回合提示（回合开始/结束）
    └── RoundMessage (Label)

HUD 控制器

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

/// <summary>
/// HUD 控制器。监听游戏事件，更新界面显示。
/// </summary>
public partial class HUDController : CanvasLayer
{
    private Label _ctScoreLabel;
    private Label _tScoreLabel;
    private Label _timerLabel;
    private ProgressBar _healthBar;
    private Label _currentAmmoLabel;
    private Label _reserveAmmoLabel;
    private Label _weaponNameLabel;
    private Label _moneyLabel;
    private Label _bombTimerLabel;
    private VBoxContainer _killFeed;
    private Label _roundMessage;
    private Control _crosshair;

    public override void _Ready()
    {
        // 获取 UI 节点引用
        _ctScoreLabel = GetNode<Label>("TopBar/CTScore");
        _tScoreLabel = GetNode<Label>("TopBar/TScore");
        _timerLabel = GetNode<Label>("TopBar/Timer");
        _healthBar = GetNode<ProgressBar>("BottomBar/HealthSection/HealthBar");
        _currentAmmoLabel = GetNode<Label>("BottomBar/AmmoSection/CurrentAmmo");
        _reserveAmmoLabel = GetNode<Label>("BottomBar/AmmoSection/ReserveAmmo");
        _weaponNameLabel = GetNode<Label>("BottomBar/WeaponName");
        _moneyLabel = GetNode<Label>("BottomBar/MoneySection/MoneyLabel");
        _bombTimerLabel = GetNode<Label>("BombIndicator/BombTimer");
        _killFeed = GetNode<VBoxContainer>("KillFeed");
        _roundMessage = GetNode<Label>("RoundInfo/RoundMessage");
        _crosshair = GetNode<Control>("Crosshair/CrosshairLines");

        // 连接游戏事件
        var gameEvents = GetNode<GameEvents>("/root/GameEvents");
        gameEvents.RoundStarted += OnRoundStarted;
        gameEvents.RoundEnded += OnRoundEnded;
        gameEvents.PlayerDied += OnPlayerDied;
        gameEvents.MoneyChanged += OnMoneyChanged;
    }

    public override void _Process(double delta)
    {
        UpdateTimer();
        UpdateAmmoDisplay();
        UpdateHealthDisplay();
        UpdateCrosshair();
    }

    private void UpdateTimer()
    {
        var roundManager = GetNode<RoundManager>("../RoundManager");
        var timeRemaining = roundManager.GetPhaseTimeRemaining();
        _timerLabel.Text = FormatTime(timeRemaining);
    }

    private void UpdateAmmoDisplay()
    {
        var weaponManager = GetNode<WeaponManager>("../Players/Player/WeaponHolder/WeaponManager");
        if (weaponManager?.CurrentWeapon != null)
        {
            _currentAmmoLabel.Text = weaponManager.CurrentWeapon.CurrentAmmo.ToString();
            _reserveAmmoLabel.Text = weaponManager.CurrentWeapon.ReserveAmmo.ToString();
            _weaponNameLabel.Text = weaponManager.CurrentWeapon.Data?.WeaponName ?? "";
        }
    }

    private void UpdateHealthDisplay()
    {
        var player = GetNode<CharacterBody3D>("../Players/Player");
        var health = player?.GetNode<HealthComponent>("HealthComponent");
        if (health != null)
        {
            _healthBar.Value = health.CurrentHealth;
        }
    }

    /// <summary>
    /// 根据移动状态动态调整准星大小。
    /// 移动时准星变大，静止时缩小。
    /// </summary>
    private void UpdateCrosshair()
    {
        var player = GetNode<PlayerController>("../Players/Player");
        if (player == null) return;

        float spread = 4f; // 基础准星大小

        // 移动时准星变大
        spread += player.SpeedFactor * 20f;

        // 蹲下时准星变小
        if (player.IsCrouching)
            spread *= 0.7f;

        // 应用准星大小（通过调整线条间距）
        _crosshair.Set("spread", spread);
    }

    private void OnRoundStarted(int roundNumber)
    {
        _roundMessage.Text = $"第 {roundNumber} 回合开始！";
        _roundMessage.Visible = true;

        // 3秒后隐藏提示
        GetTree().CreateTimer(3.0).Timeout += () => _roundMessage.Visible = false;
    }

    private void OnRoundEnded(string winner)
    {
        var message = winner == "CT" ? "反恐精英 获胜！" : "恐怖分子 获胜！";
        _roundMessage.Text = message;
        _roundMessage.Visible = true;

        // 更新比分
        var roundManager = GetNode<RoundManager>("../RoundManager");
        var (ct, t) = roundManager.GetScore();
        _ctScoreLabel.Text = ct.ToString();
        _tScoreLabel.Text = t.ToString();
    }

    private void OnPlayerDied(Node3D player, Node3D killer)
    {
        var killText = $"{killer.Name} 击杀了 {player.Name}";
        AddKillNotification(killText);
    }

    private void OnMoneyChanged(int playerId, int newAmount)
    {
        _moneyLabel.Text = $"${newAmount}";
    }

    private void AddKillNotification(string text)
    {
        var label = new Label();
        label.Text = text;
        _killFeed.AddChild(label);

        // 5秒后自动消失
        GetTree().CreateTimer(5.0).Timeout += () => label.QueueFree();
    }

    private string FormatTime(float seconds)
    {
        var mins = (int)seconds / 60;
        var secs = (int)seconds % 60;
        return $"{mins:D2}:{secs:D2}";
    }
}

炸弹系统

C4 炸弹是 CS 炸弹拆除模式的核心目标。

炸弹状态

炸弹状态流程：

没有安放 ──(T在炸弹点安放)──► 安放中（3.2秒）
                                    │
                              安放完成
                                    │
                           倒计时 40 秒
                            │           │
                    (CT拆除)          (时间到)
                        │               │
                    拆除成功          爆炸！
                    CT 赢            T 赢

炸弹系统实现

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

public enum BombState
{
    None,           // 没有炸弹
    Carried,        // 被 T 玩家携带
    Planting,       // 正在安放
    Planted,        // 已安放，倒计时中
    Defusing,       // 正在拆除
    Exploded,       // 已爆炸
    Defused         // 已拆除
}

/// <summary>
/// 炸弹系统。管理 C4 炸弹的完整生命周期。
///
/// 炸弹的"一生"：
/// 1. 回合开始时分配给一个 T 方玩家（Carried）
/// 2. T 到达炸弹点后按 E 安放（Planting → Planted）
/// 3. 安放后开始 40 秒倒计时
/// 4. CT 可以按 E 拆除（Defusing → Defused）
/// 5. 倒计时结束则爆炸（Exploded）
/// </summary>
public partial class BombSystem : Node3D
{
    [Export] public float PlantTime { get; set; } = 3.2f;
    [Export] public float DetonateTime { get; set; } = 40f;
    [Export] public float DefuseTime { get; set; } = 10f;
    [Export] public float DefuseTimeWithKit { get; set; } = 5f;
    [Export] public float ExplosionRadius { get; set; } = 17f;
    [Export] public float ExplosionDamage { get; set; } = 500f;

    private BombState _state = BombState.None;
    private Node3D _carrier;          // 携带炸弹的 T
    private Vector3 _plantedPosition;  // 安放位置
    private float _timer;
    private bool _hasDefuseKit;

    private MeshInstance3D _bombModel;
    private AudioStreamPlayer3D _beepSound;
    private AudioStreamPlayer3D _explosionSound;
    private PointLight3D _bombLight;

    public BombState State => _state;
    public float TimeRemaining => _timer;

    public override void _Ready()
    {
        _bombModel = GetNode<MeshInstance3D>("BombModel");
        _beepSound = GetNode<AudioStreamPlayer3D>("BeepSound");
        _explosionSound = GetNode<AudioStreamPlayer3D>("ExplosionSound");
        _bombLight = GetNode<PointLight3D>("BombLight");

        _bombModel.Visible = false;
        _bombLight.Visible = false;
    }

    public override void _Process(double delta)
    {
        switch (_state)
        {
            case BombState.Planting:
                _timer -= (float)delta;
                if (_timer <= 0)
                {
                    PlantComplete();
                }
                break;

            case BombState.Planted:
                _timer -= (float)delta;
                UpdateBeepInterval();

                if (_timer <= 0)
                {
                    Explode();
                }
                break;

            case BombState.Defusing:
                _timer -= (float)delta;
                if (_timer <= 0)
                {
                    DefuseComplete();
                }
                break;
        }
    }

    /// <summary>
    /// 回合开始时将炸弹分配给一个 T 方玩家。
    /// </summary>
    public void AssignToPlayer(Node3D player)
    {
        _state = BombState.Carried;
        _carrier = player;
        _bombModel.Visible = false;

        // 加入携带者的组
        player.AddToGroup("bomb_carrier");
    }

    /// <summary>
    /// 开始安放炸弹（T 方玩家按 E 键）。
    /// </summary>
    public bool TryPlant(Node3D planter)
    {
        if (_state != BombState.Carried) return false;
        if (_carrier != planter) return false;

        // 检查是否在炸弹点内
        if (!IsInBombSite(planter)) return false;

        _state = BombState.Planting;
        _timer = PlantTime;
        _plantedPosition = planter.GlobalPosition;

        return true;
    }

    private void PlantComplete()
    {
        _state = BombState.Planted;
        _timer = DetonateTime;

        // 显示炸弹模型
        _bombModel.Visible = true;
        _bombModel.GlobalPosition = _plantedPosition;
        _bombLight.Visible = true;

        // 从携带者移除标记
        if (_carrier != null)
            _carrier.RemoveFromGroup("bomb_carrier");

        // 添加到"已安放炸弹"组（AI 会查找这个组）
        AddToGroup("planted_bomb");

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

    /// <summary>
    /// 开始拆除炸弹（CT 方玩家按 E 键）。
    /// </summary>
    public bool TryDefuse(Node3D defuser, bool hasDefuseKit)
    {
        if (_state != BombState.Planted) return false;

        // 检查距离
        var dist = defuser.GlobalPosition.DistanceTo(_plantedPosition);
        if (dist > 3f) return false;

        _state = BombState.Defusing;
        _hasDefuseKit = hasDefuseKit;
        _timer = hasDefuseKit ? DefuseTimeWithKit : DefuseTime;

        return true;
    }

    private void DefuseComplete()
    {
        _state = BombState.Defused;
        _bombModel.Visible = false;
        _bombLight.Visible = false;
        RemoveFromGroup("planted_bomb");

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

    private void Explode()
    {
        _state = BombState.Exploded;

        // 播放爆炸音效
        _explosionSound.Play();

        // 爆炸范围内所有人受到伤害
        ApplyExplosionDamage();

        // 隐藏模型
        _bombModel.Visible = false;
        _bombLight.Visible = false;
        RemoveFromGroup("planted_bomb");

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

    private void ApplyExplosionDamage()
    {
        // 获取爆炸范围内所有物体
        var spaceState = GetWorld3D().DirectSpaceState;
        var shape = new SphereShape3D();
        shape.Radius = ExplosionRadius;

        var query = new PhysicsShapeQueryParameters3D();
        query.Shape = shape;
        query.Transform = new Transform3D(Basis.Identity, _plantedPosition);

        var results = spaceState.IntersectShape(query);

        foreach (var result in results)
        {
            var collider = (Node3D)result["collider"];
            var health = collider.GetNodeOrNull<HealthComponent>("HealthComponent");
            if (health != null)
            {
                // 距离越远伤害越低
                var dist = collider.GlobalPosition.DistanceTo(_plantedPosition);
                var damageFactor = 1f - (dist / ExplosionRadius);
                health.TakeDamage(ExplosionDamage * damageFactor);
            }
        }
    }

    /// <summary>
    /// 随着倒计时推进，炸弹的"滴滴"声越来越快。
    /// 这是 CS 的经典紧张感设计。
    /// </summary>
    private void UpdateBeepInterval()
    {
        if (_state != BombState.Planted) return;

        // 最后 10 秒开始加快滴滴声
        if (_timer <= 10f)
        {
            var interval = _timer / 10f * 0.5f;
            if (!_beepSound.Playing)
            {
                _beepSound.Play();
            }
        }

        // 炸弹灯闪烁
        _bombLight.Visible = ((int)(_timer * 4) % 2) == 0;
    }

    private bool IsInBombSite(Node3D player)
    {
        foreach (var node in GetTree().GetNodesInGroup("bomb_site"))
        {
            if (node is Area3D site)
            {
                if (site.GetOverlappingBodies().Contains(player))
                    return true;
            }
        }
        return false;
    }

    /// <summary>
    /// 重置炸弹状态（新回合开始时调用）。
    /// </summary>
    public void Reset()
    {
        _state = BombState.None;
        _carrier = null;
        _timer = 0;
        _bombModel.Visible = false;
        _bombLight.Visible = false;
        RemoveFromGroup("planted_bomb");
    }
}

小结

这一章实现了 HUD 和炸弹两个系统：

  1. HUD：血量条、弹药显示、金钱、计时器、准星、击杀信息、回合提示
  2. 准星动态：根据移动状态调整准星大小
  3. 炸弹系统：携带 → 安放 → 倒计时 → 爆炸/拆除的完整生命周期
  4. 爆炸伤害：距离衰减的区域伤害
  5. 紧张感设计：炸弹倒计时越少，滴滴声越快

下一章我们给游戏加上音效和视觉效果，然后做最后的打磨。

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