Cleanup uses of double spaces between words or after punctuation

conf.py

@@ -187,7 +187,7 @@ html_static_path = ["_static"]
 html_extra_path = ["robots.txt"]
 
 # These paths are either relative to html_static_path
-# or fully qualified paths (eg. https://...)
+# or fully qualified paths (e.g. https://...)
 html_css_files = [
     "css/custom.css",
 ]

development/compiling/compiling_with_script_encryption_key.rst

@@ -71,7 +71,7 @@ them at runtime.
 
 ::
 
-   ERROR: open_and_parse: Condition ' String::md5(md5.digest) != String::md5(md5d) ' is true. returned: ERR_FILE_CORRUPT
+   ERROR: open_and_parse: Condition "String::md5(md5.digest) != String::md5(md5d)" is true. Returning: ERR_FILE_CORRUPT
       At: core/io/file_access_encrypted.cpp:103
    ERROR: load_byte_code: Condition ' err ' is true. returned: err
       At: modules/gdscript/gdscript.cpp:755

development/cpp/binding_to_external_libraries.rst

@@ -118,8 +118,8 @@ this module:
     env_tts = env.Clone()
     env_tts.add_source_files(env.modules_sources, "*.cpp") # Add all cpp files to the build
 
-You'll need to install the external library on your machine to get the .a library files.  See the library's official
-documentation for specific instructions on how to do this for your operation system.  We've included the
+You'll need to install the external library on your machine to get the .a library files. See the library's official
+documentation for specific instructions on how to do this for your operation system. We've included the
 installation commands for Linux below, for reference.
 
 .. code-block:: shell
@@ -135,7 +135,7 @@ installation commands for Linux below, for reference.
     Please be sure to check the licenses and terms of use.
 
 The external library will also need to be installed inside your module to make the source
-files accessible to the compiler, while also keeping the module code self-contained.  The
+files accessible to the compiler, while also keeping the module code self-contained. The
 festival and speech_tools libraries can be installed from the modules/tts/ directory via
 git using the following commands:
 
@@ -153,9 +153,9 @@ can link to them instead by adding them as submodules (from within the modules/t
     git submodule add https://github.com/festvox/speech_tools
 
 .. important::
-    Please note that Git submodules are not used in the Godot repository.  If
+    Please note that Git submodules are not used in the Godot repository. If
     you are developing a module to be merged into the main Godot repository, you should not
-    use submodules.  If your module doesn't get merged in, you can always try to implement
+    use submodules. If your module doesn't get merged in, you can always try to implement
     the external library as a GDNative C++ plugin.
 
 To add include directories for the compiler to look at you can append it to the

development/cpp/configuring_an_ide/code_blocks.rst

@@ -126,4 +126,4 @@ Under **General Settings**, on the **Editor Settings** tab, under **Tab Options*
    :figclass: figure-w480
    :align: center
 
-That's it. You're ready to start contributing to Godot using the Code::Blocks IDE. Remember to save the project file and the **Workspace**.  If you run into any issues, ask for help in one of `Godot's community channels <https://godotengine.org/community>`__.
+That's it. You're ready to start contributing to Godot using the Code::Blocks IDE. Remember to save the project file and the **Workspace**. If you run into any issues, ask for help in one of `Godot's community channels <https://godotengine.org/community>`__.

development/cpp/custom_resource_format_loaders.rst

@@ -291,7 +291,7 @@ calls into ``std::istream``.
     		}
     	}
     	int uflow() {
-    		return _file->eof_reached() ?  EOF : _file->get_8();
+    		return _file->eof_reached() ? EOF : _file->get_8();
     	}
 
     private:

development/file_formats/tscn.rst

@@ -306,7 +306,7 @@ heading. For example, a capsule collision shape looks like:
 
 ::
 
-    [sub_resource  type="CapsuleShape" id=2]
+    [sub_resource type="CapsuleShape" id=2]
 
     radius = 0.5
     height = 3.0

getting_started/scripting/gdscript/gdscript_basics.rst

@@ -1190,7 +1190,7 @@ There are a few things to keep in mind here:
    in to ``Idle.gd``.
 4. If ``Idle.gd``'s ``_init`` constructor takes 0 arguments, it still needs to pass some value
    to the ``State.gd`` parent class, even if it does nothing. This brings us to the fact that you
-   can pass literals in the base constructor as well, not just variables. eg.::
+   can pass literals in the base constructor as well, not just variables, e.g.::
 
     # Idle.gd
 

getting_started/workflow/best_practices/data_preferences.rst

@@ -85,7 +85,7 @@ Contiguous memory stores imply the following operation performance:
       This makes only 2 copies of the array (still constant time, but slow)
       versus copying roughly 1/2 of the array, on average, N times (linear time).
 
-- **Get, Set:** Fastest *by position*. Ex. can request 0th, 2nd, 10th record, etc.
+- **Get, Set:** Fastest *by position*. E.g. can request 0th, 2nd, 10th record, etc.
   but cannot specify which record you want.
 
     - Op: 1 addition operation from array start position up to desired index.

getting_started/workflow/export/exporting_for_web.rst

@@ -278,7 +278,7 @@ Any other JavaScript value is returned as ``null``.
 HTML5 export templates may be :ref:`built <doc_compiling_for_web>` without
 support for the singleton to improve security. With such templates, and on
 platforms other than HTML5, calling ``JavaScript.eval`` will also return
-``null``.  The availability of the singleton can be checked with the
+``null``. The availability of the singleton can be checked with the
 ``JavaScript`` :ref:`feature tag <doc_feature_tags>`::
 
     func my_func3():

tutorials/2d/2d_sprite_animation.rst

@@ -9,10 +9,10 @@ Introduction
 In this tutorial, you'll learn how to create 2D animated
 characters with the AnimatedSprite class and the AnimationPlayer. Typically, when you create or download an animated character, it
 will come in one of two ways: as individual images or as a single sprite sheet
-containing all the animation's frames.  Both can be animated in Godot with the AnimatedSprite class.
+containing all the animation's frames. Both can be animated in Godot with the AnimatedSprite class.
 
 First, we'll use :ref:`AnimatedSprite <class_AnimatedSprite>` to
-animate a collection of individual images. Then we will animate a sprite sheet using this class.  Finally, we will learn another way to animate a sprite sheet
+animate a collection of individual images. Then we will animate a sprite sheet using this class. Finally, we will learn another way to animate a sprite sheet
 with :ref:`AnimationPlayer <class_AnimationPlayer>` and the *Animation*
 property of :ref:`Sprite <class_Sprite>`.
 
@@ -115,34 +115,34 @@ released.
 Sprite sheet with AnimatedSprite
 --------------------------------
 
-You can also easily animate from a sprite sheet with the class ``AnimatedSprite``.  We will use this public domain sprite sheet:
+You can also easily animate from a sprite sheet with the class ``AnimatedSprite``. We will use this public domain sprite sheet:
 
 .. image:: img/2d_animation_frog_spritesheet.png
 
 Right-click the image and choose "Save Image As" to download it, and then copy the image into your project folder.
 
-Set up your scene tree the same way you did previously when using individual images.  Select the ``AnimatedSprite`` and in its *SpriteFrames* property, select
+Set up your scene tree the same way you did previously when using individual images. Select the ``AnimatedSprite`` and in its *SpriteFrames* property, select
 "New SpriteFrames".
 
-Click on the new SpriteFrames resource.  This time, when the bottom panel appears, select "Add frames from a Sprite Sheet".
+Click on the new SpriteFrames resource. This time, when the bottom panel appears, select "Add frames from a Sprite Sheet".
 
 .. image:: img/2d_animation_add_from_spritesheet.png
 
-You will be prompted to open a file.  Select your sprite sheet.
+You will be prompted to open a file. Select your sprite sheet.
 
-A new window will open, showing your sprite sheet.  The first thing you will need to do is to change the number of vertical and horizontal images in your sprite sheet.  In this sprite sheet, we have four images horizontally and two images vertically.
+A new window will open, showing your sprite sheet. The first thing you will need to do is to change the number of vertical and horizontal images in your sprite sheet. In this sprite sheet, we have four images horizontally and two images vertically.
 
 .. image:: img/2d_animation_spritesheet_select_rows.png
 
-Next, select the frames from the sprite sheet that you want to include in your animation.  We will select the top four, then click "Add 4 frames" to create the animation.
+Next, select the frames from the sprite sheet that you want to include in your animation. We will select the top four, then click "Add 4 frames" to create the animation.
 
 .. image:: img/2d_animation_spritesheet_selectframes.png
 
-You will now see your animation under the list of animations in the bottom panel.  Double click on default to change the name of the animation to jump.
+You will now see your animation under the list of animations in the bottom panel. Double click on default to change the name of the animation to jump.
 
 .. image:: img/2d_animation_spritesheet_animation.png
 
-Finally, check Playing on the  AnimatedSprite in the inspector to see your frog jump!
+Finally, check Playing on the AnimatedSprite in the inspector to see your frog jump!
 
 .. image:: img/2d_animation_play_spritesheet_animation.png
 
@@ -266,4 +266,4 @@ Summary
 These examples illustrate the two classes you can use in Godot for
 2D animation. ``AnimationPlayer`` is
 a bit more complex than ``AnimatedSprite``, but it provides additional functionality, since you can also
-animate other properties like position or scale. The class ``AnimationPlayer`` can also be used with an ``AnimatedSprite``.  Experiment to see what works best for your needs.
+animate other properties like position or scale. The class ``AnimationPlayer`` can also be used with an ``AnimatedSprite``. Experiment to see what works best for your needs.

tutorials/3d/vertex_animation/animating_thousands_of_fish.rst

@@ -115,7 +115,7 @@ the wave making it look like a wave is moving along the fish.
 .. image:: img/wave.gif
 
 The last motion is the twist, which is a panning roll along the spine. Similarly to the pivot,
-we first  construct a rotation matrix.
+we first construct a rotation matrix.
 
 .. code-block:: glsl
 
@@ -141,7 +141,7 @@ If we apply all these motions one after another, we get a fluid jelly-like motio
 Normal fish swim mostly with the back half of their body. Accordingly, we need to limit the
 panning motions to the back half of the fish. To do this, we create a new variable, ``mask``.
 
-``mask`` is a float that goes from ``0`` at the front of the fish to ``1`` at the end  using
+``mask`` is a float that goes from ``0`` at the front of the fish to ``1`` at the end using
 ``smoothstep`` to control the point at which the transition from ``0`` to ``1`` happens.
 
 .. code-block:: glsl
@@ -229,7 +229,7 @@ MultiMeshInstance.
 
 .. note:: If performance is an issue for you, try running the scene with GLES2 or with fewer fish.
 
-Notice how all the fish  are all in the same position in their swim cycle? It makes them look very
+Notice how all the fish are all in the same position in their swim cycle? It makes them look very
 robotic. The next step is to give each fish a different position in the swim cycle so the entire
 school looks more organic.
 

tutorials/3d/vertex_animation/controlling_thousands_of_fish.rst

@@ -49,7 +49,7 @@ Then add the following two functions:
   }
 
 These functions come from the default :ref:`ParticlesMaterial <class_ParticlesMaterial>`.
-They are used to generate a random number from  each particle's ``RANDOM_SEED``.
+They are used to generate a random number from each particle's ``RANDOM_SEED``.
 
 A unique thing about particle shaders is that some built-in variables are saved across frames.
 ``TRANSFORM``, ``COLOR``, and ``CUSTOM`` can all be accessed in the Spatial shader of the mesh, and

tutorials/content/procedural_geometry/arraymesh.rst

@@ -19,7 +19,7 @@ PoolIntArray, etc.) for each type of information.
 
 - ``ARRAY_VERTEX`` = 0 | PoolVector3Array or PoolVector2Array
 - ``ARRAY_NORMAL`` = 1 | PoolVector3Array
-- ``ARRAY_TANGENT`` = 2 | PoolRealArray of groups of 4 floats. first 3 floats determine the tangent, and
+- ``ARRAY_TANGENT`` = 2 | PoolRealArray of groups of 4 floats. First 3 floats determine the tangent, and
   the last the binormal direction as -1 or 1.
 - ``ARRAY_COLOR`` = 3 | PoolColorArray
 - ``ARRAY_TEX_UV`` = 4 | PoolVector2Array or PoolVector3Array

tutorials/inputs/input_examples.rst

@@ -217,7 +217,7 @@ Keyboard modifiers
 ~~~~~~~~~~~~~~~~~~
 
 Modifier properties are inherited from
-:ref:`InputEventWithModifiers <class_InputEventWithModifiers>`. This  allows
+:ref:`InputEventWithModifiers <class_InputEventWithModifiers>`. This allows
 you to check for modifier combinations using boolean properties. Let's imagine
 you want one thing to happen when the :kbd:`T` is pressed, but something
 different when it's :kbd:`Shift + T`:

tutorials/io/saving_games.rst

@@ -251,7 +251,7 @@ load function:
     {
         var saveGame = new File();
         if (!saveGame.FileExists("user://savegame.save"))
-            return; // Error!  We don't have a save to load.
+            return; // Error! We don't have a save to load.
 
         // We need to revert the game state so we're not cloning objects during loading.
         // This will vary wildly depending on the needs of a project, so take care with

tutorials/math/beziers_and_curves.rst

@@ -190,7 +190,7 @@ Traversal
 
 The last common use case for the curves is to traverse them. Because of what was mentioned before regarding constant speed, this is also difficult.
 
-To make this easier, the curves need to be *baked* into equidistant points. This way, they can be approximated with regular  interpolation (which can be improved further with a cubic option). To do this, just use the :ref:`Curve.interpolate_baked()<class_Curve_method_interpolate_baked>` method together with
+To make this easier, the curves need to be *baked* into equidistant points. This way, they can be approximated with regular interpolation (which can be improved further with a cubic option). To do this, just use the :ref:`Curve.interpolate_baked()<class_Curve_method_interpolate_baked>` method together with
 :ref:`Curve2D.get_baked_length()<class_Curve2D_method_get_baked_length>`. The first call to either of them will bake the curve internally.
 
 Traversal at constant speed, then, can be done with the following pseudo-code:

tutorials/misc/gles2_gles3_differences.rst

@@ -37,7 +37,7 @@ Color space
 -----------
 
 GLES2 and GLES3 are in different color spaces. This means that colors will appear slightly
-different between them  especially when lighting is used.
+different between them especially when lighting is used.
 
 If your game is going to use both GLES2 and GLES3, you can use an ``if``
 statement check and see if the output is in sRGB, using ``OUTPUT_IS_SRGB``. ``OUTPUT_IS_SRGB`` is

tutorials/networking/http_request_class.rst

@@ -26,7 +26,7 @@ Below is all the code we need to make it work. The URL points to an online API m
 .. tabs::
 
     .. code-tab:: gdscript GDScript
-    
+
         extends CanvasLayer
 
         func _ready():
@@ -38,9 +38,9 @@ Below is all the code we need to make it work. The URL points to an online API m
         func _on_request_completed(result, response_code, headers, body):
             var json = JSON.parse(body.get_string_from_utf8())
             print(json.result)
-    
+
     .. code-tab:: csharp
-    
+
         class HTTPRequestDemo : CanvasLayer
         {
             public override void _Ready()
@@ -48,13 +48,13 @@ Below is all the code we need to make it work. The URL points to an online API m
                 GetNode("HTTPRequest").Connect("request_completed", this, "OnRequestCompleted");
                 GetNode("Button").Connect("pressed", this, "OnButtonPressed");
             }
-            
+
             public void OnButtonPressed()
             {
                 HTTPRequest httpRequest = GetNode<HTTPRequest>("HTTPRequest");
                 httpRequest.Request("http://www.mocky.io/v2/5185415ba171ea3a00704eed");
             }
-            
+
             public void OnRequestCompleted(int result, int response_code, string[] headers, byte[] body)
             {
                 JSONParseResult json = JSON.Parse(Encoding.UTF8.GetString(body));
@@ -71,14 +71,14 @@ Note that you may want to check whether the ``result`` equals ``RESULT_SUCCESS``
 Of course, you can also set custom HTTP headers. These are given as a string array, with each string containing a header in the format ``"header: value"``.
 For example, to set a custom user agent (the HTTP ``user-agent`` header) you could use the following:
 
-..  tabs::
+.. tabs::
 
     .. code-tab:: gdscript GDScript
-    
+
         $HTTPRequest.request("http://www.mocky.io/v2/5185415ba171ea3a00704eed", ["user-agent: YourCustomUserAgent"])
-    
+
     .. code-tab:: csharp
-    
+
         HTTPRequest httpRequest = GetNode<HTTPRequest>("HTTPRequest");
         httpRequest.Request("http://www.mocky.io/v2/5185415ba171ea3a00704eed", new string[] { "user-agent: YourCustomUserAgent" });
 
@@ -95,16 +95,16 @@ Until now, we have limited ourselves to requesting data from a server. But what
 .. tabs::
 
     .. code-tab:: gdscript GDScript
-    
+
         func _make_post_request(url, data_to_send, use_ssl):
             # Convert data to json string:
             var query = JSON.print(data_to_send)
             # Add 'Content-Type' header:
             var headers = ["Content-Type: application/json"]
             $HTTPRequest.request(url, headers, use_ssl, HTTPClient.METHOD_POST, query)
-    
+
     .. code-tab:: csharp
-    
+
             public void MakePostRequest(string url, object data_to_send, bool use_ssl)
             {
                 string query = JSON.Print(data_to_send);

tutorials/optimization/gpu_optimization.rst

@@ -81,7 +81,7 @@ Reuse Shaders and Materials
 The Godot renderer is a little different to what is out there. It's designed to
 minimize GPU state changes as much as possible. :ref:`SpatialMaterial
 <class_SpatialMaterial>` does a good job at reusing materials that need similar
-shaders.  if custom shaders are used, make sure to reuse them as much as
+shaders. If custom shaders are used, make sure to reuse them as much as
 possible. Godot's priorities are:
 
 -  **Reusing Materials:** The fewer different materials in the

tutorials/physics/physics_introduction.rst

@@ -221,7 +221,7 @@ to it and the physics engine calculates the resulting movement, including
 collisions with other bodies, and collision responses, such as bouncing,
 rotating, etc.
 
-You can modify a rigid body's behavior via  properties such as "Mass",
+You can modify a rigid body's behavior via properties such as "Mass",
 "Friction", or "Bounce", which can be set in the Inspector.
 
 The body's behavior is also affected by the world's properties, as set in

tutorials/platform/ios/ios_plugin.rst

@@ -62,7 +62,7 @@ To build an iOS plugin:
 
 5. The iOS plugin system also supports ``.xcframework`` files. To generate one, you can use a command such as: ``xcodebuild -create-xcframework -library [DeviceLibrary].a -library [SimulatorLibrary].a -output [PluginName].xcframework``.
 
-6.  Create a Godot iOS Plugin configuration file to help the system detect and load your plugin:
+6. Create a Godot iOS Plugin configuration file to help the system detect and load your plugin:
 
     -   The configuration file extension must be ``gdip`` (e.g.: ``MyPlugin.gdip``).
 

tutorials/plugins/android/android_plugin.rst

@@ -12,22 +12,22 @@ by tapping into the functionality provided by the Android platform and ecosystem
 Mobile gaming monetization is one such example since it requires features
 and capabilities that don't belong to the core feature set of a game engine:
 
--  Analytics
--  In-app purchases
--  Receipt validation
--  Install tracking
--  Ads
--  Video ads
--  Cross-promotion
--  In-game soft & hard currencies
--  Promo codes
--  A/B testing
--  Login
--  Cloud saves
--  Leaderboards and scores
--  User support & feedback
--  Posting to Facebook, Twitter, etc.
--  Push notifications
+- Analytics
+- In-app purchases
+- Receipt validation
+- Install tracking
+- Ads
+- Video ads
+- Cross-promotion
+- In-game soft & hard currencies
+- Promo codes
+- A/B testing
+- Login
+- Cloud saves
+- Leaderboards and scores
+- User support & feedback
+- Posting to Facebook, Twitter, etc.
+- Push notifications
 
 Android plugin
 --------------
@@ -43,9 +43,8 @@ As a prerequisite, make sure you understand how to set up a :ref:`custom build e
 At its core, a Godot Android plugin is a `Android archive library <https://developer.android.com/studio/projects/android-library#aar-contents>`_ (*aar* archive file)
 with the following caveats:
 
--  The library must have a dependency on the Godot engine library (``godot-lib.<version>.<status>.aar``). A stable version is made available for each Godot release on the `Godot download page <https://godotengine.org/download>`_.
-
--  The library must include a specifically configured ``<meta-data>`` tag in its manifest file.
+- The library must have a dependency on the Godot engine library (``godot-lib.<version>.<status>.aar``). A stable version is made available for each Godot release on the `Godot download page <https://godotengine.org/download>`_.
+- The library must include a specifically configured ``<meta-data>`` tag in its manifest file.
 
 Building an Android plugin
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -53,41 +52,51 @@ Building an Android plugin
 **Prerequisite:** `Android Studio <https://developer.android.com/studio>`_ is strongly recommended as the IDE to use to create Android plugins.
 The instructions below assumes that you're using Android Studio.
 
-1.  Follow `these instructions <https://developer.android.com/studio/projects/android-library>`__ to create an Android library module for your plugin.
+1. Follow `these instructions <https://developer.android.com/studio/projects/android-library>`__ to create an Android library module for your plugin.
+
+2. Add the Godot engine library as a dependency to your plugin module:
 
-2.  Add the Godot engine library as a dependency to your plugin module:
+  - Download the Godot engine library (``godot-lib.<version>.<status>.aar``) from the `Godot download page <https://godotengine.org/download>`_ (e.g.: ``godot-lib.4.0.stable.aar``).
+  - Follow `these instructions <https://developer.android.com/studio/projects/android-library#AddDependency>`__ to add
+    the Godot engine library as a dependency for your plugin.
+  - In the plugin module's ``build.gradle`` file, replace ``implementation`` with ``compileOnly`` for the dependency line for the Godot engine library.
 
-    -  Download the Godot engine library (``godot-lib.<version>.<status>.aar``) from the `Godot download page <https://godotengine.org/download>`_ (e.g: ``godot-lib.3.2.2.stable.aar``).
+    -  Download the Godot engine library (``godot-lib.<version>.<status>.aar``) from the `Godot download page <https://godotengine.org/download>`_ (e.g.: ``godot-lib.3.2.2.stable.aar``).
 
-    -   Follow `these instructions <https://developer.android.com/studio/projects/android-library#AddDependency>`__ to add
-        the Godot engine library as a dependency for your plugin.
+4. Update the plugin ``AndroidManifest.xml`` file:
 
-    -  In the plugin module's ``build.gradle`` file, replace ``implementation`` with ``compileOnly`` for the dependency line for the Godot engine library.
+  - Open the plugin ``AndroidManifest.xml`` file.
+  - Add the ``<application></application>`` tag if it's missing.
+  - In the ``<application>`` tag, add a ``<meta-data>`` tag setup as follow::
 
-3.  Create a new class in the plugin module and make sure it extends ``org.godotengine.godot.plugin.GodotPlugin``.
-    At runtime, it will be used to instantiate a singleton object that will be used by the Godot engine to load, initialize and run the plugin.
+        <meta-data
+            android:name="org.godotengine.plugin.v1.[PluginName]"
+            android:value="[plugin.init.ClassFullName]" />
 
-4.  Update the plugin ``AndroidManifest.xml`` file:
+    Where ``PluginName`` is the name of the plugin, and ``plugin.init.ClassFullName`` is the full name (package + class name) of the plugin loading class.
 
-    -   Open the plugin ``AndroidManifest.xml`` file.
+5. Add the remaining logic for your plugin and run the ``gradlew build`` command to generate the plugin's ``aar`` file.
+   The build will likely generate both a ``debug`` and ``release`` ``aar`` files.
+   Depending on your need, pick only one version (usually the ``release`` one) which to provide your users with.
 
-    -   Add the ``<application></application>`` tag if it's missing.
+   It's recommended that the ``aar`` filename matches the following pattern: ``[PluginName]*.aar`` where ``PluginName`` is the name of the plugin in PascalCase (e.g.: ``GodotPayment.release.aar``).
 
-    -   In the ``<application>`` tag, add a ``<meta-data>`` tag setup as follow::
+6. Create a Godot Android Plugin configuration file to help the system detect and load your plugin:
 
-            <meta-data
-                android:name="org.godotengine.plugin.v1.[PluginName]"
-                android:value="[plugin.init.ClassFullName]" />
+  - The configuration file extension must be ``gdap`` (e.g.: ``MyPlugin.gdap``).
+  - The configuration file format is as follow::
 
-        Where ``PluginName`` is the name of the plugin, and ``plugin.init.ClassFullName`` is the full name (package + class name) of the plugin loading class.
+        [config]
 
 5.  Add the remaining logic for your plugin and run the ``gradlew build`` command to generate the plugin's ``aar`` file.
     The build will likely generate both a ``debug`` and ``release`` ``aar`` files.
     Depending on your need, pick only one version (usually the ``release`` one) which to provide your users with.
 
-    It's recommended that the ``aar`` filename matches the following pattern: ``[PluginName]*.aar`` where ``PluginName`` is the name of the plugin in PascalCase (e.g.: ``GodotPayment.release.aar``).
+        [dependencies]
 
-6.  Create a Godot Android Plugin configuration file to help the system detect and load your plugin:
+        local=["local_dep1.aar", "local_dep2.aar"]
+        remote=["example.plugin.android:remote-dep1:0.0.1", "example.plugin.android:remote-dep2:0.0.1"]
+        custom_maven_repos=["http://repo.mycompany.com/maven2"]
 
     -   The configuration file extension must be ``gdap`` (e.g.: ``MyPlugin.gdap``).
 
@@ -109,7 +118,9 @@ The instructions below assumes that you're using Android Studio.
 
             -   **name**: name of the plugin
 
-            -   **binary_type**: can be either ``local`` or ``remote``. The type affects the **binary** field
+    - **name**: name of the plugin.
+    - **binary_type**: can be either ``local`` or ``remote``. The type affects the **binary** field.
+    - **binary**:
 
             -   **binary**:
 
@@ -125,7 +136,7 @@ The instructions below assumes that you're using Android Studio.
 
             -   **local**: contains a list of filepaths to the local ``.aar`` binary files the plugin depends on. Similarly to the ``binary`` field (when the ``binary_type`` is ``local``), the local binaries' filepaths can be relative or absolute.
 
-            -   **remote**: contains a list of remote binary gradle dependencies for the plugin.
+      - If **binary_type** is ``remote``, then this should be a declaration for a `remote gradle binary <https://developer.android.com/studio/build/dependencies#dependency-types>`_ (e.g.: ``org.godot.example:my-plugin:0.0.0``).
 
             -   **custom_maven_repos**: contains a list of URLs specifying the custom maven repositories required for the plugin's dependencies
 
@@ -153,10 +164,9 @@ Bundling GDNative resources
 An Android plugin can define and provide C/C++ GDNative resources, either to provide and/or access functionality from the game logic.
 The GDNative resources can be bundled within the plugin ``aar`` file which simplifies the distribution and deployment process:
 
-    -   The shared libraries (``.so``) for the defined GDNative libraries will be automatically bundled by the ``aar`` build system.
-
-    -   Godot ``*.gdnlib`` and ``*.gdns`` resource files must be manually defined in the plugin ``assets`` directory.
-        The recommended path for these resources relative to the ``assets`` directory should be: ``godot/plugin/v1/[PluginName]/``.
+- The shared libraries (``.so``) for the defined GDNative libraries will be automatically bundled by the ``aar`` build system.
+- Godot ``*.gdnlib`` and ``*.gdns`` resource files must be manually defined in the plugin ``assets`` directory.
+  The recommended path for these resources relative to the ``assets`` directory should be: ``godot/plugin/v1/[PluginName]/``.
 
 For GDNative libraries, the plugin singleton object must override the ``org.godotengine.godot.plugin.GodotPlugin::getPluginGDNativeLibrariesPaths()`` method,
 and return the paths to the bundled GDNative libraries config files (``*.gdnlib``). The paths must be relative to the ``assets`` directory.
@@ -165,11 +175,9 @@ At runtime, the plugin will provide these paths to Godot core which will use the
 Reference implementations
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
--   `Godot Oculus Mobile plugin <https://github.com/GodotVR/godot_oculus_mobile>`_
-
-    -   `Bundled gdnative resources <https://github.com/GodotVR/godot_oculus_mobile/tree/master/plugin/src/main/assets/addons/godot_ovrmobile>`_
-
--   `Godot Google Play Billing plugin <https://github.com/godotengine/godot-google-play-billing>`_
+- `Godot Oculus Mobile plugin <https://github.com/GodotVR/godot_oculus_mobile>`_
+  - `Bundled gdnative resources <https://github.com/GodotVR/godot_oculus_mobile/tree/master/plugin/src/main/assets/addons/godot_ovrmobile>`_
+- `Godot Google Play Billing plugin <https://github.com/godotengine/godot-google-play-billing>`_
 
 
 Troubleshooting
@@ -180,6 +188,5 @@ Godot crashes upon load
 
 Check ``adb logcat`` for possible problems, then:
 
--  Check that the methods exposed by the plugin used the following Java types:  ``void``, ``boolean``, ``int``, ``float``, ``java.lang.String``, ``org.godotengine.godot.Dictionary``, ``int[]``, ``byte[]``, ``float[]``, ``java.lang.String[]``.
-
-    -   More complex datatypes are not supported for now.
+- Check that the methods exposed by the plugin used the following Java types: ``void``, ``boolean``, ``int``, ``float``, ``java.lang.String``, ``org.godotengine.godot.Dictionary``, ``int[]``, ``byte[]``, ``float[]``, ``java.lang.String[]``.
+- More complex datatypes are not supported for now.

tutorials/plugins/editor/making_plugins.rst

@@ -73,8 +73,9 @@ change: it must be a ``tool`` script, or else it will not load properly in the
 editor, and it must inherit from :ref:`class_EditorPlugin`.
 
 .. warning::
+
     In addition to the EditorPlugin script, any other GDScript that your plugin uses
-    must *also* be a tool.  Any GDScript without ``tool`` imported into the editor
+    must *also* be a tool. Any GDScript without ``tool`` imported into the editor
     will act like an empty file!
 
 It's important to deal with initialization and clean-up of resources.

tutorials/vr/developing_for_oculus_quest.rst

@@ -81,7 +81,7 @@ is the scene we run. Godot does not ask you to set this on export.
 
 .. image:: img/quest_project_settings.png
 
-Then go into the export menu and configure a new Android export. if
+Then go into the export menu and configure a new Android export. If
 you still haven't gone through the :ref:`doc_exporting_for_android`
 page do it now. If you didn't you'll have some red messages on this
 screen.

tutorials/vr/vr_starter_tutorial/vr_starter_tutorial_part_one.rst

@@ -770,7 +770,7 @@ teleport, it will make the ``teleport_mesh`` visible so the user knows where the
 _________________
 
 If ``held_object`` is not equal to ``null``, then the VR controller is holding something. We then check to see if the object that is being held, ``held_object``, extends
-a class called ``VR_Interactable_Rigidbody``. we have not made ``VR_Interactable_Rigidbody`` yet, but ``VR_Interactable_Rigidbody`` will be a custom class we will use
+a class called ``VR_Interactable_Rigidbody``. We have not made ``VR_Interactable_Rigidbody`` yet, but ``VR_Interactable_Rigidbody`` will be a custom class we will use
 on all of the special/custom :ref:`RigidBody <class_RigidBody>`-based nodes in the project.
 
 .. tip:: Don't worry, we will cover ``VR_Interactable_Rigidbody`` after this section!

tutorials/vr/vr_starter_tutorial/vr_starter_tutorial_part_two.rst

@@ -848,7 +848,7 @@ that the functions defined defined in ``VR_Interactable_Rigidbody`` can be calle
 
 Next, let's look at the class variables:
 
-* ``SWORD_DAMAGE``: A constant to define the amount of damage the sword does. This damage is applied  to every object in the sword on every ``_physics_process`` call
+* ``SWORD_DAMAGE``: A constant to define the amount of damage the sword does. This damage is applied to every object in the sword on every ``_physics_process`` call
 * ``COLLISION_FORCE``: A constant that defines the amount of force applied to :ref:`RigidBody <class_RigidBody>` nodes when the sword collides with a :ref:`PhysicsBody <class_PhysicsBody>`.
 * ``damage_body``: A variable to hold the :ref:`KinematicBody <class_KinematicBody>` node used to detect whether the sword is stabbing a :ref:`PhysicsBody <class_PhysicsBody>` node or not.
 * ``sword_noise``: A variable to hold the :ref:`AudioStreamPlayer3D <class_AudioStreamPlayer3D>` node used to play a sound when the sword collides with something.