跳至主要內容

15. 玩家角色创建与战斗

EVOCOSMOS2026/4/14大约 14 分钟

玩家角色创建与战斗

创建玩家角色的完整流程

创建一个玩家角色就像制作一个游戏里的"演员"——需要给演员身体（模型）、大脑（控制脚本）、武器（攻击系统）和生命值（血条）。

完整流程：

  1. 搭建角色场景结构——创建角色的"身体骨架"
  2. 配置输入映射——告诉游戏"WASD 代表移动，空格代表跳跃"
  3. 编写移动和视角控制——让角色能动、能看
  4. 实现攻击系统——让角色能打怪
  5. 添加生命值系统——让角色能受伤、能死亡
  6. 实现状态机——让角色知道什么时候该做什么

角色场景结构

一个标准的第三人称角色场景包含以下节点：

每个节点的作用：

节点作用比喻
CharacterBody3D角色的物理主体，处理移动和碰撞演员的身体
CollisionShape3D定义角色的碰撞形状（通常用胶囊形）演员穿的紧身衣（标记边界）
MeshInstance3D角色的外观模型演员的服装
Camera3D跟随角色的摄像机观众的眼睛
Area3D检测攻击范围内的敌人武器的攻击范围
Node（生命值组件）管理角色的血量角色的"命"

输入映射设置

在编写控制代码之前，需要在 Godot 中配置输入映射——告诉游戏哪个按键对应哪个动作。

在编辑器中设置：项目 → 项目设置 → 输入映射（Input Map）

需要添加以下映射：

动作名称按键说明
move_forwardW向前移动
move_backwardS向后移动
move_leftA向左移动
move_rightD向右移动
jumpSpace跳跃
attack鼠标左键攻击
rotate_camera鼠标右键拖动旋转视角

也可以通过代码注册输入映射：

C#
// 通过代码注册输入映射（放在项目自动加载脚本中）
using Godot;

public partial class InputSetup : Node
{
    public override void _Ready()
    {
        RegisterInput("move_forward", Key.W);
        RegisterInput("move_backward", Key.S);
        RegisterInput("move_left", Key.A);
        RegisterInput("move_right", Key.D);
        RegisterInput("jump", Key.Space);
        RegisterInput("attack", Key.Unknown); // 鼠标左键需在编辑器设置
    }

    private static void RegisterInput(string action, Key key)
    {
        if (!InputMap.HasAction(action))
        {
            InputMap.AddAction(action);
            var ev = new InputEventKey();
            ev.Keycode = key;
            InputMap.ActionAddEvent(action, ev);
        }
    }
}

第三人称角色控制器

这是整个角色系统的核心——控制角色移动和视角旋转。

C#
// 第三人称角色控制器
using Godot;

public partial class PlayerController : CharacterBody3D
{
    [Export] public float MoveSpeed { get; set; } = 5.0f;
    [Export] public float SprintSpeed { get; set; } = 8.0f;
    [Export] public float JumpVelocity { get; set; } = 4.5f;
    [Export] public float MouseSensitivity { get; set; } = 0.003f;
    [Export] public float CameraDistance { get; set; } = 4.0f;

    private float _gravity = ProjectSettings.GetSetting("physics/3d/default_gravity").AsSingle();
    private Node3D _cameraPivot;
    private Camera3D _camera;
    private Vector2 _screenCenter;

    public override void _Ready()
    {
        // 获取摄像机挂载点
        _cameraPivot = GetNode<Node3D>("CameraPivot");
        _camera = _cameraPivot.GetNode<Camera3D>("Camera3D");

        // 设置摄像机初始位置
        _camera.Position = new Vector3(0, 1.5f, CameraDistance);

        // 捕获鼠标（隐藏光标）
        Input.MouseMode = Input.MouseModeEnum.Captured;

        _screenCenter = new Vector2(
            (float)DisplayServer.ScreenGetSize().X / 2,
            (float)DisplayServer.ScreenGetSize().Y / 2
        );
    }

    public override void _UnhandledInput(InputEvent @event)
    {
        // 鼠标移动控制视角
        if (@event is InputEventMouseMotion mouseMotion)
        {
            // 水平旋转：角色左右转
            RotateY(-mouseMotion.Relative.X * MouseSensitivity);

            // 垂直旋转：摄像机上下看
            float vertAngle = -mouseMotion.Relative.Y * MouseSensitivity;
            vertAngle = Mathf.Clamp(vertAngle, -0.05f, 0.05f);
            _cameraPivot.RotationDegrees = new Vector3(
                Mathf.Clamp(_cameraPivot.RotationDegrees.X + vertAngle * 100, -60, 60),
                0, 0
            );
        }

        // ESC 键释放鼠标
        if (@event.IsActionPressed("ui_cancel"))
        {
            Input.MouseMode = Input.MouseModeEnum.Visible;
        }
    }

    public override void _PhysicsProcess(double delta)
    {
        Vector3 velocity = Velocity;

        // 重力
        if (!IsOnFloor())
        {
            velocity.Y -= _gravity * (float)delta;
        }

        // 跳跃
        if (Input.IsActionJustPressed("jump") && IsOnFloor())
        {
            velocity.Y = JumpVelocity;
        }

        // 获取移动输入
        Vector2 inputDir = Input.GetVector(
            "move_left", "move_right",
            "move_forward", "move_backward"
        );

        // 将 2D 输入转换为 3D 方向（相对于角色朝向）
        Vector3 direction = (Transform.Basis * new Vector3(inputDir.X, 0, inputDir.Y)).Normalized();

        // 判断是否冲刺
        bool isSprinting = Input.IsActionPressed("sprint");
        float speed = isSprinting ? SprintSpeed : MoveSpeed;

        if (direction != Vector3.Zero)
        {
            velocity.X = direction.X * speed;
            velocity.Z = direction.Z * speed;
        }
        else
        {
            velocity.X = Mathf.MoveToward(velocity.X, 0, speed);
            velocity.Z = Mathf.MoveToward(velocity.Z, 0, speed);
        }

        Velocity = velocity;
        MoveAndSlide();
    }
}

攻击系统实现

攻击分为两种类型：近战（用 Area3D 检测范围内的敌人）和远程（用 RayCast3D 射线检测）。

近战攻击

C#
// 近战攻击组件
using Godot;
using Godot.Collections;
using System.Linq;

public partial class MeleeAttackComponent : Node3D
{
    [Export] public float AttackRange { get; set; } = 2.0f;
    [Export] public int AttackDamage { get; set; } = 10;
    [Export] public float AttackCooldown { get; set; } = 0.5f;
    [Export] public float AttackAngle { get; set; } = 90.0f; // 攻击扇形角度

    private Area3D _attackArea;
    private CollisionShape3D _attackShape;
    private bool _canAttack = true;
    private double _cooldownTimer;

    public override void _Ready()
    {
        // 创建攻击检测区域
        _attackArea = new Area3D();
        _attackArea.Name = "AttackArea";
        AddChild(_attackArea);

        // 创建扇形碰撞形状（简化为圆形）
        _attackShape = new CollisionShape3D();
        var sphere = new SphereShape3D();
        sphere.Radius = AttackRange;
        _attackShape.Shape = sphere;
        _attackShape.Position = Vector3.Zero;
        _attackArea.AddChild(_attackShape);
    }

    public override void _Process(double delta)
    {
        if (!_canAttack)
        {
            _cooldownTimer -= delta;
            if (_cooldownTimer <= 0)
            {
                _canAttack = true;
            }
        }

        // 按攻击键
        if (Input.IsActionJustPressed("attack") && _canAttack)
        {
            PerformAttack();
        }
    }

    /// <summary>执行近战攻击</summary>
    private void PerformAttack()
    {
        _canAttack = false;
        _cooldownTimer = AttackCooldown;

        // 获取攻击范围内所有物体
        var overlappingBodies = _attackArea.GetOverlappingBodies();

        foreach (var body in overlappingBodies)
        {
            // 排除自己
            if (body == GetParent()) continue;

            // 检查是否在攻击扇形角度内
            Vector3 toTarget = (body.GlobalPosition - GlobalPosition).Normalized();
            Vector3 forward = -GlobalTransform.Basis.Z;
            float angle = Mathf.RadToDeg(forward.AngleTo(toTarget));

            if (angle <= AttackAngle / 2.0f)
            {
                // 对目标造成伤害
                if (body.HasMethod("TakeDamage"))
                {
                    body.Call("TakeDamage", AttackDamage);
                }

                GD.Print($"攻击命中：{body.Name}，造成 {AttackDamage} 点伤害");
            }
        }
    }
}

远程攻击

C#
// 远程攻击组件（射线检测）
using Godot;

public partial class RangedAttackComponent : Node3D
{
    [Export] public float AttackRange { get; set; } = 50.0f;
    [Export] public int AttackDamage { get; set; } = 15;
    [Export] public float AttackCooldown { get; set; } = 0.3f;

    private RayCast3D _raycast;
    private bool _canAttack = true;
    private double _cooldownTimer;

    public override void _Ready()
    {
        // 创建射线
        _raycast = new RayCast3D();
        _raycast.Name = "AttackRay";
        _raycast.TargetPosition = new Vector3(0, 0, -AttackRange);
        _raycast.Enabled = true;
        AddChild(_raycast);
    }

    public override void _Process(double delta)
    {
        if (!_canAttack)
        {
            _cooldownTimer -= delta;
            if (_cooldownTimer <= 0) _canAttack = true;
        }

        if (Input.IsActionJustPressed("attack") && _canAttack)
        {
            PerformRangedAttack();
        }
    }

    private void PerformRangedAttack()
    {
        _canAttack = false;
        _cooldownTimer = AttackCooldown;

        // 强制射线立即更新
        _raycast.ForceRaycastUpdate();

        if (_raycast.IsColliding())
        {
            var target = _raycast.GetCollider();
            if (target != null && target.HasMethod("TakeDamage"))
            {
                target.Call("TakeDamage", AttackDamage);
                GD.Print($"远程命中：{target}，造成 {AttackDamage} 点伤害");
            }

            // 在命中点创建特效（简化示例）
            var hitPos = _raycast.GetCollisionPoint();
            GD.Print($"命中位置：{hitPos}");
        }
    }
}

生命值组件

C#
// 生命值组件
using Godot;

public partial class HealthComponent : Node
{
    [Signal] public delegate void HealthChangedEventHandler(int newHealth, int maxHealth);
    [Signal] public delegate void DiedEventHandler();
    [Signal] public delegate void HurtEventHandler(int damage, Vector3 fromDirection);

    [Export] public int MaxHealth { get; set; } = 100;

    private int _currentHealth;

    public int CurrentHealth => _currentHealth;
    public bool IsDead => _currentHealth <= 0;
    public float HealthPercent => (float)_currentHealth / MaxHealth;

    public override void _Ready()
    {
        _currentHealth = MaxHealth;
        EmitSignal(SignalName.HealthChanged, _currentHealth, MaxHealth);
    }

    /// <summary>受到伤害</summary>
    public void TakeDamage(int damage)
    {
        if (IsDead) return;

        _currentHealth -= damage;
        _currentHealth = Mathf.Max(_currentHealth, 0);

        GD.Print($"受到 {damage} 点伤害，剩余 {_currentHealth}/{MaxHealth}");
        EmitSignal(SignalName.HealthChanged, _currentHealth, MaxHealth);

        if (_currentHealth <= 0)
        {
            GD.Print("角色已死亡！");
            EmitSignal(SignalName.Died);
        }
    }

    /// <summary>受到伤害（带方向，用于击退）</summary>
    public void TakeDamage(int damage, Vector3 fromDirection)
    {
        TakeDamage(damage);
        EmitSignal(SignalName.Hurt, damage, fromDirection);
    }

    /// <summary>治疗</summary>
    public void Heal(int amount)
    {
        if (IsDead) return;

        _currentHealth = Mathf.Min(_currentHealth + amount, MaxHealth);
        GD.Print($"恢复了 {amount} 点生命，当前 {_currentHealth}/{MaxHealth}");
        EmitSignal(SignalName.HealthChanged, _currentHealth, MaxHealth);
    }

    /// <summary>复活</summary>
    public void Revive()
    {
        _currentHealth = MaxHealth;
        GD.Print("角色已复活！");
        EmitSignal(SignalName.HealthChanged, _currentHealth, MaxHealth);
    }
}

受击反馈

C#
// 受击反馈效果
using Godot;

public partial class HurtFeedback : Node3D
{
    [Export] public float FlashDuration { get; set; } = 0.15f;
    [Export] public float KnockbackForce { get; set; } = 5.0f;
    [Export] public Color HurtColor { get; set; } = new Color(1, 0, 0, 0.5f);

    private MeshInstance3D _mesh;
    private Material _originalMaterial;
    private double _flashTimer;
    private bool _isFlashing;
    private HealthComponent _health;
    private CharacterBody3D _body;

    public override void _Ready()
    {
        _mesh = GetNode<MeshInstance3D>("MeshInstance3D");
        _health = GetNode<HealthComponent>("../HealthComponent");
        _body = GetParent() as CharacterBody3D;

        // 监听受伤事件
        _health.Hurt += OnHurt;
    }

    public override void _Process(double delta)
    {
        if (_isFlashing)
        {
            _flashTimer -= delta;
            if (_flashTimer <= 0)
            {
                // 恢复原始材质
                _mesh.MaterialOverride = _originalMaterial;
                _isFlashing = false;
            }
        }
    }

    private void OnHurt(int damage, Vector3 fromDirection)
    {
        // 1. 材质闪烁
        _originalMaterial = _mesh.MaterialOverride;
        var flashMat = new StandardMaterial3D();
        flashMat.AlbedoColor = HurtColor;
        flashMat.ShadingMode = StandardMaterial3D.ShadingModeEnum.Unshaded;
        _mesh.MaterialOverride = flashMat;
        _isFlashing = true;
        _flashTimer = FlashDuration;

        // 2. 击退效果
        if (_body != null)
        {
            Vector3 knockback = fromDirection * KnockbackForce;
            knockback.Y = 2.0f; // 稍微向上弹起
            _body.Velocity = knockback;
        }

        GD.Print("受击反馈触发！");
    }
}

角色状态机

状态机就像角色的"大脑"——告诉角色在不同状态下应该做什么，以及什么时候切换到另一个状态。

C#
// 角色状态机
using Godot;

public enum PlayerState
{
    Idle,
    Moving,
    Attacking,
    Hurt,
    Dead
}

public partial class PlayerStateMachine : Node
{
    [Export] public float HurtDuration { get; set; } = 0.3f;
    [Export] public float AttackDuration { get; set; } = 0.5f;

    private PlayerState _currentState = PlayerState.Idle;
    private double _stateTimer;
    private HealthComponent _health;
    private CharacterBody3D _player;

    // 状态机的状态属性（方便其他脚本查询）
    public PlayerState CurrentState => _currentState;
    public bool CanMove => _currentState is PlayerState.Idle or PlayerState.Moving;
    public bool CanAttack => _currentState is PlayerState.Idle or PlayerState.Moving;

    public override void _Ready()
    {
        _player = GetParent() as CharacterBody3D;
        _health = _player.GetNode<HealthComponent>("HealthComponent");

        // 监听生命值事件
        _health.Hurt += OnHurt;
        _health.Died += OnDied;
    }

    public override void _Process(double delta)
    {
        switch (_currentState)
        {
            case PlayerState.Idle:
                ProcessIdle();
                break;
            case PlayerState.Moving:
                ProcessMoving();
                break;
            case PlayerState.Attacking:
                ProcessAttacking(delta);
                break;
            case PlayerState.Hurt:
                ProcessHurt(delta);
                break;
            case PlayerState.Dead:
                ProcessDead();
                break;
        }
    }

    private void ProcessIdle()
    {
        // 检查是否开始移动
        Vector2 input = Input.GetVector("move_left", "move_right", "move_forward", "move_backward");
        if (input != Vector2.Zero)
        {
            ChangeState(PlayerState.Moving);
            return;
        }

        // 检查是否开始攻击
        if (Input.IsActionJustPressed("attack"))
        {
            ChangeState(PlayerState.Attacking);
        }
    }

    private void ProcessMoving()
    {
        // 检查是否停止移动
        Vector2 input = Input.GetVector("move_left", "move_right", "move_forward", "move_backward");
        if (input == Vector2.Zero)
        {
            ChangeState(PlayerState.Idle);
            return;
        }

        // 检查是否开始攻击
        if (Input.IsActionJustPressed("attack"))
        {
            ChangeState(PlayerState.Attacking);
        }
    }

    private void ProcessAttacking(double delta)
    {
        _stateTimer -= delta;
        if (_stateTimer <= 0)
        {
            ChangeState(PlayerState.Idle);
        }
    }

    private void ProcessHurt(double delta)
    {
        _stateTimer -= delta;
        if (_stateTimer <= 0)
        {
            ChangeState(PlayerState.Idle);
        }
    }

    private void ProcessDead()
    {
        // 死亡状态：禁用输入，播放死亡动画
        GD.Print("角色已阵亡，等待复活...");
    }

    private void OnHurt(int damage, Vector3 fromDirection)
    {
        ChangeState(PlayerState.Hurt);
    }

    private void OnDied()
    {
        ChangeState(PlayerState.Dead);
    }

    private void ChangeState(PlayerState newState)
    {
        if (_currentState == newState) return;

        GD.Print($"状态切换：{_currentState} → {newState}");
        _currentState = newState;

        // 进入新状态时的初始化
        switch (newState)
        {
            case PlayerState.Attacking:
                _stateTimer = AttackDuration;
                break;
            case PlayerState.Hurt:
                _stateTimer = HurtDuration;
                break;
            case PlayerState.Dead:
                // 禁用碰撞，防止死后还能被攻击
                if (_player != null)
                {
                    _player.SetPhysicsProcess(false);
                }
                break;
        }
    }
}

完整的角色整合代码

将所有组件整合到一个角色场景中：

C#
// 完整的玩家角色（整合所有组件）
using Godot;

public partial class Player : CharacterBody3D
{
    // 组件引用
    private HealthComponent _health;
    private PlayerStateMachine _stateMachine;
    private MeleeAttackComponent _meleeAttack;
    private HurtFeedback _hurtFeedback;

    // 参数
    [Export] public float MoveSpeed { get; set; } = 5.0f;
    [Export] public float JumpVelocity { get; set; } = 4.5f;
    [Export] public float MouseSensitivity { get; set; } = 0.003f;

    private float _gravity;

    public override void _Ready()
    {
        _gravity = (float)ProjectSettings.GetSetting("physics/3d/default_gravity").AsSingle();

        // 获取组件引用
        _health = GetNode<HealthComponent>("HealthComponent");
        _stateMachine = GetNode<PlayerStateMachine>("StateMachine");
        _meleeAttack = GetNode<MeleeAttackComponent>("MeleeAttack");
        _hurtFeedback = GetNode<HurtFeedback>("HurtFeedback");

        // 捕获鼠标
        Input.MouseMode = Input.MouseModeEnum.Captured;

        GD.Print("玩家角色初始化完成！");
    }

    public override void _UnhandledInput(InputEvent @event)
    {
        if (@event is InputEventMouseMotion motion)
        {
            RotateY(-motion.Relative.X * MouseSensitivity);
        }
    }

    public override void _PhysicsProcess(double delta)
    {
        if (_stateMachine.CurrentState == PlayerState.Dead) return;

        Vector3 velocity = Velocity;

        // 重力
        if (!IsOnFloor())
            velocity.Y -= _gravity * (float)delta;

        // 跳跃
        if (Input.IsActionJustPressed("jump") && IsOnFloor())
            velocity.Y = JumpVelocity;

        // 移动
        if (_stateMachine.CanMove)
        {
            Vector2 input = Input.GetVector("move_left", "move_right", "move_forward", "move_backward");
            Vector3 dir = (Transform.Basis * new Vector3(input.X, 0, input.Y)).Normalized();

            if (dir != Vector3.Zero)
            {
                velocity.X = dir.X * MoveSpeed;
                velocity.Z = dir.Z * MoveSpeed;
            }
            else
            {
                velocity.X = Mathf.MoveToward(velocity.X, 0, MoveSpeed);
                velocity.Z = Mathf.MoveToward(velocity.Z, 0, MoveSpeed);
            }
        }

        Velocity = velocity;
        MoveAndSlide();
    }

    /// <summary>外部调用受伤接口</summary>
    public void TakeDamage(int damage)
    {
        _health.TakeDamage(damage);
    }
}

本章小结

本章我们学习了玩家角色的完整创建流程：

组件功能关键节点
角色主体移动和物理碰撞CharacterBody3D + CollisionShape3D
摄像机第三人称视角Camera3D + Node3D（挂载点）
近战攻击扇形范围检测Area3D + CollisionShape3D
远程攻击射线检测RayCast3D
生命值血量管理Node（自定义组件）
受击反馈闪烁和击退MeshInstance3D 材质切换
状态机行为控制枚举 + switch/match

这些组件可以自由组合、替换。例如，把近战攻击换成远程攻击，就能让角色从战士变成射手。

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