Capitalize all instances of Godot (except the binary name)

development/cpp/configuring_an_ide.rst

@@ -149,7 +149,7 @@ Add the following includes/imports:
 
 Apply the changes.
 
-Switch to the "Custom Build System" tab. Add a build configuration 
+Switch to the "Custom Build System" tab. Add a build configuration
 and keep the build directory blank. Enable build tools and add ``scons``
 as the executable then add ``platform=x11 target=debug`` (``platform=osx``
 if you're on macOS) as the arguments.
@@ -211,7 +211,7 @@ Add a Command Line Target:
 
 Add Godot Source to the Project:
 
-- Drag and drop godot source into project file browser.
+- Drag and drop Godot source into project file browser.
 - Uncheck *Create External Build System*
 
 .. image:: img/xcode_5_after_add_godot_source_to_project.png

development/cpp/creating_android_modules.rst

@@ -107,7 +107,7 @@ A singleton object template follows:
         }
 
         public void getInstanceId(int pInstanceId) {
-            // You will need to call this method from godot and pass in the get_instance_id().
+            // You will need to call this method from Godot and pass in the get_instance_id().
             instanceId = pInstanceId;
         }
 
@@ -181,7 +181,7 @@ AndroidManifest
 ---------------
 
 Some SDKs need custom values in AndroidManifest.xml. Permissions can be
-edited from the godot exporter so there is no need to add those, but
+edited from the Godot exporter so there is no need to add those, but
 maybe other functionalities are needed.
 
 Create the custom chunk of android manifest and put it inside the

development/cpp/custom_modules_in_cpp.rst

@@ -276,7 +276,7 @@ library that will be dynamically loaded when starting our game's binary.
 
     # Now define the shared library. Note that by default it would be built
     # into the module's folder, however it's better to output it into `bin`
-    # next to the godot 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.
@@ -301,7 +301,7 @@ during runtime with the ``LD_LIBRARY_PATH`` environ variable:
 you won't be able to play you project from within the editor.
 
 On top of that, it would be nice to be able to select whether to compile our
-module as shared library (for development) or as a part of the godot binary
+module as shared library (for development) or as a part of the Godot binary
 (for release). To do that we can define a custom flag to be passed to SCons
 using the `ARGUMENT` command:
 

development/cpp/custom_resource_format_loaders.rst

@@ -6,12 +6,12 @@ Custom resource format loaders
 Introduction
 ------------
 
-ResourceFormatLoader is a factory interface for loading file assets. 
-Resources are primary containers. When load is called on the same file 
-path again, the previous loaded Resource will be referenced. Naturally, 
+ResourceFormatLoader is a factory interface for loading file assets.
+Resources are primary containers. When load is called on the same file
+path again, the previous loaded Resource will be referenced. Naturally,
 loaded resources must be stateless.
 
-This guide assumes the reader knows how to create C++ modules and godot 
+This guide assumes the reader knows how to create C++ modules and Godot
 data types. If not, refer to this guide :ref:`doc_custom_modules_in_c++`.
 
 References
@@ -44,15 +44,15 @@ References
 Creating a ResourceFormatLoader
 -------------------------------
 
-Each file format consist of a data container and a ``ResourceFormatLoader``. 
+Each file format consist of a data container and a ``ResourceFormatLoader``.
 
-ResourceFormatLoaders are usually simple classes which return all the 
-necessary metadata for supporting new extensions in Godot. The 
+ResourceFormatLoaders are usually simple classes which return all the
+necessary metadata for supporting new extensions in Godot. The
 class must the return the format name and the extension string.
 
-In addition, ResourceFormatLoaders must convert file paths into 
-resources with the ``load`` function. To load a resource, ``load`` must 
-read and handle data serialization. 
+In addition, ResourceFormatLoaders must convert file paths into
+resources with the ``load`` function. To load a resource, ``load`` must
+read and handle data serialization.
 
 
 .. code:: cpp
@@ -160,7 +160,7 @@ Here is an example of how to create a custom datatype
 		}
 
 		operator String() const {
-			JSON a; 
+			JSON a;
 			return a.print(dict);
 		}
 
@@ -172,17 +172,17 @@ Here is an example of how to create a custom datatype
 Considerations
 ~~~~~~~~~~~~~~
 
-Some libraries may not define certain common routines such as i/o handling. 
+Some libraries may not define certain common routines such as i/o handling.
 Therefore, Godot call translations are required.
 
-For example, here is the code for translating ``FileAccess`` 
+For example, here is the code for translating ``FileAccess``
 calls into ``std::istream``.
 
 .. code:: cpp
 
 	#include <istream>
 	#include <streambuf>
-    
+
 	class GodotFileInStreamBuf : public std::streambuf{
 	public:
 		GodotFileInStreamBuf(FileAccess * fa) {
@@ -262,10 +262,10 @@ Loading it on GDScript
 	  ]
 	}
 
-.. code:: 
+.. code::
+
+	extends Node
 
-	extends Node 
-	
 	func _ready():
 		var myjson = load("res://demo.mjson")
 		print( myjson.toString())

getting_started/editor/command_line_tutorial.rst

@@ -66,7 +66,7 @@ The project can now be opened with Godot.
 Running the editor
 ------------------
 
-Running the editor is done by executing godot with the ``-e`` flag. This
+Running the editor is done by executing Godot with the ``-e`` flag. This
 must be done from within the project directory or a subdirectory,
 otherwise the command is ignored and the project manager appears.
 

getting_started/step_by_step/scenes_and_nodes.rst

@@ -29,7 +29,7 @@ Nodes
 -----
 
 But let's start with the basics. Nodes are fundamental building blocks for
-creating a game. As mentioned above, a node can perform a variety of specialized 
+creating a game. As mentioned above, a node can perform a variety of specialized
 functions. However, any given node always has the following attributes:
 
 -  It has a name.
@@ -80,7 +80,7 @@ Let's make these abstract concepts more concrete with an example. Following a
 long tradition in tutorials, we'll start with a "Hello World" project.
 This will introduce us to using the editor.
 
-If you run the godot executable outside of a project, the Project Manager
+If you run the Godot executable outside of a project, the Project Manager
 appears. This helps developers manage their projects.
 
 .. image:: img/project_manager.png
@@ -170,7 +170,7 @@ Configuring the project
 Ok, it's time to configure the project. Right now, the only way to run
 something is to execute the current scene. Projects, however, may have several
 scenes, so one of them must be set as the main scene. This is the scene that
-will be loaded any time the project is run. 
+will be loaded any time the project is run.
 
 These settings are all stored in a project.godot file, which is a plaintext
 file in win.ini format (for easy editing). There are dozens of settings that
@@ -193,7 +193,7 @@ project.godot file and shows their default values. If you change a value, a
 tick is marked to the left of its name. This means that the property will be
 saved to the project.godot file and remembered.
 
-As a side note, it is also possible to add custom configuration options and 
+As a side note, it is also possible to add custom configuration options and
 read them in at run-time using the :ref:`ProjectSettings <class_ProjectSettings>` singleton.
 
 To be continued...

getting_started/step_by_step/your_first_game.rst

@@ -174,7 +174,7 @@ set its value in the Inspector. This can be handy for values that you
 want to be able to adjust just like a node's built-in properties. Click on
 the ``Player`` node and set the speed property to ``400``.
 
-.. warning:: If you're using C#, you need to restart godot editor temporarily to see
+.. warning:: If you're using C#, you need to restart Godot editor temporarily to see
             exported variables in the editor until it's fixed.
 
 .. image:: img/export_variable.png

getting_started/workflow/export/exporting_for_pc.rst

@@ -4,8 +4,8 @@ Exporting for PC
 ================
 
 The simplest way to distribute a game for PC is to copy the executables
-(godot.exe on Windows, godot on the rest), compress the folder and send it
-to someone else. However, this is often not desired.
+(``godot.exe`` on Windows, ``godot`` on the rest), compress the folder
+and send it to someone else. However, this is often not desired.
 
 Godot offers a more elegant approach for PC distribution when using the
 export system. When exporting for PC (Linux, Windows, macOS), the exporter

tutorials/plugins/gdnative/gdnative-c-example.rst

@@ -112,7 +112,7 @@ These are forward declarations for the functions we'll be implementing for our o
     godot_variant simple_get_data(godot_object *p_instance, void *p_method_data
         , void *p_user_data, int p_num_args, godot_variant **p_args);
 
-Next up is the first of the entry points Godot will call when our dynamic library is loaded. These methods are all prefixed with godot (you can change this later on) followed by their name. ``gdnative_init`` is a function that initialises our dynamic library. Godot will give it a pointer to a structure that contains various bits of information we may find useful amongst which the pointers to our API structures.
+Next up is the first of the entry points Godot will call when our dynamic library is loaded. These methods are all prefixed with Godot (you can change this later on) followed by their name. ``gdnative_init`` is a function that initialises our dynamic library. Godot will give it a pointer to a structure that contains various bits of information we may find useful amongst which the pointers to our API structures.
 
 For any additional API structures we need to loop through our extensions array and check the type of extension.
 
@@ -288,7 +288,7 @@ If singleton is true our library is automatically loaded and a function called g
 
 If load_once is true our library is loaded only once and each individual script that uses our library will use the same data. Any variable you define globally will be accessible from any instance of your object you create. If load_once is false a new copy of the library is loaded into memory each time a script access the library.
 
-The symbol_prefix is a prefix for our core functions. So the godot in godot_nativescript_init for instance. If you use multiple GDnative libraries that you wish to statically link you'll have to use different prefixes. This again is a subject to dive into deeper in a separate tutorial, it is only needed at this time for deployment to iOS as this platform does not like dynamic libraries.
+The symbol_prefix is a prefix for our core functions. So the Godot in godot_nativescript_init for instance. If you use multiple GDnative libraries that you wish to statically link you'll have to use different prefixes. This again is a subject to dive into deeper in a separate tutorial, it is only needed at this time for deployment to iOS as this platform does not like dynamic libraries.
 
 The **entry** section tells us for each platform and feature combination which dynamic library has to be loaded. This also informs the exporter which files need to be exported when exporting to a specific platform.