Fix some typos and grammar mistakes found using LanguageTool

about/faq.rst

@@ -147,8 +147,8 @@ The main reasons for creating a custom scripting language for Godot were:
 5. Garbage collector results in stalls or unnecessarily large memory
    usage (Lua, Python, JavaScript, ActionScript, etc.).
 6. Difficulty to integrate with the code editor for providing code
-   completion, live editing, etc. (all of them). This is well
-   supported by GDScript.
+   completion, live editing, etc. (all of them). This is well-supported
+   by GDScript.
 
 GDScript was designed to curtail the issues above, and more.
 
@@ -259,7 +259,7 @@ I have a great idea for Godot. How can I share it?
 It might be tempting to want to bring ideas to Godot, like ones that
 result in massive core changes, some sort of mimicry of what another
 game engine does, or alternative workflows that you'd like built into
-the editor. These are great and we are thankful to have such motivated
+the editor. These are great, and we are thankful to have such motivated
 people want to contribute, but Godot's focus is and always will be the
 core functionality as outlined in the `Roadmap <https://github.com/godotengine/godot-roadmap/blob/master/ROADMAP.md>`_,
 `squashing bugs and addressing issues <https://github.com/godotengine/godot/issues>`_,
@@ -325,7 +325,7 @@ Why does Godot not force users to implement DoD (Data oriented Design)?
 -----------------------------------------------------------------------
 
 While Godot internally for a lot of the heavy performance tasks attempts
-to use cache coherency as best as possible, we believe most users don't
+to use cache coherency as well as possible, we believe most users don't
 really need to be forced to use DoD practices.
 
 DoD is mostly a cache coherency optimization that can only gain you

community/contributing/best_practices_for_engine_contributors.rst

@@ -57,7 +57,7 @@ Whether a problem is worth solving is determined by the difficulty the user has
 - The complexity of the problem
 - The frequency the problem
 
-If the problem is *too complex* for most users to solve, the software must offer a ready made solution for it. Likewise, if the problem is easy for the user to workaround, offering such a solution is unnecessary and it's up to the user to do it.
+If the problem is *too complex* for most users to solve, the software must offer a ready-made solution for it. Likewise, if the problem is easy for the user to workaround, offering such a solution is unnecessary and it's up to the user to do it.
 
 The exception, however, is when the user stumbles into this problem *frequently enough* that having to do the simple solution every time becomes an annoyance. In this case, the software must offer a solution to simplify this use case.
 
@@ -72,7 +72,7 @@ Because of this, user proposed solutions don't always contemplate other use case
 
 .. image:: img/best_practices4.png
 
-For developers, the perspective is different. They may find the user's problem too unique to justify a solution (instead of an user workaround), or maybe they will suggest a partial (usually simpler or lower level) solution that applies to a wider range of known problems, and leave the rest of the solution up to the user. 
+For developers, the perspective is different. They may find the user's problem too unique to justify a solution (instead of a user workaround), or maybe they will suggest a partial (usually simpler or lower level) solution that applies to a wider range of known problems, and leave the rest of the solution up to the user. 
 
 In any case, before attempting a contribution, it is important to discuss the actual problems with the other developers or contributors, so a better agreement on implementation can be reached. 
 
@@ -91,7 +91,7 @@ The main problem is that, in reality, it rarely works this way. Most of the time
 
 Additionally, solutions that target individual problems are better for the users, as they find something that does exactly what they need, without having to learn and remember a more complex system they will only need for simple tasks.
 
-Big and flexible solutions also have an additional drawback which is that, over time, they rarely are flexible enough for all users, which keep requesting more functions added (and making the API and codebase more and more complex).
+Big and flexible solutions also have an additional drawback which is that, over time, they are rarely flexible enough for all users, which keep requesting more functions added (and making the API and codebase more and more complex).
 
 #6: Cater to common use cases, leave the door open for the rare ones
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -106,7 +106,7 @@ The question is then, how to design software that gives users what *we know they
 
 .. image:: img/best_practices6.png
 
-The answer to this question is that, to ensure users still can do what they want to do, we need to give them access to a *low level API* that they can use to achieve what they want, even if it's more work for them because it means reimplementing some of the logic that already exists.
+The answer to this question is that, to ensure users still can do what they want to do, we need to give them access to a *low level API* that they can use to achieve what they want, even if it's more work for them because it means reimplementing some logic that already exists.
 
 In real-life scenarios, these use cases will be at most rare and uncommon anyway, so it makes sense a custom solution needs to be written. This is why it's important to still provide users the basic building blocks to do it.
 
@@ -117,7 +117,7 @@ When looking for a solution to a problem, be it implementing a new feature or fi
 
 The main problem here is, adding something to the core layers that will only be used from a single location far away will not only make the code more difficult to follow (split in two), but also make the core API larger, more complex, more difficult to understand in general. 
 
-This is bad, because readability and cleanness of core APIs is always of extreme importance given how much code relies from it, and because it's key for new contributors as a starting point to learning the codebase.
+This is bad, because readability and cleanness of core APIs is always of extreme importance given how much code relies on it, and because it's key for new contributors as a starting point to learning the codebase.
 
 
 .. image:: img/best_practices7.png

community/contributing/docs_writing_guidelines.rst

@@ -425,7 +425,7 @@ For boolean member variables, always use ``if true`` and/or
 ``if false``, to stay explicit. ``Controls whether or not`` may be
 ambiguous and won't work for every member variable.
 
-Also surround boolean values, variable names and methods with ``[code][/code]``.
+Also, surround boolean values, variable names and methods with ``[code][/code]``.
 
 **Do** start with "if true":
 

community/contributing/documentation_guidelines.rst

@@ -5,7 +5,7 @@ Documentation guidelines
 
 This page describes the rules to follow if you want to contribute to Godot
 Engine by writing or reviewing documentation, or by translating existing
-documentation. Also have a look at README of the
+documentation. Also, have a look at README of the
 `godot-docs GitHub repository <https://github.com/godotengine/godot-docs>`_
 and the `docs front page <https://docs.godotengine.org>`_
 on what steps to follow and how to contact the docs team.
@@ -67,7 +67,7 @@ What makes good documentation?
 
 Documentation should be well written in plain English, using well-formed
 sentences and various levels of sections and subsections. It should be clear
-and objective. Also have a look at the :ref:`doc_docs_writing_guidelines`.
+and objective. Also, have a look at the :ref:`doc_docs_writing_guidelines`.
 
 We differentiate tutorial pages from other documentation pages by these
 definitions:
@@ -95,7 +95,7 @@ Always begin pages with their title and a Sphinx reference name:
     Insert your title here
     ======================
 
-The reference allows to link to this page using the ``:ref:`` format, e.g.
+The reference allows linking to this page using the ``:ref:`` format, e.g.
 ``:ref:`doc_insert_your_title_here``` would link to the above example page
 (note the lack of leading underscore in the reference).
 
@@ -122,7 +122,9 @@ You can help to translate the official Godot documentation on our `Hosted Weblat
     :align: center
     :target: https://hosted.weblate.org/engage/godot-engine/?utm_source=widget
 
-There also is the official `Godot I18N repository <https://github.com/godotengine/godot-docs-l10n>`_. where you can see when the data was last synced.
+There also is the official
+`Godot i18N repository <https://github.com/godotengine/godot-docs-l10n>`_
+where you can see when the data was last synchronized.
 
 License
 -------

community/contributing/updating_the_class_reference.rst

@@ -54,7 +54,7 @@ Clone the repository on your computer:
 
     git clone https://github.com/your_name/godot.git
 
-Create a new branch to make your changes. It makes it a lot easier to sync your improvements with other docs writers, and it's easier to cleanup your repository clean if you have any issues with git.
+Create a new branch to make your changes. It makes it a lot easier to sync your improvements with other docs writers. It's also easier to clean up your repository if you run into any issues with Git.
 
 ::
 
@@ -106,7 +106,7 @@ If you made changes you don't want to keep in your local branch, use the followi
 
 **Warning:** The above command will reset your branch to the state of the ``upstream master`` branch. It will discard all local changes. Make sure to only run this *before* you make important changes.
 
-Another option is to delete the branch you're working on, synchronize the master branch with the Godot repository, and create a brand new branch:
+Another option is to delete the branch you're working on, synchronize the master branch with the Godot repository, and create a new branch:
 
 ::
 

community/tutorials.rst

@@ -3,7 +3,7 @@
 Tutorials and resources
 =======================
 
-This is a list of third-party tutorials and resources created by the Godot community. For resources, remember that there is the official `Godot Asset Library <https://godotengine.org/asset-library/asset>`_ full of official and community resources too! Also have a look at this `huge list over at Reddit <https://www.reddit.com/r/godot/comments/an0iq5/godot_tutorials_list_of_video_and_written/>`_.
+This is a list of third-party tutorials and resources created by the Godot community. For resources, remember that there is the official `Godot Asset Library <https://godotengine.org/asset-library/asset>`_ full of official and community resources too! Also, have a look at this `huge list over at Reddit <https://www.reddit.com/r/godot/comments/an0iq5/godot_tutorials_list_of_video_and_written/>`_.
 
 Think there is something missing here? Feel free to submit a `Pull Request <https://github.com/godotengine/godot-docs/blob/master/community/tutorials.rst>`_ as always.
 
@@ -14,7 +14,7 @@ The Godot video tutorials by `GDQuest <https://www.youtube.com/channel/UCxboW7x0
 
 If you're interested in Visual Scripting, `Emilio's tutorials <https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg>`_ may be worth a look.
 
-Some of the others mentioned below provide more advanced tutorials, e.g. on 3D or shaders.
+Some tutorials mentioned below provide more advanced tutorials, e.g. on 3D or shaders.
 
 Video tutorials
 ---------------

development/compiling/optimizing_for_size.rst

@@ -66,8 +66,8 @@ to play videos).
 Optimizing for size instead of speed
 ------------------------------------
 
-Godot 3.1 onwards allows to compile using size optimizations.
-To enable this, just set the ``optimize`` flag to ``size``:
+Godot 3.1 onwards allows compiling using size optimizations (instead of speed).
+To enable this, set the ``optimize`` flag to ``size``:
 
 ::
 

development/cpp/configuring_an_ide.rst

@@ -81,9 +81,9 @@ Updating sources after pulling latest commits
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 As a developer you usually want to frequently pull the latest commits
-from the upstream git repository or a specific fork etc. However this
+from the upstream git repository or a specific fork etc. However, this
 brings a little problem with it: as the development continues, source files
-(and folders) are added or removed. These changes needs to be reflected in
+(and folders) are added or removed. These changes need to be reflected in
 your project files for Qt Creator too, so you continue to have a nice
 experience coding in it. A simple way to check is to right click
 at your root folder in the "Projects View" and click on "Edit files..."
@@ -92,7 +92,7 @@ at your root folder in the "Projects View" and click on "Edit files..."
 
 Now a new dialog should appear that is similar in functionality to the one in the third step
 of the "Importing the project" section. Here you can check whether you want to add/remove
-specific files and/or folders. You can chose by clicking with your mouse or just simply by
+specific files and/or folders. You can choose by clicking with your mouse or just simply by
 clicking the "Apply Filter" button. A simple click on "Ok" and you're ready to continue your work.
 
 .. image:: img/qtcreator-edit-files-dialog.png

development/cpp/custom_audiostreams.rst

@@ -43,7 +43,7 @@ internal/external buffer, or a file reference.
 Some AudioStreams need to be stateless such as objects loaded from
 ResourceLoader. ResourceLoader loads once and references the same
 object regardless how many times ``load`` is called on a specific resource.
-Therefore, playback state must be self contained in AudioStreamPlayback.
+Therefore, playback state must be self-contained in AudioStreamPlayback.
 
 .. code-block:: cpp
 

development/cpp/custom_modules_in_cpp.rst

@@ -12,10 +12,10 @@ functionality at every level without modifying the core, which can be
 split for use and reuse in different modules.
 
 Modules are located in the ``modules/`` subdirectory of the build system.
-By default, many different modules exist, such as GDScript (which, yes,
+By default, dozens of modules are enabled, such as GDScript (which, yes,
 is not part of the base engine), the Mono runtime, a regular expressions
 module, and others. As many new modules as desired can be
-created and combined, and the SCons build system will take care of it
+created and combined. The SCons build system will take care of it
 transparently.
 
 What for?
@@ -166,8 +166,8 @@ string list:
     env.add_source_files(env.modules_sources, src_list)
 
 This allows for powerful possibilities using Python to construct the file list
-using loops and logic statements. Look at some of the other modules that ship
-with Godot by default for examples.
+using loops and logic statements. Look at some modules that ship with Godot by
+default for examples.
 
 To add include directories for the compiler to look at you can append it to the
 environment's paths:
@@ -342,7 +342,7 @@ of our new module as part of the Godot binary.
 This static approach is fine when we want to build a release version of our
 game given we want all the modules in a single binary.
 
-However the trade-off is every single change means a full recompilation of the
+However, the trade-off is every single change means a full recompilation of the
 game. Even if SCons is able to detect and recompile only the file that have
 changed, finding such files and eventually linking the final binary is a
 long and costly part.
@@ -372,7 +372,7 @@ library that will be dynamically loaded when starting our game's binary.
     # next to the Godot binary.
     shared_lib = module_env.SharedLibrary(target='#bin/summator', source=sources)
 
-    # Finally notify the main env it has our shared lirary as a new dependency.
+    # Finally, notify the main env it has our shared lirary as a new dependency.
     # To do so, SCons wants the name of the lib with it custom suffixes
     # (e.g. ".linuxbsd.tools.64") but without the final ".so".
     # We pass this along with the directory of our library to the main env.
@@ -428,8 +428,8 @@ using the `ARGUMENT` command:
 Now by default ``scons`` command will build our module as part of Godot's binary
 and as a shared library when passing ``summator_shared=yes``.
 
-Finally you can even speedup build further by explicitly specifying your
-shared module as target in the scons command:
+Finally, you can even speed up the build further by explicitly specifying your
+shared module as target in the SCons command:
 
 .. code-block:: shell
 

development/file_formats/tscn.rst

@@ -400,13 +400,13 @@ Each track is described by a list of key-value pairs in the format
 2. The ``path`` has the format ``NodePath(Path/To/Node:attribute)``.
    It's the path to the animated node or attribute, relative to the root node
    defined in the AnimationPlayer.
-
+I 
 3. The ``interp`` is the method to interpolate frames from the keyframes.
-   it is a enum variable and can has value:
+   It is an enum variable with one of the following values:
 
-    - 0 (constant)
-    - 1 (linear)
-    - 2 (cubic)
+    - ``0`` (constant)
+    - ``1`` (linear)
+    - ``2`` (cubic)
 
 4. The ``keys`` correspond to the keyframes. It appears as a ``PackedFloat32Array()``,
    but may have a different structure for tracks with different types.

getting_started/scripting/gdscript/gdscript_basics.rst

@@ -494,8 +494,8 @@ Associative container which contains values referenced by unique keys.
 
 Lua-style table syntax is also supported. Lua-style uses ``=`` instead of ``:``
 and doesn't use quotes to mark string keys (making for slightly less to write).
-Note however that like any GDScript identifier, keys written in this form cannot
-start with a digit.
+However, keys written in this form can't start with a digit (like any GDScript
+identifier).
 
 ::
 

getting_started/step_by_step/intro_to_the_editor_interface.rst

@@ -155,7 +155,7 @@ item will be displayed in the script workspace.
 
 .. image:: img/editor_ui_intro_script_class_documentation.png
 
-Finally the **AssetLib** is a library of free and open source add-ons, scripts
+Finally, the **AssetLib** is a library of free and open source add-ons, scripts
 and assets to use in your projects.
 
 Modify the interface

getting_started/step_by_step/scripting.rst

@@ -80,7 +80,7 @@ API Bridge.
 
 This language is the best choice for performance and does not need to be
 used throughout an entire game, as other parts can be written in GDScript or Visual
-Script. However the API is clear and easy to use as it resembles, mostly,
+Script. However, the API is clear and easy to use as it resembles, mostly,
 Godot's actual C++ API.
 
 More languages can be made available through the GDNative interface, but keep in mind

getting_started/step_by_step/scripting_continued.rst

@@ -37,14 +37,14 @@ It's important to bear in mind that the frequency with which ``_process()``
 will be called depends on how many frames per second (FPS) your application
 is running at. This rate can vary over time and devices.
 
-To help manage this variability the ``delta`` parameter contains the time
-elapsed in seconds, as a floating point, since the previous call to ``_process()``.
+To help manage this variability, the ``delta`` parameter contains the time
+elapsed in seconds as a floating-point number since the previous call to ``_process()``.
 
 This parameter can be used to make sure things always take the same
 amount of time, regardless of the game's FPS.
 
 For example, movement is often multiplied with a time delta to make movement
-speed both constant and independent from the frame rate.
+speed both constant and independent of the frame rate.
 
 Physics processing with ``_physics_process()`` is similar, but it should be used for processes that
 must happen before each physics step, such as controlling a character.

getting_started/step_by_step/ui_game_user_interface.rst

@@ -287,7 +287,7 @@ the size of the ``Background``.
 Let's change the ``Number``'s align properties to move it to the left
 and center of the ``Background``. Select the ``Number`` node, change its
 ``Align`` property to left and the ``Valign`` property to centre. Then
-resize its left edge a little bit to add some padding between the left
+resize its left edge a bit to add some padding between the left
 edge of the ``Background`` and the text.
 
 .. figure:: ./img/ui_gui_step_tutorial_counter_design_3.png
@@ -535,7 +535,7 @@ with the emerald icon. In the FileSystem tab, drag the ``emeralds_icon.png``
 onto the ``Icon`` node's ``Texture`` slot. ``Icon`` already anchors to
 the right edge of the ``Background`` node so we can change its position
 and it will scale and reposition with the ``EmeraldCounter`` container.
-Shift the emerald icon a little bit to the right and down. Use the Arrow
+Shift the emerald icon a bit to the right and down. Use the Arrow
 Keys on the keyboard to nudge its position. Save, and we're done with
 all the UI elements.