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

生成怪物?

在這一部分中，我們將沿著一條路徑隨機生成怪物。到最后，您將看到怪物在游戲板上漫游。

在文件系統(tǒng)中雙擊main.tscn打開Main場景。

在繪制路徑之前，我們要更改游戲分辨率。我們的游戲有一個默認的窗口大小1152x648。我們要把它設(shè)置為720x540,一個漂亮的小盒子。

轉(zhuǎn)到項目 -> 項目設(shè)置。

在左側(cè)菜單中，向下導航至Display -> Window。在右側(cè)，將?寬度設(shè)置為720，將高度設(shè)置為540。

創(chuàng)建生成路徑?

就像您在 2D 游戲教程中所做的那樣，您將設(shè)計一條路徑并使用?PathFollow3D節(jié)點對其上的隨機位置進行采樣。

但是在 3D 中，繪制路徑有點復雜。我們希望它圍繞游戲視圖，這樣怪物就出現(xiàn)在屏幕外面。但是如果我們繪制一條路徑，我們將不會從相機預覽中看到它。

為了找到視圖的限制，我們可以使用一些占位符網(wǎng)格。您的視口仍應分為兩部分，相機預覽位于底部。如果不是這種情況，請按Ctrl?+?2(在 macOS 上Cmd?+?2) 將視圖一分為二。選擇Camera3D節(jié)點并單擊底部視口中的預覽復選框。

添加占位圓柱體?

讓我們添加占位符網(wǎng)格。添加一個新的Node3D作為?Main節(jié)點的子節(jié)點并將其命名為Cylinders。我們將使用它來對圓柱體進行分組。選擇Cylinders并添加子節(jié)點MeshInstance3D

在Inspector中，將CylinderMesh分配給Mesh屬性。

使用視口左上角的菜單將頂部視口設(shè)置為頂部正交視圖?；蛘?，您可以按鍵盤上的 7 鍵。

網(wǎng)格可能會分散注意力。您可以通過轉(zhuǎn)到?工具欄中的“查看”菜單并單擊“查看網(wǎng)格”來切換它。

您現(xiàn)在想要沿著地平面移動圓柱體，在底部視口中查看相機預覽。我建議使用網(wǎng)格捕捉來這樣做。您可以通過單擊工具欄中的磁鐵圖標或按 Y 來切換它。

移動圓柱體，使其位于左上角相機視野之外。

我們將創(chuàng)建網(wǎng)格的副本并將它們放置在游戲區(qū)域周圍。按Ctrl?+?D(在 macOS 上Cmd?+?D) 復制節(jié)點。您還可以右鍵單擊場景停靠欄中的節(jié)點，然后選擇復制。沿藍色 Z 軸向下移動副本，直到它正好位于相機預覽之外。

通過按下Shift鍵并單擊未選擇的圓柱體并復制它們來選擇兩個圓柱體。

通過拖動紅色 X 軸將它們向右移動。

白色有點難看，不是嗎？讓我們通過給他們一種新材料讓他們脫穎而出。

在 3D 中，材質(zhì)定義了表面的視覺屬性，例如顏色、反射光的方式等。我們可以使用它們來改變網(wǎng)格的顏色。

我們可以一次更新所有四個圓柱體。選擇場景?？繖谥械乃芯W(wǎng)格實例?。為此，您可以單擊第一個，然后按住 Shift 單擊最后一個。

在Inspector中，展開Material部分并將StandardMaterial3D分配給 slot?0。

單擊球體圖標以打開材料資源。您可以預覽材料和一長串填充有屬性的部分。您可以使用它們來創(chuàng)建各種表面，從金屬到巖石或水。

展開反照率部分。

將顏色設(shè)置為與背景形成對比的顏色，例如亮橙色。

我們現(xiàn)在可以使用圓柱體作為指南。單擊它們旁邊的灰色箭頭，將它們折疊到場景停靠欄中。展望未來，您還可以通過單擊Cylinders旁邊的眼睛圖標來切換它們的可見性。

添加子節(jié)點Path3D到Main節(jié)點。在工具欄中，出現(xiàn)四個圖標。單擊添加點工具，即帶有綠色“+”符號的圖標。

單擊每個圓柱體的中心以創(chuàng)建一個點。然后，單擊工具欄中的關(guān)閉曲線圖標以關(guān)閉路徑。如果任何點有點偏離，您可以單擊并拖動它以重新定位。

你的路徑應該是這樣的。

要對其上的隨機位置進行采樣，我們需要一個PathFollow3D節(jié)點。添加一個?PathFollow3D作為Path3D.?分別將這兩個節(jié)點重命名為SpawnPath和?SpawnLocation。它更能描述我們將使用它們做什么。

這樣，我們就可以編寫生成機制的代碼了。

隨機生成怪物?

右鍵單擊該Main節(jié)點并將新腳本附加到它。

我們首先將一個變量導出到Inspector，以便我們可以mob.tscn?為其分配或任何其他怪物。

extends Node

@export var mob_scene: PackedScene

我們希望以固定的時間間隔生成生物。為此，我們需要回到場景并添加一個計時器。不過，在此之前，我們需要將?mob.tscn文件分配給mob_scene上面的屬性（否則它為空?。?/p>

返回 3D 屏幕并選擇Main節(jié)點。從FileSystem停靠欄拖動mob.tscn到Inspector中的Mob Scene插槽。

添加一個新的Timer節(jié)點作為 的子節(jié)點Main。命名它MobTimer。

在Inspector中，將其Wait Time設(shè)置為0.5秒并打開?Autostart以便它在我們運行游戲時自動啟動。

定時器timeout每次到達等待時間結(jié)束時都會發(fā)出一個信號。默認情況下，它們會自動重啟，并循環(huán)發(fā)出信號。我們可以從主節(jié)點連接到這個信號，每0.5秒生成一次怪物。

在MobTimer仍處于選中狀態(tài)的情況下，前往右側(cè)的節(jié)點?？繖?，然后雙擊信號timeout。

將其連接到主節(jié)點。

這會將您帶回腳本，并帶有一個新的空?_on_mob_timer_timeout()函數(shù)。

讓我們編寫MOB生成邏輯。我們要：

1. 實例化MOB場景。

2. 在生成路徑上的隨機位置采樣。

3. 獲取玩家的位置。

4. 調(diào)用生物的initialize()方法，將隨機位置和玩家的位置傳遞給它。

5. 將生物添加為主節(jié)點的子節(jié)點。

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之間產(chǎn)生一個隨機值，這是PathFollow節(jié)點所期望的：0 是路徑的起點，1 是路徑的終點。我們設(shè)置的路徑圍繞相機的視口，因此 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測試場景。你應該看到怪物生成并直線移動。

現(xiàn)在，當它們的路徑交叉時，它們會相互碰撞和滑動。我們將在下一部分解決這個問題。

跳躍和擠壓怪物?

在這一部分中，我們將添加跳躍和擠壓怪物的能力。在下一課中，我們會讓玩家在怪物擊中地面時死亡。

首先，我們必須更改一些與物理交互相關(guān)的設(shè)置。進入物理層的世界。

控制物理相互作用?

物理實體可以訪問兩個互補屬性：圖層【layers】和遮罩【mask】。圖層定義對象位于哪個物理層上。

遮罩控制身體將聆聽和檢測的層次。這會影響碰撞檢測。當你想讓兩個物體相互作用時，你至少需要一個物體有一個與另一個物體相對應的掩碼。

如果這讓您感到困惑，請不要擔心，我們馬上會看到三個示例。

重要的一點是您可以使用圖層和遮罩來過濾物理交互、控制性能并消除代碼中對額外條件的需求。

默認情況下，所有物理體和區(qū)域 layer 和 mask都設(shè)置為1。這意味著它們都相互碰撞。

物理層由數(shù)字表示，但我們可以給它們命名以跟蹤什么是什么。

設(shè)置圖層名稱?

讓我們給物理層起個名字。轉(zhuǎn)到項目 -> 項目設(shè)置。

在左側(cè)菜單中，向下導航至Layer Names -> 3D Physics。您可以在右側(cè)看到一個圖層列表，每個圖層旁邊都有一個字段。你可以在那里設(shè)置他們的名字。分別命名前三層player、enemy和world。

現(xiàn)在，我們可以將它們分配給我們的物理節(jié)點。

分配圖層和蒙版?

在主場景中，選擇Ground節(jié)點。在Inspector中，展開?Collision部分。在那里，您可以將節(jié)點的圖層和蒙版視為按鈕網(wǎng)格。

地面是世界的一部分，所以我們希望它成為第三層的一部分。單擊亮起的按鈕關(guān)閉第一層并打開第三層。然后，通過單擊關(guān)閉蒙版。

如前所述，Mask屬性允許節(jié)點監(jiān)聽與其他物理對象的交互，但我們不需要它發(fā)生碰撞。Ground不需要聽任何東西；它只是為了防止生物掉落。

請注意，您可以單擊屬性右側(cè)的“...”按鈕來查看已命名復選框的列表。

接下來是Player和Mob。通過雙擊文件系統(tǒng)?？繖谥械奈募?code>player.tscn打開。

選擇Player節(jié)點并將其Collision -> Mask設(shè)置為“enemies”和“world”。您可以保留默認Layer屬性不變，因為第一層是“播放器”層。

然后，雙擊打開Mobmob.tscn場景并選擇?Mob節(jié)點。

將其Collision -> Layer設(shè)置為“enemies”并取消其Collision -> Mask 的設(shè)置，使遮罩為空。

這些設(shè)置意味著怪物將相互移動。如果你想讓怪物相互碰撞和滑動，打開“敵人”面具。

跳躍?

跳躍機制本身只需要兩行代碼。打開播放器?腳本。我們需要一個值來控制跳躍的強度并更新?_physics_process()以對跳躍進行編碼。

在定義fall_acceleration的行之后，在腳本的頂部，添加jump_impulse.

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

在內(nèi)部_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 軸向下為正。

壓扁怪物?

接下來讓我們添加壁球機制。我們要讓角色在怪物身上彈跳并同時殺死它們。

我們需要檢測與怪物的碰撞并將它們與與地板的碰撞區(qū)分開來。為此，我們可以使用 Godot 的組標記功能。

再次打開場景mob.tscn并選擇Mob節(jié)點。轉(zhuǎn)到?右側(cè)的節(jié)點?？繖谝圆榭葱盘柫斜?em>。Node?dock 有兩個選項卡：?您已經(jīng)使用過的Signals和允許您將標簽分配給節(jié)點的Groups?。

單擊它以顯示一個字段，您可以在其中寫入標簽名稱。在字段中輸入“mob”，然后單擊“添加”按鈕。

場景?？繖谥袝霈F(xiàn)一個圖標，指示該節(jié)點至少屬于一個組。

我們現(xiàn)在可以使用代碼中的組來區(qū)分與怪物的碰撞和與地板的碰撞。

編碼擠壓機制?

回到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代碼塊之后，添加以下循環(huán)。使用 時?move_and_slide()，Godot 有時會連續(xù)多次移動身體以平滑角色的運動。所以我們必須遍歷所有可能發(fā)生的碰撞。

在循環(huán)的每次迭代中，我們檢查我們是否降落在暴徒身上。如果是這樣，我們殺死它并反彈。

使用此代碼，如果給定幀上沒有發(fā)生碰撞，則循環(huán)不會運行。

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

函數(shù)get_slide_collision_count()和get_slide_collision()都來自CharacterBody3D類，并且與?move_and_slide()相關(guān).

get_slide_collision()返回一個?KinematicCollision3D對象，該對象包含有關(guān)碰撞發(fā)生的位置和方式的信息。例如，我們使用它的get_collider屬性，通過調(diào)用is_in_group()來檢查我們是否與“暴徒”發(fā)生碰撞 ：?collision.get_collider().is_in_group("mob")

為了檢查我們是否降落在怪物身上，我們使用向量點積：Vector3.UP.dot(collision.get_normal())?>?0.1。碰撞法線是垂直于發(fā)生碰撞的平面的 3D 矢量。點積允許我們將其與向上方向進行比較。

對于點積，當結(jié)果大于 時0，兩個向量的夾角小于 90 度。高于的值0.1告訴我們，我們大致在怪物之上。

我們正在調(diào)用一個未定義的函數(shù)mob.squash()，因此我們必須將它添加到 Mob 類中。

通過在文件系統(tǒng)?？繖谥须p擊Mob.gd腳本來打開它。在腳本的頂部，我們要定義一個名為squashed的新信號。在底部，您可以添加 squash 函數(shù)，我們可以在其中發(fā)出信號并摧毀生物。

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

# ...


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

我們將在下一課中使用該信號為得分加分。

有了它，你應該能夠通過跳上它們來殺死怪物。您可以按?F5嘗試游戲并設(shè)置main.tscn為項目的主場景。

但是，玩家還不會死。我們將在下一部分進行處理。

殺死玩家?

我們可以通過跳到敵人身上殺死他們，但玩家仍然不能死。讓我們解決這個問題。

我們想要檢測被敵人擊中與壓扁他們的方式不同。我們希望玩家在地板上移動時死亡，但在空中則不會。我們可以使用矢量數(shù)學來區(qū)分這兩種碰撞。不過，我們將使用Area3D節(jié)點，它適用于碰撞盒。

帶有 Area 節(jié)點的 Hitbox?

回到player.tscn場景并添加一個新的子節(jié)點Area3D。將其命名?MobDetector?為添加一個CollisionShape3D節(jié)點作為它的子節(jié)點。

在Inspector中，為其指定一個圓柱體形狀。

這是一個技巧，您可以使用它來使碰撞僅在玩家在地面上或靠近地面時發(fā)生。您可以降低圓柱體的高度并將其向上移動到角色的頂部。這樣，當玩家跳躍時，形狀會高到敵人無法與其發(fā)生碰撞。

您還希望圓柱體比球體寬。這樣，玩家在碰撞并被推到怪物的碰撞箱頂部之前就被擊中了。

圓柱體越寬，玩家就越容易被殺死。

接下來，再次選擇該MobDetector節(jié)點，并在Inspector中關(guān)閉其Monitorable屬性。這使得其他物理節(jié)點無法檢測到該區(qū)域。互補的Monitoring屬性允許它檢測碰撞。然后，移除Collision -> Layer并將蒙版設(shè)置為“enemies”層。

當區(qū)域檢測到碰撞時，它們會發(fā)出信號。我們將把一個連接到Player節(jié)點。選擇MobDetector并轉(zhuǎn)到Inspector的節(jié)點選項卡，雙擊?body_entered信號并將其連接到Player

MobDetector將在CharacterBody3D或?RigidBody3D節(jié)點進入時發(fā)射body_entered。因為它只屏蔽“敵人”物理層，所以它只會檢測Mob節(jié)點。???????

在代碼方面，我們要做兩件事：發(fā)出一個信號，稍后我們將使用它來結(jié)束游戲并摧毀玩家。我們可以將這些操作包裝在一個die()函數(shù)中，幫助我們在代碼上貼上描述性標簽。

# 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。如果一切設(shè)置正確，角色應該在敵人撞上碰撞器時死亡。請注意，沒有Player，以下行

var player_position = $Player.position

給出錯誤，因為沒有 $Player!

另請注意，與玩家碰撞并死亡的敵人取決于?Player和 的Mob碰撞形狀的大小和位置。您可能需要移動它們并調(diào)整它們的大小以獲得緊湊的游戲感覺。

結(jié)束游戲?

我們可以使用Player的hit信號來結(jié)束游戲。我們需要做的就是將它連接到Main節(jié)點并停止MobTimer反應。

打開main.tscn，選擇Player節(jié)點，然后在Node?dock 中，將其hit信號連接到Main節(jié)點。

在函數(shù)中獲取計時器并停止它_on_player_hit()。

func _on_player_hit():
    $MobTimer.stop()

如果你現(xiàn)在嘗試游戲，怪物會在你死后停止生成，剩下的會離開屏幕。

您可以表揚一下自己：您制作了一個完整的 3D 游戲原型，即使它還有些粗糙。

從那里，我們將添加一個分數(shù)，重試游戲的選項，您將看到如何使用簡約的動畫讓游戲感覺更加生動。

代碼檢查點?

Main以下是、Mob和Player節(jié)點的完整腳本，供參考。您可以使用它們來比較和檢查您的代碼。

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

下一節(jié)課見，添加分數(shù)和重玩選項。

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