第6部分

第6部分

部分概述

在这部分,我们将添加一个主菜单和暂停菜单,为玩家添加一个重生系统,并改变和移动声音系统,以便可以从任何脚本中使用它.

这是FPS教程的最后一部分;结束后,你将有一个坚实的基础,用Godot建立惊人的FPS游戏!

注解

假设您已经完成了第5部分,才会进入本部分教程.从第5部分中完成的项目将是第六部分的起始项目

让我们开始吧！

添加主菜单

首先,打开 Main_Menu.tscn ,看看场景是如何设置的.

主菜单分为三个不同的面板,每个面板代表主菜单的不同”屏幕”.

注解

``Background_Animation``节点就是这样,菜单的背景比纯色更有趣. 这是一个环顾天空盒的相机,没什么特别的.

随意展开所有的节点,看看它们是如何设置的.记住,当你完成后,只保留 Start_Menu 可见,因为当我们进入主菜单时,希望首先显示的是这个屏幕.

选择 Main_Menu (根节点)并创建一个名为 Main_Menu.gd 的新脚本. 添加以下内容:

extends Control
var start_menu
var level_select_menu
var options_menu
export (String, FILE) var testing_area_scene
export (String, FILE) var space_level_scene
export (String, FILE) var ruins_level_scene
func _ready():
    start_menu = $Start_Menu
    level_select_menu = $Level_Select_Menu
    options_menu = $Options_Menu
    $Start_Menu/Button_Start.connect("pressed", self, "start_menu_button_pressed", ["start"])
    $Start_Menu/Button_Open_Godot.connect("pressed", self, "start_menu_button_pressed", ["open_godot"])
    $Start_Menu/Button_Options.connect("pressed", self, "start_menu_button_pressed", ["options"])
    $Start_Menu/Button_Quit.connect("pressed", self, "start_menu_button_pressed", ["quit"])
    $Level_Select_Menu/Button_Back.connect("pressed", self, "level_select_menu_button_pressed", ["back"])
    $Level_Select_Menu/Button_Level_Testing_Area.connect("pressed", self, "level_select_menu_button_pressed", ["testing_scene"])
    $Level_Select_Menu/Button_Level_Space.connect("pressed", self, "level_select_menu_button_pressed", ["space_level"])
    $Level_Select_Menu/Button_Level_Ruins.connect("pressed", self, "level_select_menu_button_pressed", ["ruins_level"])
    $Options_Menu/Button_Back.connect("pressed", self, "options_menu_button_pressed", ["back"])
    $Options_Menu/Button_Fullscreen.connect("pressed", self, "options_menu_button_pressed", ["fullscreen"])
    $Options_Menu/Check_Button_VSync.connect("pressed", self, "options_menu_button_pressed", ["vsync"])
    $Options_Menu/Check_Button_Debug.connect("pressed", self, "options_menu_button_pressed", ["debug"])
    Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
    var globals = get_node("/root/Globals")
    $Options_Menu/HSlider_Mouse_Sensitivity.value = globals.mouse_sensitivity
    $Options_Menu/HSlider_Joypad_Sensitivity.value = globals.joypad_sensitivity
func start_menu_button_pressed(button_name):
    if button_name == "start":
        level_select_menu.visible = true
        start_menu.visible = false
    elif button_name == "open_godot":
        OS.shell_open("https://godotengine.org/")
    elif button_name == "options":
        options_menu.visible = true
        start_menu.visible = false
    elif button_name == "quit":
        get_tree().quit()
func level_select_menu_button_pressed(button_name):
    if button_name == "back":
        start_menu.visible = true
        level_select_menu.visible = false
    elif button_name == "testing_scene":
        set_mouse_and_joypad_sensitivity()
        get_node("/root/Globals").load_new_scene(testing_area_scene)
    elif button_name == "space_level":
        set_mouse_and_joypad_sensitivity()
        get_node("/root/Globals").load_new_scene(space_level_scene)
    elif button_name == "ruins_level":
        set_mouse_and_joypad_sensitivity()
        get_node("/root/Globals").load_new_scene(ruins_level_scene)
func options_menu_button_pressed(button_name):
    if button_name == "back":
        start_menu.visible = true
        options_menu.visible = false
    elif button_name == "fullscreen":
        OS.window_fullscreen = !OS.window_fullscreen
    elif button_name == "vsync":
        OS.vsync_enabled = $Options_Menu/Check_Button_VSync.pressed
    elif button_name == "debug":
        pass
func set_mouse_and_joypad_sensitivity():
    var globals = get_node("/root/Globals")
    globals.mouse_sensitivity = $Options_Menu/HSlider_Mouse_Sensitivity.value
    globals.joypad_sensitivity = $Options_Menu/HSlider_Joypad_Sensitivity.value

这里的大多数代码都与制作UI有关,这超出了本教程系列的目的. 我们只是简要介绍一下与UI相关的代码.

小技巧

请参阅 :ref:`doc_ui_main_menu`以及以下教程,以获得更好的GUI和UI方法！

我们先来看看类变量.

start_menu:一个用于保存``Start_Menu``的变量 Panel.
level_select_menu:一个用于保存``Level_Select_Menu``的变量 Panel.
options_menu:一个变量来保存``Options_Menu`` Panel.
testing_area_scene:``Testing_Area.tscn``文件的路径,所以我们可以从这个场景改变它.
space_level_scene:``Space_Level.tscn``文件的路径,所以我们可以从这个场景改变它.
ruins_level_scene:``Ruins_Level.tscn``文件的路径,所以我们可以从这个场景改变它.

警告

在测试此脚本之前,您必须在编辑器中设置正确文件的路径！否则它将无法正常工作！

现在让我们回顾一下 _ready

首先,我们得到所有的 Panel 节点,并将它们分配到合适的变量中.

接下来,我们将所有的按钮 pressed 信号连接到各自的 [panel_name_here]_button_pressed 函数.

然后,我们将鼠标模式设置为 MOUSE_MODE_VISIBLE ,以保证每当玩家回到这个场景时,鼠标都是可见的.

然后我们得到一个叫 Globals 的单例.然后设置 HSlider 节点的值,使它们的值与单例中的鼠标和手柄的灵敏度一致.

注解

我们还没有制作 Globals 单例,所以不用担心！我们很快就会成功！

在 start_menu_button_pressed 中,我们检查哪个按钮被按下.

根据按下的按钮,我们要么更改当前可见的面板,退出应用程序,要么打开Godot网站.

在 level_select_menu_button_pressed 中,我们检查按下了哪个按钮.

如果按下”后退”按钮,我们会更改当前可见的面板以返回主菜单.

如果有一个场景变化按钮被按下,首先调用 set_mouse_and_joypad_sensitivity ,这样单例( Globals.gd )就有了 HSlider 节点的值.然后,用它的 load_new_scene 函数告诉单例改变节点,并传入玩家选择的场景的文件路径.

注解

不要担心单例,我们很快到了！

在 options_menu_button_pressed 中,我们检查按下了哪个按钮.

如果按下”后退”按钮,我们会更改当前可见的面板以返回主菜单.

如果按下 fullscreen 按钮,我们就会将 OS 的全屏模式设置为其当前值的翻转版本.

如果 vsync 按钮被按下,我们根据Vsync检查按钮的状态来设置 OS 的Vsync.

最后,让我们来看看 set_mouse_and_joypad_sensitivity .

首先,我们得到 Globals 单例,并将其分配给一个局部变量.

然后我们将 mouse_sensitivity 和``joypad_sensitivity``变量设置为它们各自的值 HSlider 节点对应物.

使 `Globals` 单例

现在,为了让所有这些都能正常工作,我们需要创建 Globals 单例.在 Script 选项卡中创建一个新的脚本,并将其命名为 Globals.gd .

注解

要制作 Globals 单例,请转到编辑器中的 Script 选项卡,然后单击 New 并出现一个 Create Script 框,除了 Path 您需要插入脚本名称 Globals.gd .

将以下内容添加到 Globals.gd 中.

extends Node
var mouse_sensitivity = 0.08
var joypad_sensitivity = 2
func _ready():
    pass
func load_new_scene(new_scene_path):
    get_tree().change_scene(new_scene_path)

正如你所看到的,它是相当小而简单的.随着这部分的进展,我们会不断给 Globals.gd 添加更复杂的逻辑,但现在,它所做的就是持有两个类变量,以及抽象定义我们如何改变场景.

mouse_sensitivity:我们鼠标的当前灵敏度,所以我们可以在 Player.gd 中加载它.
joypad_sensitivity:我们游戏手柄的当前灵敏度,所以我们可以在 Player.gd 中加载它.

现在,我们将使用 Globals.gd 来实现跨场景携带变量的功能.因为鼠标和手柄的灵敏度都存储在 Globals.gd 中,我们在一个场景中做的任何改变(比如在 Options_Menu 中)都会影响玩家的灵敏度.

我们在 load_new_scene 中所做的就是调用 SceneTree 的 change_scene 函数,传入 load_new_scene 中给出的场景路径.

这就是现在 Globals.gd 所需要的所有代码!在我们测试主菜单之前,首先需要将 Globals.gd 设置为自动加载脚本.

打开``Project Settings``并单击 AutoLoad 选项卡.

然后通过单击旁边的按钮( .. )选择 Path 字段中 Globals.gd 的路径. 确保 Node Name 字段中的名称是 Globals . 如果您拥有上图所示的所有内容,请按 添加 ！

这将使 Globals.gd 成为单例/自动加载脚本,这将允许我们从任何场景中的任何脚本访问它.

小技巧

有关单例/自动加载脚本的更多信息,请参阅单例(自动加载).

现在 Globals.gd 是一个单例/自动加载脚本,您可以测试主菜单！

您可能希望将主场景从 Testing_Area.tscn 更改为 Main_Menu.tscn ,因此当我们导出游戏时,游戏角色将从主菜单开始. 您可以通过 General 选项卡下的``Project Settings``来完成此操作. 然后在 Application 类别中,单击 Run 子类别,您可以通过更改``Main Scene``中的值来更改主场景.

警告

在测试主菜单之前,您必须在编辑器中的 Main_Menu 中设置正确文件的路径！否则,您将无法从级别选择菜单/屏幕更改场景.

添加调试菜单

现在,让我们添加一个简单的调试场景,这样就可以在游戏中跟踪FPS(每秒帧数)等内容.打开 Debug_Display.tscn .

你可以看到它是一个 Panel,位置在屏幕的右上角.它有三个 Labels,一个是显示游戏运行的FPS,一个是显示游戏在什么操作系统上运行,还有一个标签是显示游戏在哪个Godot版本上运行.

让我们添加填充这些代码所需的代码 Labels. 选择 Debug_Display 并创建一个名为 Debug_Display.gd 的新脚本. 添加以下内容:

extends Control
func _ready():
    $OS_Label.text = "OS: " + OS.get_name()
    $Engine_Label.text = "Godot version: " + Engine.get_version_info()["string"]
func _process(delta):
    $FPS_Label.text = "FPS: " + str(Engine.get_frames_per_second())

我们来看看这个脚本的功能.

在 _ready 中,我们使用 get_name 函数将 OS_Label 的文本设置为 OS 提供的名称.这将返回Godot被编译的操作系统或操作系统的名称.例如,当你运行Windows时,它将返回 Windows ,而当你运行Linux时,它将返回 X11 .

然后,我们将 Engine_Label 的文本设置为 Engine.get_version_info 提供的版本信息. Engine.get_version_info 会返回一个字典,里面有关于当前运行的Godot版本的有用信息.我们只关心字符串的版本,至少对这个标签来说是这样,所以我们得到这个字符串,并将其赋值为 Engine_Label 中的 text .参见 Engine 了解更多关于 get_version_info 返回值的信息.

在 _process 中,我们将 FPS_Label 的文本设置为 Engine.get_frames_per_second ,但由于 get_frames_per_second 返回的是一个整数,所以我们必须先用 str 将其转变成一个字符串,然后才能将其添加到 Label 中.

现在让我们跳回到 Main_Menu.gd 并在 options_menu_button_pressed 中更改以下内容:

elif button_name == "debug":
    pass

改为:

elif button_name == "debug":
    get_node("/root/Globals").set_debug_display($Options_Menu/Check_Button_Debug.pressed)

这将会在单例中调用一个新的函数 set_debug_display ,所以接下来让我们添加这个函数吧!

打开 Globals.gd 并添加以下类变量:

# ------------------------------------
# All the GUI/UI-related variables
var canvas_layer = null
const DEBUG_DISPLAY_SCENE = preload("res://Debug_Display.tscn")
var debug_display = null
# ------------------------------------

canvas_layer:一个画布层,因此在 Globals.gd 中创建的GUI / UI总是在顶部绘制.
DEBUG_DISPLAY:我们之前处理过的调试显示场景.
debug_display:一个变量,用于在/如果存在时保持调试显示.

现在我们已经定义了类变量,我们需要在 _ready 中添加几行,以便 Globals.gd 将使用一个画布层(我们将存储在 canvas_layer 中). 将 _ready 更改为以下内容:

func _ready():
    canvas_layer = CanvasLayer.new()
    add_child(canvas_layer)

现在在 _ready 中,我们创建一个新的画布层,将其分配给 canvas_layer ,并将其添加为子节点.因为 Globals.gd 是一个自动加载单例,所以当游戏启动时,Godot会做一个 Node ,它将有 Globals.gd 附在上面.由于Godot制作了一个 Node ,我们可以像对待其他节点一样对待 Globals.gd 来添加或删除子节点.

我们添加一个 CanvasLayer 的原因是为了在 Globals.gd 中实例/spawn的所有GUI和UI节点总是绘制在其他所有东西之上.

当将节点添加到单例自动加载时,你必须小心不要丢失对任何子节点的引用.这是因为当你改变活动场景时,节点不会被释放和销毁,这意味着如果你在实例化和生成很多节点而没有释放它们,可能会遇到内存问题.

现在我们需要将 set_debug_display 添加到``Globals.gd``:

func set_debug_display(display_on):
    if display_on == false:
        if debug_display != null:
            debug_display.queue_free()
            debug_display = null
    else:
        if debug_display == null:
            debug_display = DEBUG_DISPLAY_SCENE.instance()
            canvas_layer.add_child(debug_display)

让我们回顾一下正在发生的事情.

首先,我们检查 Globals.gd 是否正在尝试打开调试显示,或者将其关闭.

如果 Globals.gd 正在关闭显示,我们检查 debug_display 是否不等于 null . 如果 debug_display 不等于 null ,那么 Globals.gd 必须有一个当前有效的调试显示. 如果 Globals.gd 的调试显示处于活动状态,我们使用 queue_free 释放它,然后将 debug_display 分配给 null .

如果 Globals.gd 打开显示器,我们检查以确保 Globals.gd 没有激活调试显示. 我们通过确保 debug_display 等于 null 来做到这一点. 如果 debug_display 是``null``,我们实例化一个新的 DEBUG_DISPLAY_SCENE ,并将其添加为 canvas_layer 的子节点.

完成后,我们现在可以通过在 Options_Menu 面板中切换 CheckButton 来打开和关闭调试显示. 去尝试吧！

注意到即使你从 Main_Menu.tscn 到另一个场景(如 Testing_Area.tscn )改变场景时,调试显示也会保持.这就是在单例/自动加载中实例化/spawning节点并将它们作为子节点添加到单例/自动加载的好处.只要游戏还在运行,任何作为单例/自动加载的子节点都会一直存在,而不需要我们做任何额外的工作!

添加暂停菜单

让我们添加一个暂停菜单,这样当我们按下 ui_cancel 动作时我们可以返回主菜单.

打开 Pause_Popup.tscn .

注意 Pause_Popup 中的根节点是一个 WindowDialog ； WindowDialog 继承自 Popup ,这意味着 WindowDialog 可以像弹出窗口一样运行.

选择 Pause_Popup ,然后一直向下滚动,直到在检查器中找到 Pause 菜单.请注意,暂停模式被设置为 process ,而不是像通常默认设置的 inherit .这使得它即使在游戏暂停时也会继续处理,我们需要这样做才能与UI元素进行交互.

现在我们已经了解 Pause_Popup.tscn 是如何设置的,让我们编写代码来使它工作.通常,我们会在场景的根节点上附加一个脚本,在本例中是 Pause_Popup ,但由于需要在 Globals.gd 中接收一些信号,我们将在那里写弹出窗口的所有代码.

打开 Globals.gd 并添加以下类变量:

const MAIN_MENU_PATH = "res://Main_Menu.tscn"
const POPUP_SCENE = preload("res://Pause_Popup.tscn")
var popup = null

MAIN_MENU_PATH:主菜单场景的路径.
POPUP_SCENE:我们之前看过的弹出场景.
popup:一个用于保存弹出场景的变量.

现在我们需要将 _process 添加到 Globals.gd 中,这样当按下 ui_cancel 动作时它就会响应. 将以下内容添加到``_process``:

func _process(delta):
    if Input.is_action_just_pressed("ui_cancel"):
        if popup == null:
            popup = POPUP_SCENE.instance()
            popup.get_node("Button_quit").connect("pressed", self, "popup_quit")
            popup.connect("popup_hide", self, "popup_closed")
            popup.get_node("Button_resume").connect("pressed", self, "popup_closed")
            canvas_layer.add_child(popup)
            popup.popup_centered()
            Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
            get_tree().paused = true

让我们回顾一下这里发生的事情.

首先,我们检查 ui_cancel 动作是否被按下.然后,我们通过检查 popup 是否等于 null 来确保 Globals.gd 没有打开 popup .

如果 Globals.gd 没有弹出窗口,我们实例化 POPUP_SCENE 并将其分配给 popup .

然后我们得到退出按钮并将它的 pressed 信号分配给 popup_quit ,我们将很快添加.

接下来,我们将 WindowDialog 的 popup_hide 信号和resume按钮的 pressed 信号都分配给 popup_closed ,将很快添加.

然后,我们添加 popup 作为 canvas_layer 的子级,这样它就会被绘制在上面.然后用 popup_centered 通知 popup 在屏幕中心弹出.

接下来,我们确保鼠标模式为 MOUSE_MODE_VISIBLE ,这样玩家就可以与弹出窗口进行交互.如果我们不这样做,玩家将无法在任何鼠标模式为 MOUSE_MODE_CAPTURED 的场景中与弹出窗口交互.

最后,我们暂停整个 SceneTree.

注解

有关在Godot中暂停的更多信息,请参阅暂停游戏

现在,我们需要添加连接信号的函数.先添加 popup_closed .

将以下内容添加到``Globals.gd``:

func popup_closed():
    get_tree().paused = false
    if popup != null:
        popup.queue_free()
        popup = null

popup_closed 将恢复游戏,并在有弹出窗口的情况下销毁.

``popup_quit``类似,但我们也确保鼠标可见并将场景更改为标题屏幕.

将以下内容添加到``Globals.gd``:

func popup_quit():
    get_tree().paused = false
    Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
    if popup != null:
        popup.queue_free()
        popup = null
    load_new_scene(MAIN_MENU_PATH)

popup_quit 将恢复游戏,将鼠标模式设置为 MOUSE_MODE_VISIBLE 以确保鼠标在主菜单中可见,如果有弹出窗口,则销毁弹出窗口,并将场景改为主菜单.

在我们准备测试弹出窗口之前,应该在 Player.gd 中修改一件事.

打开 Player.gd 并在 process_input 中,将捕获/释放光标的代码更改为以下内容:

代替:

# Capturing/Freeing cursor
if Input.is_action_just_pressed("ui_cancel"):
    if Input.get_mouse_mode() == Input.MOUSE_MODE_VISIBLE:
        Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
    else:
        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)

您只会离开:

# Capturing/Freeing cursor
if Input.get_mouse_mode() == Input.MOUSE_MODE_VISIBLE:
    Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

现在,我们不是捕捉或释放鼠标,而是检查当前的鼠标模式是否为 MOUSE_MODE_VISIBLE .如果是,就把它设置为 MOUSE_MODE_CAPTURED .

因为每当你暂停时,弹出的窗口会使鼠标模式为 MOUSE_MODE_VISIBLE ,所以我们不再担心在 Player.gd 中释放和捕捉光标.

现在弹出的暂停菜单已经完成.现在你可以在游戏中的任何一点暂停并返回主菜单!

启动重生系统

由于游戏角色可以失去所有的健康,如果游戏角色死亡和重生,那将是理想的,所以让我们接下来添加！

首先,打开 Player.tscn ,展开 HUD .注意有一个 ColorRect 叫 Death_Screen .当玩家死亡时,我们将使 Death_Screen 可见,并向他们展示在玩家能够重生之前他们需要等待多长时间.

打开 Player.gd 并添加以下类变量:

const RESPAWN_TIME = 4
var dead_time = 0
var is_dead = false
var globals

RESPAWN_TIME:重生的时间(以秒为单位).
dead_time:一个跟踪游戏角色死亡时间的变量.
is_dead:一个跟踪游戏角色当前是否死亡的变量.
globals:一个变量来保存 Globals.gd 单例.

我们现在需要在 _ready 中添加几行,所以我们可以在 Player.gd 中使用 Globals.gd . 将以下内容添加到 _ready:

globals = get_node("/root/Globals")
global_transform.origin = globals.get_respawn_position()

现在我们得到 Globals.gd 的单例,并将其分配给 globals .我们还设置了玩家的全局位置,将玩家的全局 Transform 中的原点设置为由 globals.get_respawn_position 返回的位置.

注解

别担心,我们将在下面添加 get_respawn_position ！

接下来,我们需要对 _physics_process 进行一些修改.将 _physics_process 改为:

func _physics_process(delta):
    if !is_dead:
        process_input(delta)
        process_view_input(delta)
        process_movement(delta)
    if (grabbed_object == null):
        process_changing_weapons(delta)
        process_reloading(delta)
    process_UI(delta)
    process_respawn(delta)

现在,当游戏角色死亡时,游戏角色将不会处理输入或移动输入. 我们现在也在调用 process_respawn .

注解

if !is_dead: 表达式与 if is_dead == false: 表达式是等价的,工作方式相同.而把表达式中的 ! 号去掉,我们就可以得到相反的表达式 if is_dead == true: .这只是用一种更短的方式来写同样的代码功能.

我们还没有制作 process_respawn ,所以让我们改变它.

让我们添加 process_respawn . 将以下内容添加到``Player.gd``:

func process_respawn(delta):
    # If we've just died
    if health <= 0 and !is_dead:
        $Body_CollisionShape.disabled = true
        $Feet_CollisionShape.disabled = true
        changing_weapon = true
        changing_weapon_name = "UNARMED"
        $HUD/Death_Screen.visible = true
        $HUD/Panel.visible = false
        $HUD/Crosshair.visible = false
        dead_time = RESPAWN_TIME
        is_dead = true
        if grabbed_object != null:
            grabbed_object.mode = RigidBody.MODE_RIGID
            grabbed_object.apply_impulse(Vector3(0, 0, 0), -camera.global_transform.basis.z.normalized() * OBJECT_THROW_FORCE / 2)
            grabbed_object.collision_layer = 1
            grabbed_object.collision_mask = 1
            grabbed_object = null
    if is_dead:
        dead_time -= delta
        var dead_time_pretty = str(dead_time).left(3)
        $HUD/Death_Screen/Label.text = "You died\n" + dead_time_pretty + " seconds till respawn"
        if dead_time <= 0:
            global_transform.origin = globals.get_respawn_position()
            $Body_CollisionShape.disabled = false
            $Feet_CollisionShape.disabled = false
            $HUD/Death_Screen.visible = false
            $HUD/Panel.visible = true
            $HUD/Crosshair.visible = true
            for weapon in weapons:
                var weapon_node = weapons[weapon]
                if weapon_node != null:
                    weapon_node.reset_weapon()
            health = 100
            grenade_amounts = {"Grenade":2, "Sticky Grenade":2}
            current_grenade = "Grenade"
            is_dead = false

让我们来看看这个功能正在做什么.

首先,我们通过检查``health``是否等于或小于``0``并且``is_dead``是``false``来检查游戏角色是否刚刚死亡.

如果游戏角色刚刚去世,我们会禁用游戏角色的碰撞形状. 我们这样做是为了确保游戏角色不会用尸体挡住任何东西.

接下来,我们将 changing_weapon 设置为 true ,并将 changing_weapon_name 设置为 UNARMED .这样一来,如果玩家在使用武器,当他们死亡时,武器就会被收起来.

然后我们制作``Death_Screen`` ColorRect 可见,这样当游戏角色死亡时,游戏角色会得到漂亮的灰色覆盖. 然后我们制作UI的其余部分, Panel 和``Crosshair``节点,看不见.

接下来,我们把 dead_time 设置为 RESPAWN_TIME ,这样就可以开始倒数玩家已经死亡多久.还将 is_dead 设置为 true ,这样就知道玩家已经死亡.

如果玩家死亡的时候手里持有一个东西,我们就需要扔掉它.我们首先检查玩家是否持有一个物体.如果玩家持有一个物体,使用与第5部分中添加的投掷代码相同的代码来投掷它.

注解

表达式 You have died\n 的 \n 组合是一个命令,用于在下面的新行上显示后面的文本. 当您用魔杖很好地将显示的文本分组为多行时,这总是很有用,因此它看起来更好,并且更容易被游戏游戏角色阅读.

然后我们检查游戏角色是否死了. 如果游戏角色死了,我们就从 dead_time 中删除 delta .

然后我们创建一个名为 dead_time_pretty 的新变量,我们将 dead_time 转换为字符串,只使用从左边开始的前三个字符. 这为游戏角色提供了一个漂亮的字符串,显示游戏角色在游戏角色重生之前需要等待多长时间.

然后我们在``Death Screen``中更改 Label 来显示游戏角色离开的时间.

接下来我们检查游戏角色是否已经等待足够长时间并且可以重生. 我们通过检查 dead_time 是否为”0”或更少来做到这一点.

如果游戏角色等待足够长时间重生,我们将游戏角色的位置设置为”get_respawn_position”提供的新重生位置.

然后我们启用两个游戏角色的碰撞形状,以便游戏角色可以再次与环境发生碰撞.

接下来,我们使 Death_Screen 不可见,并使UI的其余部分, Panel 和 Crosshair 节点再次可见.

然后我们通过每个武器并调用它的 reset_weapon 函数,我们将很快添加它.

然后我们将 health 重置为 100 ,将 grenade_amounts 重置为默认值,并将 current_grenade 改为 Grenade . 这有效地将这些变量重置为其默认值.

最后,我们将 is_dead 设置为 false .

在我们离开 Player.gd 之前,我们需要在 _input 中添加一个快速的东西. 在 _input 的开头添加以下内容:

if is_dead:
    return

现在当游戏角色死了,玩家无法用鼠标环顾四周.

完成重生系统

首先让我们打开 Weapon_Pistol.gd 脚本并添加 reset_weapon 函数. 添加以下内容:

func reset_weapon():
    ammo_in_weapon = 10
    spare_ammo = 20

现在当我们调用 reset_weapon 时,手枪中的弹药和备用弹药将重置为默认值.

现在让我们在 Weapon_Rifle.gd 中添加``reset_weapon``:

func reset_weapon():
    ammo_in_weapon = 50
    spare_ammo = 100

并将以下内容添加到``Weapon_Knife.gd``:

func reset_weapon():
    ammo_in_weapon = 1
    spare_ammo = 1

现在,当游戏角色死亡时,所有武器都会重置.

现在我们需要在 Globals.gd 中添加一些东西. 首先,添加以下类变量:

var respawn_points = null

respawn_points :一个变量,用于保存关卡中的所有重生点

因为我们每次都得到一个随机的衍生点,我们需要随机化这个数字生成器.在”_ready”中添加以下内容:

randomize()

randomize 将给我们一个新的随机种子,因此当我们使用任意一个随机函数时,我们得到一个(相对的)随机数字字符串.

现在让我们将 get_respawn_position 添加到``Globals.gd``:

func get_respawn_position():
    if respawn_points == null:
        return Vector3(0, 0, 0)
    else:
        var respawn_point = rand_range(0, respawn_points.size() - 1)
        return respawn_points[respawn_point].global_transform.origin

让我们回顾一下这个功能的作用.

首先,我们通过检查 respawn_points 是否为 null 来检查 Globals.gd 是否有任何 respawn_points .

如果 respawn_points 是``null``,我们返回一个空位置 Vector 3 ,位置为``(0,0,0)``.

如果’ respawn_points ‘ ‘不是’ null ‘ ‘,那么我们就会得到一个介于’ 0 ‘ ‘和’ respawn_points ‘ ‘ ‘中的元素数量之间的随机数,减去’ 1 ‘ ‘,因为大多数编程语言,包括’ GDScript ‘ ‘ ‘,在访问列表中的元素时,都是从’ 0 ‘ ‘开始计数的.

然后,我们在 respawn_points 的``respawn_point``位置返回 Spatial 节点的位置.

在我们完成 Globals.gd 之前. 我们需要将以下内容添加到 load_new_scene :

respawn_points = null

我们将 respawn_points 设置为 null ,所以当/如果游戏角色达到没有重生点的等级时,我们不会在先前等级的重生点重生游戏角色.

现在我们需要的是一种设置重生点的方法. 打开 Ruins_Level.tscn 并选择 Spawn_Points . 添加一个名为 Respawn_Point_Setter.gd 的新脚本,并将其附加到 Spawn_Points . 将以下内容添加到``Respawn_Point_Setter.gd``:

extends Spatial
func _ready():
    var globals = get_node("/root/Globals")
    globals.respawn_points = get_children()

现在当一个带有 Respawn_Point_Setter.gd 的节点调用了它的 _ready 函数时,该节点的所有子节点都带有 Respawn_Point_Setter.gd , Spawn_Points 在 `` Ruins_Level.tscn`` 将被添加到 Globals.gd 中的 respawn_points .

警告

任何带有”Respawn_Point_Setter.gd`“的节点都必须位于 SceneTree <class_SceneTree>中的游戏角色上方,所以重新生成的点在游戏角色需要它们在游戏角色的 ``_ready` 函数之前设置.

现在当游戏角色死亡时,他们会在等待 4 秒后重生！

注解

除了 Ruins_Level.tscn 之外,还没有为任何级别设置生成点！将生成点添加到”Space_Level.tscn”将留给读者练习.

编写一个我们可以随处使用的音响系统

最后,让我们制作一个音响系统,这样我们就可以在任何地方播放声音,而无需使用播放器.

首先,打开 SimpleAudioPlayer.gd 并将其更改为以下内容:

extends Spatial
var audio_node = null
var should_loop = false
var globals = null
func _ready():
    audio_node = $Audio_Stream_Player
    audio_node.connect("finished", self, "sound_finished")
    audio_node.stop()
    globals = get_node("/root/Globals")
func play_sound(audio_stream, position=null):
    if audio_stream == null:
        print ("No audio stream passed; cannot play sound")
        globals.created_audio.remove(globals.created_audio.find(self))
        queue_free()
        return
    audio_node.stream = audio_stream
    # If you are using an AudioStreamPlayer3D, then uncomment these lines to set the position.
    #if audio_node is AudioStreamPlayer3D:
    #    if position != null:
    #        audio_node.global_transform.origin = position
    audio_node.play(0.0)
func sound_finished():
    if should_loop:
        audio_node.play(0.0)
    else:
        globals.created_audio.remove(globals.created_audio.find(self))
        audio_node.stop()
        queue_free()

旧版本有一些变化,首先是我们不再将声音文件存储在 SimpleAudioPlayer.gd 中. 这对性能要好得多,因为我们在创建声音时不再加载每个音频片段,而是强制将音频流传递到”play_sound”.

另一个变化是我们有一个名为 should_loop 的新类变量. 我们不是仅在每次完成时销毁音频播放器,而是要检查并查看音频播放器是否设置为循环播放. 这使得我们可以像循环背景音乐那样使用音频,而不必在旧音频播放完成后用音乐生成新的音频播放器.

最后,不是在 Player.gd 中实例化/生成,而是在 Player.gd 中生成音频播放器,这样我们就可以从任何场景创建声音. 现在音频播放器存储了 Globals.gd 单例,所以当音频播放器被销毁时,我们也可以从 Globals.gd 中的列表中删除它.

让我们回顾一下这些变化.

对于类变量,我们删除了所有的 audio_[insert name here] 变量,因为我们将从 Globals.gd 中传入这些变量.

我们还添加了两个新的类变量 should_loop 和 globals . 我们将使用 should_loop 来判断音频播放器是否应该在声音结束时循环,而 globals 将保留 Globals.gd 单例.

在 _ready 里的唯一变化是现在音频播放器正在获得 Globals.gd 单例并将其分配给 globals .

play_sound 现在需要传入一个名为 audio_stream 的音频流,而不是 sound_name . 我们不是检查声音名称和设置音频播放器的流,而是检查以确保传入音频流.如果未传入音频流,我们打印错误消息,从列表中删除音频播放器,在 Globals.gd 单例中称为 created_audio ,然后释放音频播放器.

最后,在 sound_finished 中,我们首先检查音频播放器是否应该使用 should_loop 循环. 如果音频播放器应该循环,我们将从头开始再次播放声音,位置为 0.0 . 如果音频播放器不应该循环,我们从名为 created_audio 的 Globals.gd 单曲列表中删除音频播放器,然后释放音频播放器.

现在我们已完成对 SimpleAudioPlayer.gd 的更改,现在我们需要将注意力转向 Globals.gd . 首先,添加以下类变量:

# All the audio files.
# You will need to provide your own sound files.
var audio_clips = {
    "Pistol_shot": null, #preload("res://path_to_your_audio_here!")
    "Rifle_shot": null, #preload("res://path_to_your_audio_here!")
    "Gun_cock": null, #preload("res://path_to_your_audio_here!")
}
const SIMPLE_AUDIO_PLAYER_SCENE = preload("res://Simple_Audio_Player.tscn")
var created_audio = []

让我们来看看这些全局变量.

audio_clips :一个包含``Globals.gd`` 中可以播放的所有音频片段的字典.
SIMPLE_AUDIO_PLAYER_SCENE:简单的音频播放器场景.
created_audio:一个列表,用于保存所有已创建的简单的音频播放器 Globals.gd.

注解

如果要添加其他音频,则需要将其添加到”audio_clips”. 本教程中未提供音频文件,因此您必须提供自己的音频文件.

我推荐的一个网站是**GameSounds.xyz**. 我正在使用2017年Sonniss’GDC游戏音频包中包含的Gamemaster音频枪声音包.我使用过的轨道(经过一些小编辑)如下:

gun_revolver_pistol_shot_04,
gun_semi_auto_rifle_cock_02,
gun_submachine_auto_shot_00_automatic_preview_01

现在我们需要在 Globals.gd 中添加一个名为 play_sound 的新函数:

func play_sound(sound_name, loop_sound=false, sound_position=null):
    if audio_clips.has(sound_name):
        var new_audio = SIMPLE_AUDIO_PLAYER_SCENE.instance()
        new_audio.should_loop = loop_sound
        add_child(new_audio)
        created_audio.append(new_audio)
        new_audio.play_sound(audio_clips[sound_name], sound_position)
    else:
        print ("ERROR: cannot play sound that does not exist in audio_clips!")

让我们回顾一下这个功能的作用.

首先,我们检查 Globals.gd 是否在 audio_clips 中有一个名为 sound_name 的音频剪辑. 如果没有,我们会打印一条错误消息.

如果 Globals.gd 有一个名为 sound_name 的音频剪辑,我们然后实例/生成一个新的 SIMPLE_AUDIO_PLAYER_SCENE 并将其分配给 new_audio .

然后我们设置 should_loop ,并添加 new_audio 作为 Globals.gd 的子节点.

注解

记住,我们必须小心地将节点添加到单例中,因为这些节点在改变场景时不会被销毁.

我们将 “new_audio “添加到 “created_audio “列表中,以保存所有创建的音频.

然后我们调用 play_sound ,传入与 sound_name 相关的音频片段和声音位置.

在我们离开 Globals.gd 之前,我们需要在 load_new_scene 中添加几行代码,这样当播放器改变场景时,所有的音频都会被销毁.

将以下内容添加到``load_new_scene``:

for sound in created_audio:
    if (sound != null):
        sound.queue_free()
created_audio.clear()

现在,在 Globals.gd 改变场景之前,它会通过 created_sounds 中的每个简单音频播放器并释放/销毁它们. 一旦 Globals.gd 完成了 created_audio 中的所有声音,我们就会清除 created_audio ,这样它就不再拥有对任何(现已释放/毁坏)简单音频播放器的引用.

让我们改变 Player.gd 中的 create_sound 来使用这个新系统. 首先,从 Player.gd 的类变量中删除 simple_audio_player ,因为我们将不再直接在 Player.gd 中实例化/产生声音.

现在,将 create_sound 更改为以下内容:

func create_sound(sound_name, position=null):
    globals.play_sound(sound_name, false, position)

现在每当调用 create_sound 时,我们只需在 Globals.gd 中调用 play_sound ,传入所有收到的参数.

现在我们的FPS中的所有声音都可以在任何地方播放. 我们所要做的就是得到 Globals.gd 单例,并调用 play_sound ,传入我们想要播放的声音的名称,无论我们是否想要它循环,以及播放声音.

例如,如果您想在手榴弹爆炸时发出爆炸声,您需要在 Globals.gd 的 audio_clips 中添加一个新的声音,得到 Globals.gd 单例, 然后您只需要在手榴弹 _ process 函数中添加类似 globals.play_sound("explosion",false,global_transform.origin) 的东西,就在手榴弹损坏其爆炸半径范围内的所有物体之后.