跳至主要內容

5. 回合制战斗

EVOCOSMOS2026/4/14大约 11 分钟

5. 伏魔记——回合制战斗

5.1 什么是回合制战斗？

想象两个人下棋——你走一步，对方走一步，轮流进行，不能同时动手。回合制战斗就是这样的：我方角色和敌方角色轮流行动，谁速度快谁先动手，一个回合结束后轮到下一个。

经典的回合制RPG（比如《仙剑奇侠传》《勇者斗恶龙》）都采用这种模式。它的好处是：

  • 玩家有充足时间思考策略
  • 不需要快速反应，操作门槛低
  • 可以设计丰富的技能和战术组合

5.2 战斗流程总览

┌───────────────┐
│  进入战斗场景   │ ← 播放遇敌动画
└───────┬───────┘
        ↓
┌───────────────┐
│  生成战斗单位   │ ← 我方队伍 + 敌方阵容
└───────┬───────┘
        ↓
┌───────────────┐
│  排列行动顺序  │ ← 根据速度值排序
└───────┬───────┘
        ↓
┌───────────────┐     ┌───────────────┐
│ 当前单位行动   │ ←→  │ 等待下一个单位 │
└───────┬───────┘     └───────────────┘
        ↓
┌───────────────┐
│  选择行动      │ ← 攻击/技能/物品/防御
└───────┬───────┘
        ↓
┌───────────────┐
│  执行行动      │ ← 计算伤害，播放动画
└───────┬───────┘
        ↓
┌──────────────────────────┐
│  检查胜负                  │
│  敌方全倒 → 战斗胜利       │
│  我方全倒 → 战斗失败       │
│  都还有人 → 下一个单位行动  │
└──────────────────────────┘

5.3 战斗单位

每个参与战斗的角色（无论是玩家还是敌人）都是一个战斗单位（BattleUnit）。

C
using Godot;
using System.Collections.Generic;

/// <summary>
/// 战斗单位——战斗场景中的角色实体
/// </summary>
public partial class BattleUnit : Node2D
{
    // ===== 角色数据 =====
    public CharacterStats Stats { get; private set; }
    public string UnitName { get; private set; }
    public bool IsPlayer { get; private set; }  // 是否是玩家方
    public bool IsDefending { get; private set; } // 本回合是否选择了防御

    // ===== UI引用 =====
    private TextureRect _sprite;
    private ProgressBar _hpBar;
    private ProgressBar _mpBar;
    private Label _nameLabel;
    private Label _hpLabel;

    // ===== 信号 =====
    [Signal] public delegate void UnitDiedEventHandler(BattleUnit unit);
    [Signal] public delegate void ActionCompletedEventHandler();

    public override void _Ready()
    {
        _sprite = GetNode<TextureRect>("Sprite");
        _hpBar = GetNode<ProgressBar>("HPBar");
        _mpBar = GetNode<ProgressBar>("MPBar");
        _nameLabel = GetNode<Label>("NameLabel");
        _hpLabel = GetNode<Label>("HPLabel");
    }

    /// <summary>
    /// 初始化战斗单位
    /// </summary>
    public void Initialize(CharacterStats stats, bool isPlayer)
    {
        Stats = stats;
        UnitName = stats.Name;
        IsPlayer = isPlayer;
        IsDefending = false;

        _nameLabel.Text = UnitName;
        UpdateUI();
    }

    /// <summary>
    /// 更新血条和状态显示
    /// </summary>
    public void UpdateUI()
    {
        float hpPercent = (float)Stats.CurrentHp / Stats.MaxHp * 100;
        float mpPercent = (float)Stats.CurrentMp / Stats.MaxMp * 100;

        _hpBar.Value = hpPercent;
        _mpBar.Value = mpPercent;
        _hpLabel.Text = $"{Stats.CurrentHp}/{Stats.MaxHp}";
    }

    /// <summary>
    /// 受到伤害
    /// </summary>
    public void TakeDamage(int damage)
    {
        var newStats = Stats.TakeDamage(damage);
        Stats = newStats;
        UpdateUI();

        // 播放受伤动画
        _play_hurt_animation();

        // 检查是否死亡
        if (!Stats.IsAlive)
        {
            _play_death_animation();
            EmitSignal(SignalName.UnitDied, this);
        }
    }

    /// <summary>
    /// 恢复HP
    /// </summary>
    public void Heal(int amount)
    {
        var newStats = Stats.Heal(amount);
        Stats = newStats;
        UpdateUI();
        _play_heal_animation();
    }

    /// <summary>
    /// 开始新的回合（重置防御状态）
    /// </summary>
    public void StartNewTurn()
    {
        IsDefending = false;
    }

    // ===== 动画 =====
    private void _play_hurt_animation()
    {
        // 闪烁效果
        var tween = CreateTween();
        tween.TweenProperty(_sprite, "modulate:a", 0.3f, 0.1f);
        tween.TweenProperty(_sprite, "modulate:a", 1.0f, 0.1f);
        tween.TweenProperty(_sprite, "modulate:a", 0.3f, 0.1f);
        tween.TweenProperty(_sprite, "modulate:a", 1.0f, 0.1f);
    }

    private void _play_death_animation()
    {
        // 淡出效果
        var tween = CreateTween();
        tween.TweenProperty(this, "modulate:a", 0.0f, 0.5f);
    }

    private void _play_heal_animation()
    {
        // 绿色闪烁
        var tween = CreateTween();
        tween.TweenProperty(_sprite, "modulate",
            new Color(0.5f, 1.0f, 0.5f), 0.2f);
        tween.TweenProperty(_sprite, "modulate",
            Colors.White, 0.3f);
    }
}

5.4 战斗管理器

BattleManager 是战斗的"裁判"，它控制整个战斗流程：谁先行动、什么时候轮到谁、战斗什么时候结束。

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

/// <summary>
/// 战斗管理器——回合制战斗的"裁判"
/// </summary>
public partial class BattleManager : Node
{
    // 所有参战单位
    private List<BattleUnit> _allUnits = new();
    private List<BattleUnit> _playerUnits = new();
    private List<BattleUnit> _enemyUnits = new();

    // 行动队列（按速度排序）
    private Queue<BattleUnit> _actionQueue = new();

    // 当前行动单位
    private BattleUnit _currentUnit;

    // 战斗状态
    private bool _battleActive = false;
    private bool _waitingForPlayerInput = false;

    // UI引用
    private Control _actionMenu;
    private Control _targetSelection;
    private Control _battleResultPanel;

    // 信号
    [Signal] public delegate void BattleWonEventHandler();
    [Signal] public delegate void BattleLostEventHandler();

    public override void _Ready()
    {
        _actionMenu = GetNode<Control>("%ActionMenu");
        _targetSelection = GetNode<Control>("%TargetSelection");
        _battleResultPanel = GetNode<Control>("%BattleResultPanel");

        _actionMenu.Visible = false;
        _targetSelection.Visible = false;
        _battleResultPanel.Visible = false;
    }

    /// <summary>
    /// 初始化战斗——创建我方和敌方的战斗单位
    /// </summary>
    public void StartBattle(
        List<CharacterStats> partyStats,
        List<CharacterStats> enemyStats)
    {
        // 创建我方战斗单位
        _playerUnits.Clear();
        foreach (var stats in partyStats)
        {
            var unit = CreateBattleUnit(stats, true);
            _playerUnits.Add(unit);
            _allUnits.Add(unit);
        }

        // 创建敌方战斗单位
        _enemyUnits.Clear();
        foreach (var stats in enemyStats)
        {
            var unit = CreateBattleUnit(stats, false);
            _enemyUnits.Add(unit);
            _allUnits.Add(unit);
        }

        // 按速度排序，建立行动队列
        BuildActionQueue();

        _battleActive = true;
        GameManager.Instance.GameState = RpgGameState.Battle;

        // 开始第一个回合
        NextTurn();
    }

    /// <summary>
    /// 根据速度值排序建立行动队列
    /// </summary>
    private void BuildActionQueue()
    {
        var sorted = _allUnits
            .Where(u => u.Stats.IsAlive)
            .OrderByDescending(u => u.Stats.Speed)
            .ToList();

        _actionQueue = new Queue<BattleUnit>(sorted);
    }

    /// <summary>
    /// 进入下一个单位的回合
    /// </summary>
    private void NextTurn()
    {
        // 跳过已死亡的单位
        while (_actionQueue.Count > 0
            && !_actionQueue.Peek().Stats.IsAlive)
        {
            _actionQueue.Dequeue();
        }

        // 行动队列空了，重新排序开始新一轮
        if (_actionQueue.Count == 0)
        {
            BuildActionQueue();
        }

        if (_actionQueue.Count == 0)
        {
            // 所有人都死了（理论上不会发生）
            return;
        }

        _currentUnit = _actionQueue.Dequeue();
        _currentUnit.StartNewTurn();

        if (_currentUnit.IsPlayer)
        {
            // 玩家回合：显示行动菜单
            ShowActionMenu();
        }
        else
        {
            // 敌人回合：由AI决定行动
            EnemyAiTurn(_currentUnit);
        }
    }

    /// <summary>
    /// 显示行动菜单（攻击/技能/物品/防御）
    /// </summary>
    private void ShowActionMenu()
    {
        _waitingForPlayerInput = true;
        _actionMenu.Visible = true;
    }

    /// <summary>
    /// 玩家选择"攻击"
    /// </summary>
    public void OnAttackSelected()
    {
        _actionMenu.Visible = false;
        // 让玩家选择攻击目标
        ShowTargetSelection(
            _enemyUnits.Where(u => u.Stats.IsAlive).ToList(),
            ExecuteAttack);
    }

    /// <summary>
    /// 玩家选择"防御"
    /// </summary>
    public void OnDefendSelected()
    {
        _actionMenu.Visible = false;
        _currentUnit.IsDefending = true;

        // 显示"防御"提示
        GD.Print($"{_currentUnit.UnitName} 选择了防御！");

        // 防御完成后进入下一个回合
        var timer = GetTree().CreateTimer(0.5);
        timer.Timeout += NextTurn;
    }

    /// <summary>
    /// 执行攻击
    /// </summary>
    private void ExecuteAttack(BattleUnit target)
    {
        _waitingForPlayerInput = false;

        int damage = BattleCalculator.CalculateDamage(
            _currentUnit.Stats, target.Stats);

        // 如果目标在防御，伤害减半
        if (target.IsDefending)
        {
            damage = Mathf.Max((int)(damage * RpgConstants.DefendDamageReduction), 1);
        }

        target.TakeDamage(damage);
        GD.Print($"{_currentUnit.UnitName} 攻击 {target.UnitName}，造成 {damage} 点伤害");

        // 延迟后检查战斗状态
        var timer = GetTree().CreateTimer(0.8);
        timer.Timeout += () => CheckBattleState();
    }

    /// <summary>
    /// 敌人AI回合
    /// </summary>
    private void EnemyAiTurn(BattleUnit enemy)
    {
        // 简单AI：随机攻击一个存活的玩家单位
        var alivePlayers = _playerUnits
            .Where(u => u.Stats.IsAlive)
            .ToList();

        if (alivePlayers.Count == 0) return;

        int targetIndex = GD.Randi() % alivePlayers.Count;
        var target = alivePlayers[targetIndex];

        int damage = BattleCalculator.CalculateDamage(
            enemy.Stats, target.Stats);

        if (target.IsDefending)
        {
            damage = Mathf.Max((int)(damage * RpgConstants.DefendDamageReduction), 1);
        }

        target.TakeDamage(damage);
        GD.Print($"{enemy.UnitName} 攻击 {target.UnitName}，造成 {damage} 点伤害");

        var timer = GetTree().CreateTimer(0.8);
        timer.Timeout += () => CheckBattleState();
    }

    /// <summary>
    /// 检查战斗是否结束
    /// </summary>
    private void CheckBattleState()
    {
        bool enemiesAlive = _enemyUnits.Any(u => u.Stats.IsAlive);
        bool playersAlive = _playerUnits.Any(u => u.Stats.IsAlive);

        if (!enemiesAlive)
        {
            // 战斗胜利
            BattleVictory();
        }
        else if (!playersAlive)
        {
            // 战斗失败
            BattleDefeat();
        }
        else
        {
            // 战斗继续
            NextTurn();
        }
    }

    /// <summary>
    /// 战斗胜利处理
    /// </summary>
    private void BattleVictory()
    {
        _battleActive = false;
        GD.Print("战斗胜利！");

        // 计算经验值和金币奖励
        int totalExp = _enemyUnits.Sum(u => u.Stats.Level * 10 + 5);
        int totalGold = _enemyUnits.Sum(u => u.Stats.Level * 3 + 2);

        GD.Print($"获得经验: {totalExp}，获得金币: {totalGold}");

        // 分配经验给存活的角色
        foreach (var unit in _playerUnits.Where(u => u.Stats.IsAlive))
        {
            var (newStats, levels) = LevelSystem.AddExperience(
                unit.Stats, totalExp);
            unit.Stats = newStats;
            if (levels > 0)
            {
                GD.Print($"{unit.UnitName} 升了 {levels} 级！");
            }
        }

        // 发送胜利信号
        EmitSignal(SignalName.BattleWon);
    }

    /// <summary>
    /// 战斗失败处理
    /// </summary>
    private void BattleDefeat()
    {
        _battleActive = false;
        GD.Print("战斗失败...");
        EmitSignal(SignalName.BattleLost);
    }

    /// <summary>
    /// 显示目标选择界面
    /// </summary>
    private void ShowTargetSelection(
        List<BattleUnit> targets,
        System.Action<BattleUnit> onSelected)
    {
        _targetSelection.Visible = true;
        // 为每个目标创建选择按钮
        foreach (var target in targets)
        {
            var button = new Button { Text = target.UnitName };
            button.Pressed += () =>
            {
                _targetSelection.Visible = false;
                onSelected(target);
            };
            _targetSelection.GetNode<VBoxContainer>("ButtonList")
                .AddChild(button);
        }
    }

    private BattleUnit CreateBattleUnit(
        CharacterStats stats, bool isPlayer)
    {
        var scene = GD.Load<PackedScene>(
            "res://scenes/battle/battle_unit.tscn");
        var unit = scene.Instantiate<BattleUnit>();
        unit.Initialize(stats, isPlayer);
        return unit;
    }
}

5.5 技能系统

技能是战斗中的"大招"——比普通攻击更强，但消耗MP。

技能属性说明
技能名称显示在技能菜单中的名字
MP消耗释放技能需要的法力值
技能威力威力越高伤害越大
技能倍率伤害 = (威力 x 攻击力 - 防御力) x 倍率
目标类型单体 / 全体 / 自身
C
/// <summary>
/// 技能数据
/// </summary>
public class SkillData
{
    public string Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public int MpCost { get; set; }
    public int Power { get; set; }
    public float Multiplier { get; set; }
    public enum TargetType { SingleEnemy, AllEnemies, Self, SingleAlly }
    public TargetType Target { get; set; }
}

/// <summary>
/// 预定义技能列表
/// </summary>
public static class SkillDatabase
{
    public static readonly SkillData[] AllSkills = new[]
    {
        new SkillData
        {
            Id = "fireball",
            Name = "火球术",
            Description = "向敌人投掷一颗火球",
            MpCost = 8,
            Power = 20,
            Multiplier = 1.5f,
            Target = SkillData.TargetType.SingleEnemy
        },
        new SkillData
        {
            Id = "heal",
            Name = "治愈术",
            Description = "恢复一个队友的HP",
            MpCost = 6,
            Power = 40,
            Multiplier = 1.0f,
            Target = SkillData.TargetType.SingleAlly
        },
        new SkillData
        {
            Id = "thunder_storm",
            Name = "雷霆万钧",
            Description = "召唤雷电攻击所有敌人",
            MpCost = 15,
            Power = 25,
            Multiplier = 1.3f,
            Target = SkillData.TargetType.AllEnemies
        },
        new SkillData
        {
            Id = "iron_wall",
            Name = "铁壁",
            Description = "大幅提升自身防御力",
            MpCost = 5,
            Power = 10,
            Multiplier = 1.0f,
            Target = SkillData.TargetType.Self
        }
    };

    public static SkillData FindById(string id)
    {
        foreach (var skill in AllSkills)
        {
            if (skill.Id == id) return skill;
        }
        return null;
    }
}

5.6 战斗UI布局

┌──────────────────────────────────────────────────┐
│  [妖怪A] HP:████░░ 30/50   [妖怪B] HP:██████ 60/60│
│                                                  │
│  ┌────────────────────────────────────────────┐  │
│  │        （敌人精灵/动画区域）                 │  │
│  └────────────────────────────────────────────┘  │
│                                                  │
│  ───────────── 行动顺序条 ──────────────────────  │
│  玩家 > 敌A > 敌B > 玩家2                        │
│                                                  │
│  ┌────────────────────────────────────────────┐  │
│  │        （玩家精灵/动画区域）                 │  │
│  └────────────────────────────────────────────┘  │
│                                                  │
│  [主角] HP:████████ 80/80  [同伴] HP:████░░ 40/60│
│                                                  │
│  ┌──────┬──────┬──────┬──────┐                  │
│  │ 攻击 │ 技能 │ 物品 │ 防御 │                  │
│  └──────┴──────┴──────┴──────┘                  │
└──────────────────────────────────────────────────┘

5.7 本章小结

知识点说明
战斗单位BattleUnit封装角色属性、动画和UI显示
战斗管理器控制行动队列、回合切换、胜负判定
伤害计算攻击力-防御力，加随机波动，防御减半
技能系统MP消耗、技能威力、倍率、目标类型
敌人AI简单AI：随机攻击存活玩家单位
战斗结算胜利获得经验和金币，失败返回城镇

下一章我们将实现物品与背包系统，让玩家能管理装备和使用道具。

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