杀死玩家

我们可以通过跳到敌人身上来杀死他们，但玩家仍然不能死亡。让我们来解决这个问题。

我们希望检测到被敌人击中与压扁敌人时的不同。我们希望玩家在地板上移动时死亡，但如果他们在空中，则不会死亡。我们可以使用向量数学来区分这两种碰撞。但是，我们将使用 Area3D 节点，该节点适用于命中框。

使用 Area 节点制作攻击框

回到 player.tscn 场景，添加一个新的 Area3D 子节点。把它命名为 MobDetector（小怪检测器）。添加一个 CollisionShape3D 节点作为它的一个子节点。

在检查器中，给它指定一个圆柱体形状。

这里有一个技巧，你可以用它来使碰撞只发生在玩家在地面上或靠近地面时。你可以降低圆柱体的高度并将其向上移动到角色的顶部。这样，当玩家跳跃时，形状会太高，敌人无法与之碰撞。

你还希望圆柱体比球体更宽。这样一来，玩家在碰撞之前就会被击中，并被推到怪物的碰撞盒之上。

圆柱体越宽，玩家就越容易被杀死。

接下来，再次选择 MobDetector 节点，并在检查器中， 关闭 其 Monitorable 属性。这使得其他物理节点无法检测到这个区域。补充的 Monitoring 属性允许它检测碰撞。然后，清除 Collision -> Layer，并将掩码设置为“enemies”层。

当区域检测到碰撞时，它们会发出信号。我们要将一个信号连接到 Player 节点。在节点选项卡中，双击 body_entered 信号并将其连接到 Player

当一个 CharacterBody3D 或 RigidBody3D 节点进入它时，MobDetector 将发出 body_entered 信号。由于它只遮罩了“enemies”物理层，它将只检测 Mob 节点。

从代码上看，我们要做两件事：发出一个信号，我们以后会用来结束游戏，并销毁玩家。我们可以用 die() 函数来包装这些操作，帮助我们给代码贴上描述性标签。

GDScriptC#

# Emitted when the player was hit by a mob.
# Put this at the top of the script.
signal hit
# And this function at the bottom.
func die():
    hit.emit()
    queue_free()
func _on_mob_detector_body_entered(body):
    die()

// Don't forget to rebuild the project so the editor knows about the new signal.
// Emitted when the player was hit by a mob.
[Signal]
public delegate void HitEventHandler();
// ...
private void Die()
{
    EmitSignal(SignalName.Hit);
    QueueFree();
}
// We also specified this function name in PascalCase in the editor's connection window.
private void OnMobDetectorBodyEntered(Node3D body)
{
    Die();
}

结束游戏

我们可以利用 Player 的 hit 信号来结束游戏。我们所要做的就是将它连接到 Main 节点上，在处理时停止 MobTimer。

打开 main.tscn 场景，选中 Player 节点，然后在节点面板中把 hit 信号连接到 Main 节点。

在 _on_player_hit() 函数中获取并停止计时器。

GDScriptC#

func _on_player_hit():
    $MobTimer.stop()

// We also specified this function name in PascalCase in the editor's connection window.
private void OnPlayerHit()
{
    GetNode<Timer>("MobTimer").Stop();
}

如果你现在试玩游戏，你死亡后就会停止刷怪，现有的怪物会离开屏幕。

同时注意到在玩家死亡时，游戏不再崩溃或报错。 这是因为我们停止了 Mobtimer，也就不再触发 _on_mob_timer_timeout() 函数了.

另外请注意，敌人与玩家碰撞并死亡取决于 Player 和 Mob 的碰撞形状的大小和位置。你可能需要移动它们，调整它们的大小，以达到紧凑的游戏感觉。

你可以鼓励鼓励自己了：你做出了完整 3D 游戏的原型，虽说还有点粗糙。

在此基础上，我们将会添加计分、重启游戏的选项，你还会看到如何使用简单的动画让游戏变得更加活灵活现。

代码检查点

这些是 Main、Mob、Player 节点的完整脚本，仅供参考。你可以把它们和你的代码进行对比检查。

首先是 main.gd。

GDScriptC#

extends Node
@export var mob_scene: PackedScene
func _on_mob_timer_timeout():
    # Create a new instance of the Mob scene.
    var mob = mob_scene.instantiate()
    # Choose a random location on the SpawnPath.
    # We store the reference to the SpawnLocation node.
    var mob_spawn_location = get_node("SpawnPath/SpawnLocation")
    # And give it a random offset.
    mob_spawn_location.progress_ratio = randf()
    var player_position = $Player.position
    mob.initialize(mob_spawn_location.position, player_position)
    # Spawn the mob by adding it to the Main scene.
    add_child(mob)
func _on_player_hit():
    $MobTimer.stop()

using Godot;
public partial class Main : Node
{
    [Export]
    public PackedScene MobScene { get; set; }
    private void OnMobTimerTimeout()
    {
        // Create a new instance of the Mob scene.
        Mob mob = MobScene.Instantiate<Mob>();
        // Choose a random location on the SpawnPath.
        // We store the reference to the SpawnLocation node.
        var mobSpawnLocation = GetNode<PathFollow3D>("SpawnPath/SpawnLocation");
        // And give it a random offset.
        mobSpawnLocation.ProgressRatio = GD.Randf();
        Vector3 playerPosition = GetNode<Player>("Player").Position;
        mob.Initialize(mobSpawnLocation.Position, playerPosition);
        // Spawn the mob by adding it to the Main scene.
        AddChild(mob);
    }
    private void OnPlayerHit()
    {
        GetNode<Timer>("MobTimer").Stop();
    }
}

Next is mob.gd.

GDScriptC#

extends CharacterBody3D
# Minimum speed of the mob in meters per second.
@export var min_speed = 10
# Maximum speed of the mob in meters per second.
@export var max_speed = 18
# Emitted when the player jumped on the mob
signal squashed
func _physics_process(_delta):
    move_and_slide()
# This function will be called from the Main scene.
func initialize(start_position, player_position):
    # We position the mob by placing it at start_position
    # and rotate it towards player_position, so it looks at the player.
    look_at_from_position(start_position, player_position, Vector3.UP)
    # Rotate this mob randomly within range of -45 and +45 degrees,
    # so that it doesn't move directly towards the player.
    rotate_y(randf_range(-PI / 4, PI / 4))
    # We calculate a random speed (integer)
    var random_speed = randi_range(min_speed, max_speed)
    # We calculate a forward velocity that represents the speed.
    velocity = Vector3.FORWARD * random_speed
    # We then rotate the velocity vector based on the mob's Y rotation
    # in order to move in the direction the mob is looking.
    velocity = velocity.rotated(Vector3.UP, rotation.y)
func _on_visible_on_screen_notifier_3d_screen_exited():
    queue_free()
func squash():
    squashed.emit()
    queue_free() # Destroy this node

using Godot;
public partial class Mob : CharacterBody3D
{
    // Emitted when the played jumped on the mob.
    [Signal]
    public delegate void SquashedEventHandler();
    // Minimum speed of the mob in meters per second
    [Export]
    public int MinSpeed { get; set; } = 10;
    // Maximum speed of the mob in meters per second
    [Export]
    public int MaxSpeed { get; set; } = 18;
    public override void _PhysicsProcess(double delta)
    {
        MoveAndSlide();
    }
    // This function will be called from the Main scene.
    public void Initialize(Vector3 startPosition, Vector3 playerPosition)
    {
        // We position the mob by placing it at startPosition
        // and rotate it towards playerPosition, so it looks at the player.
        LookAtFromPosition(startPosition, playerPosition, Vector3.Up);
        // Rotate this mob randomly within range of -45 and +45 degrees,
        // so that it doesn't move directly towards the player.
        RotateY((float)GD.RandRange(-Mathf.Pi / 4.0, Mathf.Pi / 4.0));
        // We calculate a random speed (integer)
        int randomSpeed = GD.RandRange(MinSpeed, MaxSpeed);
        // We calculate a forward velocity that represents the speed.
        Velocity = Vector3.Forward * randomSpeed;
        // We then rotate the velocity vector based on the mob's Y rotation
        // in order to move in the direction the mob is looking.
        Velocity = Velocity.Rotated(Vector3.Up, Rotation.Y);
    }
    public void Squash()
    {
        EmitSignal(SignalName.Squashed);
        QueueFree(); // Destroy this node
    }
    private void OnVisibilityNotifierScreenExited()
    {
        QueueFree();
    }
}

Finally, the longest script, player.gd:

GDScriptC#

extends CharacterBody3D
signal hit
# How fast the player moves in meters per second
@export var speed = 14
# The downward acceleration while in the air, in meters per second squared.
@export var fall_acceleration = 75
# Vertical impulse applied to the character upon jumping in meters per second.
@export var jump_impulse = 20
# Vertical impulse applied to the character upon bouncing over a mob
# in meters per second.
@export var bounce_impulse = 16
var target_velocity = Vector3.ZERO
func _physics_process(delta):
    # We create a local variable to store the input direction
    var direction = Vector3.ZERO
    # We check for each move input and update the direction accordingly
    if Input.is_action_pressed("move_right"):
        direction.x = direction.x + 1
    if Input.is_action_pressed("move_left"):
        direction.x = direction.x - 1
    if Input.is_action_pressed("move_back"):
        # Notice how we are working with the vector's x and z axes.
        # In 3D, the XZ plane is the ground plane.
        direction.z = direction.z + 1
    if Input.is_action_pressed("move_forward"):
        direction.z = direction.z - 1
    # Prevent diagonal moving fast af
    if direction != Vector3.ZERO:
        direction = direction.normalized()
        $Pivot.look_at(position + direction, Vector3.UP)
    # Ground Velocity
    target_velocity.x = direction.x * speed
    target_velocity.z = direction.z * speed
    # Vertical Velocity
    if not is_on_floor(): # If in the air, fall towards the floor. Literally gravity
        target_velocity.y = target_velocity.y - (fall_acceleration * delta)
    # Jumping.
    if is_on_floor() and Input.is_action_just_pressed("jump"):
        target_velocity.y = jump_impulse
    # Iterate through all collisions that occurred this frame
    # in C this would be for(int i = 0; i < collisions.Count; i++)
    for index in range(get_slide_collision_count()):
        # We get one of the collisions with the player
        var collision = get_slide_collision(index)
        # If the collision is with ground
        if collision.get_collider() == null:
            continue
        # If the collider is with a mob
        if collision.get_collider().is_in_group("mob"):
            var mob = collision.get_collider()
            # we check that we are hitting it from above.
            if Vector3.UP.dot(collision.get_normal()) > 0.1:
                # If so, we squash it and bounce.
                mob.squash()
                target_velocity.y = bounce_impulse
                # Prevent further duplicate calls.
                break
    # Moving the Character
    velocity = target_velocity
    move_and_slide()
# And this function at the bottom.
func die():
    hit.emit()
    queue_free()
func _on_mob_detector_body_entered(body):
    die()

using Godot;
public partial class Player : CharacterBody3D
{
    // Emitted when the player was hit by a mob.
    [Signal]
    public delegate void HitEventHandler();
    // How fast the player moves in meters per second.
    [Export]
    public int Speed { get; set; } = 14;
    // The downward acceleration when in the air, in meters per second squared.
    [Export]
    public int FallAcceleration { get; set; } = 75;
    // Vertical impulse applied to the character upon jumping in meters per second.
    [Export]
    public int JumpImpulse { get; set; } = 20;
    // Vertical impulse applied to the character upon bouncing over a mob in meters per second.
    [Export]
    public int BounceImpulse { get; set; } = 16;
    private Vector3 _targetVelocity = Vector3.Zero;
    public override void _PhysicsProcess(double delta)
    {
        // We create a local variable to store the input direction.
        var direction = Vector3.Zero;
        // We check for each move input and update the direction accordingly.
        if (Input.IsActionPressed("move_right"))
        {
            direction.X += 1.0f;
        }
        if (Input.IsActionPressed("move_left"))
        {
            direction.X -= 1.0f;
        }
        if (Input.IsActionPressed("move_back"))
        {
            // Notice how we are working with the vector's X and Z axes.
            // In 3D, the XZ plane is the ground plane.
            direction.Z += 1.0f;
        }
        if (Input.IsActionPressed("move_forward"))
        {
            direction.Z -= 1.0f;
        }
        // Prevent diagonal moving fast af
        if (direction != Vector3.Zero)
        {
            direction = direction.Normalized();
            GetNode<Node3D>("Pivot").LookAt(Position + direction, Vector3.Up);
        }
        // Ground Velocity
        _targetVelocity.X = direction.X * Speed;
        _targetVelocity.Z = direction.Z * Speed;
        // Vertical Velocity
        if (!IsOnFloor()) // If in the air, fall towards the floor. Literally gravity
        {
            _targetVelocity.Y -= FallAcceleration * (float)delta;
        }
        // Jumping.
        if (IsOnFloor() && Input.IsActionJustPressed("jump"))
        {
            _targetVelocity.Y = JumpImpulse;
        }
        // Iterate through all collisions that occurred this frame.
        for (int index = 0; index < GetSlideCollisionCount(); index++)
        {
            // We get one of the collisions with the player.
            KinematicCollision3D collision = GetSlideCollision(index);
            // If the collision is with a mob.
            if (collision.GetCollider() is Mob mob)
            {
                // We check that we are hitting it from above.
                if (Vector3.Up.Dot(collision.GetNormal()) > 0.1f)
                {
                    // If so, we squash it and bounce.
                    mob.Squash();
                    _targetVelocity.Y = BounceImpulse;
                    // Prevent further duplicate calls.
                    break;
                }
            }
        }
        // Moving the Character
        Velocity = _targetVelocity;
        MoveAndSlide();
    }
    private void Die()
    {
        EmitSignal(SignalName.Hit);
        QueueFree();
    }
    private void OnMobDetectorBodyEntered(Node3D body)
    {
        Die();
    }
}

在下一节课中我们会添加计分和重试选项，再见。