extends CharacterBody3D

# How fast the player moves in meters per second.
@export var speed = 14
# The downward acceleration when in the air, in meters per second squared.
@export var fall_acceleration = 75

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 += 1
    if Input.is_action_pressed("move_left"):
        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 += 1
    if Input.is_action_pressed("move_forward"):
        direction.z -= 1

#func _physics_process(delta):
    #...

    if direction != Vector3.ZERO:
        direction = direction.normalized()
        $Pivot.look_at(position + direction, Vector3.UP)

func _physics_process(delta):
    #...
    if direction != Vector3.ZERO:
        #...

    # 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)

    # Moving the Character
    velocity = target_velocity
    move_and_slide()

extends CharacterBody3D

# How fast the player moves in meters per second.
@export var speed = 14
# The downward acceleration when in the air, in meters per second squared.
@export var fall_acceleration = 75

var target_velocity = Vector3.ZERO


func _physics_process(delta):
    var direction = Vector3.ZERO

    if Input.is_action_pressed("move_right"):
        direction.x += 1
    if Input.is_action_pressed("move_left"):
        direction.x -= 1
    if Input.is_action_pressed("move_back"):
        direction.z += 1
    if Input.is_action_pressed("move_forward"):
        direction.z -= 1

    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)

    # Moving the Character
    velocity = target_velocity
    move_and_slide()

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


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 -90 and +90 degrees,
    # so that it doesn't move directly towards the player.
    rotate_y(randf_range(-PI / 4, PI / 4))

func initialize(start_position, player_position):
    # ...

    # 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()

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

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 -90 and +90 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()

生成怪物¶

在这一部分中，我们将沿着一条路径随机生成怪物。到最后，您将看到怪物在游戏板上漫游。

在文件系统中双击main.tscn打开Main场景。

在绘制路径之前，我们要更改游戏分辨率。我们的游戏有一个默认的窗口大小1152x648。我们要把它设置为720x540,一个漂亮的小盒子。

转到项目 -> 项目设置。

在左侧菜单中，向下导航至Display -> Window。在右侧，将 宽度设置为720，将高度设置为540。

创建生成路径¶

就像您在 2D 游戏教程中所做的那样，您将设计一条路径并使用 PathFollow3D节点对其上的随机位置进行采样。

但是在 3D 中，绘制路径有点复杂。我们希望它围绕游戏视图，这样怪物就出现在屏幕外面。但是如果我们绘制一条路径，我们将不会从相机预览中看到它。

为了找到视图的限制，我们可以使用一些占位符网格。您的视口仍应分为两部分，相机预览位于底部。如果不是这种情况，请按Ctrl + 2(在 macOS 上Cmd + 2) 将视图一分为二。选择Camera3D节点并单击底部视口中的预览复选框。

添加占位圆柱体¶

让我们添加占位符网格。添加一个新的Node3D作为 Main节点的子节点并将其命名为Cylinders。我们将使用它来对圆柱体进行分组。选择Cylinders并添加子节点MeshInstance3D

在Inspector中，将CylinderMesh分配给Mesh属性。

使用视口左上角的菜单将顶部视口设置为顶部正交视图。或者，您可以按键盘上的 7 键。

网格可能会分散注意力。您可以通过转到 工具栏中的“查看”菜单并单击“查看网格”来切换它。

您现在想要沿着地平面移动圆柱体，在底部视口中查看相机预览。我建议使用网格捕捉来这样做。您可以通过单击工具栏中的磁铁图标或按 Y 来切换它。

移动圆柱体，使其位于左上角相机视野之外。

我们将创建网格的副本并将它们放置在游戏区域周围。按Ctrl + D(在 macOS 上Cmd + D) 复制节点。您还可以右键单击场景停靠栏中的节点，然后选择复制。沿蓝色 Z 轴向下移动副本，直到它正好位于相机预览之外。

通过按下Shift键并单击未选择的圆柱体并复制它们来选择两个圆柱体。

通过拖动红色 X 轴将它们向右移动。

白色有点难看，不是吗？让我们通过给他们一种新材料让他们脱颖而出。

在 3D 中，材质定义了表面的视觉属性，例如颜色、反射光的方式等。我们可以使用它们来改变网格的颜色。

我们可以一次更新所有四个圆柱体。选择场景停靠栏中的所有网格实例 。为此，您可以单击第一个，然后按住 Shift 单击最后一个。

在Inspector中，展开Material部分并将StandardMaterial3D分配给 slot 0。

单击球体图标以打开材料资源。您可以预览材料和一长串填充有属性的部分。您可以使用它们来创建各种表面，从金属到岩石或水。

展开反照率部分。

将颜色设置为与背景形成对比的颜色，例如亮橙色。

我们现在可以使用圆柱体作为指南。单击它们旁边的灰色箭头，将它们折叠到场景停靠栏中。展望未来，您还可以通过单击Cylinders旁边的眼睛图标来切换它们的可见性。

添加子节点Path3D到Main节点。在工具栏中，出现四个图标。单击添加点工具，即带有绿色“+”符号的图标。

单击每个圆柱体的中心以创建一个点。然后，单击工具栏中的关闭曲线图标以关闭路径。如果任何点有点偏离，您可以单击并拖动它以重新定位。

你的路径应该是这样的。

要对其上的随机位置进行采样，我们需要一个PathFollow3D节点。添加一个 PathFollow3D作为Path3D. 分别将这两个节点重命名为SpawnPath和 SpawnLocation。它更能描述我们将使用它们做什么。

这样，我们就可以编写生成机制的代码了。

随机生成怪物¶

右键单击该Main节点并将新脚本附加到它。

我们首先将一个变量导出到Inspector，以便我们可以mob.tscn 为其分配或任何其他怪物。

extends Node

@export var mob_scene: PackedScene

我们希望以固定的时间间隔生成生物。为此，我们需要回到场景并添加一个计时器。不过，在此之前，我们需要将 mob.tscn文件分配给mob_scene上面的属性（否则它为空！）

返回 3D 屏幕并选择Main节点。从FileSystem停靠栏拖动mob.tscn到Inspector中的Mob Scene插槽。

添加一个新的Timer节点作为 的子节点Main。命名它MobTimer。

在Inspector中，将其Wait Time设置为0.5秒并打开 Autostart以便它在我们运行游戏时自动启动。

定时器timeout每次到达等待时间结束时都会发出一个信号。默认情况下，它们会自动重启，并循环发出信号。我们可以从主节点连接到这个信号，每0.5秒生成一次怪物。

在MobTimer仍处于选中状态的情况下，前往右侧的节点停靠栏，然后双击信号timeout。

将其连接到主节点。

这会将您带回脚本，并带有一个新的空 _on_mob_timer_timeout()函数。

让我们编写MOB生成逻辑。我们要：

1. 实例化MOB场景。

2. 在生成路径上的随机位置采样。

3. 获取玩家的位置。

4. 调用生物的initialize()方法，将随机位置和玩家的位置传递给它。

5. 将生物添加为主节点的子节点。

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)

上面，randf()在0和1之间产生一个随机值，这是PathFollow节点所期望的：0 是路径的起点，1 是路径的终点。我们设置的路径围绕相机的视口，因此 0 到 1 之间的任何随机值progress_ratio都是视口边缘的随机位置！

main.gd这是到目前为止的完整脚本，供参考。

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)

您可以按F6测试场景。你应该看到怪物生成并直线移动。

现在，当它们的路径交叉时，它们会相互碰撞和滑动。我们将在下一部分解决这个问题。

跳跃和挤压怪物¶

在这一部分中，我们将添加跳跃和挤压怪物的能力。在下一课中，我们会让玩家在怪物击中地面时死亡。

首先，我们必须更改一些与物理交互相关的设置。进入物理层的世界。

控制物理相互作用¶

物理实体可以访问两个互补属性：图层【layers】和遮罩【mask】。图层定义对象位于哪个物理层上。

遮罩控制身体将聆听和检测的层次。这会影响碰撞检测。当你想让两个物体相互作用时，你至少需要一个物体有一个与另一个物体相对应的掩码。

如果这让您感到困惑，请不要担心，我们马上会看到三个示例。

重要的一点是您可以使用图层和遮罩来过滤物理交互、控制性能并消除代码中对额外条件的需求。

默认情况下，所有物理体和区域 layer 和 mask都设置为1。这意味着它们都相互碰撞。

物理层由数字表示，但我们可以给它们命名以跟踪什么是什么。

设置图层名称¶

让我们给物理层起个名字。转到项目 -> 项目设置。

在左侧菜单中，向下导航至Layer Names -> 3D Physics。您可以在右侧看到一个图层列表，每个图层旁边都有一个字段。你可以在那里设置他们的名字。分别命名前三层player、enemy和world。

现在，我们可以将它们分配给我们的物理节点。

分配图层和蒙版¶

在主场景中，选择Ground节点。在Inspector中，展开 Collision部分。在那里，您可以将节点的图层和蒙版视为按钮网格。

地面是世界的一部分，所以我们希望它成为第三层的一部分。单击亮起的按钮关闭第一层并打开第三层。然后，通过单击关闭蒙版。

如前所述，Mask属性允许节点监听与其他物理对象的交互，但我们不需要它发生碰撞。Ground不需要听任何东西；它只是为了防止生物掉落。

请注意，您可以单击属性右侧的“...”按钮来查看已命名复选框的列表。

接下来是Player和Mob。通过双击文件系统停靠栏中的文件player.tscn打开。

选择Player节点并将其Collision -> Mask设置为“enemies”和“world”。您可以保留默认Layer属性不变，因为第一层是“播放器”层。

然后，双击打开Mobmob.tscn场景并选择 Mob节点。

将其Collision -> Layer设置为“enemies”并取消其Collision -> Mask 的设置，使遮罩为空。

这些设置意味着怪物将相互移动。如果你想让怪物相互碰撞和滑动，打开“敌人”面具。

跳跃¶

跳跃机制本身只需要两行代码。打开播放器 脚本。我们需要一个值来控制跳跃的强度并更新 _physics_process()以对跳跃进行编码。

在定义fall_acceleration的行之后，在脚本的顶部，添加jump_impulse.

#...
# Vertical impulse applied to the character upon jumping in meters per second.
@export var jump_impulse = 20

在内部_physics_process()，在代码块之前添加以下代码move_and_slide()。

func _physics_process(delta):
    #...

    # Jumping.
    if is_on_floor() and Input.is_action_just_pressed("jump"):
        target_velocity.y = jump_impulse

    #...

这就是你需要跳的全部！

该is_on_floor()方法是来自该类的工具CharacterBody3D。true如果身体在此帧中与地板碰撞，它会返回。这就是为什么我们对Player施加重力：所以我们与地板碰撞而不是像怪物那样漂浮在地板上。

如果角色在地板上并且玩家按下“跳跃”，我们会立即给他们很大的垂直速度。在游戏中，您真的希望控件能够响应并提供像这样的即时速度提升，虽然不切实际，但感觉很棒。

请注意，Y 轴向上为正。这与 2D 不同，其中 Y 轴向下为正。

压扁怪物¶

接下来让我们添加壁球机制。我们要让角色在怪物身上弹跳并同时杀死它们。

我们需要检测与怪物的碰撞并将它们与与地板的碰撞区分开来。为此，我们可以使用 Godot 的组标记功能。

再次打开场景mob.tscn并选择Mob节点。转到 右侧的节点停靠栏以查看信号列表。Node dock 有两个选项卡： 您已经使用过的Signals和允许您将标签分配给节点的Groups 。

单击它以显示一个字段，您可以在其中写入标签名称。在字段中输入“mob”，然后单击“添加”按钮。

场景停靠栏中会出现一个图标，指示该节点至少属于一个组。

我们现在可以使用代码中的组来区分与怪物的碰撞和与地板的碰撞。

编码挤压机制¶

回到Player脚本来编写挤压和弹跳的代码。

在脚本的顶部，我们需要另一个属性bounce_impulse. 压扁敌人时，我们不一定希望角色像跳跃时那样飞得那么高。

# Vertical impulse applied to the character upon bouncing over a mob in
# meters per second.
@export var bounce_impulse = 16

然后，在我们在上面_physics_process()添加的Jumping代码块之后，添加以下循环。使用 时 move_and_slide()，Godot 有时会连续多次移动身体以平滑角色的运动。所以我们必须遍历所有可能发生的碰撞。

在循环的每次迭代中，我们检查我们是否降落在暴徒身上。如果是这样，我们杀死它并反弹。

使用此代码，如果给定帧上没有发生碰撞，则循环不会运行。

func _physics_process(delta):
   #...

   # Iterate through all collisions that occurred this frame
   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

函数get_slide_collision_count()和get_slide_collision()都来自CharacterBody3D类，并且与 move_and_slide()相关.

get_slide_collision()返回一个 KinematicCollision3D对象，该对象包含有关碰撞发生的位置和方式的信息。例如，我们使用它的get_collider属性，通过调用is_in_group()来检查我们是否与“暴徒”发生碰撞 ： collision.get_collider().is_in_group("mob")

为了检查我们是否降落在怪物身上，我们使用向量点积：Vector3.UP.dot(collision.get_normal()) > 0.1。碰撞法线是垂直于发生碰撞的平面的 3D 矢量。点积允许我们将其与向上方向进行比较。

对于点积，当结果大于 时0，两个向量的夹角小于 90 度。高于的值0.1告诉我们，我们大致在怪物之上。

我们正在调用一个未定义的函数mob.squash()，因此我们必须将它添加到 Mob 类中。

通过在文件系统停靠栏中双击Mob.gd脚本来打开它。在脚本的顶部，我们要定义一个名为squashed的新信号。在底部，您可以添加 squash 函数，我们可以在其中发出信号并摧毁生物。

# Emitted when the player jumped on the mob.
signal squashed

# ...


func squash():
    squashed.emit()
    queue_free()

我们将在下一课中使用该信号为得分加分。

有了它，你应该能够通过跳上它们来杀死怪物。您可以按 F5尝试游戏并设置main.tscn为项目的主场景。

但是，玩家还不会死。我们将在下一部分进行处理。

杀死玩家¶

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

我们想要检测被敌人击中与压扁他们的方式不同。我们希望玩家在地板上移动时死亡，但在空中则不会。我们可以使用矢量数学来区分这两种碰撞。不过，我们将使用Area3D节点，它适用于碰撞盒。

带有 Area 节点的 Hitbox¶

回到player.tscn场景并添加一个新的子节点Area3D。将其命名 MobDetector 为添加一个CollisionShape3D节点作为它的子节点。

在Inspector中，为其指定一个圆柱体形状。

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

您还希望圆柱体比球体宽。这样，玩家在碰撞并被推到怪物的碰撞箱顶部之前就被击中了。

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

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

当区域检测到碰撞时，它们会发出信号。我们将把一个连接到Player节点。选择MobDetector并转到Inspector的节点选项卡，双击 body_entered信号并将其连接到Player

MobDetector将在CharacterBody3D或 RigidBody3D节点进入时发射body_entered。因为它只屏蔽“敌人”物理层，所以它只会检测Mob节点。​​​​​​​

在代码方面，我们要做两件事：发出一个信号，稍后我们将使用它来结束游戏并摧毁玩家。我们可以将这些操作包装在一个die()函数中，帮助我们在代码上贴上描述性标签。

# 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()

按 再次尝试游戏F5。如果一切设置正确，角色应该在敌人撞上碰撞器时死亡。请注意，没有Player，以下行

var player_position = $Player.position

给出错误，因为没有 $Player!

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

结束游戏¶

我们可以使用Player的hit信号来结束游戏。我们需要做的就是将它连接到Main节点并停止MobTimer反应。

打开main.tscn，选择Player节点，然后在Node dock 中，将其hit信号连接到Main节点。

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

func _on_player_hit():
    $MobTimer.stop()

如果你现在尝试游戏，怪物会在你死后停止生成，剩下的会离开屏幕。

您可以表扬一下自己：您制作了一个完整的 3D 游戏原型，即使它还有些粗糙。

从那里，我们将添加一个分数，重试游戏的选项，您将看到如何使用简约的动画让游戏感觉更加生动。

代码检查点¶

Main以下是、Mob和Player节点的完整脚本，供参考。您可以使用它们来比较和检查您的代码。

从main.gd开始

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()

接下来是Mob.gd。

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 -90 and +90 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

最后，最长的脚本Player.gd：

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

    # 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()

下一节课见，添加分数和重玩选项。

extends Label

var score = 0

func _on_mob_timer_timeout():
    #...
    # We connect the mob to the score label to update the score upon squashing one.
    mob.squashed.connect($UserInterface/ScoreLabel._on_mob_squashed.bind())

func _on_mob_squashed():
    score += 1
    text = "Score: %s" % score

func _ready():
    $UserInterface/Retry.hide()

func _on_player_hit():
    #...
    $UserInterface/Retry.show()

func _unhandled_input(event):
    if event.is_action_pressed("ui_accept") and $UserInterface/Retry.visible:
        # This restarts the current scene.
        get_tree().reload_current_scene()

extends Node

@export var mob_scene: PackedScene

func _ready():
    $UserInterface/Retry.hide()


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)

    # We connect the mob to the score label to update the score upon squashing one.
    mob.squashed.connect($UserInterface/ScoreLabel._on_mob_squashed.bind())

func _on_player_hit():
    $MobTimer.stop()
    $UserInterface/Retry.show()

func _unhandled_input(event):
    if event.is_action_pressed("ui_accept") and $UserInterface/Retry.visible:
        # This restarts the current scene.
        get_tree().reload_current_scene()

func _physics_process(delta):
    #...
    if direction != Vector3.ZERO:
        #...
        $AnimationPlayer.speed_scale = 4
    else:
        $AnimationPlayer.speed_scale = 1

func _physics_process(delta):
    #...
    $Pivot.rotation.x = PI / 6 * velocity.y / jump_impulse

func initialize(start_position, player_position):
    #...
    $AnimationPlayer.speed_scale = random_speed / min_speed

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 movement being very fast
    if direction != Vector3.ZERO:
        direction = direction.normalized()
        $Pivot.look_at(position + direction,Vector3.UP)
        $AnimationPlayer.speed_scale = 4
    else:
        $AnimationPlayer.speed_scale = 1

    # 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
        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

    # Moving the Character
    velocity = target_velocity
    move_and_slide()

    $Pivot.rotation.x = PI / 6 * velocity.y / jump_impulse

# And this function at the bottom.
func die():
    hit.emit()
    queue_free()

func _on_mob_detector_body_entered(body):
    die()

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 -90 and +90 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)

    $AnimationPlayer.speed_scale = random_speed / min_speed

func _on_visible_on_screen_notifier_3d_screen_exited():
    queue_free()

func squash():
    squashed.emit()
    queue_free() # Destroy this node​​​​​​​