Fixed code tags for true/false/null and a few property references

getting_started/scripting/c_sharp/c_sharp_features.rst

@@ -33,7 +33,7 @@ You would use it instead of the ``as`` operator if you are pretty sure it won't
 
 **Using the AS operator**
 
-The ``as`` operator returns null if the node cannot be cast to Sprite,
+The ``as`` operator returns ``null`` if the node cannot be cast to Sprite,
 and for that reason, it cannot be used with value types.
 
 .. code-block:: csharp

getting_started/scripting/visual_script/nodes_purposes.rst

@@ -330,7 +330,7 @@ given condition.
 Condition
 ^^^^^^^^^
 
-This is a simple node that checks a bool port. If true, it will go via the "true" sequence port. If false,
+This is a simple node that checks a bool port. If ``true``, it will go via the "true" sequence port. If ``false``,
 the second. After going for either of them, it goes via the "done" port. Leaving sequence
 ports disconnected is fine if not all of them are used.
 

getting_started/step_by_step/singletons_autoload.rst

@@ -70,7 +70,7 @@ This means that any node can access a singleton named "PlayerVariables" with:
     var playerVariables = (PlayerVariables)GetNode("/root/PlayerVariables");
     playerVariables.Health -= 10; // Instance field.
 
-If the "Enable" column is checked (default true) then the singleton can simply
+If the "Enable" column is checked (default ``true``) then the singleton can simply
 be accessed directly:
 
 .. tabs::

tutorials/3d/fps_tutorial/part_five.rst

@@ -271,7 +271,7 @@ If the body the sticky grenade has collided with is indeed ``player_body``, we i
 
 Next, we check if the sticky grenade has attached to something already or not.
 
-If the sticky grenade is not attached, we then set ``attached`` to true so we know the sticky grenade has attached to something.
+If the sticky grenade is not attached, we then set ``attached`` to ``true`` so we know the sticky grenade has attached to something.
 
 We then make a new :ref:`Spatial <class_Spatial>` node, and make it a child of the body the sticky grenade collided with. We then set the :ref:`Spatial <class_Spatial>`'s position
 to the sticky grenade's current global position.

tutorials/3d/fps_tutorial/part_one.rst

@@ -779,7 +779,7 @@ Now we need to change some of the code in ``process_input``. Add the following s
 
 Let's go over the additions:
 
-We set ``is_sprinting`` to true when the player is holding down the ``movement_sprint`` action, and false
+We set ``is_sprinting`` to ``true`` when the player is holding down the ``movement_sprint`` action, and ``false``
 when the ``movement_sprint`` action is released. In ``process_movement`` we'll add the code that makes the player faster when
 they sprint. Here in ``process_input`` we are just going to change the ``is_sprinting`` variable.
 

tutorials/3d/fps_tutorial/part_two.rst

@@ -1055,13 +1055,13 @@ the player has and it ensures ``weapon_change_number`` is ``0`` or more.
 
 Then we check to make sure the player is not already changing weapons. If the player is not, we then check to see if the weapon the player wants to change to
 is a new weapon and not the weapon the player is currently using. If the weapon the player is wanting to change to is a new weapon, we then set ``changing_weapon_name`` to
-the weapon at ``weapon_change_number`` and set ``changing_weapon`` to true.
+the weapon at ``weapon_change_number`` and set ``changing_weapon`` to ``true``.
 
 For firing the weapon we first check to see if the ``fire`` action is pressed.
 Then we check to make sure the player is not changing weapons.
 Next we get the weapon node for the current weapon.
 
-If the current weapon node does not equal null, and the player is in its ``IDLE_ANIM_NAME`` state, we set the player's animation
+If the current weapon node does not equal ``null``, and the player is in its ``IDLE_ANIM_NAME`` state, we set the player's animation
 to the current weapon's ``FIRE_ANIM_NAME``.
 
 _________

tutorials/3d/vertex_animation/controlling_thousands_of_fish.rst

@@ -61,7 +61,7 @@ and no others.
 First we will distinguish between code that needs to be run only when the particle system starts
 and code that should always run. We want to give each fish a random position and a random animation
 offset when the system is first run so we wrap that code in an ``if`` statement that checks the 
-built-in variable ``RESTART`` which becomes true for one frame when the particle system is restarted.
+built-in variable ``RESTART`` which becomes ``true`` for one frame when the particle system is restarted.
 
 From a high level, this looks like:
 

tutorials/io/background_loading.rst

@@ -243,7 +243,7 @@ Remove a resource from the queue, discarding any loading done.
 
     func is_ready(path)
 
-Returns true if a resource is fully loaded and ready to be retrieved.
+Returns ``true`` if a resource is fully loaded and ready to be retrieved.
 
 ::
 
@@ -259,8 +259,8 @@ actually ready.
 
     func get_resource(path)
 
-Returns the fully loaded resource, or null on error. If the resource is
-not fully loaded (``is_ready`` returns false), it will block your thread
+Returns the fully loaded resource, or ``null`` on error. If the resource is
+not fully loaded (``is_ready`` returns ``false``), it will block your thread
 and finish the load. If the resource is not on the queue, it will call
 ``ResourceLoader::load`` to load it normally and return it.
 

tutorials/networking/high_level_multiplayer.rst

@@ -342,9 +342,9 @@ The network master of a node is the peer that has the ultimate authority over it
 When not explicitly set, the network master is inherited from the parent node, which if not changed, is always going to be the server (ID 1). Thus the server has authority over all nodes by default.
 
 The network master can be set
-with the function :ref:`Node.set_network_master(id, recursive) <class_Node_method_set_network_master>` (recursive is true by default and means the network master is recursively set on all child nodes of the node as well).
+with the function :ref:`Node.set_network_master(id, recursive) <class_Node_method_set_network_master>` (recursive is ``true`` by default and means the network master is recursively set on all child nodes of the node as well).
 
-Checking that a specific node instance on a peer is the network master for this node for all connected peers is done by calling :ref:`Node.is_network_master() <class_Node_method_is_network_master>`. This will return true when executed on the server and false on all client peers.
+Checking that a specific node instance on a peer is the network master for this node for all connected peers is done by calling :ref:`Node.is_network_master() <class_Node_method_is_network_master>`. This will return ``true`` when executed on the server and ``false`` on all client peers.
 
 If you have paid attention to the previous example, it's possible you noticed that each peer was set to have network master authority for their own player (Node) instead of the server:
 

tutorials/plugins/editor/making_main_screen_plugins.rst

@@ -66,7 +66,7 @@ file. In our example, ``main_screen_plugin.gd``.
        return "Main Screen Plugin"
 
 The important part in this script is the ``has_main_screen()`` function, which is
-overloaded so it returns true. This function is automatically called by the
+overloaded so it returns ``true``. This function is automatically called by the
 editor on plugin activation, to tell it that this plugin adds a new center view to
 the editor. For now, we'll leave this script as-is and we'll come back to it
 later.

tutorials/shading/shading_reference/canvas_item_shader.rst

@@ -104,7 +104,7 @@ is usually:
 +--------------------------------+----------------------------------------------------------------+
 | in vec4 **INSTANCE_CUSTOM**    | Instance custom data.                                          |
 +--------------------------------+----------------------------------------------------------------+
-| in bool **AT_LIGHT_PASS**      | True if this is a light pass.                                  |
+| in bool **AT_LIGHT_PASS**      | ``true`` if this is a light pass.                              |
 +--------------------------------+----------------------------------------------------------------+
 | inout vec2 **VERTEX**          | Vertex, in image space.                                        |
 +--------------------------------+----------------------------------------------------------------+
@@ -175,7 +175,7 @@ it to the ``NORMALMAP`` property. Godot will handle converting it for use in 2D
 +----------------------------------+----------------------------------------------------------------+
 | in float **TIME**                | Global time in seconds.                                        |
 +----------------------------------+----------------------------------------------------------------+
-| in bool **AT_LIGHT_PASS**        | True if this is a light pass.                                  |
+| in bool **AT_LIGHT_PASS**        | ``true`` if this is a light pass.                              |
 +----------------------------------+----------------------------------------------------------------+
 | in sampler2D **SCREEN_TEXTURE**  | Screen texture, mipmaps contain gaussian blurred versions.     |
 +----------------------------------+----------------------------------------------------------------+

tutorials/shading/shading_reference/particle_shader.rst

@@ -56,9 +56,9 @@ to ``true``. In a ShaderMaterial, access it with the ``COLOR`` variable.
 +---------------------------------+-------------------------------------------------------------------------------------+
 | out float **MASS**              | Particle mass, use for attractors (not implemented in 3.1).                         |
 +---------------------------------+-------------------------------------------------------------------------------------+
-| inout bool **ACTIVE**           | True when Particle is active, can be set to false.                                  |
+| inout bool **ACTIVE**           | ``true`` when Particle is active, can be set to ``false``.                          |
 +---------------------------------+-------------------------------------------------------------------------------------+
-| in bool **RESTART**             | True when particle must restart (lifetime cycled).                                  |
+| in bool **RESTART**             | ``true`` when particle must restart (lifetime cycled).                              |
 +---------------------------------+-------------------------------------------------------------------------------------+
 | inout vec4 **CUSTOM**           | Custom particle data. Accessible from shader of mesh as **INSTANCE_CUSTOM**.        |
 +---------------------------------+-------------------------------------------------------------------------------------+

tutorials/shading/shading_reference/shading_language.rst

@@ -22,7 +22,7 @@ Most GLSL ES 3.0 datatypes are supported:
 +=====================+=================================================================================+
 | **void**            | Void datatype, useful only for functions that return nothing.                   |
 +---------------------+---------------------------------------------------------------------------------+
-| **bool**            | Boolean datatype, can only contain "true" or "false".                           |
+| **bool**            | Boolean datatype, can only contain ``true`` or ``false``.                       |
 +---------------------+---------------------------------------------------------------------------------+
 | **bvec2**           | Two-component vector of booleans.                                               |
 +---------------------+---------------------------------------------------------------------------------+
@@ -702,9 +702,9 @@ When vec_type (float), vec_int_type, vec_uint_type, vec_bool_type nomenclature i
 +----------------------------------------------------------------------------+--------------------------------------------------+
 | bvec_type **notEqual** ( vec_type x, vec_type y )                          | Bool vector cmp on != int/uint/float vectors     |
 +----------------------------------------------------------------------------+--------------------------------------------------+
-| bool **any** ( bvec_type x )                                               | Any component is true                            |
+| bool **any** ( bvec_type x )                                               | Any component is ``true``                        |
 +----------------------------------------------------------------------------+--------------------------------------------------+
-| bool **all** ( bvec_type x )                                               | All components are true                          |
+| bool **all** ( bvec_type x )                                               | All components are ``true``                      |
 +----------------------------------------------------------------------------+--------------------------------------------------+
 | bvec_type **not** ( bvec_type x )                                          | Invert boolean vector                            |
 +----------------------------------------------------------------------------+--------------------------------------------------+

tutorials/shading/shading_reference/spatial_shader.rst

@@ -156,8 +156,8 @@ shader, this value can be used as desired.
 +--------------------------------------+-------------------------------------------------------+
 | inout vec2 **UV2**                   | UV secondary channel.                                 |
 +--------------------------------------+-------------------------------------------------------+
-| in bool **OUTPUT_IS_SRGB**           | True when calculations happen in sRGB color space     |
-|                                      | (true in GLES2, false in GLES3).                      |
+| in bool **OUTPUT_IS_SRGB**           | ``true`` when calculations happen in sRGB color space |
+|                                      | (``true`` in GLES2, ``false`` in GLES3).              |
 +--------------------------------------+-------------------------------------------------------+
 | inout vec4 **COLOR**                 | Color from vertices.                                  |
 +--------------------------------------+-------------------------------------------------------+
@@ -199,7 +199,7 @@ these properties, and if you don't write to them, Godot will optimize away the c
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
 | in vec3 **VIEW**                  | Vector from camera to fragment position (in view space).                                         |
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
-| in bool **FRONT_FACING**          | True if current face is front face.                                                              |
+| in bool **FRONT_FACING**          | ``true`` if current face is front face.                                                          |
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
 | inout vec3 **NORMAL**             | Normal that comes from vertex function (default, in view space).                                 |
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
@@ -215,7 +215,7 @@ these properties, and if you don't write to them, Godot will optimize away the c
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
 | in vec2 **UV2**                   | UV2 that comes from vertex function.                                                             |
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
-| in bool **OUTPUT_IS_SRGB**        | True when calculations happen in sRGB color space (true in GLES2, false in GLES3).               |
+| in bool **OUTPUT_IS_SRGB**        | ``true`` when calculations happen in sRGB color space (``true`` in GLES2, ``false`` in GLES3).   |
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
 | in vec4 **COLOR**                 | COLOR that comes from vertex function.                                                           |
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
@@ -288,55 +288,55 @@ Below is an example of a custom light function using a Lambertian lighting model
 
 If you want the lights to add together, add the light contribution to ``DIFFUSE_LIGHT`` using ``+=``, rather than overwriting it.
 
-+-----------------------------------+---------------------------------------------+
-| Built-in                          | Description                                 |
-+===================================+=============================================+
-| in float **TIME**                 | Elapsed total time in seconds.              |
-+-----------------------------------+---------------------------------------------+
-| in vec2 **VIEWPORT_SIZE**         | Size of viewport (in pixels).               |
-+-----------------------------------+---------------------------------------------+
-| in vec4 **FRAGCOORD**             | Coordinate of pixel center in screen space. |
-|                                   | ``xy`` specifies position in window, ``z``  |
-|                                   | specifies fragment depth if ``DEPTH`` is    |
-|                                   | not used. Origin is lower-left.             |
-+-----------------------------------+---------------------------------------------+
-| in mat4 **WORLD_MATRIX**          | Model space to world space transform.       |
-+-----------------------------------+---------------------------------------------+
-| in mat4 **INV_CAMERA_MATRIX**     | World space to view space transform.        |
-+-----------------------------------+---------------------------------------------+
-| in mat4 **CAMERA_MATRIX**         | View space to world space transform.        |
-+-----------------------------------+---------------------------------------------+
-| in mat4 **PROJECTION_MATRIX**     | View space to clip space transform.         |
-+-----------------------------------+---------------------------------------------+
-| in mat4 **INV_PROJECTION_MATRIX** | Clip space to view space transform.         |
-+-----------------------------------+---------------------------------------------+
-| in vec3 **NORMAL**                | Normal vector, in view space.               |
-+-----------------------------------+---------------------------------------------+
-| in vec2 **UV**                    | UV that comes from vertex function.         |
-+-----------------------------------+---------------------------------------------+
-| in vec2 **UV2**                   | UV2 that comes from vertex function.        |
-+-----------------------------------+---------------------------------------------+
-| in vec3 **VIEW**                  | View vector, in view space.                 |
-+-----------------------------------+---------------------------------------------+
-| in vec3 **LIGHT**                 | Light Vector, in view space.                |
-+-----------------------------------+---------------------------------------------+
-| in vec3 **ATTENUATION**           | Attenuation based on distance or shadow.    |
-+-----------------------------------+---------------------------------------------+
-| in bool **OUTPUT_IS_SRGB**        | True when calculations happen in sRGB       |
-|                                   | color space (true in GLES2, false in GLES3).|
-+-----------------------------------+---------------------------------------------+
-| in vec3 **ALBEDO**                | Base albedo.                                |
-+-----------------------------------+---------------------------------------------+
-| in vec3 **LIGHT_COLOR**           | Color of light multiplied by energy.        |
-+-----------------------------------+---------------------------------------------+
-| out float **ALPHA**               | Alpha (0..1); if written to, the material   |
-|                                   | will go to the transparent pipeline.        |
-+-----------------------------------+---------------------------------------------+
-| in float **ROUGHNESS**            | Roughness.                                  |
-+-----------------------------------+---------------------------------------------+
-| in vec3 **TRANSMISSION**          | Transmission mask from fragment function.   |
-+-----------------------------------+---------------------------------------------+
-| out vec3 **DIFFUSE_LIGHT**        | Diffuse light result.                       |
-+-----------------------------------+---------------------------------------------+
-| out vec3 **SPECULAR_LIGHT**       | Specular light result.                      |
-+-----------------------------------+---------------------------------------------+
++-----------------------------------+-----------------------------------------------------+
+| Built-in                          | Description                                         |
++===================================+=====================================================+
+| in float **TIME**                 | Elapsed total time in seconds.                      |
++-----------------------------------+-----------------------------------------------------+
+| in vec2 **VIEWPORT_SIZE**         | Size of viewport (in pixels).                       |
++-----------------------------------+-----------------------------------------------------+
+| in vec4 **FRAGCOORD**             | Coordinate of pixel center in screen space.         |
+|                                   | ``xy`` specifies position in window, ``z``          |
+|                                   | specifies fragment depth if ``DEPTH`` is not used.  |
+|                                   | Origin is lower-left.                               |
++-----------------------------------+-----------------------------------------------------+
+| in mat4 **WORLD_MATRIX**          | Model space to world space transform.               |
++-----------------------------------+-----------------------------------------------------+
+| in mat4 **INV_CAMERA_MATRIX**     | World space to view space transform.                |
++-----------------------------------+-----------------------------------------------------+
+| in mat4 **CAMERA_MATRIX**         | View space to world space transform.                |
++-----------------------------------+-----------------------------------------------------+
+| in mat4 **PROJECTION_MATRIX**     | View space to clip space transform.                 |
++-----------------------------------+-----------------------------------------------------+
+| in mat4 **INV_PROJECTION_MATRIX** | Clip space to view space transform.                 |
++-----------------------------------+-----------------------------------------------------+
+| in vec3 **NORMAL**                | Normal vector, in view space.                       |
++-----------------------------------+-----------------------------------------------------+
+| in vec2 **UV**                    | UV that comes from vertex function.                 |
++-----------------------------------+-----------------------------------------------------+
+| in vec2 **UV2**                   | UV2 that comes from vertex function.                |
++-----------------------------------+-----------------------------------------------------+
+| in vec3 **VIEW**                  | View vector, in view space.                         |
++-----------------------------------+-----------------------------------------------------+
+| in vec3 **LIGHT**                 | Light Vector, in view space.                        |
++-----------------------------------+-----------------------------------------------------+
+| in vec3 **ATTENUATION**           | Attenuation based on distance or shadow.            |
++-----------------------------------+-----------------------------------------------------+
+| in bool **OUTPUT_IS_SRGB**        | ``true`` when calculations happen in sRGB color     |
+|                                   | space (``true`` in GLES2, ``false`` in GLES3).      |
++-----------------------------------+-----------------------------------------------------+
+| in vec3 **ALBEDO**                | Base albedo.                                        |
++-----------------------------------+-----------------------------------------------------+
+| in vec3 **LIGHT_COLOR**           | Color of light multiplied by energy.                |
++-----------------------------------+-----------------------------------------------------+
+| out float **ALPHA**               | Alpha (0..1); if written to, the material will go   |
+|                                   | to the transparent pipeline.                        |
++-----------------------------------+-----------------------------------------------------+
+| in float **ROUGHNESS**            | Roughness.                                          |
++-----------------------------------+-----------------------------------------------------+
+| in vec3 **TRANSMISSION**          | Transmission mask from fragment function.           |
++-----------------------------------+-----------------------------------------------------+
+| out vec3 **DIFFUSE_LIGHT**        | Diffuse light result.                               |
++-----------------------------------+-----------------------------------------------------+
+| out vec3 **SPECULAR_LIGHT**       | Specular light result.                              |
++-----------------------------------+-----------------------------------------------------+

tutorials/viewports/viewports.rst

@@ -149,7 +149,7 @@ following code:
    # Set Sprite Texture.
    $sprite.texture = tex
 
-But if you use this in _ready() or from the first frame of the :ref:`Viewport's <class_Viewport>` initialization,
+But if you use this in ``_ready()`` or from the first frame of the :ref:`Viewport's <class_Viewport>` initialization,
 you will get an empty texture because there is nothing to get as texture. You can deal with
 it using (for example):
 
@@ -167,7 +167,7 @@ If the :ref:`Viewport <class_Viewport>` is a child of a :ref:`ViewportContainer
 .. image:: img/container.png
 
 The :ref:`Viewport <class_Viewport>` will cover the area of its parent :ref:`ViewportContainer <class_viewportcontainer>` completely
-if stretch is set to true in :ref:`ViewportContainer <class_viewportcontainer>`.
+if :ref:`Stretch<class_viewportcontainer_property_stretch>` is set to ``true`` in :ref:`ViewportContainer <class_viewportcontainer>`.
 Note: The size of the :ref:`ViewportContainer <class_viewportcontainer>` cannot be smaller than the size of the :ref:`Viewport <class_Viewport>`.
 
 Rendering
@@ -237,7 +237,7 @@ and then selecting the :ref:`Viewport <class_Viewport>` you want to use.
 .. image:: img/texturepath.png
 
 Every frame, the :ref:`Viewport <class_Viewport>`'s texture is cleared away with the default clear color (or a transparent
-color if Transparent BG is set to true). This can be changed by setting Clear Mode to Never or Next Frame.
+color if :ref:`Transparent BG<class_Viewport_property_transparent_bg>` is set to ``true``). This can be changed by setting :ref:`Clear Mode<class_Viewport_property_render_target_clear_mode>` to Never or Next Frame.
 As the name implies, Never means the texture will never be cleared, while next frame will
 clear the texture on the next frame and then set itself to Never.
 

tutorials/vr/vr_primer.rst

@@ -34,9 +34,9 @@ To enable an interface, you execute the following code:
 
 This code finds the interface we wish to use, initializes it and, if that is successful, binds the main viewport to the interface. This last step gives some control over the viewport to the interface, which automatically enables things like stereoscopic rendering on the viewport.
 
-For our mobile VR interface, and any interface where the main input is directly displayed on screen, the main viewport needs to be the viewport where arvr is set to true. But for interfaces that render on an externally attached device, you can use a secondary viewport. In the latter case, a viewport that shows its output on screen will show an undistorted version of the left eye, while showing the fully processed stereoscopic output on the device.
+For our mobile VR interface, and any interface where the main input is directly displayed on screen, the main viewport needs to be the viewport where :ref:`arvr<class_Viewport_property_arvr>` is set to ``true``. But for interfaces that render on an externally attached device, you can use a secondary viewport. In the latter case, a viewport that shows its output on screen will show an undistorted version of the left eye, while showing the fully processed stereoscopic output on the device.
 
-Finally, you should only initialize an interface once; switching scenes and reinitializing interfaces will just introduce a lot of overhead. If you want to turn the headset off temporarily, just disable the viewport or set arvr to false on the viewport. In most scenarios though, you wouldn't disable the headset once you're in VR, this can be disconcerting to the gamer.
+Finally, you should only initialize an interface once; switching scenes and reinitializing interfaces will just introduce a lot of overhead. If you want to turn the headset off temporarily, just disable the viewport or set :ref:`arvr<class_Viewport_property_arvr>` to ``false`` on the viewport. In most scenarios though, you wouldn't disable the headset once you're in VR, this can be disconcerting to the gamer.
 
 New AR/VR nodes
 ---------------

tutorials/vr/vr_starter_tutorial.rst

@@ -471,7 +471,7 @@ Next, we check to see if the collision body the :ref:`Raycast <class_Raycast>` i
 can only teleport on :ref:`StaticBody <class_StaticBody>` nodes. We then check to see if the ``Y`` value returned by the :ref:`Raycast <class_Raycast>`'s
 ``get_collision_normal`` function is more than ``0.85``, which is mostly pointing straight up. This allows the player only to teleport on fairly flat faces pointing upwards.
 
-If all those checks for the teleport :ref:`Raycast <class_Raycast>` return true, we then set ``teleport_pos`` to the collision point, and we move the teleportation
+If all those checks for the teleport :ref:`Raycast <class_Raycast>` return ``true``, we then set ``teleport_pos`` to the collision point, and we move the teleportation
 mesh to ``teleport_pos``.
 
 The next thing we check is to see if the :ref:`ARVRController <class_ARVRController>` is active or not. If the :ref:`ARVRController <class_ARVRController>` is active, then
@@ -823,7 +823,7 @@ Next, we need to add the ``remove_sphere`` function. Add the following to ``Game
 
 What this function does is it subtracts one from ``spheres_left``.
 
-Then, it checks to see whether ``sphere_ui`` is not null, and if it is not, then it calls its ``update_ui`` function, passing in the amount of spheres left.
+Then, it checks to see whether ``sphere_ui`` is not ``null``, and if it is not, then it calls its ``update_ui`` function, passing in the amount of spheres left.
 We'll add the UI code later in this part.
 
 Now that we have destroyable targets, we need a way to destroy them!
@@ -1181,7 +1181,7 @@ Then, we go through everything inside the explosion :ref:`Area <class_Area>`. We
 do not want to explode the bomb with itself. We then check to see whether the bodies have the ``damage`` method/function, and if it does, we call that, while if it does not, we check to
 see if it has the ``apply_impulse`` method/function, and call that instead.
 
-Then, we set ``explode`` to true since the bomb has exploded, and we play a sound.
+Then, we set ``explode`` to ``true`` since the bomb has exploded, and we play a sound.
 
 Next, we check to see if the bomb has exploded, as we need to wait until the explosion :ref:`Particles <class_Particles>` are done.