杀死玩家

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

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

使用 Area 节点制作攻击框

回到 Player 场景，添加一个新的 Area 节点。把它命名为 MobDetector（小怪检测器）。添加一个 CollisionShape 节点作为它的一个子节点。

image0

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

image1

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

image2

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

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

Next, select the MobDetector node again, and in the Inspector, turn off its Monitorable property. This makes it so other physics nodes cannot detect the area. The complementary Monitoring property allows it to detect collisions. Then, remove the Collision -> Layer and set the mask to the “enemies” layer.

image3

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

image4

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

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

GDScriptC#

  1. # Emitted when the player was hit by a mob.
  2. # Put this at the top of the script.
  3. signal hit
  6. # And this function at the bottom.
  7. func die():
  8.     emit_signal("hit")
  9.     queue_free()
  12. func _on_MobDetector_body_entered(_body):
  13.     die()
  1. // Don't forget to rebuild the project so the editor knows about the new signal.
  3. // Emitted when the player was hit by a mob.
  4. [Signal]
  5. public delegate void Hit();
  7. // ...
  9. private void Die()
  10. {
  11.     EmitSignal(nameof(Hit));
  12.     QueueFree();
  13. }
  15. // We also specified this function name in PascalCase in the editor's connection window
  16. public void OnMobDetectorBodyEntered(Node body)
  17. {
  18.     Die();
  19. }

按 F5 再试一下游戏。如果一切设置正确，角色在被敌人碰到时应该会死亡。

然而，请注意，这完全取决于 Player 和 Mob 的碰撞形状的大小和位置。你可能需要移动它们，调整它们的大小，以达到紧凑的游戏感觉。

结束游戏

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

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

image5

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

GDScriptC#

  1. func _on_Player_hit():
  2.     $MobTimer.stop()
  1. // We also specified this function name in PascalCase in the editor's connection window
  2. public void OnPlayerHit()
  3. {
  4.     GetNode<Timer>("MobTimer").Stop();
  5. }

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

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

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

代码检查点

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

首先是 Main.gd。

GDScriptC#

  1. extends Node
  3. export(PackedScene) var mob_scene
  6. func _ready():
  7.     randomize()
  10. func _on_MobTimer_timeout():
  11.     # Create a new instance of the Mob scene.
  12.     var mob = mob_scene.instance()
  14.     # Choose a random location on the SpawnPath.
  15.     var mob_spawn_location = get_node("SpawnPath/SpawnLocation")
  16.     # And give it a random offset.
  17.     mob_spawn_location.unit_offset = randf()
  19.     # Communicate the spawn location and the player's location to the mob.
  20.     var player_position = $Player.transform.origin
  21.     mob.initialize(mob_spawn_location.translation, player_position)
  23.     # Spawn the mob by adding it to the Main scene.
  24.     add_child(mob)
  27. func _on_Player_hit():
  28.     $MobTimer.stop()
  1. public class Main : Node
  2. {
  3. #pragma warning disable 649
  4.     [Export]
  5.     public PackedScene MobScene;
  6. #pragma warning restore 649
  8.     public override void _Ready()
  9.     {
  10.         GD.Randomize();
  11.     }
  13.     public void OnMobTimerTimeout()
  14.     {
  15.         // Create a new instance of the Mob scene.
  16.         var mob = (Mob)MobScene.Instance();
  18.         // Choose a random location on the SpawnPath.
  19.         // We store the reference to the SpawnLocation node.
  20.         var mobSpawnLocation = GetNode<PathFollow>("SpawnPath/SpawnLocation");
  21.         // And give it a random offset.
  22.         mobSpawnLocation.UnitOffset = GD.Randf();
  24.         // Communicate the spawn location and the player's location to the mob.
  25.         Vector3 playerPosition = GetNode<Player>("Player").Transform.origin;
  26.         mob.Initialize(mobSpawnLocation.Translation, playerPosition);
  28.         // Spawn the mob by adding it to the Main scene.
  29.         AddChild(mob);
  30.     }
  32.     public void OnPlayerHit()
  33.     {
  34.         GetNode<Timer>("MobTimer").Stop();
  35.     }
  36. }

然后是 Mob.gd。

GDScriptC#

  1. extends KinematicBody
  3. # Emitted when the player jumped on the mob.
  4. signal squashed
  6. # Minimum speed of the mob in meters per second.
  7. export var min_speed = 10
  8. # Maximum speed of the mob in meters per second.
  9. export var max_speed = 18
  11. var velocity = Vector3.ZERO
  14. func _physics_process(_delta):
  15.     move_and_slide(velocity)
  18. func initialize(start_position, player_position):
  19.     look_at_from_position(start_position, player_position, Vector3.UP)
  20.     rotate_y(rand_range(-PI / 4, PI / 4))
  22.     var random_speed = rand_range(min_speed, max_speed)
  23.     velocity = Vector3.FORWARD * random_speed
  24.     velocity = velocity.rotated(Vector3.UP, rotation.y)
  27.  func squash():
  28.     emit_signal("squashed")
  29.     queue_free()
  32. func _on_VisibilityNotifier_screen_exited():
  33.     queue_free()
  1. public class Mob : KinematicBody
  2. {
  3.     // Emitted when the played jumped on the mob.
  4.     [Signal]
  5.     public delegate void Squashed();
  7.     // Minimum speed of the mob in meters per second
  8.     [Export]
  9.     public int MinSpeed = 10;
  10.     // Maximum speed of the mob in meters per second
  11.     [Export]
  12.     public int MaxSpeed = 18;
  14.     private Vector3 _velocity = Vector3.Zero;
  16.     public override void _PhysicsProcess(float delta)
  17.     {
  18.         MoveAndSlide(_velocity);
  19.     }
  21.     public void Initialize(Vector3 startPosition, Vector3 playerPosition)
  22.     {
  23.         LookAtFromPosition(startPosition, playerPosition, Vector3.Up);
  24.         RotateY((float)GD.RandRange(-Mathf.Pi / 4.0, Mathf.Pi / 4.0));
  26.         float randomSpeed = (float)GD.RandRange(MinSpeed, MaxSpeed);
  27.         _velocity = Vector3.Forward * randomSpeed;
  28.         _velocity = _velocity.Rotated(Vector3.Up, Rotation.y);
  29.     }
  31.     public void Squash()
  32.     {
  33.         EmitSignal(nameof(Squashed));
  34.         QueueFree();
  35.     }
  37.     public void OnVisibilityNotifierScreenExited()
  38.     {
  39.         QueueFree();
  40.     }
  41. }

最后是最长的脚本 Player.gd。

GDScriptC#

  1. extends KinematicBody
  3. # Emitted when a mob hit the player.
  4. signal hit
  6. # How fast the player moves in meters per second.
  7. export var speed = 14
  8. # The downward acceleration when in the air, in meters per second squared.
  9. export var fall_acceleration = 75
  10. # Vertical impulse applied to the character upon jumping in meters per second.
  11. export var jump_impulse = 20
  12. # Vertical impulse applied to the character upon bouncing over a mob in meters per second.
  13. export var bounce_impulse = 16
  15. var velocity = Vector3.ZERO
  18. func _physics_process(delta):
  19.     var direction = Vector3.ZERO
  21.     if Input.is_action_pressed("move_right"):
  22.         direction.x += 1
  23.     if Input.is_action_pressed("move_left"):
  24.         direction.x -= 1
  25.     if Input.is_action_pressed("move_back"):
  26.         direction.z += 1
  27.     if Input.is_action_pressed("move_forward"):
  28.         direction.z -= 1
  30.     if direction != Vector3.ZERO:
  31.         direction = direction.normalized()
  32.         $Pivot.look_at(translation + direction, Vector3.UP)
  34.     velocity.x = direction.x * speed
  35.     velocity.z = direction.z * speed
  37.     # Jumping.
  38.     if is_on_floor() and Input.is_action_just_pressed("jump"):
  39.         velocity.y += jump_impulse
  41.     velocity.y -= fall_acceleration * delta
  42.     velocity = move_and_slide(velocity, Vector3.UP)
  44.     for index in range(get_slide_count()):
  45.         var collision = get_slide_collision(index)
  46.         if collision.collider.is_in_group("mob"):
  47.             var mob = collision.collider
  48.             if Vector3.UP.dot(collision.normal) > 0.1:
  49.                 mob.squash()
  50.                 velocity.y = bounce_impulse
  53. func die():
  54.     emit_signal("hit")
  55.     queue_free()
  58. func _on_MobDetector_body_entered(_body):
  59.     die()
  1. public class Player : KinematicBody
  2. {
  3.     // Emitted when the player was hit by a mob.
  4.     [Signal]
  5.     public delegate void Hit();
  7.     // How fast the player moves in meters per second.
  8.     [Export]
  9.     public int Speed = 14;
  10.     // The downward acceleration when in the air, in meters per second squared.
  11.     [Export]
  12.     public int FallAcceleration = 75;
  13.     // Vertical impulse applied to the character upon jumping in meters per second.
  14.     [Export]
  15.     public int JumpImpulse = 20;
  16.     // Vertical impulse applied to the character upon bouncing over a mob in meters per second.
  17.     [Export]
  18.     public int BounceImpulse = 16;
  20.     private Vector3 _velocity = Vector3.Zero;
  22.     public override void _PhysicsProcess(float delta)
  23.     {
  24.         var direction = Vector3.Zero;
  26.         if (Input.IsActionPressed("move_right"))
  27.         {
  28.             direction.x += 1f;
  29.         }
  30.         if (Input.IsActionPressed("move_left"))
  31.         {
  32.             direction.x -= 1f;
  33.         }
  34.         if (Input.IsActionPressed("move_back"))
  35.         {
  36.             direction.z += 1f;
  37.         }
  38.         if (Input.IsActionPressed("move_forward"))
  39.         {
  40.             direction.z -= 1f;
  41.         }
  43.         if (direction != Vector3.Zero)
  44.         {
  45.             direction = direction.Normalized();
  46.             GetNode<Spatial>("Pivot").LookAt(Translation + direction, Vector3.Up);
  47.         }
  49.         _velocity.x = direction.x * Speed;
  50.         _velocity.z = direction.z * Speed;
  52.         // Jumping.
  53.         if (IsOnFloor() && Input.IsActionJustPressed("jump"))
  54.         {
  55.             _velocity.y += JumpImpulse;
  56.         }
  58.         _velocity.y -= FallAcceleration * delta;
  59.         _velocity = MoveAndSlide(_velocity, Vector3.Up);
  61.         for (int index = 0; index < GetSlideCount(); index++)
  62.         {
  63.             KinematicCollision collision = GetSlideCollision(index);
  64.             if (collision.Collider is Mob mob && mob.IsInGroup("mob"))
  65.             {
  66.                 if (Vector3.Up.Dot(collision.Normal) > 0.1f)
  67.                 {
  68.                     mob.Squash();
  69.                     _velocity.y = BounceImpulse;
  70.                 }
  71.             }
  72.         }
  73.     }
  75.     private void Die()
  76.     {
  77.         EmitSignal(nameof(Hit));
  78.         QueueFree();
  79.     }
  81.     public void OnMobDetectorBodyEntered(Node body)
  82.     {
  83.         Die();
  84.     }
  85. }

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