Merge branch 'master' of https://github.com/defold/doc

docs/en/en.json

@@ -342,6 +342,18 @@
                 "description": "In this tutorial you will convert a shader from shadertoy.com to Defold.",
                 "image": "/tutorials/images/videos/shadertoy.png"
             },
+            {
+                "path": "/tutorials/runner",
+                "name": "Runner",
+                "description": "In this tutorial you start with an empty project and build a complete runner game with an animated character, physics collision, pickups and scoring.",
+                "image": "/tutorials/images/runner/2/run_game.png"
+            },
+            {
+                "path": "/tutorials/car",
+                "name": "Building a car",
+                "description": "If you are new to Defold, this guide will help you getting your bearings right in the editor. It also explains the basic ideas and the most common building blocks in Defold - game objects, collections, scripts and sprites.",
+                "image": "/tutorials/images/car/start_car_collection_complete.png"
+            },
             {
                 "path": "https://defold.com/2021/03/02/Creating-online-games-using-Nakama-and-Defold/",
                 "name": "Creating online games using Nakama and Defold",
@@ -411,24 +423,12 @@
                 "description": "In this article, you go through the implementation of a basic tile-based 2D platformer in Defold. The mechanics you learn are moving left/right, jumping and falling.",
                 "image": "/tutorials/images/platformer/collision.png"
             },
-            {
-                "path": "/tutorials/runner",
-                "name": "Runner (OLD)",
-                "description": "In this tutorial you start with an empty project and build a complete runner game with an animated character, physics collision, pickups and scoring.",
-                "image": "/tutorials/images/runner/2/run_game.png"
-            },
             {
                 "path": "/tutorials/magic-link",
                 "name": "Magic link (OLD)",
                 "description": "In this tutorial you will build a complete little puzzle game with a start screen, the mechanics of the game and simple level progression in the form of increasing difficulty.",
                 "image": "/tutorials/images/magic-link/linker_connector_screen.png"
             },
-            {
-                "path": "/tutorials/car",
-                "name": "Building a car (OLD)",
-                "description": "If you are new to Defold, this guide will help you getting your bearings right in the editor. It also explains the basic ideas and the most common building blocks in Defold - game objects, collections, scripts and sprites.",
-                "image": "/tutorials/images/car/start_car_collection_complete.png"
-            },
             {
                 "path": "/tutorials/main-menu",
                 "name": "Main menu (OLD)",

docs/en/manuals/importing-graphics.md

@@ -5,7 +5,7 @@ brief: This manual covers how to import and use 2D graphics.
 
 # Importing 2D graphics
 
-Defold supports many kinds of visual components frequently used in 2D games. Use can use Defold to create static and animated sprites, UI components, particle effects, tile maps, bitmap fonts and Spine animations. Before you can create any of these visual components you need to import image files with the graphics that you wish to use. To import image files you simply drag the files from the file system on your computer and drop them in an appropriate place in the Defold editor *Assets pane*.
+Defold supports many kinds of visual components frequently used in 2D games. You can use Defold to create static and animated sprites, UI components, particle effects, tile maps, bitmap fonts and Spine animations. Before you can create any of these visual components you need to import image files with the graphics that you wish to use. To import image files you simply drag the files from the file system on your computer and drop them in an appropriate place in the Defold editor *Assets pane*.
 
 ![Importing files](images/graphics/import.png){srcset="images/graphics/[email protected] 2x"}
 

docs/en/shared/blend-modes.md

@@ -7,4 +7,7 @@ Add
 : Brighten the background with the color values of the corresponding pixels of the component: `src.rgb + dst.rgb`
 
 Multiply
-: Darken the background with values of the the corresponding pixels of the component: `src.rgb * dst.rgb`
+: Darken the background with values of the corresponding pixels of the component: `src.rgb * dst.rgb`
+
+Screen
+: Opposite of Multiply. Brighten background and values of the corresponding pixels of the component: `src.rgb - dst.rgb * dst.rgb`

docs/en/tutorials/car.md

@@ -9,6 +9,21 @@ If you are new to Defold, this guide will help you getting your bearings right i
 
 We're going to start from an empty project and work step by step to a very small, playable application. At the end you will hopefully have a feel for how Defold works and you will be ready to tackle a more extensive tutorial or dive right into the manuals.
 
+::: sidenote
+Throughout the tutorial, detailed descriptions on concepts and how to do certain moments are marked like this paragraph. If you feel that these section go into too much detail, please skip them.
+:::
+
+## Creating a new project
+
+![New Project](images/new_empty.png)
+
+1. Start Defold.
+2. Select *New Project* on the left.
+3. Select the *From Template* tab.
+4. Select *Empty Project*
+5. Select a location for the project on your local drive.
+6. Click *Create New Project*.
+
 ## The editor
 
 Start by creating a [new project](/manuals/project-setup/) and opening it in the editor. If you double-click the file *main/main.collection* the file will open up:
@@ -37,15 +52,19 @@ Console
 
 ## Running the game
 
-The "Empty" project template actually isn't completely empty. As you've already seen, it contains one game object with a simple image. Select <kbd>Project ▸ Build and Launch</kbd> to build the project and launch the game.
+The "Empty" project template actually is completely empty. Nonetheless, select <kbd>Project ▸ Build and Launch</kbd> to build the project and launch the game.
 
 ![Build and launch](images/car/start_build_and_launch.png)
 
-It's perhaps not very exciting, but it's a running Defold game application and we can easily modify it into something more interesting. So let's do that.
+A black screen is perhaps not very exciting, but it's a running Defold game application and we can easily modify it into something more interesting. So let's do that.
+
+::: sidenote
+The Defold editor works on files. By double-clicking a file in the *Assets pane* you open it in a suitable editor. You can then work with the contents of the file.
 
-First of all, let's clean the file *main.collection* of the one game object it contains. Select "logo" in the *Outline* view, right-click and select *Delete*. That's it. If you run the game again, the application window will be totally black.
+When you are done editing a file you have to save it. Select <kbd>File ▸ Save</kbd> in the main menu. The editor gives a hint by adding an asterisk '\*' to the filename in the tab for any file that contain unsaved changes.
 
-![Delete game object](images/car/start_delete_go.png)
+![File with unsaved changes](images/car/file_changed.png)
+:::
 
 ## Assembling the car
 
@@ -98,110 +117,155 @@ Move the tire game objects into place by selecting them and then choosing <kbd>S
 
 ![Car collection complete](images/car/start_car_collection_complete.png)
 
+## The car script
+
 The last piece of the puzzle is a _script_ to control the car. A script is a component that contains a program that defines game object behaviors. With scripts you can specify the rules of your game, how objects should respond to various interactions (with the player as well as other objects). All scripts are written in the Lua programming language. To be able to work with Defold, you or someone on your team needs to learn how to program in Lua.
 
 Mark "main" in the *Assets pane*, right-click and select <kbd>New ▸ Script File</kbd>. Name the new file *car.script*, then add it to the "car" game object by marking "car" in the *Outline* view, right click and select <kbd>Add Component File</kbd>. Select *car.script* and click *OK*. Save the collection file.
 
-Double click *car.script* and edit the script so it contains the following:
+Double click *car.script* to open it.
+
+::: sidenote
+Defold provides several lifecycle functions to code game logic. Read more about them in the [Script Manual](/manuals/script).
+:::
+
+Start by removing the `final`, `on_message` and `on_reload` functions as we won't be needing them
+for this tutorial.
+
+Next, add the following lines of code before the init function start starts.
 
 ```lua
--- car.script
 -- Constants
-local turn_speed = 0.1                           -- Slerp factor
+local turn_speed = 0.1                           									  -- Slerp factor
 local max_steer_angle_left = vmath.quat_rotation_z(math.pi / 6)     -- 30 degrees
 local max_steer_angle_right = vmath.quat_rotation_z(-math.pi / 6)   -- -30 degrees
-local wheels_vector = vmath.vector3(0, 72, 0)               -- Vector from center of back and front wheel pairs
+local steer_angle_zero = vmath.quat_rotation_z(0)									  -- Zero degrees
+local wheels_vector = vmath.vector3(0, 72, 0)         		        	-- Vector from center of back and front wheel pairs
 
-function init(self)
-    -- Send a message to the render script (see builtins/render/default.render_script) to set the clear color.
-    -- This changes the background color of the game. The vector4 contains color information
-    -- by channel from 0-1: Red = 0.2. Green = 0.2, Blue = 0.2 and Alpha = 1.0
-    msg.post("@render:", "clear_color", { color = vmath.vector4(0.2, 0.2, 0.2, 1.0) } )
+local acceleration = 100 																						-- The acceleration of the car
 
-    -- Acquire input focus so we can react to input
-    msg.post(".", "acquire_input_focus")
+-- prehash the inputs
+local left = hash("left")
+local right = hash("right")
+local accelerate = hash("accelerate")
+local brake = hash("brake")
+```
 
-    -- Some variables
-    self.steer_angle = vmath.quat()
-    self.direction = vmath.quat()
+The changes made here are fairly simple, we just added a bunch of `constants` to our script that we'll be using later on to code our car.
 
-    -- Velocity and acceleration are car relative (not rotated)
-    self.velocity = vmath.vector3()
-    self.acceleration = vmath.vector3()
-end
+::: sidenote
+Pay notice to how we store the hashes beforehand in variables. It is actually a good practice to do so as it makes your code more readable and performant.
+:::
 
-function update(self, dt)
-    -- Calculate new velocity based on current acceleration
-    self.velocity = self.velocity + self.acceleration * dt
+Next, edit the `init` function so that it contains the following:
 
-    -- Calculate the new positions of front and back wheels
-    local front_vel = vmath.rotate(self.steer_angle, self.velocity)
-    local new_front_pos = vmath.rotate(self.direction, wheels_vector + front_vel)
-    local new_back_pos = vmath.rotate(self.direction, self.velocity)
+```lua
+function init(self)
+	-- Send a message to the render script (see builtins/render/default.render_script) to set the clear color.
+	-- This changes the background color of the game. The vector4 contains color information
+	-- by channel from 0-1: Red = 0.2. Green = 0.2, Blue = 0.2 and Alpha = 1.0
+	msg.post("@render:", "clear_color", { color = vmath.vector4(0.2, 0.2, 0.2, 1.0) } )		--<1>
 
-    -- Calculate the car's new direction
-    local new_dir = vmath.normalize(new_front_pos - new_back_pos)
-    self.direction = vmath.quat_rotation_z(math.atan2(new_dir.y, new_dir.x) - math.pi / 2)
+	-- Acquire input focus so we can react to input
+	msg.post(".", "acquire_input_focus")		-- <2>
 
-    -- Update position based on current velocity and direction
-    local pos = go.get_position()
-    pos = pos + vmath.rotate(self.direction, self.velocity)
-    go.set_position(pos)
+	-- Some variables
+	self.steer_angle = vmath.quat()				 -- <3>
+	self.direction = vmath.quat()
 
-    -- Set the game object's rotation to the direction
-    go.set_rotation(self.direction)
-end
+	-- Velocity and acceleration are car relative (not rotated)
+	self.velocity = vmath.vector3()
+	self.acceleration = vmath.vector3()
 
-function on_message(self, message_id, message, sender)
-    if message_id == hash("left") then
-        -- Interpolate the steering angle.
-        self.steer_angle = vmath.slerp(turn_speed, self.steer_angle, max_steer_angle_left)
-        go.set_rotation(self.steer_angle, "left_wheel")
-        go.set_rotation(self.steer_angle, "right_wheel")
-    elseif message_id == hash("right") then
-        -- Interpolate the steering angle.
-        self.steer_angle = vmath.slerp(turn_speed, self.steer_angle, max_steer_angle_right)
-        go.set_rotation(self.steer_angle, "left_wheel")
-        go.set_rotation(self.steer_angle, "right_wheel")
-    elseif message_id == hash("set_acceleration") then
-        -- Set acceleration y component (car relative) to the message data field "acc".
-        self.acceleration.y = message.acc
-    end
+	-- Input vector. This is modified later in the on_input function
+	-- to store the input.
+	self.input = vmath.vector3()
 end
+```
 
-function on_input(self, action_id, action)
-    if action_id == hash("left") then
-        msg.post("#", "left")
-    elseif action_id == hash("right") then
-        msg.post("#", "right")
-    elseif action_id == hash("accelerate") and action.value == 1 then
-        msg.post("#", "set_acceleration", { acc = 10 })
-    elseif action_id == hash("accelerate") and action.value == 0 then
-        msg.post("#", "set_acceleration", { acc = 0 })
-    elseif action_id == hash("brake") and action.value == 1 then
-        msg.post("#", "set_acceleration", { acc = -10 })
-    elseif action_id == hash("brake") and action.value == 0 then
-        msg.post("#", "set_acceleration", { acc = 0 })
-    end
+Wondering what we just changed? Here is an explanation.
+
+1. Send a message to our render script asking it set the background color to grey. Render scripts are special scripts in Defold that control how objects are shown on the screen.
+2. To listen to input actions in a script component or GUI script, the message `acquire_input_focus` needs to be sent to the game object holding the component. In our case we send this message to the gameobject that holds the car script.
+3. Then, we declare some variables that we'll use to keep track of the current state of our car.
+
+That was easy now, wasn't it? We'll continue now by editing the `update` function so that it now contains the following:
+
+```lua
+function update(self, dt)
+	-- Set acceleration to the y input
+	self.acceleration.y = self.input.y * acceleration				-- <1>
+
+	-- Calculate the new positions of front and back wheels
+	local front_vel = vmath.rotate(self.steer_angle, self.velocity)
+	local new_front_pos = vmath.rotate(self.direction, wheels_vector + front_vel)
+	local new_back_pos = vmath.rotate(self.direction, self.velocity)								-- <2>
+
+	-- Calculate the car's new direction
+	local new_dir = vmath.normalize(new_front_pos - new_back_pos)
+	self.direction = vmath.quat_rotation_z(math.atan2(new_dir.y, new_dir.x) - math.pi / 2)			-- <3>
+
+	-- Calculate new velocity based on current acceleration
+	self.velocity = self.velocity + self.acceleration * dt			-- <4>
+
+	-- Update position based on current velocity and direction
+	local pos = go.get_position()
+	pos = pos + vmath.rotate(self.direction, self.velocity)
+	go.set_position(pos)																			-- <5>
+
+	-- Interpolate the wheels using vmath.slerp
+	if self.input.x > 0 then																		-- <6>
+		self.steer_angle = vmath.slerp(turn_speed, self.steer_angle, max_steer_angle_right)
+	elseif self.input.x < 0 then
+		self.steer_angle = vmath.slerp(turn_speed, self.steer_angle, max_steer_angle_left)
+	else
+		self.steer_angle = vmath.slerp(turn_speed, self.steer_angle, steer_angle_zero)
+	end
+
+	-- Update the wheel rotation
+	go.set_rotation(self.steer_angle, "left_wheel")					-- <7>
+	go.set_rotation(self.steer_angle, "right_wheel")
+
+	-- Set the game object's rotation to the direction
+	go.set_rotation(self.direction)
+
+	-- reset acceleration and input
+	self.acceleration = vmath.vector3()								-- <8>
+	self.input = vmath.vector3()
 end
 ```
 
-Don't forget to save your edits. The script contains 5 parts:
+That was a huge function! But don't worry, this is how it all works:
 
-Constants
-: At the top we define a couple of local variables that we use as constants throughout the script. This is optional but usually a good practice since it makes changes of the values easier.
+1. We first set our acceleration vector based on our input vector. This ensures that the car's acceleration is in the direction of the input.
+2. Next, the displacement of both the wheels is calculated based on the simple logic that while the back wheels of the car always move forward, the front wheel move in the direction they're turned towards.
+3. Based on the displacement of both wheels, the new direction of motion of our car is calculated.
+4. Here, we add the calculated acceleration to the velocity.
+5. Finally, we update the position of the car based on our current velocity.
+6. We slerp the steering angle based on our left/right input. This is done so that the wheels don't snap instantly whenever the input changes.
+7. The rotation of the the wheels is then set based on the current steer angle of the car. Similarily, the rotation of the car is set based on the direction it is currently moving in.
+8. Finally, we reset the acceleration and input vectors.
 
-`init()`
-: The function `init()` is run when the game object that the script component exists in is brought to life in the game. This function is usually used to set up internal variables, that we add to the game object "self" that is passed to the function. Any variable added to "self" will be kept through the lifetime of the game object. This script sends two messages during initialization. The first is to the rendering system, which sets the background color for the game. The second message is sent to the game object harboring the script ("." is shorthand for that) asking the game object to start receiving input.
+Finally, it is time to make our car react to input. Update the `on_input` function so it looks like this:
 
-`update()`
-: This function is called once each frame (i.e. 60 times a second) during the lifetime of the game object. We use the function to calculate the speed and direction of the car based on the rotation of the car and the tires. The parameter "dt" is the current timestep (1/60 of a second in this case) and we use that to scale the calculations right. The way steering is computed is an approximation but yields pretty good results if the steering angles are not too extreme. After the calculations, the script updates the position of the game object. This affects all components in the game object (the car body sprite) as well as any child game objects (the tires).
+```lua
+function on_input(self, action_id, action)
+	-- set the input vector to correspond to the key press
+	if action_id == left then
+		self.input.x = -1
+	elseif action_id == right then
+		self.input.x = 1
+	elseif action_id == accelerate then
+		self.input.y = 1
+	elseif action_id == brake then
+		self.input.y = -1
+	end
+end
+```
 
-`on_message()`
-: This function is called whenever a message arrives to the script component. We check what message is arriving and take proper action, setting game object variables to new values. If steering left or right, we interpolate with `vmath.slerp()` against the max values, if we are accelerating or decelerating both are handled by the message "set_acceleration" and a message value "acc" with the value of acceleration, positive or negative.
+This function is actually fairly simple, we just accept the input and set our input vector.
 
-`on_input()`
-: Since this game object listens to input (through the message "acquire_input_focus" in `init()` we receive input actions. Input are mapped from actual key, mouse, touch or game pad input to input "actions". We react to steering, accelerate and brake actions. When these actions arrive we send messages to the script component itself ("#" is shorthand for that) and through the logic in `on_message()` the car reacts. Now, we could just as well have skipped `on_message()` and put all logic straight into `on_input()` but there are benefits to using messages like we do. By allowing the car object to react to messages we can move the input handling to a different place, or perhaps add an AI driver somewhere that could drive the car through messages.
+Don't forget to save your edits.
 
 ## Input
 
@@ -215,12 +279,161 @@ Now the car is ready to roll. We have created it inside "car.collection" but it
 
 ![Adding the car collection](images/car/start_adding_car_collection.png)
 
+Now, select <kbd>Project ▸ Build</kbd> and take your new car for a spin!
+You'll notice that you're now able to move to make the car move to your will. But something isn't right yet. When you leave the controls, the car does not stop, as it should have. It's time to add that in!
+
+## Drag to the rescue
+
+Whenever an object moves in the real world, the force of drag acts against the object causing it to slow down. This force almost falls proportional to the square velocity of the moving object, and hence can be described as `D = k * |V| * V` where `k` is a constant, `V` is the velocity and `|V|` its magnitude (speed). Let's add that.
+
+In the constants section at the top of the script, add the following constant
+
+```lua
+local drag = 1.1	        --the drag constant <1>
+```
+
+Then in the update function, just above this line add the following lines and save the file.
+
+```lua
+function update(self, dt)
+	...
+  -- Calculate new velocity based on current acceleration
+	self.velocity = self.velocity + self.acceleration * dt
+  ...
+end
+```
+
+```lua
+function update(self, dt)
+	...
+	-- Speed is the magnitude of the velocity
+	local speed = vmath.length_sqr(self.velocity)
+
+	-- Apply drag
+	self.acceleration = self.acceleration - speed * self.direction * drag
+
+	-- Stop if we are already slow enough
+	if speed < 0.5 then self.velocity = vmath.vector3(0) end
+  ...
+end
+```
+
+1. Declare the drag value as a constant.
+2. Calculate the speed with which we are moving.
+3. Apply the drag to the current acceleration based on the formula
+4. Stop if the car is already slow enough.
+
+## The complete car script
+
+After completing the above steps, your *car.script* should look like :
+
+```lua
+local turn_speed = 0.1                           				          	-- Slerp factor
+local max_steer_angle_left = vmath.quat_rotation_z(math.pi / 6)	    -- 30 degrees
+local max_steer_angle_right = vmath.quat_rotation_z(-math.pi / 6)   -- -30 degrees
+local steer_angle_zero = vmath.quat_rotation_z(0)				          	-- Zero degrees
+local wheels_vector = vmath.vector3(0, 72, 0)         				      -- Vector from center of back and front wheel pairs
+
+local acceleration = 100 		                      									-- The acceleration of the car
+local drag = 1.1                                                  	-- the drag constant
+
+function init(self)
+	-- Send a message to the render script (see builtins/render/default.render_script) to set the clear color.
+	-- This changes the background color of the game. The vector4 contains color information
+	-- by channel from 0-1: Red = 0.2. Green = 0.2, Blue = 0.2 and Alpha = 1.0
+	msg.post("@render:", "clear_color", { color = vmath.vector4(0.2, 0.2, 0.2, 1.0) } )
+
+	-- Acquire input focus so we can react to input
+	msg.post(".", "acquire_input_focus")
+
+	-- Some variables
+	self.steer_angle = vmath.quat()
+	self.direction = vmath.quat()
+
+	-- Velocity and acceleration are car relative (not rotated)
+	self.velocity = vmath.vector3()
+	self.acceleration = vmath.vector3()
+
+	-- Input vector. This is modified later in the on_input function
+	-- to store the input.
+	self.input = vmath.vector3()
+end
+
+function update(self, dt)
+	-- Set acceleration to the y input
+	self.acceleration.y = self.input.y * acceleration
+
+	-- Calculate the new positions of front and back wheels
+	local front_vel = vmath.rotate(self.steer_angle, self.velocity)
+	local new_front_pos = vmath.rotate(self.direction, wheels_vector + front_vel)
+	local new_back_pos = vmath.rotate(self.direction, self.velocity)
+
+	-- Calculate the car's new direction
+	local new_dir = vmath.normalize(new_front_pos - new_back_pos)
+	self.direction = vmath.quat_rotation_z(math.atan2(new_dir.y, new_dir.x) - math.pi / 2)
+
+	-- Speed is the magnitude of the velocity
+	local speed = vmath.length(self.velocity)
+
+	-- Apply drag
+	self.acceleration = self.acceleration - speed * self.velocity * drag
+
+	-- Stop if we are already slow enough
+	if speed < 0.5 then self.velocity = vmath.vector3() end
+
+	-- Calculate new velocity based on current acceleration
+	self.velocity = self.velocity + self.acceleration * dt
+
+	-- Update position based on current velocity and direction
+	local pos = go.get_position()
+	pos = pos + vmath.rotate(self.direction, self.velocity)
+	go.set_position(pos)
+
+	-- Interpolate the wheels using vmath.slerp
+	if self.input.x > 0 then
+		self.steer_angle = vmath.slerp(turn_speed, self.steer_angle, max_steer_angle_right)
+	elseif self.input.x < 0 then
+		self.steer_angle = vmath.slerp(turn_speed, self.steer_angle, max_steer_angle_left)
+	else
+		self.steer_angle = vmath.slerp(turn_speed, self.steer_angle, steer_angle_zero)
+	end
+
+	-- Update the wheel rotation
+	go.set_rotation(self.steer_angle, "left_wheel")
+	go.set_rotation(self.steer_angle, "right_wheel")
+
+	-- Set the game object's rotation to the direction
+	go.set_rotation(self.direction)
+
+	-- reset acceleration and input
+	self.acceleration = vmath.vector3()
+	self.input = vmath.vector3()
+end
+
+function on_input(self, action_id, action)
+	-- set the input vector to correspond to the key press
+	if action_id == hash("left") then
+		self.input.x = -1
+	elseif action_id == hash("right") then
+		self.input.x = 1
+	elseif action_id == hash("accelerate") then
+		self.input.y = 1
+	elseif action_id == hash("brake") then
+		self.input.y = -1
+	end
+end
+```
+
 ## Trying the final game
 
-Now, select <kbd>Project ▸ Build And Launch</kbd> from the main menu and take your new car for a spin!
+Now, select <kbd>Project ▸ Build</kbd> from the main menu and take your new car for a spin!
+
+That concludes this introductory tutorial. Here is a set of challenges that you may wish to tackle on your own:
 
-If you want you can try to add more instances of *car.collection* to *main.collection*. Each instance is a clone of what's inside *car.collection* with the exact same behavior. Each one listens to input and reacts to the same messages.
+1. Currently the car moves with the same acceleration in both forward and backward direction. You may wish to change this so that the car moves slower when it is moving backwards.
+2. Make some of the constants (like acceleration) `properties` so that they can be changed for different instances of the car.
+3. Add sounds to your car and make it go vroom! ([Hint](manuals/sound/))
 
-That concludes this introductory tutorial. Now go ahead and dive into Defold. We have lots of [manuals and tutorials](/learn) prepared to guide you, and if you get stuck, you are very welcome to the [forum](//forum.defold.com).
+Now go ahead and dive into Defold. We have lots of [manuals and tutorials](/learn) prepared to guide you, and if you get stuck, you are very welcome to the [forum](//forum.defold.com).
 
 Happy Defolding!

docs/en/tutorials/runner.md

@@ -27,6 +27,8 @@ Throughout the tutorial, detailed descriptions on concepts and how to do certain
 
 So let's begin. We hope you will have a lot of fun going through this tutorial and that it helps you getting going with Defold.
 
+> Download the assets for this tutorial [here](images/runner/assets_runner.zip).
+
 <a name="part-1"></a>
 ## STEP 1 - Installation and setup
 
@@ -44,7 +46,7 @@ The first time you start the editor, the editor starts blank, without any projec
 
 Now, in the *Assets pane* you will see all files that are part of the project. If you double-click the file "main/main.collection" the file will open up in the editor view in the center:
 
-![Editor overview](images/runner/1/editor_overview.png)
+![Editor overview](images/runner/1/editor2_overview.png)
 
 The editor consists of the following main areas:
 
@@ -68,19 +70,11 @@ Console
 
 ## Running the game
 
-The "Empty" project template actually isn't completely empty. As you've already seen, it contains one game object with a simple image. Select <kbd>Project ▸ Build and Launch</kbd> to build the project and launch the game.
+The "Empty" project template actually is completely empty. Nonetheless, select <kbd>Project ▸ Build and Launch</kbd> to build the project and launch the game.
 
 ![Build and launch](images/runner/1/build_and_launch.png)
 
-It's perhaps not very exciting, but it's a running Defold game application and we can easily modify it into something more interesting. So let's do that.
-
-First of all, let's clean the *main.collection* file of the one game object it contains.
-
-* Double click the file *main.collection* to open it in the editor.
-* Select (click) "logo" in the *Outline* view to the right.
-* Right-click and select <kbd>Delete</kbd> from the pop up menu.
-* Save the file. Select <kbd>File ▸ Save</kbd> in the main menu.
-That's it!
+A black screen is perhaps not very exciting, but it's a running Defold game application and we can easily modify it into something more interesting. So let's do that.
 
 ::: sidenote
 The Defold editor works on files. By double-clicking a file in the *Assets pane* you open it in a suitable editor. You can then work with the contents of the file.
@@ -90,9 +84,13 @@ When you are done editing a file you have to save it. Select <kbd>File ▸ Save<
 ![File with unsaved changes](images/runner/1/file_changed.png)
 :::
 
-![Delete game object](images/runner/1/delete_go.png)
+## Setting up the project
+
+Before we begin, let's set up several settings for our projects. Open the `game.project` asset from the `Assets Pane` and scroll down to the Display section. Set the `width` and `height` of the project to `1280` and `720` respectively. 
 
-If you run the game again, the application window will be totally black.
+::: sidenote
+If your Display's refresh rate is greater than 60 hz then you might want to disable `vsync` and set a frame cap to a value like 60.
+:::
 
 <a name="part-2"></span></a>
 ## STEP 2 - Creating the ground
@@ -187,14 +185,16 @@ end
 6. Decrease the current X-position with the set speed. Multiply with `dt` to get framerate independent speed in pixels/s.
 7. Update the object's position with the new speed.
 
-![Ground script](images/runner/1/ground_script.png)
-
 ::: 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 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.
 :::
 
+::: sidenote
+You can toggle the Assets Pane, Console and Outline sections of the editor using the <kbd>F6</kbd>, <kbd>F7</kbd> and <kbd>F8</kbd> keys respectively
+:::
+
 Now that we have a script file, we should add a reference to it to a component in a game object. That way, the script will be executed as part of the game object lifecycle. We do this by creating a new game object in *ground.collection* and add a *Script* component to the object that refers to the Lua script file we just created:
 
 1. Right-click the root of the collection and select <kbd>Add Game Object</kbd>. Set the object's *id* to "controller".
@@ -271,13 +271,13 @@ It is important that we specify what the collision object should interact with:
 1. Set the *Group* property to a new collision group called "hero".
 2. Setting the *Mask* property to another group "geometry" that this collision object should register collisions with. Note that the "geometry" group does not yet exist, but we will soon add collision objects belonging to it.
 
-![Hero game object](images/runner/2/hero_game_object.png)
-
 Finally, create a new *hero.script* file and add it to the game object.
 
 1. Right-click the *hero* folder in the *Assets pane*  and select <kbd>New ▸ Script File</kbd>. Name the new file *hero.script*.
 2. Open the new file, then copy and paste the following code into the script file, then save it. (The code is pretty straightforward apart from the solver that separates the hero collision shape from what it collides with. That is done by the `handle_geometry_contact()` function.)
 
+![Hero game object](images/runner/2/hero_game_object.png)
+
 ::: sidenote
 The reason we are handling the collision ourselves is that if we instead set the type on the frog's collision object to dynamic, the engine will peform a Newtonian simulation of the bodies involved. For a game like this, such a simulation is far from optimal so instead of fighting the physics engine with various forces, we take full control.
 
@@ -384,7 +384,7 @@ function on_input(self, action_id, action)
 end
 ```
 
-3. Add the script as a *Script* component to the hero object (right-click the root of *hero.go* in the *Outline* and select <kbd>Add Component from File</kbd>, then select the *hero.script* file).
+1. Add the script as a *Script* component to the hero object (right-click the root of *hero.go* in the *Outline* and select <kbd>Add Component from File</kbd>, then select the *hero.script* file).
 
 If you want you can now try and temporarily add the hero frog to the main collection and run the game to see it fall through the world.
 
@@ -935,6 +935,8 @@ And now we have a simple, but functional game! If you make it this far you might
 2. Particle effects for the pickups and death
 3. Nice background imagery
 
+> Download the completed version of the project [here](images/runner/sample-runner.zip)
+
 That concludes this introductory tutorial. Now go ahead and dive into Defold. We have lots of [manuals and tutorials](//www.defold.com/learn) prepared to guide you, and if you get stuck, your're welcome to the [forum](//forum.defold.com).
 
 Happy Defolding!

docs/pl/manuals/importing-assets.md

@@ -0,0 +1,44 @@
+---
+title: Importowanie i edytowanie zasobów
+brief: Ta instrukcja opisuje ze szczegółami jak importować i edytować zasoby.
+---
+
+# Importowanie i edytowanie zasobów
+
+Projekt gry zazwyczaj składa się z wielkiej liczby różnego rodzaju zasobów (ang. assets), które są tworzone w wyspecjalizowanych programach do grafiki, modelowania 3D, produkcji plików muzycznych, animacji itp. Defold jest stworzony z myślą o pracy, gdzie wykorzystuje się zewnętrzne narzędzie, żeby potem można zaimportować stworzone zasoby do edytora Defold.
+
+
+## Importowanie zasobów
+
+Defold wymaga, aby pliki używane w projekcie znajdowały się w hierarchii katalogu projektu. Należy więc zaimportować tam uprzednio wszystkie zasoby, zanim będzie można ich użyć. Aby zaimporotwać zasoby przenieś pliki w Twoim systemie operacyjnym do katalogu projektu lub bezpośrednio przeciągnij nad panel *Assets pane* edytora Defold w odpowiednim katalogu.
+
+![Importowanie plików](images/graphics/import.png){srcset="images/graphics/[email protected] 2x"}
+
+::: sidenote
+Defold wspiera pliki graficzne w formatach PNG i JPEG. Pliki PNG muszą być w formacie 32-bitowym RGBA. Inne pliki graficzne muszą być przekonwertowane do wspieranych, aby móc ich użyć.
+:::
+
+
+## Używanie zasobów
+
+Kiedy zasoby są już zaimportowane do projektu, mogą być wykorzystywane przez różne komponenty silnika Defold:
+
+* Pliki graficzne mogą być używane w różnego rodzaju komponentach wizualnych, często używanych np. w grach 2D. Więcej szczegółów znajdziesz w [tej instrukcji jak importować i używać grafiki 2D](/manuals/importing-graphics).
+* Pliki dźwiękowe mogą być używane przez [komponent dźwięku](/manuals/sound) w celu odtwarzania dźwięków.
+* Pliki animacji szkieletowej (Spine) mogą być używane przez [komponent Spine](/manuals/spinemodel) w celu wyświetlania i animowania modeli Spine.
+* Pliki fontów mogą być używane przez [komponent etykiety](/manuals/label) i przez [węzły tekstowe](/manuals/gui-text) w GUI.
+* Pliki modeli Collada mogą być używane przez [komponent modeli trójwymiarowych](/manuals/model) w celu wyświetlania i animowania modeli trójwymiarowych. Więcej szczegółów znajdziesz w [tej instrukcji jak importować i używać grafiki 3D](/manuals/importing-models). 
+
+
+## Edytowanie zewnętrznych zasobów
+
+Defold nie udostępnia narzędzi do edycji plików graficznych, dźwiękowych, modeli 3D czy animacji. Zasoby te muszą być stworzone w przeznaczonych do tego narzędziach i zaimportowane. Defold automatycznie wykrywa zmiany w hierarchii plików i zmiany w zasobach i aktualizuje je w edytorze Defold.
+
+
+## Edytowanie zasobów Defolda
+
+Edytor Defold zapisuje wszystkie zasoby Defolda w plikach tesktowych, dzięki czemu łatwo jest utrzymywać je w systemach kontroli wersji i tworzyć lub edytować przy użyciu prostych skryptów. Zobacz [ten wątek na forum Defold](https://forum.defold.com/t/deftree-a-python-module-for-editing-defold-files/15210). Warto pamiętać, że nie publikujemy szczegółów formatu naszych plików, ponieważ te ulegają od czasu do czasu zmianie. Możesz również używać [skryptów Edytora](/manuals/editor-scripts/), aby w momencie danych wydarzeń w Edytorze Defold uruchomić skrypt, który dokona operacji i zmodyfikuje zasoby Defolda.
+
+Należy zachować szczególną ostrożność przy zmienianiu plików zasobów Defolda przy użyciu edytorów tekstu czy innych zewnętrznych narzędzi. Jeśli wprowadzi się do pliku błąd, może on spowodować, że Defold nie otworzy danego pliku.
+
+Niektóre zewnętrzne narzędzia takie jak [Tiled](/assets/tiled/) czy [Tilesetter](https://www.tilesetter.org/beta) mogą być używane do automatycznego tworzenia zasobów Defolda (np. tilemap).

docs/pl/manuals/importing-graphics.md

@@ -0,0 +1,83 @@
+---
+title: Importowanie i używanie grafiki 2D
+brief: Ta instrukcja opisuje ze szczegółami jak importować i używać grafiki 2D.
+---
+
+# Importowanie grafiki 2D
+
+Defold wspiera różnego rodzaju komponenty wizualne używane często w grach 2D. Możesz użyć Defolda do stworzenia statycznych i animowanych sprite'ów, komponentów interfejsu użytkownika (GUI), efektór cząsteczkowych (particle fx), map kafelków (tilemap) fontów bitmapowych i animacji Spine. Zanim możliwe będzie stworzenie tych wizualnych komponentów, musisz zaimportować pliki graficzne, których chcesz używać. Aby zaimportować pliki, przenieś je do katalogu projektu lub przeciągnij nad panel *Assets pane* w edytorze Defold.
+
+![Importowanie plików](images/graphics/import.png){srcset="images/graphics/[email protected] 2x"}
+
+::: sidenote
+Defold wspiera pliki graficzne w formatach PNG i JPEG. Pliki PNG muszą być w formacie 32-bitowym RGBA. Inne pliki graficzne muszą być przekonwertowane do wspieranych, aby móc ich użyć.
+:::
+
+
+## Tworzenie zasobów Defolda
+
+Kiedy pliki graficzne są już zaimportowane do projektu, mogą być wykorzystywane do stworzenia różnych specyficznych dla Defolda zasobów:
+
+![atlas](images/icons/atlas.png){.icon} Atlas (galeria)
+: Atlas (galeria obrazów) zawiera listę oddzielnych plików graficznych, które są automatycznie połączone w jedną, większą teksturę. Atlasy mogą zawierać statyczne, pojedyncze obrazy lub mogą zawierać grupy tworzące animację poklatkową używając opcji *Animation Groups*.
+
+  ![atlas](images/graphics/atlas.png){srcset="images/graphics/[email protected] 2x"}
+
+Więcej szczegółów na ten temat znajdziejsz w [tej instrukcji do atlasów](/manuals/atlas).
+
+![tile source](images/icons/tilesource.png){.icon} Tile Source (źródło kafelków)
+: Żródła kafelków zawierają referencje do plików graficznych, które są przygotowane w ten sposób, że mogą być podzielone na mniejsze kafelki (ang. tile) ułożone na kwadratowej, jednakowej siatce. Często obrazki takie nazywane są również _sprite sheet_. Źródła kafelków mogą również zawierać animacje poklatkowe zdefiniowane przez określenie pierwszego i ostatniego numeru kafelka, które są po kolei odtwarzane. Ponadto, korzystając ze źródła kafelków, można automatycznie określić kształt kolizji na podstawie obrazu na danym kafelku (transparentne tło jest "wycinane" z kształtu kolizji danego kafelka).
+
+  ![tile source](images/graphics/tilesource.png){srcset="images/graphics/[email protected] 2x"}
+
+Więcej szczegółów na ten temat znajdziejsz w [tej instrukcji do źródeł kafelków](/manuals/tilesource).
+
+![bitmap font](images/icons/font.png){.icon} Fonty bitmapowe
+: Fonty bitmapowe zawierają informacje o znakach (ang. glyph) w arkuszu fontowym PNG. Te typy fontów nie są lepsze od fontów TrueType czy OpenType pod kątem wydajności, ale mogą dodaktowo zawierać informację o kolorach, cieniach, obrysowaniach i grafice bezpośrednio w pliku.
+
+Więcej szczegółów na ten temat znajdziejsz w [tej instrukcji do fontów](/manuals/font/#bitmap-bmfonts).
+
+  ![BMfont](images/font/bm_font.png){srcset="images/font/[email protected] 2x"}
+
+
+## Używanie zasobów Defolda
+
+Kiedy już pliki graficzne są przekonwertowane w zasoby typu Atlas czy Tile Source, możesz używać ich do tworzenia wielu różnych rodzajów komponentów wizualnych:
+
+![sprite](images/icons/sprite.png){.icon}
+: Sprite (obraz) jest statycznym obrazem lub animacją poklatkową (ang. flipbook animation) wyświetlaną na ekranie.
+
+  ![sprite](images/graphics/sprite.png){srcset="images/graphics/[email protected] 2x"}
+
+Więcej szczegółów na ten temat znajdziejsz w [tej instrukcji do sprite'ów](/manuals/sprite).
+
+![tile map](images/icons/tilemap.png){.icon} Tile map (mapy kafelków)
+: Mapa kafelków (ang. tile map) składa w jedną całość (mapę) kafelki (zarówno obrazy jak i kształty kolizji) ze źródeł kafelków. Mapy kafelków nie mogą korzystać z atlasów jako źródła.
+
+  ![tilemap](images/graphics/tilemap.png){srcset="images/graphics/[email protected] 2x"}
+
+Więcej szczegółów na ten temat znajdziejsz w [tej instrukcji do map kafelków](/manuals/tilemap).
+
+![particle effect](images/icons/particlefx.png){.icon} Particle fx (efekty cząsteczkowe)
+: Efekty cząteczkowe są tworzone przy użyciu cząsteczek (ang. particles) rozpylanych z emiterów cząsteczek (ang. particle emitter). Cząstki te mogą składać się ze statycznych obrazów lub animacji poklatkowych zarówno z atlasów jak i źródeł kafelków.
+
+  ![particles](images/graphics/particles.png){srcset="images/graphics/[email protected] 2x"}
+
+Więcej szczegółów na ten temat znajdziejsz w [tej instrukcji do efektów cząsteczkowych](/manuals/particlefx).
+
+![gui](images/icons/gui.png){.icon} GUI (graficzny interfejs użytkownika)
+: Węzły prostokątne i kołowe GUI (ang. box nodes, pie nodes) mogą wykorzystywać statyczne obrazy lub animacje poklatkowe zarówno z atlasów jak i źródeł kafelków.
+
+  ![gui](images/graphics/gui.png){srcset="images/graphics/[email protected] 2x"}
+
+Więcej szczegółów na ten temat znajdziejsz w [tej instrukcji do interfejsów użytkownika GUI](/manuals/gui).
+
+![spine](images/icons/spine-model.png){.icon} Model Spine
+: Modele szkieletowe Spine przetwarzają dane ze scen Spine. Zawierają dwie składowe danych:
+
+  1. Plik w formacie Spine JSON, który opisuje animację kości (ang. bone) czy też tzw. szkieletu.
+  2. Atlas zawierający informacje o obrazach dołączanych do poszczególnych kości szkieletu. Modele Spine nie mogą korzystać ze źródeł kafelków.
+
+  ![spine](images/graphics/spine.png){srcset="images/graphics/[email protected] 2x"}
+
+Więcej szczegółów na ten temat znajdziejsz w [tej instrukcji do modeli Spine](/manuals/spinemodel).

docs/pl/manuals/importing-models.md

@@ -0,0 +1,77 @@
+---
+title: Importowanie modeli 3D
+brief: Ta instrukcja opisuje ze szczegółami jak importować i edytować modele 3D.
+---
+
+# Importowanie modeli 3D
+Defold obecnie wspiera modele, szkielety i animacje tylko w formacie Collada *.dae*. Możesz używać narzędzi takich jak Maya, 3D Max, Sketchup czy Blender do tworzenia i/lub konwertowania modeli trójwymiarowych do formatu Collada. Blender jest jednym z popularniejszych i potężnych narzędzi do modelowania 3D, animacji, a nawet renderowania. Działa na systemach operacyjnych Windows, macOS i Linux i jest dostępny za darmo do pobrania ze strony http://www.blender.org
+
+![Model w Blenderze](images/model/blender.png){srcset="images/model/[email protected] 2x"}
+
+## Exportowanie do formatu Collada
+Kiedy eksportujesz model 3D do formatu Collada, otrzymujesz plik z rozszerzeniem *.dae*. Plik ten zawiera wszystkie informacje o wierzchołkach (ang. vertices), krawędziach i teksturach (ang. faces), które składają się na model trójwymiarowy, a także współrzędne UV (ang. _UV coordinates_) (które, w skrócie, przypisują daną część tekstury do siatki modelu) jeśli zostały zdefiniowane, kości szkieletu i dane o animacji.
+
+* Szczegółowy opisy wielokątów (ang. polygons) siatki możesz znaleźć na stronie http://en.wikipedia.org/wiki/Polygon_mesh.
+
+* Współrzędne UV i mapowanie UV opisane jest na stronie http://en.wikipedia.org/wiki/UV_mapping.
+
+Defold nakłada pewne ograniczenia na eksportowane dane o animacji:
+
+* Defold obecnie wspiera tylko wypiekane animacje (ang. baked animations). Animacje muszą posiadać macierze dla każdej ramki animacji szkieletowej, a nie pozycję, rotację i skalę w osobnych kluczach.
+
+* Animacje są interpolowane liniowo. Jeśli tworzysz bardziej zaawansowaną krzywą interpolacji animacje muszę być wypiekane przed eksportowaniem (prebaked).
+
+* Klipy animacji (ang. animation clips) w formacie Collada nie są wspierane. W celu używania wielu animacji dla modelu wyeksportuj je do osobnych plików *.dae* i zbierz je w zasób *.animationset* w edytorze Defold.
+
+
+### Wymagania
+Kiedy eksportujesz model do formatu Collada musisz zapewnić spełnienie poniższych wymagań:
+
+* Model musi zawierać pojedynczą siatkę (ang. mesh)
+* Model musi używać jednego materiału
+
+
+#### Łączenie wielu siatek
+Możesz użyć np. Blendera do połączenia wielu siatek. Wybierz wszystkie siatki i naciśnij `CTRL`/`CMD` + `J`.
+
+![Łączenie siatek](images/model/blender_join_meshes.png)
+
+
+#### Usuwanie materiałów
+Możesz użyć np. Blendera do usunięcia dodatkowych materiałó z modeli. Wybierz dany materiał i naciśnij `-`.
+
+![Usuwanie materiałów](images/model/blender_remove_materials.png)
+
+
+#### Exportowanie tekstur
+Jeśli nie masz jeszcze gotowej tekstury dla modelu, możesz użyć np. Blendera do wygenerowania tekstury. Powinno się to uczynić przed usunięciem materiałów z modelu. Najpierw wybierz siatkę i wszystkie jej wierzchołki:
+
+![Wybierz wszystkie](images/model/blender_select_all_vertices.png)
+
+Kiedy wszystkie wierzchołki są wybrane, rozwiń (ang. unwrap) siatkę, żeby otrzymać rozkład (ang. layout) UV:
+
+![Rozwiń siatkę](images/model/blender_unwrap_mesh.png)
+
+Następnie możesz wyeksportować rozkład UV do pliku graficznego, który później można używać jako teksturę:
+
+![Eksportuj rozkład UV](images/model/blender_export_uv_layout.png)
+
+![Eksportuj ustawienia rozkładu UV layout settings](images/model/blender_export_uv_layout_settings.png)
+
+![Eksportuj rozkład UV layout result](images/model/blender_export_uv_layout_result.png)
+
+
+## Exportowanie używając Blendera
+Możesz eksportować modele do formatu Collada używając opcji Export z menu w Blenderze. Wybierz dany model, wybierz opcję Export i zaznacz opcję "Selection Only".
+
+![Exportowanie używając Blendera](images/model/blender_export.png)
+
+
+## Importowanie do Defolda
+Żeby zaimportować model, przenieś go do katalogu projektu lub przeciągnij plik *.dae* nad wybrany obraz tekstury w panelu *Assets Pane*.
+
+![Importowane zasoby modelu](images/model/assets.png){srcset="images/model/[email protected] 2x"}
+
+
+## Używanie modeli
+Kiedy model 3D jest zaimportowany do Defolda możesz go użyć w [komponencie Model](/manuals/model).

docs/pl/manuals/message-passing.md

@@ -0,0 +1,254 @@
+---
+title: Przekazywanie wiadomości
+brief: Przekazywanie wiadomości (ang. message passing) w Defoldzie jest mechanizmem umożliwiającym komunikację luźnie połączonym ze sobą obiektom. Ta instrukcja dokładnie opisuje przekazywanie wiadomości.
+---
+
+# Przekazywanie wiadomości
+
+Przekazywanie wiadomości to mechanizm umożliwiający obiektom gry (ang. game objects) w Defoldzie komunikację. Ten materiał wymaga uprzedniego zaznajomienia się z [mechanizmem adresowania](/manuals/addressing) i [podstawowymi elementami Defolda](/manuals/building-blocks).
+
+Defold nie jest zorientowany obiektowo w tym sensie, że aplikację zdefiniować można poprzez utworzenie hierarchii klas z dziedziczeniem i metodami w obiektach (jak np. w Javie, C++ czy C#). Zamiast tego, Defold rozszerza możliwości języka Lua o prosty i potężny mechanizm obiektowy, gdzie stan obiektów jest przetrzymywany wewnątrz skryptów (ang. script) dostępny przez referencję do siebie, tzw. `self`. Obiekty mogą być ponadto całkowicie odseparowane od mechanizmu przekazywania asynchronicznych wiadomości Objects can furthermore be fully decoupled with asynchronous message passing jako środka komunikacji między nimi.
+
+
+## Przykłady użycia
+
+Spójrzmy najpierw na kilka przykładów przekazywania wiadomości. Załóżmy, że budujesz grę, w której znajduje się:
+
+1. Głowna kolekcja nazwana "main" z jednym obiektem gry z komponentem typu GUI nazwanym "interface" (z minimapą i licznikiem zdobytych punktów).
+2. Druga kolekcja nazwana "level" z dwoma obiektami gry: jednym dla postaci bohatera/gracza ("hero"), a drugim dla postaci przeciwnika ("enemy").
+
+![Struktura przekazywania wiadomości](images/message_passing/message_passing_structure.png)
+
+::: sidenote
+Zawartość tego przykładu jest podzielona na dwa dwa osobne pliki - jeden dla kolekcji głównej "main" oraz drugi dla kolekcji "level". Pamiętaj jednak, że same nazwy plików _nie mają znaczenia_ w Defoldzie. Znaczenie ma identyfikator (id) przypisany do instancji.
+:::
+
+Gra składa się z kilku prostych zasad, które wymagają komunikacji między obiektami:
+
+![Przekazywanie wiadomości](images/message_passing/message_passing.png)
+
+① Bohater trafia przeciwnika
+: Dla tej funkcjonalności, wiadomość o nazwie `"punch"` (z ang. cios) jest wysłana ze skryptu obiektu gracza "hero" do skryptu obiektu przeciwnika "enemy". Ponieważ obydwa obiekty są w hierarchi tej samej kolekcji, można użyć adresowania pośredniego (bez nazwy kolekcji):
+
+  ```lua
+  -- Send "punch" from the "hero" script to "enemy" script
+  msg.post("enemy#controller", "punch")
+  ```
+
+  W grze jest tylko jeden rodzaj ruchu ataku, więc wiadomość nie musi zawierać żadnych innych informacji oprócz samej nazwy "punch".
+
+  W skrypcie obiektu przeciwnika, utwórz funkcję do obsługi przysłanej wiadomości:
+
+  ```lua
+  function on_message(self, message_id, message, sender)
+    if message_id == hash("punch") then
+      self.health = self.health - 100
+    end
+  end
+  ```
+
+  W tym przypadku kod sprawdza nazwę wiadomości (wysłanej jak skrócony hash string w polu "message_id"). Kod nie bierze pod uwagę ani danych zawartych w wiadomości, ani kto był nadawcą - więc *każdy* wysyłający wiadomość "punch" spowoduje, że biedny przeciwnik otrzyma obrażenia.
+
+② Bohater zdobywa punkty
+: Kiedy bohater pokona przeciwnika, licznik jego punktów wzrasta. Wiadomość nazwana `"update_score"` (z ang. zaktualizuj wynik) jest wysła ze skryptu obiektu gracza "hero" do komponentu "gui" obiektu "interface".
+
+  ```lua
+  -- Enemy defeated. Increase score counter by 100.
+  self.score = self.score + 100
+  msg.post("/interface#gui", "update_score", { score = self.score })
+  ```
+
+  W tym przypadku nie jest możliwe użycie pośredniego adresu, ponieważ obiekt "interface" jest w hierarchi w innej kolekcji, niż obiekt gracza "hero". Wiadomość zostaje wysłana do komponentu GUI, który ma dołączony do siebie skrypt GUI, więc w tym skrypcie możemy zareagować na otrzymaną wiadomość. Wiadomości możemy wysyłać dowolnie między wszystkimi trzema typami skyptów: skryptami, skryptami GUI oraz skryptami do renderowania (render script).
+
+  The message `"update_score"` is coupled with score data. The data is passed as a Lua table in the `message` parameter:
+
+  ```lua
+  function on_message(self, message_id, message, sender)
+    if message_id == hash("update_score") then
+      -- set the score counter to new score
+      local score_node = gui.get_node("score")
+      gui.set_text(score_node, "SCORE: " .. message.score)
+    end
+  end
+  ```
+
+③ Pozycja przeciwnika jest aktualizowana na minimapie.
+: Gracz patrząc na minmapę z pozycjami przeciwników może łatwiej ich zlokalizować i śledzić ruchy. Każdy przeciwniki sygnalizuje więc swoją pozycję, wysyłając wiadomość nazwaną `"update_minimap"` (z ang. zaktualizuj minimapę) do komponentu "gui" obiektu "interface":
+
+  ```lua
+  -- Send the current position to update the interface minimap
+  local pos = go.get_position()
+  msg.post("/interface#gui", "update_minimap", { position = pos })
+  ```
+
+  Skrypt GUI musi śledzić pozycję każdego przeciwnika, a jeśli przeciwnik wyśle aktualizację swojej pozycji, to jego ostatnia pozycja musi być zaktualizowana. Nazwa nadawcy wiadomości (przekazana w polu `sender`) może być użyta jako klucz w tablicy Lua z pozycjami:
+
+  ```lua
+  function init(self)
+    self.minimap_positions = {}
+  end
+
+  local function update_minimap(self)
+    for url, pos in pairs(self.minimap_positions) do
+      -- update position on map
+      ...
+    end
+  end
+
+  function on_message(self, message_id, message, sender)
+    if message_id == hash("update_score") then
+      -- set the score counter to new score
+      local score_node = gui.get_node("score")
+      gui.set_text(score_node, "SCORE: " .. message.score)
+    elseif message_id == hash("update_minimap") then
+      -- update the minimap with new positions
+      self.minimap_positions[sender] = message.position
+      update_minimap(self)
+    end
+  end
+  ```
+
+## Wysyłanie wiadomości
+
+Mechanizm wysyłania wiadomości, jak w przykładach powyżej, jest bardzo prosty. Wywołujesz funkcję `msg.post()`, która przekierowuje wiadomość do kolejki wiadomości. Następnie, w każdej ramce, silnik Defold przegląda tę kolejkę i dostarcza każdą z wiadomości do odbiorców. Dla niektórych wiadomości systemowych (jak `"enable"`, `"disable"`, `"set_parent"` itd.) silnik sam odpowiada w odpowiedni sposób na taką wiadomość. Silnik tworzy również wiadomości systemowe (jak `"collision_response"` w przypadku kolizji fizycznych), które są rozsyłane do odpowiednich obiektów gry. W przypadku wiadomości użytkownika wysyłanych do skryptów silnik wywołuje specjalną funkcję `on_message()`.
+
+Możesz wysyłać dowolne wiadomości do istniejących obiektów lub komponentów, a już decyzja, czy i jak zareagować na daną wiadomość zależy od kodu funkcji. Jeśli wyślesz wiadomość do skryptu, a skrypt zignoruje ją, jest to w porządku. Odpowiedzialność za obsługę wiadomości leży w całości po stronie odbiorcy.
+
+Silnik sprawdza docelowy adres wiadomości. Jeśli próbujesz wysłać wiadomość do nieznanego lub nieistniejącego odbiorcy, Defold powiadomi Cię o tym stosowną informacją z błędem w konsoli:
+
+```lua
+-- Try to post to a non existing object
+msg.post("dont_exist#script", "hello")
+```
+
+```txt
+ERROR:GAMEOBJECT: Instance '/dont_exists' could not be found when dispatching message 'hello' sent from main:/my_object#script
+```
+
+Kompletna sygnatura dla funkcji `msg.post()` to:
+
+`msg.post(receiver, message_id, [message])`
+
+receiver
+: Odbiorca, id komponentu lub obiektu gry, do którego wiadomość ma być wysłana. Uwaga! Jeśli wiadomość jest wysłana do obiektu gry, a nie pojedynczego komponentu (np. skryptu), to każdy komponent w hierarchii ooiektu otrzymuje tę samą wiadomość.
+
+message_id
+: Nazwa wiadomości, identyfikator będący skróconym ciągiem znaków (hash string).
+
+[message]
+: Opcjonalna tablica Lua z parami klucz-wartość zawierającymi dane. Niemal każdy typ danych może być załączony w tablicy Lua - możesz dołączyć liczby, string, boolean, adresy URL, hashe czy zagnieżdżone tablice Lua. Nie można dołączyć funkcji.
+
+  ```lua
+  -- Send table data containing a nested table
+  local inventory_table = { sword = true, shield = true, bow = true, arrows = 9 }
+  local stats = { score = 100, stars = 2, health = 4, inventory = inventory_table }
+  msg.post("other_object#script", "set_stats", stats)
+  ```
+
+::: sidenote
+Istnieje konkretny i niezmienialny limit na wielkość danych przesyłanych jako tablica Lua w polu w wiadomości `message` i wynosi 2 kilobajty. Nie istnieje obecnie prosty sposób na sprawdzenie zajętej pamięci przez tablicę w Lua, ale można przykładowo porównać wartość zwracaną przez funkcję `collectgarbage("count")` z momentu przed dodaniem danych do tablicy oraz po ich umieszczeniu, aby monitorować użycie pamięci.
+:::
+
+### Skróty
+
+Defold wprowadza dwa przydatne skróty, których można używać, zamiast określania konretnego adresu (co pozwala na stworzenie bardziej ogólnej funkcji w jednym skrypcie, której można użyć np. w wielu, różnych obiektach):
+
+:[Shorthands](../shared/url-shorthands.md)
+
+
+## Odbieranie wiadomości
+
+Odbieranie wiadomości polega jedynie na zapewnieniu obsługi wiadomości w skrypcie przy użyciu specjalnej funkcji `on_message()`. Funkcja ta przyjmuje 4 parametry:
+
+`function on_message(self, message_id, message, sender)`
+
+`self`
+: Referencja do własnej instancji skryptu, tablica unikalna dla każdego stworzonego skryptu.
+
+`message_id`
+: Nazwa wiadomości, unikalny _skrócony_ (hash) identyfikator.
+
+`message`
+: Zawiera dane wiadomości, tablicę Lua. Jeśli nie ma żadnych danych przekazanych w wiadomości, tablica jest, ale pusta.
+
+`sender`
+: Zawiera pełny adres URL nadawcy.
+
+```lua
+function on_message(self, message_id, message, sender)
+    print(message_id) --> hash: [my_message_name]
+
+    pprint(message) --> {
+                    -->   score = 100,
+                    -->   value = "some string"
+                    --> }
+
+    print(sender) --> url: [main:/my_object#script]
+end
+```
+
+## Wysyłanie wiadomości między światami gry (game worlds)
+
+Jeśli używasz pełnomocników kolekcji (collection proxy) to wczytywania nowych światów gry dynamicznie, możesz chcieć przesyłać do utworzonych światów wiadomości. Załóżmy, że wczytano kolekcję o nazwie "level" przy użyciu pełnomocnika kolekcji:
+
+![Nazwa kolekcji](images/message_passing/collection_name.png)
+
+Kiedy tylko kolekcja zostanie wczytana, zainijcjalizowana i aktywowana, możesz wysyłać wiadomości do każdego z jej komponentów lub obiektów gry w tym nowym świecie poprzez określenie w adresie pola "socket":
+
+```lua
+-- Send a message to the player in the new game world
+msg.post("level:/player#controller", "wake_up")
+```
+Więcej szczegółów na temat działania pełnomocników kolekcji znajdziesz w tej [instrukcji do pełnomocników](/manuals/collection-proxy).
+
+## Łańcuchy wiadomości
+
+Kiedy wiadomość zostaje wysłana, może być odczytana przez jednego z odbiorców w wywołaniu funkcji `on_message()`. Możliwe i często stosowane jest przesłanie kolejnej wiadomości do kolejki wiadomości w odpowiedzi na odebraną wiadomość.
+
+Kiedy silnik rozpoczyna rozładowywanie kolejki wiadomości w danej ramce, dla każdej z nich wywoła funkcję `on_message()` nadawcy i tak do momentu, aż kolejka będzie pusta. Jeśli obecnie rozsyłana wiadomość doda nową wiadomość do kolejki, silnik będzie rozsyłał wiadomości z kolejki ponownie. Jest jednak stały, określony limit określający ile razy kolejka może być przez silnik rozładowywana, czego skutkiem jest również limit długości łańcucha wiadomości na ramkę. Możesz sprawdzić jak wiele wiadomości w łańcuchu silnik jest w stanie rozładować między kolejnymi wywołaniami funkcji `update()`, czyli w ciągu trwania jednej ramki, używajać poniższego skryptu:
+
+```lua
+function init(self)
+    -- We’re starting a long message chain during object init
+    -- and keeps it running through a number of update() steps.
+    print("INIT")
+    msg.post("#", "msg")
+    self.updates = 0
+    self.count = 0
+end
+
+function update(self, dt)
+    if self.updates < 5 then
+        self.updates = self.updates + 1
+        print("UPDATE " .. self.updates)
+        print(self.count .. " dispatch passes before this update.")
+        self.count = 0
+    end
+end
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("msg") then
+        self.count = self.count + 1
+        msg.post("#", "msg")
+    end
+end
+```
+
+Uruchomienie skryptu powinno spowodować wypisanie podobnych informacji:
+
+```txt
+DEBUG:SCRIPT: INIT
+INFO:ENGINE: Defold Engine 1.2.36 (5b5af21)
+DEBUG:SCRIPT: UPDATE 1
+DEBUG:SCRIPT: 10 dispatch passes before this update.
+DEBUG:SCRIPT: UPDATE 2
+DEBUG:SCRIPT: 75 dispatch passes before this update.
+DEBUG:SCRIPT: UPDATE 3
+DEBUG:SCRIPT: 75 dispatch passes before this update.
+DEBUG:SCRIPT: UPDATE 4
+DEBUG:SCRIPT: 75 dispatch passes before this update.
+DEBUG:SCRIPT: UPDATE 5
+DEBUG:SCRIPT: 75 dispatch passes before this update.
+```
+
+Widzimy, że ta wersja silnika Defold jest w stanie wykonać 10 przejść rozładowywania kolejki wiadomości między wywołaniem funkcji `init()` oraz pierwszym wywołaniem funkcji `update()`. Następnie jest w stanie wykonać 75 przejść kolejki w każdej ramce.

docs/pt/manuals/application-lifecycle.md

@@ -0,0 +1,119 @@
+---
+title: Manual de ciclo de vida da aplicação Defold.
+brief: Esse manual detalha o ciclo de vida dos games e aplicações do Defold.
+---
+
+# Ciclo de vida da aplicação
+
+O ciclo de vida de uma aplicação ou jogo no Defold esta em uma escala simples. A engine movimenta entre três estágios de execução: inicialização, update (onde apps e jogos passam maior parte do tempo) e finalização.
+
+![Visão geral do Ciclo de vida](images/application_lifecycle/application_lifecycle_overview.png)
+
+Em varios casos somente um conhecimento rudimentar do funcionamento do Defold é necessário. De qualquer forma, você pode se deparar com casos em que a ordem que o Defold leva se torna vital. Esse documento descreve como a engine roda uma aplicação do início ao fim
+
+A aplicação começa incializando tudo que é necessário para rodar a engine. Ela carrega a coleção principal e chama [`init()`](/ref/go#init) em todos os componentes carregados que têm uma função Lua `init()` (componentes de scripts e GUI com scripts de GUI). Isso permite que você customize a inicialização.
+
+A aplicação então insere um loop de update em que a aplicação ira gastar maior parte de seu tempo de vida. Cada frame, objeto do jogo e os componentes neles contidas são atualizados. Qualquer script e script de GUI tem suas funções [`update()`](/ref/go#update) chamadas. Durante um loop de update mensagens são disparadas para seus recipientes, sons são tocados e todos os gráficos são renderizados 
+
+Em algum ponto, o ciclo de vida da aplicação chegará a um fim. Antes da aplicação sair, a engine sai do update loop e entra na fase de finalização. Isso prepara todos objetos do jogo carregados para serem deletados. Todos componentes de objetos tem a função [`final()`](/ref/go#final) que são chamados, permitindo uma limpeza personalizada. Então os objetos são deletados e a coleção principal e descarregada. 
+
+## Inicialização
+
+O diagrama contem uma simplificação mais detalhada dos passos de incialização. Os passos envolvendo as "mensagens de despache" (logo antes de "spawn dynamic objects") foram colocados em um bloco separado à direita para dar maior clareza.
+
+![Visão geral do Ciclo de vida](images/application_lifecycle/application_lifecycle_init.png)
+
+A engine atualmente requer muito mais passos durante a inicialização, antes da coleção principal ser carregada. O perfilador de memôria, os sockets,os gráficos, os HID (dispositivos de entrada), os sons, a física e muito mais são settados. A configuração da aplicação ("game.project") também é carregada e settada.
+
+O primeiro ponto de entrada controlavel pelo usuário, no fim da inicialização da engine, é a chamada para a função do script de renderização `init()`. 
+
+A coleção principal é então carregada e inicializada. Todos os objetos do jogo na coleção aplicam suas transformações (tradução (mudança de posição), rotação e escala) ao seus filhos. Todas funções de componentes `init()` que existem então são chamados.
+
+::: sidenote
+A ordem em que a função do objeto componente `init()` é chamada não é específica. Você não deve assumir que a engine incializa objetos pertencentes a mesma coleção em uma certa ordem.
+:::
+
+Desde que o código do seu `init()` possa postar novas mensagens, dizer as fábricas para spawnarem novos objetos, marcar objetos para serem deletados e fazer todo tipo de coisas, a engine performa um full "post-update" em seguida. Esse pass carrega uma mensagem, que contem o objeto factory spawnando e deletando objetos. Perceba que o post-update inclui uma sequencia de "mensagens despachadas" que não somente envia mensagens que estão na fila mas também lida com mensagens enviadas para coletores proxies. Qualquer updates subsequentes nos proxies (habilitados ou desabilitados, carregando e marcado para descarregamento) são realizados durante esses pasos.
+
+Estudando o diagrama acima revela que é possível carregar uma [coleção proxy](/manuals/collection-proxy) durante o `init()`, isso assegura que objetos contidos serão inicializados, e então descarregam a coleção pelo proxy---isso tudo antes do primeiro componente `update()` ser chamado, i.e. antes da engine deixar a fase de incialização e entrar no loop de update:
+
+```lua
+function init(self)
+    print("init()")
+    msg.post("#collectionproxy", "load")
+end
+
+function update(self, dt)
+    -- The proxy collection is unloaded before this code is reached.
+    print("update()")
+end
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("proxy_loaded") then
+        print("proxy_loaded. Init, enable and then unload.")
+        msg.post("#collectionproxy", "init")
+        msg.post("#collectionproxy", "enable")
+        msg.post("#collectionproxy", "unload")
+        -- The proxy collection objects’ init() and final() functions
+        -- are called before we reach this object’s update()
+    end
+end
+```
+
+## O loop de update
+
+O loop de update roda durante uma longa sequencia em cada frama. A sequência no diagrama abaixo é dividida entre sequências logicas de blocos para clareza. "Mensagens de despache" também são separados pela mesma razão:
+
+![loop de Update](images/application_lifecycle/application_lifecycle_update.png)
+
+## Input
+
+Input é lido de dispositivos disponíveis, mapeados contra [binds de input](/manuals/input) e então despachados. Qualquer objeto que adquirir foco de imput pega inputs enviados para todos as funções de componentes `on_input()`. Um objeto com um componente de script e um GUI componente com um script GUI vai pegar um input para ambas funções de componentes `on_input()` ---dado que eles são definidos e tenham foco de input.
+
+Qualquer objecto que tenha adquirido foco de input e contenha coleções proxy com componentes dispachaveis com input para componentes dentro da coleção da proxy. Esse processo continua recursivamente abaixo em coleções proxyes dentro de coleções proxies ativas.
+
+## Update
+
+Cada componente game object na coleção principal é atravessado. Se qualquer um desses componentes tiver um função de script `update()`, então isso será chamado. Se o componente é uma coleçaõ proxy, cada componente na coleção proxy é recursivamente atualizado com todos os passos na sequência "update" no diagrama acima. 
+
+::: sidenote
+A ordem em cada função de componende de game object `update()` não é específica. Você não deve assumir que a engine atualiza os objetos pertencentes a mesma coleção em uma certa ordem. 
+:::
+
+No próximo passo, todas as mensagens são despachadas. Desde que qualquer componenente receptor `on_message()` pode postar mensagens adicionais o dispachante de mensagens irá continuar a dispachar mensagens postadas, ate que a fila esteja vazia. Entretanto tem-se um limite a quantas rodadas na fila de mensagens podem ser rodadas pelo dispacher. Veja [Passagem de mensagem](/manuals/message-passing) e a sessão "Tópicos avançados" para maiores detalhes.
+
+Para componentes de objeto de colisão, mensagens de physics (colisões, gatilhos, respostas ray_cast e etc) são dispachados pelo encompassing game object para todos os componentes que contêm funções de script com uma `on_message()`.
+
+Transformações são entao finalizadas, aplicando qualquer movimento de game object, rotação e escalamento a cada componente de game object e qualquer filho componente de game object.
+
+## Atualização de Render
+
+O bloco de atualização render despacha mensagens ao socket `@render` (mensagens de componente de camera `set_view_projection`, `set_clear_color`, etc). O script de render `update()` é então chamado.   
+
+## Atualização de Post
+
+Depois das atualizações, uma atualização post é rodada. Ela descarrega da memoria coleções proxy que estão marcas para unloading (isso acontede durante a sequência de "mensagens de despache"). Qualquer game object que é marcado para deleção vai chamar todas suas funções de compontens `final()`, se tiver alguma. O código em funções `final()` geralmente postam novas mensagens na fila para que um dispacher seja rodado posteriormente. 
+
+Qualquer componente de fabrica que foi invocado para spawnar um game object vai fazer isso depois, Finalmente game objects que estão marcados para deleção serão deletados. 
+
+O último passo no loop de updates envolve as mensagens do dispatching `@system` (mensagens de `exit`, `reboot`, habilitando o profiler, inciando e parando capturas de vídeo, etc). Então gráficos são renderizados. Durante a renderização dos gráficos, a captura do vídeo é feita, como qualquer rendering do visual profiler (Veja em [Documentação de debugação](/manuals/debugging).)
+
+## Frame rate e time step das coleções
+
+O número de frases atualizadas por segundo (que iguala o número runs de loops de update por segundo) podem ser settadas nas configurações do projeto, ou programavelmente enviando uma mensagem de `set_update_frequency` ao socket do `@system`. Em adição, é possível settar o _time step_ para cada coleção de proxies individualmente enviando a mensagem `set_time_step` para o proxy. Mudando o time step da coleção não afeta a frama rate. Afeta o time step do update da física  assim como as variaveis `dt` passadas para o `update().` Também perceba que alterando o time step nao altera o número maximo de `update().` chamados por frame---é sempre um.
+
+(Veja [Manual de coleção de proxy](/manuals/collection-proxy) e [`set_time_step`](/ref/collectionproxy#set-time-step) para detalhes)
+
+## Finalização
+
+Quando a aplicação sai, primeiro finaliza a última sequência de loop de update, que vai descarregar qualquer coleção proxy: finalizando e deletando todos game objects em cada coleção proxy.
+
+Quando isso é feito a engine entra em uma sequencia de finalização que lidá a coleção principal e seus objetos:
+
+![Finalização](images/application_lifecycle/application_lifecycle_final.png)
+
+A função de componente `final()` são chamadas primeiramente. Subsequentemente despachando mensagens. Finalmente, todos game objects são deletados e a coleção principal é descarregada. 
+
+A engine segue com o desligamento por tras das cenas, desligando os subsystemas: configurações de projeto é deletada, o memory profiler e desligado, e assim por diante. 
+
+A aplicação agora está totalmente desligada.

docs/pt/manuals/caching-assets.md

@@ -0,0 +1,51 @@
+---
+title: Caching de recursos
+brief: Esse manual irá explicar como utilizar o cache de recursos para acelerar suas builds.
+---
+
+# Caching de recursos
+
+Jogos criados com Defold geralmente são contruindos em questão de segundos, mas com o crescimento de um projeto também há um crescimento no numero de recursos(assets). Compilando fontes e comprimindo texturas pode demorar em um grande projeto, assim existe o cache de recurso ou(asset cache), que serve para acelerar as builds somente recosntruindo recursos que foram alterados enquanto recursos ja compilados estavão sendo utilizados do cache para recursos que não foram mudados. 
+
+O Defold utiliza um cache de três camadas
+
+1. Projeto de cache
+2. Cache Local
+3. Cache Remoto
+
+
+## Projeto de cache
+
+O Defold por padrão ira dar cache nos recursos já compilados na pasta `build/default` de um projeto Defold. O projeto cache vai acelerar builds subsequentes sendo que elas so modifica recursos que precisam ser re-compilados, enquanto recursos sem mudanças serão usados do cache do projeto. Esse cache sempre está ativado e é utilizado tanto pelo editor como pelas ferramentas da linha de comando.
+
+O projeto de cache pode ser deletado manualmente simplesmente deletandos os arquivos em `build/default` ou insinuando o comando `clean` da [Ferramenta de construção da linha de comando Bob](/manuals/bob).
+
+
+## Cache Local
+
+Adicionado no Defold 1.2.187
+
+O cache local é um cache secundário opcional onde recursos compilados estarão guardados em uma localização externa de arquivos na mesma maquina ou em um network drive. Graças ao seu local externo os conteudos do cache sobrevivem a limpeza do cache do projeto. Ele pode ser compartilhado por multiplos desenvolvedores trabalhando no mesmo projeto. O cache é atualmente so está disponivel quando construindo a partir das ferramentas da linha de comando. Ele é ativado pela opção `resource-cache-local`:
+
+```sh
+java -jar bob.jar --resource-cache-local /Users/john.doe/defold_local_cache
+```
+
+Recursos compilados são acessados do cache local baseado em um chcksum computado que leva em conta a versão da engine Defold, o nome e os conteudos dos recursos fonte assim como as opções de construção. Isso irá garantir que os recursos em cache sejam únicos e que o cache possa ser compartilhado entre multiplas versões do Defold.
+
+::: sidenote
+Arquivos guardados no cache local são armazenados de forma indefinida. Está sob comando do desenvolvedor a ação de remover arquivos antigos/sem-uso.
+:::
+
+
+## Cache Remoto
+
+Adicionado no Defold 1.2.187
+
+O cache remoto é uma opção terciária de cache em que recursos compilados são armazenados em um servidor que é acessado via requisições HTTP. O cache é atualmente somente disponível quando construindo a partir das ferramentas da linha de comando. Isso pode ser ativado a partir da opção `resource-cache-remote`:
+
+```sh
+java -jar bob.jar --resource-cache-remote http://192.168.0.100/
+```
+
+Assim como o cache local todos os recursos são acessados de um cache remoto baseado em um checksum computado. Recursos em cache são acessados por uma requisição HTTP pelos metodos GET, PUT e HEAD. Defold não provê o servidor de cache remoto. Cada desenvolvedor está responsavel por settar esse recurso. Um exemplo de [um servidor básico em Python pode ser visto aqui](https://github.com/britzl/httpserver-python).

docs/ru/manuals/adapting-graphics-to-screen-size.md

@@ -0,0 +1,118 @@
+---
+title: Адаптация графики к разным размерам экрана 
+brief: В этом руководстве объясняется, как адаптировать игру и графику к разным размерам экрана.
+---
+
+# Введение
+
+При адаптации игры и графики к разным размерам экрана необходимо учесть несколько моментов:
+
+* Это будет ретро-игра с pixel-perfect графикой низкого разрешения или современная игра с графикой HD-качества?
+* Как должна вести себя игра в полноэкранном режиме на экранах разных размеров?
+  * Должен ли игрок видеть больше игрового контента на экране с высоким разрешением или графику следует адаптивно масштабировать, чтобы всегда отображать один и тот же контент? 
+* Как игра должна работать с соотношением сторон экрана, отличным от того, что установили в game.project ?
+  * Должен ли игрок видеть больше игрового контента? А может быть там  должны быть чёрные полосы? Или, может быть, элементы графического интерфейса с измененными размерами? 
+* Какие меню и экранные компоненты графического интерфейса вам нужны и как они должны адаптироваться к разным размерам экрана и ориентации экрана?
+  * Должны ли меню и другие компоненты графического интерфейса менять свою компоновку при изменении ориентации или они должны сохранять такую же компоновку независимо от ориентации? 
+
+В этом руководстве будут рассмотрены некоторые из этих вопросов и предложены наилучшие практики.
+
+
+## Как изменить способ отображения вашего контента 
+
+Рендер скрипт в Defold дает вам полный контроль над всем конвейером рендеринга. Рендер скрипт определяет порядок, а также что и как рисовать. Поведение рендер скрипта по умолчанию - всегда рисовать одну и ту же область пикселей, определяемую шириной и высотой в файле *game.project*, независимо от того, изменяется ли размер окна или фактическое разрешение экрана не совпадает. Это приведет к растягиванию содержимого при изменении соотношения сторон и увеличению или уменьшению масштаба при изменении размера окна. В некоторых играх это может быть приемлемо, но более вероятно то, что вы захотите показать большую или меньшую область игрового контента, если разрешение экрана или соотношение сторон отличается, или, по крайней мере, хотели бы убедиться, что произошло масштабирование контента без изменения соотношения сторон. Поведение при растягивании по умолчанию можно легко изменить, и вы можете узнать больше о том, как это сделать, в [Руководство по рендерингу](https://defold.com/ru/manuals/render/#проекция-вида-по-умолчанию). 
+
+## Ретро/8-битная графика
+
+Под ретро / 8-битной графикой часто подразумевают игры, имитирующие графический стиль старых игровых консолей или компьютеров с их низким разрешением и ограниченной цветовой палитрой. Например, Nintendo Entertainment System (NES) имела разрешение экрана 256x240, Commodore 64 - 320x200, а Gameboy - 160x144, и все это лишь небольшая доля от размеров современных экранов. Чтобы игры, имитирующие этот графический стиль и разрешение экрана, можно было воспроизводить на современном экране с высоким разрешением, графику необходимо масштабировать или увеличивать в несколько раз. Один из простых способов сделать это - нарисовать всю графику в низком разрешении и в стиле, который вы хотите имитировать, и масштабировать графику во время рендеринга. Этого легко добиться в Defold с помощью скрипта рендеринга и параметра [Fixed Projection](/manuals/render/#fixed-projection), установленного в подходящее значение для масштабирования. 
+
+Давайте возьмем этот набор тайлов и персонажа игрока ([источник](https://ansimuz.itch.io/grotto-escape-game-art-pack)) и воспользуемся ими для 8-битной ретро-игры с разрешением 320x200: 
+
+![](images/screen_size/retro-player.png)
+
+![](images/screen_size/retro-tiles.png)
+
+При установке разрешения в 320x200 в файле *game.project* и запуске игра будет выглядеть так: 
+
+![](images/screen_size/retro-original_320x200.png)
+
+Окно совершенно крошечное на современном экране высокого разрешения! Увеличение размера окна в четыре раза до 1280x800 делает его более подходящим для современного экрана: 
+
+![](images/screen_size/retro-original_1280x800.png)
+
+Теперь, когда размер окна стал более подходящим, нам также нужно что-то сделать с графикой. Графика настолько мизерная, что очень сложно понять, что происходит в игре. Мы можем использовать скрипт рендеринга, чтобы установить проекцию с фиксированным соотношением сторон и масштабированную: 
+
+```Lua
+msg.post("@render:", "use_fixed_projection", { zoom = 4 })
+```
+
+Это даст нам следующий результат:
+
+![](images/screen_size/retro-zoomed_1280x800.png)
+
+Это уже лучше. И окно, и графика имеют хорошие размеры, но если мы присмотримся, то обнаружим очевидную проблему: 
+
+![](images/screen_size/retro-zoomed_linear.png)
+
+Графика выглядит замыленной! Это обусловлено тем, каким способом увеличенная графика семплируется из текстуры при рендеринге графическим процессором. По умолчанию в файле *game.project* в разделе «Графика» установлено значение *linear*: 
+
+![](images/screen_size/retro-settings_linear.png)
+
+Изменение этого параметра на *nearest* даст результат, который нам нужен: 
+
+![](images/screen_size/retro-settings_nearest.png)
+
+![](images/screen_size/retro-zoomed_nearest.png)
+
+Теперь у нас есть четкая pixel-perfect графика для нашей ретро-игры. Есть еще кое-что, что нужно учитывать, например, отключение субпикселей для спрайтов в *game.project*: 
+
+![](images/screen_size/retro-subpixels.png)
+
+Когда параметр «Subpixels» отключен, спрайты никогда не будут отображаться на половинных пикселях, а вместо этого всегда будут привязываться к ближайшему целому пикселю. 
+
+## Графика высокого разрешения 
+
+При работе с графикой высокого разрешения нам нужно подходить к настройке проекта и контента иначе, чем к ретро / 8-битной графике. С растровой графикой вам необходимо создать свой контент таким образом, чтобы он хорошо смотрелся на экране с высоким разрешением при отображении в масштабе 1: 1.
+
+Как и для ретро / 8-битной графики, вам нужно изменить скрипт рендеринга. В этом случае вы хотели бы, чтобы графика масштабировалась в соответствии с размером экрана при сохранении исходного соотношения сторон: 
+
+```Lua
+msg.post("@render:", "use_fixed_fit_projection")
+```
+
+Это гарантирует, что размер экрана будет изменяться, чтобы всегда отображать то же количество контента, что указано в файле *game.project*, возможно, с дополнительным контентом, показываемым сверху и снизу или по бокам, в зависимости от того, отличается соотношение сторон или нет.
+
+Вы должны настроить ширину и высоту в файле *game.project* на размер, позволяющий отображать содержимое игры в немасштабированном виде. 
+
+### Настройка высокого разрешения и Retina экраны 
+
+Если вы также хотите поддерживать экраны Retina с высоким разрешением, вы можете включить это в файле *game.project* в разделе Display:
+
+![](images/screen_size/highdpi-enabled.png)
+
+Это создаст вторичный буфер высокого разрешения (high dpi back buffer) для поддерживающих его дисплеев. Игра будет отображаться в двойном разрешении от того, что установлено в настройках ширины и высоты, что по-прежнему будет логическим разрешением, используемым в скриптах и свойствах. Это означает, что все измерения останутся прежними, и любой контент, отображаемый в масштабе 1x, будет выглядеть так же. Но если вы импортируете изображения с высоким разрешением и масштабируете их до 0,5x, они будут иметь высокое разрешение на экране. 
+
+
+## Создание адаптивного графического интерфейса
+
+Система для создания компонентов графического интерфейса основана на нескольких базовых строительных блоках, или [нодах](/manuals/gui/#node-types), и, хотя она может показаться слишком простой, ее можно использовать для создания чего угодно, от кнопок до сложных меню и всплывающих окон. Создаваемые вами графические интерфейсы пользователя можно настроить для автоматической адаптации к изменениям размера и ориентации экрана. Вы можете, например, удерживать узлы привязанными к верхней, нижней или боковым сторонам экрана, а узлы могут либо сохранять свой размер, либо растягиваться. Взаимодействие между узлами, а также их размер и внешний вид также можно настроить для изменения при изменении размера или ориентации экрана. 
+
+### Свойства нод
+
+Каждая нода в графическом интерфейсе имеет точку поворота (pivot point), горизонтальную и вертикальную привязку, а также режим настройки.
+
+* Точка поворота определяет центральную точку узла.
+* Режим привязки контролирует, как поменяется вертикальное и горизонтальное положение узла, когда границы сцены или границы родительского узла растягиваются, чтобы соответствовать физическому размеру экрана.
+* Настройка Adjust mode контролирует, что происходит с узлом, когда границы сцены или границы родительского узла настраиваются в соответствии с физическим размером экрана. 
+
+Вы можете узнать больше об этих свойствах [в руководстве по графическому интерфейсу](/manuals/gui/#node-properties). 
+
+### Компоновки
+
+Defold поддерживает графические интерфейсы пользователя, которые автоматически адаптируются к изменениям ориентации экрана на мобильных устройствах. Используя эту функцию, вы можете спроектировать графический интерфейс, который может адаптироваться к ориентации и соотношению сторон из диапазона различных экранов. Также можно создавать компоновки, соответствующие конкретным моделям устройств. Вы можете узнать больше об этой системе в [Руководстве по GUI-компоновкам](/manuals/gui-layouts/) 
+
+## Тестирование экранов разных размеров
+
+В меню «Debug» есть возможность имитировать разрешение либо определенной модели устройства, либо настраиваемое разрешение. Пока приложение работает, вы можете выбрать <kbd>Debug->Simulate Resolution</kbd> и выбрать одну из моделей устройства из списка. Размер окна запущенного приложения изменится, и вы сможете увидеть, как ваша игра выглядит в другом разрешении или с другим соотношением сторон. 
+
+![](images/screen_size/simulate-resolution.png)

docs/ru/manuals/bob.md

@@ -0,0 +1,161 @@
+---
+title: Руководство по сборщику проектов Defold 
+brief: Bob - это инструмент командной строки для создания проектов Defold. В этом руководстве объясняется, как использовать инструмент.
+---
+
+# Сборщик Bob
+
+Bob - это инструмент командной строки для сборки проектов на Defold вне обычного рабочего процесса в редакторе.
+
+Bob может делать сборки (соответствует этапу сборки при выборе пункта меню редактора <kbd>Project ▸ Build</kbd>), создавать архивы данных и создавать автономные распространяемые бандлы (соответствует пункту меню редактора <kbd> Project ▸ Bundle ▸ ... </kbd>)
+
+Bob распространяется в виде Java _JAR_ архива, содержащего все необходимое для сборки. Вы найдете дистрибутив *bob.jar* последней актуальной версии на [странице загрузки Defold](http://d.defold.com) и на [GitHub странице релизов](https://github.com/defold/defold/releases) . Выберите релиз, затем загрузите *bob/bob.jar*. Чтобы запустить утилиту Bob, вам необходимо [установить на вашем компьютере OpenJDK 11](https://openjdk.java.net/projects/jdk/11/). 
+
+## Применение
+
+Bob запускается из оболочки или из командной строки, вызовом `java` (или` java.exe` в Windows) и передачей файла java-архива утилиты bob в качестве аргумента: 
+
+```text
+$ java -jar bob.jar --help
+usage: bob [options] [commands]
+  -a,--archive                       Build archive
+ -ar,--architectures <arg>           comma separated list of architectures
+                                     to include for the platform, for example
+                                     "arm64-android,armv7-android"
+  -u,--auth <arg>                    User auth token
+     --binary-output <arg>           Location where built engine binary
+                                     will be placed. Default is
+                                     "<build-output>/<platform>/"
+ -br,--build-report <arg>            Filepath where to save a build report
+                                     as JSON
+ -brhtml,--build-report-html <arg>   Filepath where to save a build report
+                                     as HTML
+     --build-server <arg>            The build server (when using native
+                                     extensions)
+ -bo,--bundle-output <arg>           Bundle output directory
+     --bundle-format <apk|aab>       Which format to generate Android bundle in
+  -d,--debug                         Use debug version of dmengine (when
+                                     bundling). Deprecated, use --variant
+                                     instead
+     --debug-ne-upload               Outputs the files sent to build server as
+                                     upload.zip
+     --defoldsdk <arg>               What version of the defold sdk (sha1)
+                                     to use
+     --exclude-build-folder          Comma separated list of folders to exclude
+                                     from the build
+  -e,--email <arg>                   User email
+  -h,--help                          This help message
+  -i,--input <arg>                   Source directory. Default is current
+                                     directory
+     --identity <arg>                Sign identity (iOS)
+  -k,--keep-unused                   Keep unused resources in archived
+                                     output
+     --keystore <arg>                Which keystore file to use when signing the
+                                     Android bundle.
+     --keystore-pass <arg>           Path to file with keystore password used to
+                                     when bundling for Android.
+     --keystore-alias <arg>          Name of alias from provided keystore to use
+                                     when bundling for Android.
+  -l,--liveupdate <arg>              yes if liveupdate content should be
+                                     published
+ -mp,--mobileprovisioning <arg>      mobileprovisioning profile (iOS)
+  -o,--output <arg>                  Output directory. Default is
+                                     "build/default"
+  -p,--platform <arg>                Platform (when bundling)
+  -r,--root <arg>                    Build root directory. Default is
+                                     current directory
+     --settings <arg>                Path to a game project settings
+                                     file. more than one occurrance are
+                                     allowed. the settings files are
+                                     applied left to right.
+     --strip-executable              Strip the dmengine of debug symbols
+                                     (when bundling iOS or Android)
+ -tc,--texture-compression <arg>     Use texture compression as specified
+                                     in texture profiles
+ -tp,--texture-profiles <arg>        Use texture profiles (deprecated)
+     --use-vanilla-lua               Only ships vanilla source code (i.e.
+                                     no byte code)
+  -v,--verbose                       Verbose output
+     --variant <arg>                 Specify debug, release or headless
+                                     version of dmengine (when bundling)
+     --version                       Prints the version number to the
+                                     output
+     --with-symbols                  Generate the symbol file (if
+                                     applicable)
+```
+
+Доступные команды:
+
+`clean`
+: Удалить собранные файлы в каталоге сборки.
+
+`distclean`
+: Удалить все файлы в каталоге сборки.
+
+`build`
+: Собирает все данные проекта. Добавьте параметр `--archive` для создания файла архива данных («game.darc» в каталоге сборки). 
+
+`bundle`
+: Создает бандл под конкретную платформу. Бандлинг требует наличие собранного архива (`билд` с параметром --archive) и указание целевой платформы (ключом `--platform`). Bob создает бандл в каталоге вывода, если другой каталог не указан ключом `--bundle-output`. Бандл будет назван в соответствии с настройкой project name в *game.project*. Ключ `--variant` указывает тип исполняемого файла для сборки при бандлинге и вместе с ключом `--strip-executable` заменяет ключ `--debug`. Если не указан ключ `--variant`, вы получите релизную версию движка (без debug символов для Android и iOS). Установка ключа `--variant` в debug и опускание ключа ` --strip-executable` дает тот же тип исполняемого файла, что и ключ `--debug`. 
+
+`resolve`
+: Подтягивание всех зависимостей внешних библиотек. 
+
+Доступные платформы и архитектуры
+Available platforms and architectures:
+
+`x86_64-darwin`
+: macOS 64 бита 
+
+`x86_64-win32`
+: Windows 64 бита
+
+`x86-win32`
+: Windows 32 бита
+
+`x86_64-linux`
+: Linux 64 бита
+
+`x86_64-ios`
+: iOS macOS 64 бита (Эмулятор iOS)
+
+`armv7-darwin`
+: iOS с доступной 32-битной архитектурой `armv7-darwin` и 64-битной` arm64-darwin`. По умолчанию значение аргумента `--architectures` - `armv7-darwin,arm64-darwin`. 
+
+`armv7-android`
+: Android с доступной 32-битной архитектурой `armv7-android` и 64-битной` arm64-android`. По умолчанию значение аргумента `--architectures` - `armv7-android,arm64-android`. 
+
+`js-web`
+: HTML5 с доступными архитектурами `js-web` и `wasm-web`. По умолчанию значение аргумента `--architectures` - `js-web,wasm-web`. 
+
+По умолчанию Bob ищет в текущем каталоге проект, который нужно собрать. Если вы измените текущий каталог на проект Defold и вызовете bob, он соберёт данные для проекта в каталоге вывода по умолчанию *build/default*. 
+
+```sh
+$ cd /Applications/Defold-beta/branches/14/4/main
+$ java -jar bob.jar
+100%
+$
+```
+
+Вы можете связывать команды вместе, чтобы выполнить последовательность задач за один раз. В следующем примере выполняются подтягивание библиотек, стирание каталога сборки, сборка данных архива и сборка приложения macOS (с именем *My Game.app*): 
+
+```sh
+$ java -jar bob.jar --archive --platform x86-darwin resolve distclean build bundle
+100%
+$ ls -al build/default/
+total 70784
+drwxr-xr-x   13 sicher  staff       442  1 Dec 10:15 .
+drwxr-xr-x    3 sicher  staff       102  1 Dec 10:15 ..
+drwxr-xr-x    3 sicher  staff       102  1 Dec 10:15 My Game.app
+drwxr-xr-x    8 sicher  staff       272  1 Dec 10:15 builtins
+-rw-r--r--    1 sicher  staff    140459  1 Dec 10:15 digest_cache
+drwxr-xr-x    4 sicher  staff       136  1 Dec 10:15 fonts
+-rw-r--r--    1 sicher  staff  35956340  1 Dec 10:15 game.darc
+-rw-r--r--    1 sicher  staff       735  1 Dec 10:15 game.projectc
+drwxr-xr-x  223 sicher  staff      7582  1 Dec 10:15 graphics
+drwxr-xr-x    3 sicher  staff       102  1 Dec 10:15 input
+drwxr-xr-x   20 sicher  staff       680  1 Dec 10:15 logic
+drwxr-xr-x   27 sicher  staff       918  1 Dec 10:15 sound
+-rw-r--r--    1 sicher  staff    131926  1 Dec 10:15 state
+$
+```

docs/ru/manuals/bundling.md

@@ -0,0 +1,58 @@
+---
+title: Бандлинг (сборка пакета) приложения
+brief: В этом руководстве рассказывается, как создать бандл приложения.
+---
+
+# Бандлинг приложения
+
+При разработке приложения вы должны выработать привычку как можно чаще тестировать игру на целевых платформах. Это необходимо для того, чтобы выявлять проблемы с производительностью на ранних этапах процесса разработки, когда эти проблемы гораздо легче исправить. Также рекомендуется тестировать на всех целевых платформах, чтобы найти расхождения в таких вещах, как шейдеры. При разработке на мобильных устройствах у вас есть возможность использовать [приложение для мобильной разработки](/manuals/dev-app/) для отправки содержимого в приложение вместо того, чтобы выполнять полную пересборку и цикл удаления/установки.
+
+Вы можете создать бандл приложения для всех платформ, которые поддерживает Defold, из самого редактора Defold без каких-либо внешних инструментов. Вы также можете сделать бандл из командной строки с помощью наших инструментов командной строки. Бандлинг приложения требует сетевое соединение, если ваш проект содержит одно или несколько [нативных расширений](/manuals/extensions).
+
+## Бандлинг прямо из редактора
+
+Создать бандл можно из меню Project и опции Bundle: 
+
+![](images/bundling/bundle_menu.png)
+
+Выбор любого из пунктов меню вызовет диалог Бандла для этой конкретной платформы. 
+
+### Отчеты о сборке
+
+При сборке вашей игры есть возможность создать отчет о сборке. Это очень полезно, чтобы получить представление о размере всех ассетов, входящих в бандл. Просто установите флажок *Generate build report* при сборке игры. 
+
+![build report](images/profiling/build_report.png){srcset="images/profiling/[email protected] 2x"}
+
+Чтобы узнать больше об отчетах о сборке, обратитесь к [Руководству по профилированию](/manuals/profiling/#build-reports).
+
+### Android
+
+Создание бандла для Android (файл .apk) описано в [Руководстве по Android](/manuals/android/#creating-an-android-application-bundle).
+
+### iOS
+
+Создание бандла для iOS (файл .ipa) описано в [Руководстве по iOS](/manuals/ios/#creating-an-ios-application-bundle).
+
+### macOS
+
+Создание бандла для macOS (файл .app) описано в [Руководстве по macOS](/manuals/macos).
+
+### Linux
+
+Создание бандла для Linux не требует специальной настройки и дополнительной конфигурации для конкретной платформы в [файле настроек проекта][project settings file](/manuals/project-settings/#linux) "game.project".
+
+### Windows
+
+Создание Windows-приложения (файл .exe) описано в [Руководстве по Windows](/manuals/windows).
+
+### HTML5
+
+Создание HTML5 билда, а также дополнительная настройка описаны в [руководстве по HTML5](/manuals/html5/#creating-html5-bundle).
+
+#### Facebook Instant Games
+
+Можно создать специальную версию HTML5 билда специально для Facebook Instant Games. Этот процесс задокументирован в [руководстве по Facebook Instant Games](/manuals/instant-games/).
+
+## Бандлинг из командной строки
+
+При повседневной разработке вашего приложения вполне вероятно, что вы собираете и бандлите прямо из редактора Defold. В других обстоятельствах вы можете захотеть автоматически создавать бандлы, например, пакетный бандлинг для всех платформ при выпуске новой версии или при создании ночных сборок последней версии игры, возможно, в среде CI. Сборка и бандлинг приложения могут выполняться вне обычного рабочего процесса в редакторе, с помощью [инструмента командной строки Bob](/manuals/bob/). 

docs/ru/manuals/dev-app.md

@@ -0,0 +1,86 @@
+---
+title: Запуск приложения для разработки на устройстве 
+brief: В этом руководстве объясняется, как установить приложение для разработки на ваше устройство для итеративной разработки на нем.
+---
+
+# Приложение для мобильной разработки
+
+Приложение для разработки позволяет загружать в него контент через Wi-Fi. Это значительно сократит время итерации, поскольку вам не нужно делать бандл и устанавливать его каждый раз, когда вы хотите протестировать свои изменения. Вы устанавливаете приложение для разработки на свое устройство(а), запускаете приложение, а затем выбираете устройство в качестве цели сборки в редакторе. 
+
+## Установка приложения для разработки
+
+Любое приложение, собранное в режиме отладки, сможет действовать как приложение для разработки. На Android доступна автономная версия движка Defold, а на iOS вам необходимо вручную собрать бандл и подписать его, используя свой собственный идентификатор подписи и provisioning профиль. 
+
+### Установка на iOS 
+
+Любое iOS приложение, бандл которого был собран как отладочный вариант, сможет действовать как приложение для разработки. Рекомендуется сделать бандл отладочного варианта приложения, над которым вы сейчас работаете. Это гарантирует, что приложение для разработки имеет правильные настройки проекта и использует те же [нативные расширения](/manuals/extensions/). Следуйте [инструкциям в руководстве по iOS](/manuals/ios/#creating-an-ios-application-bundle), чтобы собрать бандл для iOS. Обязательно выберите вариант Debug!
+
+### Установка на Android
+
+Такая же рекомендация делать бандл отладочной версии, что и для iOS, работает и для Android. В дополнение к этой опции существует также автономная версия движка Defold, доступная в виде готового файла *.apk*, который вы можете установить на устройство и использовать для итеративной разработки по беспроводной сети. 
+::: important
+Автономная версия будет работать только для проектов без каких-либо [нативных расширений](/manuals/extensions/). Если ваш проект содержит native extension-ы, вы должны собрать бандл отладочного варианта вашего проекта, чтобы убедиться, что приложение для разработки содержит все native extension-ы, которые вы собираетесь использовать. 
+:::
+* Посетите http://d.defold.com, где можно найти скачать Defold. 
+* Щелкните версию, которую хотите загрузить, чтобы развернуть список доступных сборок движка.
+* Выберите *engine/armv7-android/dmengine.apk* для сборки с включенной отладкой для платформы Android (Armv7).
+
+![Скачать dmengine](images/dev-app/download_dmengine.png)
+
+Скачайте файл, затем введите следующую команду `adb` из папки содержащей *.apk*: 
+
+```sh
+$ adb install dmengine.apk
+4445 KB/s (8706017 bytes in 1.912s)
+    pkg: /data/local/tmp/dmengine.apk
+Success
+```
+
+Приложение для разработки "dmengine" теперь доступно на устройстве.
+
+![dmengine на устройстве](images/dev-app/dmengine_on_device.png)
+
+## Запуск вашей игры
+
+Чтобы запустить игру на вашем устройстве, приложение для разработки и редактор должны иметь возможность подключаться через одну и ту же сеть Wi-Fi или через USB (см. ниже). 
+
+1. Убедитесь, что редактор запущен.
+2. Запустите приложение для разработки на устройстве.
+3. Выберите свое устройство в редакторе в разделе <kbd>Project ▸ Targets</kbd>.
+4. Выберите <kbd>Project ▸ Build</kbd>, чтобы запустить игру. Для запуска игры может потребоваться некоторое время, поскольку игровой контент передается на устройство по сети.
+5. Пока игра запущена, вы по-прежнему можете использовать [горячую перезагрузку](/manuals/hot-reload/).
+
+![запуск](images/dev-app/launch.png)
+
+### Подключение к устройству iOS через USB в Windows
+
+При подключении через USB в Windows к приложению для разработки, работающему на устройстве iOS, сначала необходимо [установить iTunes](https://www.apple.com/lae/itunes/download/). После установки iTunes вам также необходимо [включить персональную точку доступа](https://support.apple.com/en-us/HT204023) на вашем устройстве iOS в меню «Настройки». Если вы видите предупреждение, которое спрашивает «Доверять этому компьютеру?», тапните Доверять. Теперь устройство должно отображаться в разделе <kbd>Project ▸ Targets</kbd>, когда приложение для разработки запущено. 
+
+### Подключение к устройству iOS через USB в Linux
+
+В Linux вам необходимо включить Personal Hotspot на вашем устройстве в меню настроек при подключении через USB. Если вы видите предупреждение, которое спрашивает «Доверять этому компьютеру?», тапните Доверять. Теперь устройство должно отображаться в разделе <kbd>Project ▸ Targets</kbd>, когда приложение для разработки запущено. 
+
+### Подключение к устройству iOS через USB в macOS
+
+В более новых версиях iOS устройство автоматически откроет новый интерфейс Ethernet между устройством и компьютером при подключении через USB в macOS. Устройство должно отображаться в разделе <kbd>Project ▸ Targets</kbd>, когда приложение для разработки запущено.
+
+В более старых версиях iOS вам необходимо включить Personal Hotspot на вашем устройстве в меню «Настройки» при подключении через USB в macOS. Если вы видите предупреждение, которое спрашивает «Доверять этому компьютеру?», тапните Доверять. Теперь устройство должно отображаться в разделе <kbd>Project ▸ Targets</kbd>, когда приложение для разработки запущено. 
+
+### Подключение к устройству Android через USB в macOS
+
+В macOS можно подключиться через USB к работающему приложению для разработки на устройстве Android, когда устройство находится в режиме USB-модема. В macOS необходимо установить сторонний драйвер, например [HoRNDIS](https://joshuawise.com/horndis#available_versions). Когда HoRNDIS установлен, вам также необходимо разрешить его запуск в настройках Security & Privacy. После включения USB-модема устройство будет отображаться в разделе <kbd>Project ▸ Targets</kbd> при запуске приложения для разработки. 
+
+### Подключение к устройству Android через USB в Windows или Linux
+
+В Windows и Linux можно подключиться через USB к работающему приложению для разработки на устройстве Android, когда устройство находится в режиме USB-модема. После включения USB-модема устройство будет отображаться в разделе <kbd>Project ▸ Targets</kbd> при запуске приложения для разработки. 
+
+## Поиск и устранение проблем
+
+Невозможно скачать приложение
+: Убедитесь, что UDID вашего устройства включен в mobile provisioning, который использовался для подписи приложения. 
+
+Ваше устройство не отображается в меню "Targets".
+: Убедитесь, что ваше устройство подключено к той же сети Wi-Fi, что и ваш компьютер. 
+
+Игра не запускается с сообщением о несовпадении версий
+: Это происходит, когда вы обновили редактор до последней версии. Вам необходимо собрать и установить новую версию приложения.

docs/ru/manuals/hot-reload.md

@@ -0,0 +1,122 @@
+---
+title: Горячая перезагрузка
+brief: В этом руководстве объясняется функция горячей перезагрузки (перезагрузки на лету) в Defold. 
+---
+
+# Перезагрузка ресурсов на лету
+
+Defold позволяет выполнять горячую перезагрузку ресурсов. При разработке игры эта функция помогает значительно ускорить выполнение определенных задач. Она позволяет вам изменять код и содержимое игры во время ее работы. Типовые варианты использования:
+
+- Для настройки параметров игрового процесса в Lua-скриптах.
+- Для редактирования и настройки графических элементов (например, эффектов частиц или элементов графического интерфейса) и просмотра результатов в актуальном контексте.
+- Для редактирования и настройки кода шейдера и просмотра результатов в актуальном контексте.
+- Для облегчения тестирования игры путем перезапуска уровней, настройки состояния и т. д. без остановки игры. 
+
+## Как сделать горячую перезагрузку
+
+Запустите свою игру из редактора (<kbd>Project ▸ Build</kbd>).
+
+Чтобы затем перезагрузить обновленный ресурс, просто выберите пункт меню <kbd> File ▸ Hot Reload </kbd> или нажмите соответствующую комбинацию на клавиатуре: 
+
+![Reloading resources](images/hot-reload/menu.png){srcset="images/hot-reload/[email protected] 2x"}
+
+## Горячая перезагрузка на устройстве
+
+Горячая перезагрузка работает как на устройстве, так и на компьютере. Чтобы использовать её на устройстве, запустите отладочную сборку своей игры или [приложение для разработки](/manuals/dev-app) на своем мобильном устройстве, затем выберите его в качестве цели в редакторе: 
+
+![target device](images/hot-reload/target.png){srcset="images/hot-reload/[email protected] 2x"}
+
+Теперь при сборке и запуске редактор загружает все ассеты в работающее приложение на устройстве и запускает игру. После этого любой файл, который вы загружаете в горячем режиме, будет обновлен на устройстве.
+
+Например, чтобы добавить пару кнопок в графический интерфейс, который отображается в запущенной игре на вашем телефоне, просто откройте файл графического интерфейса: 
+
+![reload gui](images/hot-reload/gui.png){srcset="images/hot-reload/[email protected] 2x"}
+
+Добавьте новые кнопки, сохраните и перезагрузите GUI-файл в горячем режиме. Теперь вы можете видеть новые кнопки на экране телефона: 
+
+![reloaded gui](images/hot-reload/gui-reloaded.png){srcset="images/hot-reload/[email protected] 2x"}
+
+При горячей перезагрузке файла движок выведет в консоль каждый перезагруженный файл ресурсов. 
+
+## Перезагрузка скриптов
+
+Любой перезагруженный файл Lua-скрипта будет повторно выполнен в среде исполнения Lua. 
+
+```lua
+local my_value = 10
+
+function update(self, dt)
+    print(my_value)
+end
+```
+
+Изменение `my_value` на 11 и горячая перезагрузка файла дадут немедленный эффект: 
+
+```text
+...
+DEBUG:SCRIPT: 10
+DEBUG:SCRIPT: 10
+DEBUG:SCRIPT: 10
+INFO:RESOURCE: /main/hunter.scriptc was successfully reloaded.
+DEBUG:SCRIPT: 11
+DEBUG:SCRIPT: 11
+DEBUG:SCRIPT: 11
+...
+```
+
+Обратите внимание, что горячая перезагрузка не влияет на выполнение функций жизненного цикла. Например, вызова `init()` при горячей перезагрузке не произойдёт. Однако, если вы переопределите функции жизненного цикла, будут использоваться новые версии. 
+
+## Перезагрузка Lua модулей 
+
+Пока вы добавляете переменные в глобальную область видимости в файле модуля, перезагрузка файла приведет к изменению этих глобальных переменных: 
+
+```lua
+--- my_module.lua
+my_module = {}
+my_module.val = 10
+```
+
+```lua
+-- user.script
+require "my_module"
+
+function update(self, dt)
+    print(my_module.val) -- hot reload "my_module.lua" and the new value will print
+end
+```
+
+Распространенный паттерн модуля Lua - создать локальную таблицу, заполнить ее и затем вернуть: 
+
+```lua
+--- my_module.lua
+local M = {} -- a new table object is created here
+M.val = 10
+return M
+```
+
+```lua
+-- user.script
+local mm = require "my_module"
+
+function update(self, dt)
+    print(mm.val) -- will print 10 even if you change and hot reload "my_module.lua"
+end
+```
+
+Изменение и перезагрузка "my_module.lua" _не_ изменит поведение "user.script". См. [Руководство по модулям](/manuals/modules) для получения дополнительной информации о том, почему и как избежать этой ошибки.
+
+## Функция on_reload()
+
+Каждый компонент скрипта может содержать определение функции `on_reload()`. Если она существует, она будет вызываться каждый раз при перезагрузке скрипта. Это полезно для проверки или изменения данных, отправки сообщений и так далее: 
+
+```lua
+function on_reload(self)
+    print(self.velocity)
+
+    msg.post("/level#controller", "setup")
+end
+```
+
+## Перезагрузка кода шейдера
+
+При перезагрузке вершинных и фрагментных шейдеров код GLSL перекомпилируется графическим драйвером и загружается в GPU. Если код шейдера вызывает сбой, что легко сделать, поскольку GLSL написан на очень низком уровне, это приведет к остановке движка.