Words and fixes

.wordlist.txt

@@ -40,7 +40,11 @@ tilesource
 collectionfactory
 apis
 init
+playtesting
 gameplay
+bodypart
+gameobject
+tilemaps
 blockfactory
 subfolder
 spinescene
@@ -49,6 +53,7 @@ subfolder
 symbolicate
 symbolication
 callstack
+backbuffer
 framerate
 namespace
 shadertoy

docs/en/tutorials/grading.md

@@ -268,7 +268,7 @@ Here `B` is the blue component value between 0 and 1 and `N` is the total number
 
 For example, the RGB value `(0.63, 0.83, 0.4)` is found in the cell containing all the colors with a blue value of `0.4`, which is cell number 6. Knowing that, the lookup of the final texture coordinates based on the green and red values is straightforward:
 
-![lut lookup](images/grading/lut_lookup.png)
+![lookup table](images/grading/lut_lookup.png)
 
 Note that we need to treat red and green values `(0, 0)` as being in the *center* of the bottom left pixel and the values `(1.0, 1.0)` as being in the *center* of the top right pixel.
 
@@ -278,7 +278,7 @@ The reason we read starting at the center of the lower left pixel and up to the
 
 When sampling at these specific coordinates on the texture we see that we end up right between 4 pixels. So what color value will GL tell us that point has?
 
-![lut filtering](images/grading/lut_filtering.png)
+![lookup table filtering](images/grading/lut_filtering.png)
 
 The answer depends on how we have specified the sampler's *filtering* in the material.
 
@@ -296,15 +296,15 @@ Let's implement the texture lookup in the fragment shader:
 2. Add a second sampler called "lut" (for lookup table).
 3. Set the *Filter min* property to `FILTER_MODE_MIN_LINEAR` and the *Filter mag* property to `FILTER_MODE_MAG_LINEAR`.
 
-    ![lut sampler](images/grading/material_lut_sampler.png)
+    ![lookup table sampler](images/grading/material_lut_sampler.png)
 
 4. Download the following lookup table texture (*lut16.png*) and add it to your project.
 
-    ![16 colors lut lookup table](images/grading/lut16.png)
+    ![16 colors lookup table](images/grading/lut16.png)
 
 5. Open *main.collection* and set the *lut* texture property to the downloaded lookup texture.
 
-    ![quad model lut](images/grading/quad_lut.png)
+    ![quad model lookup table](images/grading/quad_lut.png)
 
 6. Finally, open *grade.fp* so we can add support for color lookup:
 
@@ -431,6 +431,7 @@ void main()
     gl_FragColor = graded_color;
 }
 ```
+
 1. Calculate the two adjacent cells to read from.
 2. Calculate two separate lookup positions, one for each cell.
 3. Sample the two colors from the cell positions.
@@ -448,7 +449,7 @@ Okay, that was a lot of work to draw something that looks exactly like the origi
 2. Open the screenshot in your favorite image manipulation program.
 3. Apply any number of color adjustments (brightness, contrast, color curves, white balance, exposure etc, etc).
 
-    ![world in Affinity](images/grading/world_graded_affinity.png)
+![world in Affinity](images/grading/world_graded_affinity.png)
 
 4. Apply the same color adjustments to the lookup table texture file (*lut16.png*).
 5. Save the color adjusted lookup table texture file.

docs/en/tutorials/magic-link.md

@@ -293,7 +293,7 @@ Now, the blocks will be sprayed with first one `make_orange` message, then `make
 
 Now we need  assets for the marker that will be used to indicate when the blocks are linked by the player. The idea is to simply overlay a graphic on each block to show that it is linked.
 
-We need to create a "connector" game object, that holds the connector sprite image as well as a "connectorfactory" factory component in the "board" game object:
+We need to create a "connector" game object, that holds the connector sprite image as well as a "connector factory" factory component in the "board" game object:
 
 ![Connector game object](images/magic-link/linker_connector.png)
 

docs/en/tutorials/runner.md

@@ -194,7 +194,7 @@ end
 7. Update the object's position with the new speed.
 
 ::: sidenote
-Defold is a fast engine core that manages your data and game objects. Any logic or behavior that you need for your game is created in the Lua language. Lua is a fast and light-weight programming language that is great for writing game logic. There are great resources available to learn the language, like the book http://www.lua.org/pil/[Programming in Lua] and the official http://www.lua.org/manual/5.3/[Lua reference manual].
+Defold is a fast engine core that manages your data and game objects. Any logic or behavior that you need for your game is created in the Lua language. Lua is a fast and light-weight programming language that is great for writing game logic. There are great resources available to learn the language, like the book [Programming in Lua](http://www.lua.org/pil/) and the official [Lua reference manual](http://www.lua.org/manual/5.3/).
 
 Defold adds a set of APIs on top of Lua, as well as a _message passing_ system that allows you to program communications between game objects. See the [Message passing manual](/manuals/message-passing) for details on how this works.
 :::

docs/en/tutorials/texture-scrolling.md

@@ -62,7 +62,7 @@ void main()
 }
 ```
 
-The model supplies the attribute `texcoord0` which is our texture UV coordinates. We declare our vec4 uniform named animation_time and we also have two vec2 varying texcoords 0 and 1 which we pass these to the fragment program after we assign them the attribute UV coords `texcoord0` in `void main()`. As you can see `var_texcoord1` is different because this one we are offsetting before it is sent to the fragment program. Assign a vec2 so that we can `animation_time` to the x and y separately if we want. In this case we only take `texcoord0.x` and subtract our constant `animation_time.x` which when animated will offset in the negative U axis (horizontal left), we set `texcoord0.y` to keep its attribute position. EZ PZ!
+The model supplies the attribute `texcoord0` which is our texture UV coordinates. We declare our vec4 uniform named animation_time and we also have two vec2 varying texcoords 0 and 1 which we pass to the fragment program after we assign them the attribute UV coordinates `texcoord0` in `void main()`. As you can see `var_texcoord1` is different because this one we are offsetting before it is sent to the fragment program. Assign a vec2 so that we can `animation_time` to the x and y separately if we want. In this case we only take `texcoord0.x` and subtract our constant `animation_time.x` which when animated will offset in the negative U axis (horizontal left), we set `texcoord0.y` to keep its attribute position. EZ PZ!
 
 
 ```glsl