Tweak part_six (#2064)

Fix some grammar, punctuation, word order, word choice and spelling in part_six. Add defensive programming guard clause. Reduce verbiage.

tutorials/3d/fps_tutorial/part_six.rst

@@ -6,22 +6,22 @@ Part 6
 Part Overview
 -------------
 
-In this part we're going to add a main menu and pause menu,
+In this part, we're going to add a main menu and pause menu,
 add a respawn system for the player, and change/move the sound system so we can use it from any script.
 
-This is the last part of the FPS tutorial, by the end of this you will have a solid base to build amazing FPS games with Godot!
+This is the last part of the FPS tutorial; by the end of this, you will have a solid base to build amazing FPS games with Godot!
 
 .. image:: img/FinishedTutorialPicture.png
 
 .. note:: You are assumed to have finished :ref:`doc_fps_tutorial_part_five` before moving on to this part of the tutorial.
-          The finished project from :ref:`doc_fps_tutorial_part_four` will be the starting project for part 6
+          The finished project from :ref:`doc_fps_tutorial_part_five` will be the starting project for part 6
 
 Let's get started!
 
 Adding the main menu
 --------------------
 
-First, open up ``Main_Menu.tscn`` and take a look at how the scene is set up.
+Firstly, open up ``Main_Menu.tscn`` and take a look at how the scene is set up.
 
 The main menu is broken up into three different panels, each representing a different
 'screen' of our main menu.
@@ -29,7 +29,7 @@ The main menu is broken up into three different panels, each representing a diff
 .. note:: The ``Background_Animation`` node is just so the background of the menu is a bit more interesting than a solid color.
           It's a camera looking around the skybox, nothing fancy.
 
-Feel free to expand all of the nodes and see how their set up. Remember to keep only ``Start_Menu`` visible
+Feel free to expand all the nodes and see how they're set up. Remember to keep only ``Start_Menu`` visible
 when you're done, as that's the screen we want to show first when we enter the main menu.
 
 Select ``Main_Menu`` (the root node) and create a new script called ``Main_Menu.gd``. Add the following:
@@ -139,11 +139,11 @@ ______
 
 Now let's go over ``_ready``
 
-First we get all of the :ref:`Panel <class_Panel>` nodes and assign them to the proper variables.
+Firstly, we get all the :ref:`Panel <class_Panel>` nodes and assign them to the proper variables.
 
-Next we connect all of the buttons ``pressed`` signals to their respective ``[panel_name_here]_button_pressed`` functions.
+Next, we connect all the buttons ``pressed`` signals to their respective ``[panel_name_here]_button_pressed`` functions.
 
-We then set the mouse mode to ``MOUSE_MODE_VISIBLE`` to ensure whenever the player returns to this scene the mouse will be visible.
+We then set the mouse mode to ``MOUSE_MODE_VISIBLE`` to ensure whenever the player returns to this scene, the mouse will be visible.
 
 Then we get a singleton, called ``Globals``. We then set the values for the :ref:`HSlider <class_HSlider>` nodes so their values line up with the mouse and joypad sensitivity
 in the singleton.
@@ -152,7 +152,7 @@ in the singleton.
 
 ______
 
-In ``start_menu_pressed``, we check to see which button is pressed.
+In ``start_menu_button_pressed``, we check to see which button is pressed.
 
 Based on the button pressed, we either change the currently visible panel, quit the application, or open the Godot website.
 
@@ -162,9 +162,9 @@ In ``level_select_menu_button_pressed``, we check to see which button is pressed
 
 If the ``back`` button has been pressed, we change the currently visible panels to return to the main menu.
 
-If one of the scene changing buttons are pressed, we fist call ``set_mouse_and_joypad_sensitivity`` so the singleton (``Globals.gd``) has the values from the :ref:`HSlider
+If one of the scene changing buttons is pressed, we fist call ``set_mouse_and_joypad_sensitivity`` so the singleton (``Globals.gd``) has the values from the :ref:`HSlider
 <class_HSlider>` nodes.
-Then we tell the singleton to change nodes using its ``load_new_scene`` function, passing in the file path of the scene the player has selected.
+Then, we tell the singleton to change nodes using its ``load_new_scene`` function, passing in the file path of the scene the player has selected.
 
 .. note:: Don't worry about the singleton, we'll get there soon!
 
@@ -174,22 +174,22 @@ In ``options_menu_button_pressed``, we check to see which button is pressed.
 
 If the ``back`` button has been pressed, we change the currently visible panels to return to the main menu.
 
-If the ``fullscreen`` button is pressed we toggle the :ref:`OS <class_OS>`'s full screen mode by setting it to the flipped version of its current value.
+If the ``fullscreen`` button is pressed, we toggle the :ref:`OS <class_OS>`'s full screen mode by setting it to the flipped version of its current value.
 
-If the ``vsync`` button is pressed we set the :ref:`OS <class_OS>`'s Vsync based on the state of the Vsync check button.
+If the ``vsync`` button is pressed, we set the :ref:`OS <class_OS>`'s Vsync based on the state of the Vsync check button.
 
 ______
 
 Finally, lets take a look at ``set_mouse_and_joypad_sensitivity``.
 
-First we get the ``Globals`` singleton and assign it to a local variable.
+Firstly, we get the ``Globals`` singleton and assign it to a local variable.
 
 We then set the ``mouse_sensitivity`` and ``joypad_sensitivity`` variables to the values in their respective :ref:`HSlider <class_HSlider>` node counterparts.
 
 Making the ``Globals`` singleton
 --------------------------------
 
-Now, for this all to work we need to create the ``Globals`` singleton. Make a new script in the ``Script`` tab and call it ``Globals.gd``.
+Now, for all this to work, we need to create the ``Globals`` singleton. Make a new script in the ``Script`` tab and call it ``Globals.gd``.
 
 .. note:: To make the ``Globals`` singleton, go to the ``Script`` tab in the editor, then click ``New`` and a ``Create Script`` box will appear, leave everything unchanged except for the ``Path`` where you need to insert the script's name ``Globals.gd``.
 
@@ -208,18 +208,18 @@ Add the following to ``Globals.gd``.
     func load_new_scene(new_scene_path):
         get_tree().change_scene(new_scene_path)
 
-As you can see, it's quite small and simple. As this part progresses we will
-keep adding more complex logic to ``Globals.gd``, but for now all it is doing is holding two class variables, and abstract defining how we change scenes.
+As you can see, it's quite small and simple. As this part progresses, we will
+keep adding more complex logic to ``Globals.gd``, but for now, all it is doing is holding two class variables, and abstract defining how we change scenes.
 
 * ``mouse_sensitivity``: The current sensitivity for our mouse, so we can load it in ``Player.gd``.
 * ``joypad_sensitivity``: The current sensitivity for our joypad, so we can load it in ``Player.gd``.
 
-Right now all we will be using ``Globals.gd`` for is a way to carry variables across scenes. Because the sensitivity for our mouse and joypad are
-stored in ``Globals.gd``, any changes we make in one scene (like in ``Options_Menu``) will effect the sensitivity for the player.
+Right now, all we will be using ``Globals.gd`` for is a way to carry variables across scenes. Because the sensitivities of our mouse and joypad are
+stored in ``Globals.gd``, any changes we make in one scene (like in ``Options_Menu``) will affect the sensitivity for the player.
 
 All we're doing in ``load_new_scene`` is calling :ref:`SceneTree <class_SceneTree>`'s ``change_scene`` function, passing in the scene path given in ``load_new_scene``.
 
-That's all of the code needed for ``Globals.gd`` right now! Before we can test the main menu, we first need to set ``Globals.gd`` as an autoload script.
+That's all the code needed for ``Globals.gd`` right now! Before we can test the main menu, we first need to set ``Globals.gd`` as an autoload script.
 
 Open up the ``Project Settings`` and click the ``AutoLoad`` tab.
 
@@ -244,10 +244,10 @@ the value in ``Main Scene``.
 Adding the debug menu
 ---------------------
 
-Now let's add a simple debugging scene so we can track things like FPS (Frames Per Second) in game. Open up ``Debug_Display.tscn``.
+Now, let's add a simple debugging scene so we can track things like FPS (Frames Per Second) in-game. Open up ``Debug_Display.tscn``.
 
 You can see it's a :ref:`Panel <class_Panel>` positioned in the top right corner of the screen. It has three :ref:`Labels <class_Label>`,
-one for displaying the FPS the game is running at, one for showing what OS the game is running on, and a label for showing the Godot version the game is running with.
+one for displaying the FPS at which the game is running, one for showing on what OS the game is running, and a label for showing with which Godot version the game is running.
 
 Let's add the code needed to fill these :ref:`Labels <class_Label>`. Select ``Debug_Display`` and create a new script called ``Debug_Display.gd``. Add the following:
 
@@ -256,25 +256,25 @@ Let's add the code needed to fill these :ref:`Labels <class_Label>`. Select ``De
     extends Control
 
     func _ready():
-        $OS_Label.text = "OS:" + OS.get_name()
-        $Engine_Label.text = "Godot version:" + Engine.get_version_info()["string"]
+        $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())
+        $FPS_Label.text = "FPS: " + str(Engine.get_frames_per_second())
 
 Let's go over what this script does.
 
 ______
 
-In ``_ready`` we set the ``OS_Label``'s text to the name provided by :ref:`OS <class_OS>` using the ``get_name`` function. This will return the
-name of the OS (or Operating System) that Godot was compiled for. For example, when you are running Windows it will return ``Windows``, while when you
-are running Linux it will return ``X11``.
+In ``_ready``, we set the ``OS_Label``'s text to the name provided by :ref:`OS <class_OS>` using the ``get_name`` function. This will return the
+name of the OS (or Operating System) for which Godot was compiled. For example, when you are running Windows, it will return ``Windows``, while when you
+are running Linux, it will return ``X11``.
 
-Then we set the ``Engine_Label``'s text to the version info provided by ``Engine.get_version_info``. ``Engine.get_version_info`` returns a dictionary full
-of useful information about the version Godot is currently running with. We only care for the string version, for this label at least, so we get the string
+Then, we set the ``Engine_Label``'s text to the version info provided by ``Engine.get_version_info``. ``Engine.get_version_info`` returns a dictionary full
+of useful information about the version of Godot which is currently running. We only care about the string version, for this label at least, so we get the string
 and assign that as the ``text`` in ``Engine_Label``. See :ref:`Engine <class_Engine>` for more information on the values ``get_version_info`` returns.
 
-In ``_process`` we set the text of the ``FPS_Label`` to ``Engine.get_frames_per_second``, but because ``get_frames_per_second`` returns a integer, we have to cast
+In ``_process``, we set the text of the ``FPS_Label`` to ``Engine.get_frames_per_second``, but because ``get_frames_per_second`` returns an integer, we have to cast
 it to a string using ``str`` before we can add it to the :ref:`Label <class_Label>`.
 
 ______
@@ -293,7 +293,7 @@ to this instead:
     elif button_name == "debug":
         get_node("/root/Globals").set_debug_display($Options_Menu/Check_Button_Debug.pressed)
 
-This will call a new function in our singleton called ``set_debug_display``, so let's add that next!
+This will call a new function called ``set_debug_display`` in our singleton, so let's add that next!
 
 ______
 
@@ -302,7 +302,7 @@ Open up ``Globals.gd`` and add the following class variables:
 ::
 
     # ------------------------------------
-    # All of the GUI/UI related variables
+    # All the GUI/UI-related variables
 
     var canvas_layer = null
 
@@ -326,13 +326,13 @@ Change ``_ready`` to the following:
 
 Now in ``_ready``, we create a new canvas layer, assign it to ``canvas_layer`` and add it as a child.
 Because ``Globals.gd`` is an autoload/singleton, Godot will make a :ref:`Node <class_Node>` when the game is launched, and it will have ``Globals.gd`` attached to it.
-Since Godot makes a :ref:`Node <class_Node>`, we can treat ``Globals.gd`` like any other node regarding to adding/removing children nodes.
+Since Godot makes a :ref:`Node <class_Node>`, we can treat ``Globals.gd`` like any other node with regard to adding/removing children nodes.
 
-The reason we're adding a :ref:`CanvasLayer <class_CanvasLayer>` is so all of our GUI and UI nodes we instance/spawn in ``Globals.gd``
+The reason we're adding a :ref:`CanvasLayer <class_CanvasLayer>` is so all our GUI and UI nodes we instance/spawn in ``Globals.gd``
 are always drawn on top of everything else.
 
 When adding nodes to a singleton/autoload, you have to be careful not to lose reference to any of the child nodes.
-This is because nodes will not be freed/destroyed when you change scene, meaning you can run into memory problems if you are
+This is because nodes will not be freed/destroyed when you change the active scene, meaning you can run into memory problems if you are
 instancing/spawning lots of nodes and you are not freeing them.
 
 ______
@@ -377,15 +377,15 @@ Let's add a pause menu so we can return to the main menu when we press the ``ui_
 
 Open up ``Pause_Popup.tscn``.
 
-Notice how the root node in ``Pause_Popup`` is a :ref:`WindowDialog <class_WindowDialog>`. :ref:`WindowDialog <class_WindowDialog>` inherits from
+Notice how the root node in ``Pause_Popup`` is a :ref:`WindowDialog <class_WindowDialog>`; :ref:`WindowDialog <class_WindowDialog>` inherits from
 :ref:`Popup <class_Popup>`, which means :ref:`WindowDialog <class_WindowDialog>` can act like a popup.
 
 Select ``Pause_Popup`` and scroll down all the way till you get to the ``Pause`` menu in the inspector. Notice how the pause mode is set to
-``process`` instead of ``inherit`` like it is normally set by default. This makes it where it will continue to process even when the game is paused,
+``process`` instead of ``inherit`` like it is normally set by default. This makes it so it will continue to process even when the game is paused,
 which we need in order to interact with the UI elements.
 
-Now that we've looked at how ``Pause_Popup.tscn`` is set up, lets write the code to make it work. Normally we'd attach a script to the root node of
-the scene, ``Pause_Popup`` in this case, but since we'll need to receive a couple of signals in ``Globals.gd``, we'll write all of the code for
+Now that we've looked at how ``Pause_Popup.tscn`` is set up, let's write the code to make it work. Normally, we'd attach a script to the root node of
+the scene, ``Pause_Popup`` in this case, but since we'll need to receive a couple of signals in ``Globals.gd``, we'll write all the code for
 the popup there.
 
 Open up ``Globals.gd`` and add the following class variables:
@@ -425,19 +425,19 @@ Let's go over what's happening here.
 
 ______
 
-First we check to see if the ``ui_cancel`` action is pressed. Then we check to make sure ``Globals.gd`` does not already
+Firstly, we check to see if the ``ui_cancel`` action is pressed. Then, we check to make sure ``Globals.gd`` does not already
 have a ``popup`` open by checking to see if ``popup`` is equal to ``null``.
 
-If ``Globals.gd`` do not have a pop up open, we instance ``POPUP_SCENE`` and assign it to ``popup``.
+If ``Globals.gd`` do not have a pop-up open, we instance ``POPUP_SCENE`` and assign it to ``popup``.
 
 We then get the quit button and assign its ``pressed`` signal to ``popup_quit``, which we will be adding shortly.
 
-Next we assign both the ``popup_hide`` signal from the :ref:`WindowDialog <class_WindowDialog>` and the ``pressed`` signal from the resume button
+Next, we assign both the ``popup_hide`` signal from the :ref:`WindowDialog <class_WindowDialog>` and the ``pressed`` signal from the resume button
 to ``popup_closed``, which we will be adding shortly.
 
-Then we add ``popup`` as a child of ``canvas_layer`` so it's drawn on top. We then tell ``popup`` to pop up at the center of the screen using ``popup_centered``.
+Then, we add ``popup`` as a child of ``canvas_layer`` so it's drawn on top. We then tell ``popup`` to pop up at the center of the screen using ``popup_centered``.
 
-Next we make sure the mouse mode is ``MOUSE_MODE_VISIBLE`` so the player can interact with the pop up. If we did not do this, the player would not be able to
+Next, we make sure the mouse mode is ``MOUSE_MODE_VISIBLE`` so the player can interact with the pop-up. If we did not do this, the player would not be able to
 interact with the pop up in any scene where the mouse mode is ``MOUSE_MODE_CAPTURED``.
 
 Finally, we pause the entire :ref:`SceneTree <class_SceneTree>`.
@@ -446,7 +446,7 @@ Finally, we pause the entire :ref:`SceneTree <class_SceneTree>`.
 
 ______
 
-Now we need to add the functions we've connected the signals to. Let's add ``popup_closed`` first.
+Now, we need to add the functions to which we've connected the signals. Let's add ``popup_closed`` first.
 
 Add the following to ``Globals.gd``:
 
@@ -459,7 +459,7 @@ Add the following to ``Globals.gd``:
             popup.queue_free()
             popup = null
 
-``popup_closed`` will resume the game and destroy the pop up if there is one.
+``popup_closed`` will resume the game and destroy the pop-up if there is one.
 
 ``popup_quit`` is similar, but we're also making sure the mouse is visible and changing scenes to the title screen.
 
@@ -479,11 +479,11 @@ Add the following to ``Globals.gd``:
         load_new_scene(MAIN_MENU_PATH)
 
 ``popup_quit`` will resume the game, set the mouse mode to ``MOUSE_MODE_VISIBLE`` to ensure the mouse is visible in the main menu, destroy
-the pop up if there is one, and change scenes to the main menu.
+the pop-up if there is one, and change scenes to the main menu.
 
 ______
 
-Before we're ready to test the pop up, we should change one thing in ``Player.gd``.
+Before we're ready to test the pop-up, we should change one thing in ``Player.gd``.
 
 Open up ``Player.gd`` and in ``process_input``, change the code for capturing/freeing the cursor to the following:
 
@@ -506,21 +506,21 @@ You will leave only:
     if Input.get_mouse_mode() == Input.MOUSE_MODE_VISIBLE:
         Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
 
-Now instead of capturing/freeing the mouse, we check to see if the current mouse mode is ``MOUSE_MODE_VISIBLE``. If it is, we set it back to
+Now, instead of capturing/freeing the mouse, we check whether the current mouse mode is ``MOUSE_MODE_VISIBLE``. If it is, we set it back to
 ``MOUSE_MODE_CAPTURED``.
 
-Because the popup makes the mouse mode ``MOUSE_MODE_VISIBLE`` whenever you pause, we no longer have to worry about freeing and capturing the cursor in ``Player.gd``.
+Because the pop-up makes the mouse mode ``MOUSE_MODE_VISIBLE`` whenever you pause, we no longer have to worry about freeing and capturing the cursor in ``Player.gd``.
 
 ______
 
-Now the pause menu pop up is finished. You can now pause at any point in the game and return to the main menu!
+Now the pause menu pop-up is finished. You can now pause at any point in the game and return to the main menu!
 
 Starting the respawn system
 ---------------------------
 
 Since the player can lose all their health, it would be ideal if the player died and respawned too, so let's add that next!
 
-First, open up ``Player.tscn`` and expand ``HUD``. Notice how there is a :ref:`ColorRect <class_ColorRect>` called ``Death_Screen``.
+Firstly, open up ``Player.tscn`` and expand ``HUD``. Notice how there is a :ref:`ColorRect <class_ColorRect>` called ``Death_Screen``.
 When the player dies, we're going to make ``Death_Screen`` visible, and show them how long they have to wait before the player is able to respawn.
 
 Open up ``Player.gd`` and add the following class variables:
@@ -555,7 +555,7 @@ by setting the origin in the player's global :ref:`Transform <class_Transform>`
 
 ______
 
-Next we need to make a few changes to ``physics_process``. Change ``physics_processing`` to the following:
+Next, we need to make a few changes to ``_physics_process``. Change ``_physics_process`` to the following:
 
 ::
 
@@ -575,7 +575,7 @@ Next we need to make a few changes to ``physics_process``. Change ``physics_proc
 
 Now the player will not be processing input or movement input when the player is dead. We are also now calling ``process_respawn``.
 
-.. note:: The ``if !is_dead:`` expression is equivalent and works in the same way as the expression ``if is_dead == false:``. And by removing the ``!`` sign from the expression we obtain the opposite expression ``if is_dead == true:``. It is just a shorter way to write the same code functionality.
+.. note:: The ``if !is_dead:`` expression is equivalent and works in the same way as the expression ``if is_dead == false:``. And by removing the ``!`` sign from the expression we obtain the opposite expression ``if is_dead == true:``. It is just a shorter way of writing the same code functionality.
 
 We have not made ``process_respawn`` yet, so let's change that.
 
@@ -587,7 +587,7 @@ Let's add ``process_respawn``. Add the following to ``Player.gd``:
 
     func process_respawn(delta):
 
-        # If we just died
+        # If we've just died
         if health <= 0 and !is_dead:
             $Body_CollisionShape.disabled = true
             $Feet_CollisionShape.disabled = true
@@ -605,7 +605,7 @@ Let's add ``process_respawn``. Add the following to ``Player.gd``:
 
             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.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
@@ -644,26 +644,26 @@ Let's go through what this function is doing.
 
 ______
 
-First we check to see if the player has just died by checking to see if ``health`` is equal or less than ``0`` and ``is_dead`` is ``false``.
+Firstly, we check whether the player has just died by checking if ``health`` is less than or equal to ``0`` and ``is_dead`` is ``false``.
 
 If the player has just died, we disable the collision shapes for the player. We do this to make sure the player is not blocking anything with their dead body.
 
-Next we set ``changing_weapon`` to ``true`` and set ``changing_weapon_name`` to ``UNARMED``. This is so if the player is using a weapon, it is put away
-when the player dies.
+Next, we set ``changing_weapon`` to ``true`` and set ``changing_weapon_name`` to ``UNARMED``. This is so, if the player is using a weapon, it is put away
+when they dies.
 
 We then make the ``Death_Screen`` :ref:`ColorRect <class_ColorRect>` visible so the player gets a nice grey overlay over everything when they have died.
 We then make the rest of the UI, the ``Panel`` and ``Crosshair`` nodes, invisible.
 
-Next we set ``dead_time`` to ``RESPAWN_TIME`` so we can start counting down how long the player has been dead. We also set ``is_dead`` to ``true`` so we know the player has died.
+Next, we set ``dead_time`` to ``RESPAWN_TIME`` so we can start counting down how long the player has been dead. We also set ``is_dead`` to ``true`` so we know the player has died.
 
-If the player is holding an object when they died, we need to throw it. We first check to see if the player is holding an object or not.
+If the player is holding an object when they died, we need to throw it. We first check whether the player is holding an object or not.
 If the player is holding a object, we throw it using the same code as the throwing code we added in :ref:`doc_fps_tutorial_part_five`.
 
-.. note:: The ``\n`` combination from the expression ``You have died\n`` is a command used to display the text following after it on a new line below. This is always useful when you wand to nicely group displayed text in multiple lines so it looks better and is more readable by the players of your games.
+.. note:: The ``\n`` combination from the expression ``You have died\n`` is a command used to display the text following after it on a new line below. This is always useful when you want to nicely group displayed text in multiple lines so it looks better and is more readable by the players of your games.
 
 ______
 
-Then we check to see if the player is dead. If the player is dead, we then remove ``delta`` from ``dead_time``.
+Then we check whether the player is dead. If so, we then remove ``delta`` from ``dead_time``.
 
 We then make a new variable called ``dead_time_pretty``, where we convert ``dead_time`` to a string, using only the first three characters starting from the left. This gives
 the player a nice looking string showing how much time the player has left to wait before the player can respawn.
@@ -676,11 +676,11 @@ If the player has waited long enough to respawn, we set the player's position to
 
 We then enable both of the player's collision shapes so the player can collide again with the environment.
 
-Next we make the ``Death_Screen`` invisible and make the rest of the UI, the ``Panel`` and ``Crosshair`` nodes, visible again.
+Next, we make the ``Death_Screen`` invisible and make the rest of the UI, the ``Panel`` and ``Crosshair`` nodes, visible again.
 
 We then go through each weapon and call its ``reset_weapon`` function, which we will add soon.
 
-Then we reset ``health`` to ``100``, ``grenade_amounts`` to its default values, and change ``current_grenade`` to ``Grenade``.
+Then, we reset ``health`` to ``100``, ``grenade_amounts`` to its default values, and change ``current_grenade`` to ``Grenade``.
 This effectively resets these variables to their default values.
 
 Finally, we set ``is_dead`` to ``false``.
@@ -694,12 +694,12 @@ Before we leave ``Player.gd``, we need to add one quick thing to ``_input``. Add
     if is_dead:
         return
 
-Now when the player is dead, the player cannot look around with the mouse.
+Now, when the player is dead, they cannot look around with the mouse.
 
 Finishing the respawn system
 ----------------------------
 
-First let's open ``Weapon_Pistol.gd`` and add the ``reset_weapon`` function. Add the following:
+Firstly, let's open ``Weapon_Pistol.gd`` and add the ``reset_weapon`` function. Add the following:
 
 ::
 
@@ -707,7 +707,7 @@ First let's open ``Weapon_Pistol.gd`` and add the ``reset_weapon`` function. Add
         ammo_in_weapon = 10
         spare_ammo = 20
 
-Now when we call ``reset_weapon``, the ammo in the pistol and the ammo in the spares will be reset to their default values.
+Now, when we call ``reset_weapon``, the ammo in the pistol and the ammo in the spares will be reset to their default values.
 
 Now let's add ``reset_weapon`` in ``Weapon_Rifle.gd``:
 
@@ -725,17 +725,17 @@ And add the following to ``Weapon_Knife.gd``:
         ammo_in_weapon = 1
         spare_ammo = 1
 
-Now all of the weapons will reset when the player dies.
+Now all the weapons will reset when the player dies.
 
 ______
 
-Now we need to add a few things to ``Globals.gd``. First, add the following class variable:
+Now we need to add a few things to ``Globals.gd``. Firstly, add the following class variable:
 
 ::
 
     var respawn_points = null
 
-* ``respawn_points``: A variable to hold all of the respawn points in a level
+* ``respawn_points``: A variable to hold all the respawn points in a level
 
 Because we're getting a random spawn point each time, we need to randomize the number generator. Add the following to ``_ready``:
 
@@ -743,7 +743,7 @@ Because we're getting a random spawn point each time, we need to randomize the n
 
     randomize()
 
-``randomize`` will get us a new random seed so we get a (relatively) random string of numbers when we using any of the random functions.
+``randomize`` will get us a new random seed so we get a (relatively) random string of numbers when we use any of the random functions.
 
 Now let's add ``get_respawn_position`` to ``Globals.gd``:
 
@@ -753,14 +753,14 @@ Now let's add ``get_respawn_position`` to ``Globals.gd``:
         if respawn_points == null:
             return Vector3(0, 0, 0)
         else:
-            var respawn_point = rand_range(0, respawn_points.size()-1)
+            var respawn_point = rand_range(0, respawn_points.size() - 1)
             return respawn_points[respawn_point].global_transform.origin
 
 Let's go over what this function does.
 
 ______
 
-First we check to see if ``Globals.gd`` has any ``respawn_points`` by checking to see if ``respawn_points`` is ``null`` or not.
+Firstly, we check if ``Globals.gd`` has any ``respawn_points`` by checking whether ``respawn_points`` is ``null`` or not.
 
 If ``respawn_points`` is ``null``, we return a position of empty :ref:`Vector 3 <class_Vector3>` with the position ``(0, 0, 0)``.
 
@@ -771,7 +771,7 @@ We then return the position of the :ref:`Spatial <class_Spatial>` node at ``resp
 
 ______
 
-Before we are done with ``Globals.gd``. We need to add the following to ``load_new_scene``:
+Before we are done with ``Globals.gd``, we need to add the following to ``load_new_scene``:
 
 ::
 
@@ -793,7 +793,7 @@ Now all we need is a way to set the respawn points. Open up ``Ruins_Level.tscn``
         var globals = get_node("/root/Globals")
         globals.respawn_points = get_children()
 
-Now when a node with ``Respawn_Point_Setter.gd`` has its ``_ready`` function called, all of the children
+Now, when a node with ``Respawn_Point_Setter.gd`` has its ``_ready`` function called, all the children
 nodes of the node with ``Respawn_Point_Setter.gd``, ``Spawn_Points`` in the case of ``Ruins_Level.tscn``, will be added
 to ``respawn_points`` in ``Globals.gd``.
 
@@ -802,7 +802,7 @@ to ``respawn_points`` in ``Globals.gd``.
 
 ______
 
-Now when the player dies, they will respawn after waiting ``4`` seconds!
+Now, when the player dies, they will respawn after waiting ``4`` seconds!
 
 .. note:: No spawn points are already set up for any of the levels besides ``Ruins_Level.tscn``!
           Adding spawn points to ``Space_Level.tscn`` is left as an exercise for the reader.
@@ -810,9 +810,9 @@ Now when the player dies, they will respawn after waiting ``4`` seconds!
 Writing a sound system we can use anywhere
 ------------------------------------------
 
-Finally, lets make a sound system so we can play sounds from anywhere, without having to use the player.
+Finally, let's make a sound system so we can play sounds from anywhere, without having to use the player.
 
-First, open up ``SimpleAudioPlayer.gd`` and change it to the following:
+Firstly, open up ``SimpleAudioPlayer.gd`` and change it to the following:
 
 ::
 
@@ -832,16 +832,17 @@ First, open up ``SimpleAudioPlayer.gd`` and change it to the following:
 
     func play_sound(audio_stream, position=null):
         if audio_stream == null:
-            print ("No audio stream passed, cannot play sound")
+            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 a AudioPlayer3D, then uncomment these lines to set the position.
-        #if position != null:
-        #    audio_node.global_transform.origin = position
+        # 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)
 
@@ -868,12 +869,12 @@ Let's go over the changes.
 
 ______
 
-For the class variables we removed all of the ``audio_[insert name here]`` variables since we will instead have these passed in from ``Globals.gd``.
+For the class variables, we removed all the ``audio_[insert name here]`` variables since we will instead have these passed in from ``Globals.gd``.
 
 We also added two new class variables, ``should_loop`` and ``globals``. We'll use ``should_loop`` to tell whether the audio player should loop when the sound has
 finished, and ``globals`` will hold the ``Globals.gd`` singleton.
 
-The only change in ``_ready`` is now audio player is getting the ``Globals.gd`` singleton and assigning it to ``globals``
+The only change in ``_ready`` is now audio player is getting the ``Globals.gd`` singleton and assigning it to ``globals``.
 
 ``play_sound`` now expects an audio stream, named ``audio_stream``, to be passed in, instead of ``sound_name``. Instead of checking the
 sound name and setting the stream for the audio player, we instead check to make sure an audio stream was passed in. If an audio stream was not passed
@@ -889,7 +890,7 @@ Now that we've finished our changes to ``SimpleAudioPlayer.gd``, we now need to
 
 ::
 
-    # All of the audio files.
+    # All the audio files.
 
     # You will need to provide your own sound files.
     var audio_clips = {
@@ -901,11 +902,11 @@ Now that we've finished our changes to ``SimpleAudioPlayer.gd``, we now need to
     const SIMPLE_AUDIO_PLAYER_SCENE = preload("res://Simple_Audio_Player.tscn")
     var created_audio = []
 
-Lets go over these global variables.
+Let's go over these global variables.
 
-* ``audio_clips``: A dictionary holding all of the audio clips ``Globals.gd`` can play.
+* ``audio_clips``: A dictionary holding all the audio clips ``Globals.gd`` can play.
 * ``SIMPLE_AUDIO_PLAYER_SCENE``: The simple audio player scene.
-* ``created_audio``: A list to hold all of the simple audio players ``Globals.gd`` has created
+* ``created_audio``: A list to hold all the simple audio players ``Globals.gd`` has created.
 
 .. note:: If you want to add additional audio, you need to add it to ``audio_clips``. No audio files are provided in this tutorial,
           so you will have to provide your own.
@@ -939,7 +940,7 @@ Now we need to add a new function called ``play_sound`` to ``Globals.gd``:
 
 Let's go over what this function does.
 
-First we check to see if ``Globals.gd`` has an audio clip with the name ``sound_name`` in ``audio_clips``. If it does not, we print an error message.
+Firstly, we check whether ``Globals.gd`` has an audio clip with the name ``sound_name`` in ``audio_clips``. If it does not, we print an error message.
 
 If ``Globals.gd`` has an audio clip with the name ``sound_name``, we then instance/spawn a new ``SIMPLE_AUDIO_PLAYER_SCENE`` and assign it to ``new_audio``.
 
@@ -951,7 +952,7 @@ We then call ``play_sound``, passing in the audio clip associated with ``sound_n
 
 ______
 
-Before we leave ``Globals.gd``, we need to add a few lines of code to ``load_new_scene`` so when the player changes scenes, all of the audio is destroyed.
+Before we leave ``Globals.gd``, we need to add a few lines of code to ``load_new_scene`` so when the player changes scenes, all the audio is destroyed.
 
 Add the following to ``load_new_scene``:
 
@@ -962,12 +963,12 @@ Add the following to ``load_new_scene``:
             sound.queue_free()
     created_audio.clear()
 
-Now before ``Globals.gd`` changes scenes, it goes through each simple audio player in ``created_sounds`` and frees/destroys them. Once ``Globals.gd`` has gone through
-all of the sounds in ``created_audio``, we clear ``created_audio`` so it no longer holds any references to any (noew freed/destroyed) simple audio players.
+Now, before ``Globals.gd`` changes scenes, it goes through each simple audio player in ``created_sounds`` and frees/destroys them. Once ``Globals.gd`` has gone through
+all the sounds in ``created_audio``, we clear ``created_audio`` so it no longer holds any references to any (now freed/destroyed) simple audio players.
 
 ______
 
-Let's change ``create_sound`` in ``Player.gd`` to use this new system. First, remove ``simple_audio_player`` from ``Player.gd``'s class variables, since we will
+Let's change ``create_sound`` in ``Player.gd`` to use this new system. First, remove ``simple_audio_player`` from ``Player.gd``'s class variables since we will
 no longer be directly instancing/spawning sounds in ``Player.gd``.
 
 Now, change ``create_sound`` to the following:
@@ -977,17 +978,17 @@ Now, change ``create_sound`` to the following:
     func create_sound(sound_name, position=null):
         globals.play_sound(sound_name, false, position)
 
-Now whenever ``create_sound`` is called, we simply call ``play_sound`` in ``Globals.gd``, passing in all of the arguments received.
+Now, whenever ``create_sound`` is called, we simply call ``play_sound`` in ``Globals.gd``, passing in all the arguments received.
 
 ______
 
-Now all of the sounds in our FPS can be played from anywhere. All we have to do is get the ``Globals.gd`` singleton, and call ``play_sound``, pass in the name of the sound
-we want to play, whether we want it to loop or not, and the position to play the sound from.
+Now all the sounds in our FPS can be played from anywhere. All we have to do is get the ``Globals.gd`` singleton, and call ``play_sound``, pass in the name of the sound
+we want to play, whether we want it to loop or not, and the position from which to play the sound.
 
-For example, if you want to play an explosion sound when the grenades explodes you'd need to add a new sound to ``audio_clips`` in ``Globals.gd``,
+For example, if you want to play an explosion sound when the grenade explodes you'd need to add a new sound to ``audio_clips`` in ``Globals.gd``,
 get the ``Globals.gd`` singleton, and then you just need to add something like
 ``globals.play_sound("explosion", false, global_transform.origin)`` in the grenades
-``_process`` function, right after the grenade damages all of the bodies within its blast radius.
+``_process`` function, right after the grenade damages all the bodies within its blast radius.
 
 Final notes
 -----------
@@ -996,13 +997,13 @@ Final notes
 
 Now you have a fully working single player FPS!
 
-At this point you have a good base to build more complicated FPS games.
+At this point, you have a good base to build more complicated FPS games.
 
 .. warning:: If you ever get lost, be sure to read over the code again!
 
              You can download the finished project for the entire tutorial here: :download:`Godot_FPS_Part_6.zip <files/Godot_FPS_Finished.zip>`
 
-.. note:: The finished project source files contain the same exact code, just written in a different order.
+.. note:: The finished project source files contain the same code, just written in a different order.
           This is because the finished project source files are what the tutorial is based on.
 
           The finished project code was written in the order that features were created, not necessarily
@@ -1016,9 +1017,9 @@ At this point you have a good base to build more complicated FPS games.
          **Please note that the code in Github may or may not be in sync with the tutorial in the documentation**.
 
          The code in the documentation is likely better managed and/or more up to date.
-         If you are unsure on which to use, use the project(s) provided in the documentation as they are maintained by the Godot community.
+         If you are unsure of which to use, use the project(s) provided in the documentation, as they are maintained by the Godot community.
 
-You can download all of the ``.blend`` files used in this tutorial here: :download:`Godot_FPS_BlenderFiles.zip <files/Godot_FPS_BlenderFiles.zip>`
+You can download all the ``.blend`` files used in this tutorial here: :download:`Godot_FPS_BlenderFiles.zip <files/Godot_FPS_BlenderFiles.zip>`
 
 All assets provided in the started assets (unless otherwise noted) were **originally created by TwistedTwigleg, with changes/additions by the Godot community.**
 All original assets provided for this tutorial are released under the ``MIT`` license.