Merge branch 'master' into 3.2

about/introduction.rst

@@ -76,7 +76,7 @@ attribution to "Juan Linietsky, Ariel Manzur and the Godot Engine community".
 Organization of the documentation
 ---------------------------------
 
-This documentation is organised in five sections with an impressively
+This documentation is organized in five sections with an impressively
 unbalanced distribution of contents – but the way it is split up should be
 relatively intuitive:
 

community/channels.rst

@@ -47,7 +47,7 @@ Social networks
 - `Facebook group <https://www.facebook.com/groups/godotengine/>`_
 - `Twitter (also, #godotengine) <https://twitter.com/godotengine>`_
 - `Reddit <https://www.reddit.com/r/godot>`_
-- `Youtube <https://www.youtube.com/c/GodotEngineOfficial>`_
+- `YouTube <https://www.youtube.com/c/GodotEngineOfficial>`_
 - `Steam <https://steamcommunity.com/app/404790>`_
 
 Forum

community/contributing/code_style_guidelines.rst

@@ -34,16 +34,16 @@ not introducing trailing whitespace or space-based indentation, you should be
 fine. If you plan to contribute regularly however, we strongly advise that you
 setup clang-format locally to check and automatically fix all your commits.
 
-.. warning:: Godot's code style should *not* be applied to thirdparty code,
+.. warning:: Godot's code style should *not* be applied to third-party code,
              i.e. that is included in Godot's source tree but was not written
              specifically for our project. Such code usually come from
              different upstream projects with their own style guides (or lack
              thereof), and don't want to introduce differences that would make
              syncing with upstream repositories harder.
 
-             Thirdparty code is usually included in the ``thirdparty/`` folder
+             Third-party code is usually included in the ``thirdparty/`` folder
              and can thus easily be excluded from formatting scripts. For the
-             rare cases where a thirdparty code snippet needs to be included
+             rare cases where a third-party code snippet needs to be included
              directly within a Godot file, you can use
              ``/* clang-format off */`` and ``/* clang-format on */`` to tell
              clang-format to ignore a chunk of code.
@@ -139,11 +139,11 @@ ones, the following rules should be followed:
   includes should be done with quotes, e.g. ``#include "core/object.h"``. The
   block of Godot header includes should then be followed by an empty line for
   separation.
-- Finally, thirdparty headers (either from ``thirdparty`` or from the system's
+- Finally, third-party headers (either from ``thirdparty`` or from the system's
   include paths) come next and should be included with the < and > symbols, e.g.
-  ``#include <png.h>``. The block of thirdparty headers should also be followed
+  ``#include <png.h>``. The block of third-party headers should also be followed
   by an empty line for separation.
-- Godot and thirdparty headers should be included in the file that requires
+- Godot and third-party headers should be included in the file that requires
   them, i.e. in the `.h` header if used in the declarative code or in the `.cpp`
   if used only in the imperative code.
 
@@ -240,7 +240,7 @@ Java
 Godot's Java code (mostly in ``platform/android``) is also enforced via
 ``clang-format``, so see the instructions above to set it up. Keep in mind that
 this style guide only applies to code written and maintained by Godot, not
-thirdparty code such as the ``java/src/com/google`` subfolder.
+third-party code such as the ``java/src/com/google`` subfolder.
 
 Python
 ------

community/contributing/documentation_guidelines.rst

@@ -52,7 +52,7 @@ reading as follows:
 
 3. Complete all the edits you want to make for that page.
 
-4. Summarise the changes you made in the form at the bottom of the page and
+4. Summarize the changes you made in the form at the bottom of the page and
    click the button labelled **Propose file change** when done.
 
 5. On the following screens, click the **Create pull request** button until you

community/contributing/pr_workflow.rst

@@ -21,7 +21,7 @@ the *master* branch).
 
 We will go together through an example to show the typical workflow and
 associated Git commands. But first, let's have a quick look at the
-organisation of Godot's Git repository.
+organization of Godot's Git repository.
 
 Git source repository
 ---------------------
@@ -442,7 +442,7 @@ will raise an error:
     hint: Updates were rejected because the tip of your current branch is behind
     hint: its remote counterpart.
 
-This is a sane behaviour, Git will not let you push changes that would
+This is a sane behavior, Git will not let you push changes that would
 override remote content. But that's actually what we want to do here, so we
 will have to *force* it:
 

community/contributing/updating_the_class_reference.rst

@@ -79,7 +79,7 @@ You can check the list of all remote servers with:
 
     git remote -v
 
-You should have two: ``origin``, your fork on github, that git adds by default, and ``upstream``, that you just added:
+You should have two: ``origin``, your fork on GitHub, that git adds by default, and ``upstream``, that you just added:
 
 
 ::
@@ -162,7 +162,7 @@ How to edit class XML
 
 Edit the file for your chosen class in ``doc/classes/`` to update the class reference. The folder contains an XML file for each class. The XML lists the constants and methods you'll find in the class reference. Godot generates and updates the XML automatically.
 
-Edit it using your favourite text editor. If you use a code editor, make sure that it doesn't change the indent style: tabs for the XML, and 4 spaces inside BBcode-style blocks. More on that below.
+Edit it using your favorite text editor. If you use a code editor, make sure that it doesn't change the indent style: tabs for the XML, and 4 spaces inside BBcode-style blocks. More on that below.
 
 If you need to check that the modifications you've made are correct in the generated documentation, build Godot as described :ref:`here <toc-devel-compiling>`, run the editor and open the help for the page you modified.
 

community/contributing/ways_to_contribute.rst

@@ -41,7 +41,7 @@ positive to the engine, regardless of their skill set:
    user donations for many things. Apart from usual expenses such as hosting
    costs or promotional material on events, we also use donation money to
    acquire hardware when necessary (e.g. we used donation money to buy a
-   Macbook Pro to implement Retina/HiDPI support and various other
+   MacBook Pro to implement Retina/HiDPI support and various other
    macOS-related features).
    Most importantly, we also used donation money to hire core developers so they
    can work full-time on the engine. Even with a low

development/cpp/custom_audiostreams.rst

@@ -231,7 +231,7 @@ Since AudioStreamPlayback is controlled by the audio thread, i/o and dynamic mem
 Resampling
 ~~~~~~~~~~
 
-Godot’s AudioServer currently uses 44100 Hz sample rate. When other sample rates are
+Godot's AudioServer currently uses 44100 Hz sample rate. When other sample rates are
 needed such as 48000, either provide one or use AudioStreamPlaybackResampled.
 Godot provides cubic interpolation for audio resampling.
 

getting_started/editor/unity_to_godot.rst

@@ -12,7 +12,7 @@ and aims to help you migrate your existing Unity experience into the world of Go
 
 .. note::
 
-   This article talks about older versions of Unity. Nestable prefabs ('Nested prefabs') were added to Unity 2018.3. Nestable prefabs are analogous to Godot's scenes, and allow a more Godot-like approach to scene organisation.
+   This article talks about older versions of Unity. Nestable prefabs ('Nested prefabs') were added to Unity 2018.3. Nestable prefabs are analogous to Godot's scenes, and allow a more Godot-like approach to scene organization.
 
 Differences
 -----------
@@ -28,7 +28,7 @@ Differences
 |                   | * **Mobile:** Android, iOS, Windows Phone, Tizen                                   | * **Mobile:** Android, iOS                                                                                     |
 |                   | * **Web:** WebAssembly or asm.js                                                   | * **Web:** WebAssembly                                                                                         |
 |                   | * **Consoles:** PS4, PS Vita, Xbox One, Xbox 360, Wii U, Nintendo 3DS              | * **Console:** See :ref:`doc_consoles`                                                                         |
-|                   | * **VR:** Oculus Rift, SteamVR, Google Cardboard, Playstation VR, Gear VR, HoloLens| * **VR:** Oculus Rift, SteamVR                                                                                 |
+|                   | * **VR:** Oculus Rift, SteamVR, Google Cardboard, PlayStation VR, Gear VR, HoloLens| * **VR:** Oculus Rift, SteamVR                                                                                 |
 |                   | * **TV:** Android TV, Samsung SMART TV, tvOS                                       |                                                                                                                |
 +-------------------+------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------+
 | Scene system      | * Component/Scene (GameObject > Component)                                         | :ref:`Scene tree and nodes <doc_scenes_and_nodes>`, allowing scenes to be nested and/or inherit other scenes   |
@@ -87,7 +87,7 @@ and debugging/live editing on it after the game is exported.
 The scene system
 ----------------
 
-This is the most important difference between Unity and Godot and the favourite feature of most Godot users.
+This is the most important difference between Unity and Godot and the favorite feature of most Godot users.
 
 Working on a 'level' in Unity usually means embedding all the required assets in a scene
 and linking them together with components and scripts.
@@ -116,14 +116,14 @@ Consider the player as an element we'd like to use in different parent scenes (f
 2. **A scene for the Enemy.**
 
 An enemy is also an element we'd like to use in several scenes. It's almost the same
-as the Player node. The only differences are the script (it needs 'AI' routines to generate the enemy's behaviour)
+as the Player node. The only differences are the script (it needs 'AI' routines to generate the enemy's behavior)
 and the sprite textures used by the AnimatedSprite node.
 
 3. **A Level scene.**
 
 A Level scene is composed of Bricks (for platforms), Coins (for the player to collect) and a
 number of instances of the Enemy scene. Each instance is a node in the Level scene tree. These instances are separate enemies,
-which initially have shared behaviour and appearance as defined in the Enemy scene. You can set different properties for each Enemy node (to change its color, for example).
+which initially have shared behavior and appearance as defined in the Enemy scene. You can set different properties for each Enemy node (to change its color, for example).
 
 4. **A Main scene.**
 The Main scene would be composed of one root node with 2 children: a Player instance node, and a Level instance node.
@@ -202,7 +202,7 @@ please read the :ref:`doc_gdscript` and :ref:`doc_faq` pages. GDScript is strong
 and doesn't take long to learn: Between one evening for an experienced programmer and a week for a complete beginner.
 
 Unity allows you to attach as many scripts as you want to a GameObject.
-Each script adds a behaviour to the GameObject: For example, you can attach a script so that it reacts to the player's controls,
+Each script adds a behavior to the GameObject: For example, you can attach a script so that it reacts to the player's controls,
 and another that controls its specific game logic.
 
 In Godot, you can only attach one script per node. You can use either an external GDScript file

getting_started/scripting/c_sharp/c_sharp_basics.rst

@@ -35,7 +35,7 @@ page in the Mono documentation.
 Setting up C# for Godot
 -----------------------
 
-Windows (Visaul Studio)
+Windows (Visual Studio)
 ~~~~~~~~~~~~~~~~~~~~~~~
 
 Download and install the latest version of

getting_started/scripting/gdscript/static_typing.rst

@@ -23,10 +23,10 @@ A brief look at static typing
 -----------------------------
 
 With typed GDScript, Godot can detect even more errors as you write
-code! It gives you and your teammates more information as you’re
-working, as the arguments’ types show up when you call a method.
+code! It gives you and your teammates more information as you're
+working, as the arguments' types show up when you call a method.
 
-Imagine you’re programming an inventory system. You code an ``Item``
+Imagine you're programming an inventory system. You code an ``Item``
 node, then an ``Inventory``. To add items to the inventory, the people
 who work with your code should always pass an ``Item`` to the
 ``Inventory.add`` method. With types, you can enforce this:
@@ -56,14 +56,14 @@ Static types also give you better code completion options. Below, you
 can see the difference between a dynamic and a static typed completion
 options for a class called ``PlayerController``.
 
-You’ve probably stored a node in a variable before, and typed a dot to
+You've probably stored a node in a variable before, and typed a dot to
 be left with no autocomplete suggestions:
 
 .. figure:: ./img/typed_gdscript_code_completion_dynamic.png
    :alt: code completion options for dynamic
 
 This is due to dynamic code. Godot cannot know what node or value type
-you’re passing to the function. If you write the type explicitly
+you're passing to the function. If you write the type explicitly
 however, you will get all public methods and variables from the node:
 
 .. figure:: ./img/typed_gdscript_code_completion_typed.png
@@ -75,9 +75,9 @@ on the roadmap!
 
 Overall, typed programming gives you a more structured experience. It
 helps prevent errors and improves the self-documenting aspect of your
-scripts. This is especially helpful when you’re working in a team or on
+scripts. This is especially helpful when you're working in a team or on
 a long-term project: studies have shown that developers spend most of
-their time reading other people’s code, or scripts they wrote in the
+their time reading other people's code, or scripts they wrote in the
 past and forgot about. The clearer and the more structured the code, the
 faster it is to understand, the faster you can move forward.
 
@@ -85,7 +85,7 @@ How to use static typing
 ------------------------
 
 To define the type of a variable or a constant, write a colon after the
-variable’s name, followed by its type. E.g. ``var health: int``. This
+variable's name, followed by its type. E.g. ``var health: int``. This
 forces the variable's type to always stay the same:
 
 ::
@@ -169,7 +169,7 @@ to use this type. This forces the variable to stick to the
 
         player.damage()
 
-As we’re dealing with a custom type, if the ``body`` doesn’t extend
+As we're dealing with a custom type, if the ``body`` doesn't extend
 ``PlayerController``, the ``player``\ variable will be set to ``null``.
 We can use this to check if the body is the player or not. We will also
 get full autocompletion on the player variable thanks to that cast.
@@ -184,15 +184,15 @@ Safe lines
 You can also use casting to ensure safe lines. Safe lines are a new
 tool in Godot 3.1 to tell you when ambiguous lines of code are
 type-safe. As you can mix and match typed and dynamic code, at times,
-Godot doesn’t have enough information to know if an instruction will trigger
+Godot doesn't have enough information to know if an instruction will trigger
 an error or not at runtime.
 
-This happens when you get a child node. Let’s take a timer for example:
+This happens when you get a child node. Let's take a timer for example:
 with dynamic code, you can get the node with ``$Timer``. GDScript
 supports `duck-typing <https://stackoverflow.com/a/4205163/8125343>`__,
 so even if your timer is of type ``Timer``, it is also a ``Node`` and an
 ``Object``, two classes it extends. With dynamic GDScript, you also
-don’t care about the node’s type as long as it has the methods you need
+don't care about the node's type as long as it has the methods you need
 to call.
 
 You can use casting to tell Godot the type you expect when you get a
@@ -249,12 +249,12 @@ Typed or dynamic: stick to one style
 
 Typed GDScript and dynamic GDScript can coexist in the same project. But
 I recommended to stick to either style for consistency in your codebase,
-and for your peers. It’s easier for everyone to work together if you
+and for your peers. It's easier for everyone to work together if you
 follow the same guidelines, and faster to read and understand other
-people’s code.
+people's code.
 
 Typed code takes a little more writing, but you get the benefits we
-discussed above. Here’s an example of the same, empty script, in a
+discussed above. Here's an example of the same, empty script, in a
 dynamic style:
 
 ::
@@ -283,8 +283,8 @@ And with static typing:
     func _process(delta: float) -> void:
         pass
 
-As you can see, you can also use types with the engine’s virtual
-methods. Signal callbacks, like any methods, can also use types. Here’s
+As you can see, you can also use types with the engine's virtual
+methods. Signal callbacks, like any methods, can also use types. Here's
 a ``body_entered`` signal in a dynamic style:
 
 ::
@@ -299,7 +299,7 @@ And the same callback, with type hints:
     func _on_area_entered(area: CollisionObject2D) -> void:
         pass
 
-You’re free to replace, e.g. the ``CollisionObject2D``, with your own type,
+You're free to replace, e.g. the ``CollisionObject2D``, with your own type,
 to cast parameters automatically:
 
 ::
@@ -312,13 +312,13 @@ to cast parameters automatically:
 
 The ``bullet`` variable could hold any ``CollisionObject2D`` here, but
 we make sure it is our ``Bullet``, a node we created for our project. If
-it’s anything else, like an ``Area2D``, or any node that doesn’t extend
+it's anything else, like an ``Area2D``, or any node that doesn't extend
 ``Bullet``, the ``bullet`` variable will be ``null``.
 
 Warning system
 --------------
 
-The warning system complements typed GDScript. It’s here to help you
+The warning system complements typed GDScript. It's here to help you
 avoid mistakes that are hard to spot during development, and that may
 lead to runtime errors.
 
@@ -331,7 +331,7 @@ called ``GDScript``:
    warning system project settings
 
 You can find a list of warnings for the active GDScript file in the
-script editor’s status bar. The example below has 3 warnings:
+script editor's status bar. The example below has 3 warnings:
 
 .. figure:: ./img/typed_gdscript_warning_example.png
    :alt: warning system example
@@ -340,8 +340,8 @@ script editor’s status bar. The example below has 3 warnings:
 
 To ignore specific warnings in one file, insert a special comment of the
 form ``# warning-ignore:warning-id``, or click on the ignore link to the
-right of the warning’s description. Godot will add a comment above the
-corresponding line and the code won’t trigger the corresponding warning
+right of the warning's description. Godot will add a comment above the
+corresponding line and the code won't trigger the corresponding warning
 anymore:
 
 .. figure:: ./img/typed_gdscript_warning_system_ignore.png
@@ -353,10 +353,10 @@ You can also choose to ignore not just one but all warnings of a certain
 type in this file with ``# warning-ignore-all:warning-id``. To ignore all
 warnings of all types in a file add the comment ``# warnings-disable`` to it.
 
-Warnings won’t prevent the game from running, but you can turn them into
-errors if you’d like. This way your game won’t compile unless you fix
+Warnings won't prevent the game from running, but you can turn them into
+errors if you'd like. This way your game won't compile unless you fix
 all warnings. Head to the ``GDScript`` section of the Project Settings to
-turn on this option. Here’s the same file as the previous example with
+turn on this option. Here's the same file as the previous example with
 warnings as errors turned on:
 
 .. figure:: ./img/typed_gdscript_warning_system_errors.png
@@ -364,27 +364,27 @@ warnings as errors turned on:
 
    warnings as errors
 
-Cases where you can’t specify types
+Cases where you can't specify types
 -----------------------------------
 
-To wrap up this introduction, let’s cover a few cases where you can’t
+To wrap up this introduction, let's cover a few cases where you can't
 use type hints. All the examples below **will trigger errors**.
 
-You can’t use Enums as types:
+You can't use Enums as types:
 
 ::
 
     enum MoveDirection {UP, DOWN, LEFT, RIGHT}
     var current_direction: MoveDirection
 
-You can’t specify the type of individual members in an array. This will
+You can't specify the type of individual members in an array. This will
 give you an error:
 
 ::
 
     var enemies: Array = [$Goblin: Enemy, $Zombie: Enemy]
 
-You can’t force the assignment of types in a ``for`` loop, as each
+You can't force the assignment of types in a ``for`` loop, as each
 element the ``for`` keyword loops over already has a different type. So you
 **cannot** write:
 
@@ -394,7 +394,7 @@ element the ``for`` keyword loops over already has a different type. So you
     for name: String in names:
         pass
 
-Two scripts can’t depend on each other in a cyclic fashion:
+Two scripts can't depend on each other in a cyclic fashion:
 
 ::
 

getting_started/scripting/visual_script/custom_visualscript_nodes.rst

@@ -1,6 +1,6 @@
 .. _doc_custom_visualscript_nodes:
 
-Custom VisualScript Nodes
+Custom VisualScript nodes
 =========================
 
 Custom nodes are written in GDScript and can then be used in VisualScript.

getting_started/step_by_step/godot_design_philosophy.rst

@@ -1,6 +1,6 @@
 .. _doc_godot_design_philosophy:
 
-Godot’s design philosophy
+Godot's design philosophy
 =========================
 
 Now that you've gotten your hands wet, let's talk about Godot's design.
@@ -8,7 +8,7 @@ Now that you've gotten your hands wet, let's talk about Godot's design.
 **Every game engine is different and fits different needs.**
 Not only do they offer a range of features, but the design of each engine
 is unique. This leads to different workflows and different ways to form
-your games’ structures. This all stems from their respective design philosophies.
+your games' structures. This all stems from their respective design philosophies.
 
 This page is here to help you understand how Godot works, starting
 with some of its core pillars. It is not a list of available features, nor
@@ -36,22 +36,22 @@ BrokenLanterns in the city will update instantly.
 On top of that, you can **inherit** from any scene.
 
 A Godot scene could be a Weapon, a Character, an Item, a Door, a Level,
-part of a level… anything you’d like. It works like a class in pure code,
-except you’re free to design it by using the editor, using only the
+part of a level… anything you'd like. It works like a class in pure code,
+except you're free to design it by using the editor, using only the
 code, or mixing and matching the two.
 
-It’s different from prefabs you find in several 3D engines, as you can
+It's different from prefabs you find in several 3D engines, as you can
 then inherit from and extend those scenes. You may create a Magician
 that extends your Character. Modify the Character in the editor and the Magician
 will update as well. It helps you build your projects so that their
-structure matches the game’s design.
+structure matches the game's design.
 
 |image0|
 
 Also note that Godot offers many different types of objects called
 nodes, each with a specific purpose. Nodes are part of a tree and always
 inherit from their parents up to the Node class. Although the engine
-does feature components like collision shapes, they’re the
+does feature components like collision shapes, they're the
 exception, not the norm.
 
 |image1|
@@ -76,8 +76,8 @@ there is an import plugin for it. Or you can create one, like the `Tiled
 Map Importer <https://github.com/vnen/godot-tiled-importer>`__.
 
 That is also partly why Godot offers its own programming languages
-GDscript and VisualScript, along with C#. They’re designed for the needs
-of game developers and game designers, and they’re tightly integrated in
+GDscript and VisualScript, along with C#. They're designed for the needs
+of game developers and game designers, and they're tightly integrated in
 the engine and the editor.
 
 GDscript lets you write simple code using Python-like syntax,
@@ -94,9 +94,9 @@ without recompiling the engine.
 in the editor. You can drag and drop nodes or resources into the graph
 to create new code blocks.*
 
-Note that the 3D workspace doesn’t feature as many tools as the 2D workspace.
-You’ll need external programs or add-ons to edit terrains, animate complex characters, and so on.
-Godot provides a complete API to extend the editor’s functionality using
+Note that the 3D workspace doesn't feature as many tools as the 2D workspace.
+You'll need external programs or add-ons to edit terrains, animate complex characters, and so on.
+Godot provides a complete API to extend the editor's functionality using
 game code. See `The Godot editor is a Godot game`_ below.
 
 |image4|
@@ -110,40 +110,40 @@ Open source
 Godot offers a fully open source codebase under the **MIT license**.
 This means all the technologies that ship with it have to be Free
 (as in freedom) as well.
-For the most part, they’re developed from the ground up by contributors.
+For the most part, they're developed from the ground up by contributors.
 
 Anyone can plug in proprietary tools for the needs of their projects —
-they just won’t ship with the engine. This may include Google AdMob,
+they just won't ship with the engine. This may include Google AdMob,
 or FMOD. Any of these can come as
 third-party plugins instead.
 
 On the other hand, an open codebase means you can **learn from and extend
-the engine** to your heart’s content. You can also debug games easily,
+the engine** to your heart's content. You can also debug games easily,
 as Godot will print errors with a stack trace, even if they come from the engine itself.
 
 .. note::
 
-   This **does not affect the work you do with Godot** in any way: there’s
+   This **does not affect the work you do with Godot** in any way: there's
    no strings attached to the engine or anything you make with it.
 
 Community-driven
 ----------------
 
 **Godot is made by its community, for the community, and for all game
-creators out there.** It’s the needs of the users and open discussions
+creators out there.** It's the needs of the users and open discussions
 that drive the core updates. New features from the core developers often
 focus on what will benefit the most users first.
 
 That said, although a handful of core developers work on it full-time,
 the project has over 600 contributors at the time of writing. Benevolent
-programmers work on features they may need themselves, so you’ll see
+programmers work on features they may need themselves, so you'll see
 improvements in all corners of the engine at the same time in every
 major release.
 
 The Godot editor is a Godot game
 --------------------------------
 
-The Godot editor runs on the game engine. It uses the engine’s own UI
+The Godot editor runs on the game engine. It uses the engine's own UI
 system, it can hot-reload code and scenes when you test your projects,
 or run game code in the editor. This means you can **use the same code**
 and scenes for your games, or **build plugins and extend the editor.**
@@ -153,7 +153,7 @@ itself. With the ``tool`` keyword, you can run any game code in the editor.
 
 |image5|
 
-*RPG in a Box is a voxel RPG editor made with Godot 2. It uses Godot’s
+*RPG in a Box is a voxel RPG editor made with Godot 2. It uses Godot's
 UI tools for its node-based programming system and for the rest of the
 interface.*
 

getting_started/step_by_step/intro_to_the_editor_interface.rst

@@ -1,16 +1,16 @@
 .. _doc_intro_to_the_editor_interface:
 
-Introduction to Godot’s editor
+Introduction to Godot's editor
 ==============================
 
-This tutorial will run you through Godot’s interface. We’re going to
+This tutorial will run you through Godot's interface. We're going to
 look at the **Project Manager, docks, workspaces** and everything you
 need to know to get started with the engine.
 
 Project manager
 ---------------
 
-When you launch Godot, the first window you’ll see is the Project
+When you launch Godot, the first window you'll see is the Project
 Manager. Since you have no projects there will be a popup asking if you
 want to open the asset library, just click cancel, we'll look at it later.
 
@@ -21,8 +21,8 @@ or play game projects.
 
 .. image:: img/editor_ui_intro_project_manager_01.png
 
-In the top-right corner you’ll find a drop-down menu to change the
-editor’s language.
+In the top-right corner you'll find a drop-down menu to change the
+editor's language.
 
 .. image:: img/editor_ui_intro_project_manager_02.png
 
@@ -43,8 +43,8 @@ and choose a renderer.
 
 .. image:: img/editor_ui_intro_project_manager_04.png
 
-Click the Browse button to open Godot’s file browser and pick a location
-or type the folder’s path in the Project Path field.
+Click the Browse button to open Godot's file browser and pick a location
+or type the folder's path in the Project Path field.
 
 .. image:: img/editor_ui_intro_project_manager_05.png
 
@@ -61,7 +61,7 @@ later on. For this tutorial either backend is fine.
 Once you are done click ``Create & Edit``. Godot will create
 the project for you and open it in the editor.
 
-The next time you open the project manager, you’ll see your new project in the
+The next time you open the project manager, you'll see your new project in the
 list. Double click on it to open it in the editor.
 
 .. image:: img/editor_ui_intro_project_manager_06.png
@@ -76,10 +76,10 @@ When the folder path is correct, you'll see a green checkmark.
 
 .. image:: img/editor_ui_intro_project_manager_09.png
 
-Your first look at Godot’s editor
+Your first look at Godot's editor
 ---------------------------------
 
-Welcome to Godot! With your project open, you should see the editor’s interface
+Welcome to Godot! With your project open, you should see the editor's interface
 with menus along the top of the interface and docks along the far extremes of
 the interface on either side of the viewport.
 
@@ -88,24 +88,24 @@ the interface on either side of the viewport.
 At the top, from left to right, you can see the **main menus**, the
 **workspaces**, and the **playtest buttons**.
 
-The **FileSystem dock** is where you’ll manage your project files and assets.
+The **FileSystem dock** is where you'll manage your project files and assets.
 
 .. image:: img/editor_ui_intro_dock_filesystem.png
 
-The **Scene dock** lists the active scene’s content and the **Inspector**
+The **Scene dock** lists the active scene's content and the **Inspector**
 allows for the management of the properties of a scene's content.
 
 .. image:: img/editor_ui_intro_dock_inspector.png
 
-In the center, you have the **Toolbar** at the top, where you’ll find
-tools to move, scale or lock your scene’s objects. It changes as you
+In the center, you have the **Toolbar** at the top, where you'll find
+tools to move, scale or lock your scene's objects. It changes as you
 jump to different workspaces.
 
 .. image:: img/editor_ui_intro_editor_02_toolbar.png
 
 The **Bottom Panel** is the host for the debug console, the animation
 editor, the audio mixer… They are wide and can take precious space.
-That’s why they’re folded by default.
+That's why they're folded by default.
 
 .. image:: img/editor_ui_intro_editor_03_animation_player.png
 
@@ -115,7 +115,7 @@ The workspaces
 You can see four workspace buttons at the top: 2D, 3D, Script and
 AssetLib.
 
-You’ll use the **2D workspace** for all types of games. In addition to 2D games,
+You'll use the **2D workspace** for all types of games. In addition to 2D games,
 the 2D workspace is where you'll build your interfaces. Press :kbd:`F1` 
 (or :kbd:`Alt + 1` on macOS) to access it.
 
@@ -161,7 +161,7 @@ and assets to use in your projects.
 Modify the interface
 --------------------
 
-Godot’s interface lives in a single window. You cannot split it across
+Godot's interface lives in a single window. You cannot split it across
 multiple screens although you can work with an external code editor like
 Atom or Visual Studio Code for instance.
 

getting_started/step_by_step/ui_code_a_life_bar.rst

@@ -110,7 +110,7 @@ scene:
 
 .. note::
 
-    The project uses a simple organisation that works for game jams and tiny games.
+    The project uses a simple organization that works for game jams and tiny games.
 
     At the root of the project, in the `res://` folder, you will find the `LevelMockup`. That's the main game scene and the one we will work with. All the components that make up the game are in the `scenes/` folder. The `assets/` folder contains the game sprites and the font for the HP counter. In the `scripts/` folder you will find the enemy, the player, and the GUI controller scripts.
 

getting_started/step_by_step/ui_game_user_interface.rst

@@ -22,7 +22,7 @@ Download the project files: :download:`ui_gui_design.zip <files/ui_gui_design.zi
 
 .. note::
 
-    You can watch this tutorial as a `video on Youtube <https://www.youtube.com/watch?v=y1E_y9AIqow>`_.
+    You can watch this tutorial as a `video on YouTube <https://www.youtube.com/watch?v=y1E_y9AIqow>`_.
 
 Breaking down the UI
 --------------------
@@ -625,9 +625,9 @@ find the final project here: :download:`ui_gui_design.zip <files/ui_gui_design.z
     **A final note about Responsive Design**. If you resize the
     GUI, you'll see the nodes move, but the textures and text won't scale.
     The GUI also has a minimum size, based on the textures inside of it. In
-    games, we don’t need the interface to be as flexible as that of a
+    games, we don't need the interface to be as flexible as that of a
     website. You almost never want to support both landscape and portrait
-    screen orientations. It’s one or the other. In landscape orientation,
+    screen orientations. It's one or the other. In landscape orientation,
     the most common ratios range from 4:3 to 16:9. They are close to one
-    another. That's why it’s enough for the GUI elements to only move
+    another. That's why it's enough for the GUI elements to only move
     horizontally when we change the window size.

getting_started/step_by_step/ui_main_menu.rst

@@ -28,7 +28,7 @@ folder.
 .. note::
 
     Read the :doc:`ui_introduction_to_the_ui_system` first to learn how
-    Godot’s UI system works.
+    Godot's UI system works.
 
 How to design your game UI
 --------------------------
@@ -70,7 +70,7 @@ There are two ways to design your UI in Godot. You can:
    components that inherit from your base scenes.
 
 We will use the first approach, because the first version of your UI may
-not work as well as you’d like. You’re likely to throw parts away and
+not work as well as you'd like. You're likely to throw parts away and
 redesign components as you go. When you're sure everything works, it's
 easy to make some parts reusable, as you'll see below.
 
@@ -150,7 +150,7 @@ Select the ``MarginContainer``, and create the UI elements as
 1. the title or logo,
 2. the three text options as individual nodes,
 3. the version note,
-4. and the main menu’s illustration.
+4. and the main menu's illustration.
 
 Click the **Add Node** button or press :kbd:`Meta + A` on your keyboard.
 Start to type ``TextureRect`` to find the corresponding node and press
@@ -191,8 +191,8 @@ containers split the area into two: a left and a right side or a top and
 a bottom side. They also allow the user to resize the left and right
 areas using an interactive bar. On the other hand, ``HBoxContainer``
 just splits itself into as many columns as it has children. Although you
-can deactivate the split container's resize behaviour, I recommend to
-favour box containers.
+can deactivate the split container's resize behavior, I recommend to
+favor box containers.
 
 Select the ``MarginContainer`` and add an ``HBoxContainer``. Then, we
 need two containers as children of our ``HBoxContainer``: a

getting_started/step_by_step/your_first_game.rst

@@ -1216,7 +1216,7 @@ and ``$Music.stop()`` in the ``game_over()`` function.
 
 Finally, add ``$DeathSound.play()`` in the ``game_over()`` function.
 
-Keyboard Shortcut
+Keyboard shortcut
 ~~~~~~~~~~~~~~~~~
 
 Since the game is played with keyboard controls, it would be convenient if we

getting_started/workflow/assets/escn_exporter/animation.rst

@@ -81,7 +81,7 @@ are placed in just one AnimationPlayer in the scene root.
 
 **Mode 'Animation as Action with Squash'**
 
-This mode has very similar behaviour of mode 'Animation as Action', but it
+This mode has very similar behavior of mode 'Animation as Action', but it
 can generate fewer AnimationPlayers; objects in parent-children relationship would
 share their AnimationPlayer. It is useful when you have several rigs, and each
 Skeleton and Mesh has actions; then one rig would have just one AnimationPlayer.

getting_started/workflow/export/exporting_for_web.rst

@@ -116,10 +116,10 @@ The following functionality is currently unavailable on the HTML5 platform:
  -  Threads
  -  GDNative
  -  C#
- -  Clipboard synchronisation between engine and operating system
+ -  Clipboard synchronization between engine and operating system
  -  Networking other than :ref:`class_HTTPClient` and :ref:`class_WebSocketClient`
 
-.. tip:: Check the `list of open HTML5 issues on Github
+.. tip:: Check the `list of open HTML5 issues on GitHub
          <https://github.com/godotengine/godot/issues?q=is:open+is:issue+label:platform:html5>`__
          to see if the functionality you're interested in has an issue yet. If
          not, open one to communicate your interest.

getting_started/workflow/export/exporting_pcks.rst

@@ -31,7 +31,7 @@ with extension ``.pck``).
 - offer mod support
 - no source code disclosure needed for mods
 - more modular project structure
-- users don’t have to replace the entire game
+- users don't have to replace the entire game
 
 The first part of using them involves exporting and delivering the project to
 players. Then, when one wants to add functionality or content later on, they

tutorials/2d/2d_lights_and_shadows.rst

@@ -14,7 +14,7 @@ to make a scene like the demo step by step.
 .. image:: img/light_shadow_main.png
 
 All the resources for this tutorial can be found in the `official demo repository <https://github.com/godotengine/godot-demo-projects>`_
-on github. I suggest you download it before starting. Alternatively,
+on GitHub. I suggest you download it before starting. Alternatively,
 it can be downloaded from the Project Manager. Launch Godot and in the top
 bar select "Templates" and search for "2D Lights and Shadows Demo".
 

tutorials/2d/using_tilemaps.rst

@@ -106,7 +106,7 @@ the node's lock button:
 
 .. image:: img/tile_lock.png
 
-Collision Shapes
+Collision shapes
 ----------------
 
 If you're making a map that needs collisions - walls, floor, or other obstacles,

tutorials/3d/fps_tutorial/part_four.rst

@@ -118,7 +118,7 @@ If there is a joypad connected, we then get its left stick axes for right/left a
 Because a wired Xbox 360 controller has different joystick axis mapping based on OS, we will use different axes based on
 the OS.
 
-.. warning:: This tutorial assumes you are using a XBox 360 or a Playstation wired controller.
+.. warning:: This tutorial assumes you are using a XBox 360 or a PlayStation wired controller.
              Also, I do not (currently) have access to a Mac computer, so the joystick axes may need changing.
              If they do, please open a GitHub issue on the Godot documentation repository! Thanks!
 
@@ -178,7 +178,7 @@ Make a new function called ``process_view_input`` and add the following:
             rotation_helper.rotation_degrees = camera_rot
         # ----------------------------------
 
- .. code-tab:: gdscript Playstation Controller
+ .. code-tab:: gdscript PlayStation Controller
 
      func process_view_input(delta):
 

tutorials/3d/fps_tutorial/part_six.rst

@@ -1014,9 +1014,9 @@ At this point, you have a good base to build more complicated FPS games.
           Other than that, the source is exactly the same, just with helpful comments explaining what
           each part does.
 
-.. tip:: The finished project source is hosted on Github as well: https://github.com/TwistedTwigleg/Godot_FPS_Tutorial
+.. tip:: The finished project source is hosted on GitHub as well: https://github.com/TwistedTwigleg/Godot_FPS_Tutorial
 
-         **Please note that the code in Github may or may not be in sync with the tutorial in the documentation**.
+         **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 of which to use, use the project(s) provided in the documentation, as they are maintained by the Godot community.

tutorials/animation/animation_tree.rst

@@ -212,7 +212,7 @@ Check the "Parameters" section of the ``AnimationTree`` node to see all the para
 .. image:: img/animtree16.png
 
 This is handy because it makes it possible to animate them from an ``AnimationPlayer``, or even the ``AnimationTree`` itself,
-allowing the realisation of very complex animation logic.
+allowing the realization of very complex animation logic.
 
 To modify these values from code, the property path must be obtained. This is done easily by hovering the mouse over any of the parameters:
 

tutorials/animation/introduction_2d.rst

@@ -212,7 +212,7 @@ the end.
    Animation loop
 
 If you set the animation length to 4 seconds now, the animation moves
-back and forth. You can change this behaviour if you change the track's
+back and forth. You can change this behavior if you change the track's
 loop mode. This is covered in the next chapter.
 
 Track settings

tutorials/inputs/inputevent.rst

@@ -115,7 +115,7 @@ specific Controls, only direct ancestors of the targeted Control node receive th
 In accordance with Godot's node-based design, this enables
 specialized child nodes to handle and consume particular events, while
 their ancestors, and ultimately the scene root, can provide more
-generalized behaviour if needed.
+generalized behavior if needed.
 
 Anatomy of an InputEvent
 ------------------------
@@ -124,14 +124,14 @@ Anatomy of an InputEvent
 anything and only contains some basic information, such as event ID
 (which is increased for each event), device index, etc.
 
-There are several specialised types of InputEvent, described in the table below:
+There are several specialized types of InputEvent, described in the table below:
 
 +-------------------------------------------------------------------+--------------------+-----------------------------------------+
 | Event                                                             | Type Index         | Description                             |
 +-------------------------------------------------------------------+--------------------+-----------------------------------------+
 | :ref:`InputEvent <class_InputEvent>`                              | NONE               | Empty Input Event.                      |
 +-------------------------------------------------------------------+--------------------+-----------------------------------------+
-| :ref:`InputEventKey <class_InputEventKey>`                        | KEY                | Contains a scancode and unicode value,  |
+| :ref:`InputEventKey <class_InputEventKey>`                        | KEY                | Contains a scancode and Unicode value,  |
 |                                                                   |                    | as well as modifiers.                   |
 +-------------------------------------------------------------------+--------------------+-----------------------------------------+
 | :ref:`InputEventMouseButton <class_InputEventMouseButton>`        | MOUSE_BUTTON       | Contains click information, such as     |

tutorials/networking/high_level_multiplayer.rst

@@ -65,7 +65,7 @@ This class interface can abstract most types of network layers, topologies and l
 provides an implementation based on ENet (:ref:`NetworkedMultiplayerEnet <class_NetworkedMultiplayerENet>`),
 one based on WebRTC (:ref:`WebRTCMultiplayer <class_WebRTCMultiplayer>`), and one based on WebSocket
 (:ref:`WebSocketMultiplayerPeer <class_WebSocketMultiplayerPeer>`), but this could be used to implement
-mobile APIs (for adhoc WiFi, Bluetooth) or custom device/console-specific networking APIs.
+mobile APIs (for ad hoc WiFi, Bluetooth) or custom device/console-specific networking APIs.
 
 For most common cases, using this object directly is discouraged, as Godot provides even higher level networking facilities.
 Yet it is made available in case a game has specific needs for a lower level API.

tutorials/shading/advanced_postprocessing.rst

@@ -91,8 +91,8 @@ When displaying depth directly from the ``DEPTH_TEXTURE``, everything will look
 white unless it is very close. This is because the depth buffer stores objects closer
 to the camera using more bits than those further, so most of the detail in depth
 buffer is found close to the camera. In order to make the depth value align with world or 
-model coordinates, we need to linearise the value. When we apply the projection matrix to the 
-vertex position, the z value is made nonlinear, so to linearise it, we multiply it by the 
+model coordinates, we need to linearize the value. When we apply the projection matrix to the 
+vertex position, the z value is made nonlinear, so to linearize it, we multiply it by the 
 inverse of the projection matrix, which in Godot, is accessible with the variable 
 ``INV_PROJECTION_MATRIX``.
 

tutorials/shading/shading_reference/canvas_item_shader.rst

@@ -143,7 +143,7 @@ the texture color for such nodes, use:
 
   COLOR = texture(TEXTURE, UV);
 
-This differs from the behaviour of the built-in normal map. If a normal map is attached, Godot uses
+This differs from the behavior of the built-in normal map. If a normal map is attached, Godot uses
 it by default and assigns its value to the built-in ``NORMAL`` variable. If you are using a normal
 map meant for use in 3D, it will appear inverted. In order to use it in your shader, you must assign
 it to the ``NORMALMAP`` property. Godot will handle converting it for use in 2D and overwriting ``NORMAL``.

tutorials/shading/shading_reference/shading_language.rst

@@ -509,7 +509,7 @@ to make the compiler understand for what the uniform is used.
     uniform float amount : hint_range(0, 1);
     uniform vec4 other_color : hint_color = vec4(1.0);
 
-It's important to understand that textures that are supplied as color require hints for proper sRGB->linear conversion (i.e. ``hint_albedo``), as Godot’s 3D engine renders in linear color space.
+It's important to understand that textures that are supplied as color require hints for proper sRGB->linear conversion (i.e. ``hint_albedo``), as Godot's 3D engine renders in linear color space.
 
 Full list of hints below:
 
@@ -557,7 +557,7 @@ to shaders, Godot converts the type automatically. Below is a table of the corre
 +-----------------+-----------+
 
 .. note:: Be careful when setting shader uniforms from GDScript, no error will be thrown if the
-          type does not match. Your shader will just exhibit undefined behaviour.
+          type does not match. Your shader will just exhibit undefined behavior.
 
 Uniforms can also be assigned default values:
 

tutorials/vr/vr_primer.rst

@@ -74,7 +74,7 @@ The first are our units. In normal 3D games, you don't have to think a lot about
 In AR and VR, this changes because things in your virtual world are mapped to things in the real world. If you step 1 meter forward in the real world, but you only move 1 cm forward in your virtual world, you have a problem. The same with the position of your controllers; if they don't appear in the right relative space, it breaks the immersion for the player.
 Most VR platforms, including our AR/VR Server, assume that 1 unit = 1 meter. The AR/VR server, however, has a property that, for convenience, is also exposed on the ARVROrigin node called world scale. For instance, setting this to a value of 10 changes our coordinate system so 10 units = 1 meter.
 
-Performance is another thing that needs to be carefully considered. Especially VR taxes your game a lot more than most people realise. For mobile VR, you have to be extra careful here, but even for desktop games, there are three factors that make life extra difficult:
+Performance is another thing that needs to be carefully considered. Especially VR taxes your game a lot more than most people realize. For mobile VR, you have to be extra careful here, but even for desktop games, there are three factors that make life extra difficult:
 
 * You are rendering stereoscopic, two for the price of one. While not exactly doubling the work load and with things in the pipeline such as supporting the new MultiView OpenGL extension in mind, there still is an extra workload in rendering images for both eyes
 * A normal game will run acceptably on 30fps and ideally manages 60fps. That gives you a big range to play with between lower end and higher end hardware. For any HMD application of AR or VR, however, 60fps is the absolute minimum and you should target your games to run at a stable 90fps to ensure your users don't get motion sickness right off the bat.