From e78937db34a9b279548ab33af0edd28c9790effc Mon Sep 17 00:00:00 2001
From: Icaro Alves <33491428+Roxicaro@users.noreply.github.com>
Date: Fri, 10 Oct 2025 13:33:13 -0300
Subject: [PATCH 1/6] Create adapting-graphics-to-screen-size.md
---
.../adapting-graphics-to-screen-size.md | 126 ++++++++++++++++++
1 file changed, 126 insertions(+)
create mode 100644 docs/pt/manuals/adapting-graphics-to-screen-size.md
diff --git a/docs/pt/manuals/adapting-graphics-to-screen-size.md b/docs/pt/manuals/adapting-graphics-to-screen-size.md
new file mode 100644
index 00000000..cbb086c1
--- /dev/null
+++ b/docs/pt/manuals/adapting-graphics-to-screen-size.md
@@ -0,0 +1,126 @@
+---
+title: Adaptando gráficos a diferentes tamanhos de tela
+brief: Este manual explica como adaptar seu jogo e gráficos a diferentes tamanhos de tela.
+---
+
+# Introdução
+
+Existem vários pontos a considerar ao adaptar seu jogo e gráficos a diferentes tamanhos de tela:
+
+* Seu jogo é retrô, com gráficos pixel-perfect de baixa resolução, ou moderno, com gráficos em HD?
+* Como o jogo deve se comportar quando jogado em tela cheia em diferentes tamanhos de tela?
+ * O jogador deve ver mais conteúdo do jogo em uma tela de alta resolução ou os gráficos devem ser ajustados automaticamente para sempre mostrar o mesmo conteúdo?
+* Como o jogo deve lidar com proporções de tela diferentes da configurada em *game.project*?
+ * O jogador deve ver mais conteúdo do jogo? Ou talvez deveriam aparecer barras pretas? Ou talvez os elementos da interface precisem ser redimensionados?
+* Que tipo de menus e componentes GUI (interface gráfica) você precisa e como eles devem se adaptar a diferentes tamanhos de tela e orientações?
+ * Menus e outros componentes da interface devem mudar de layout quando a orientação mudar, ou devem manter o mesmo layout independentemente da orientação?
+
+Este manual abordará alguns desses pontos e sugerirá boas práticas.
+
+
+## How to change how your content is rendered
+
+The Defold render script give you total control over the entire rendering pipeline. The render script decides the order as well as what and how to draw things. The default behavior of the render script is to always draw the same area of pixels, defined by the width and height in the *game.project* file, regardless if the window is resized or the actual screen resolution doesn't match. This will result in the content being stretched if the aspect ratio changes and zoomed in or out if the window size changes. In some games this might be acceptable, but it is more likely that you want to show more or less game content if the screen resolution or aspect ratio is different, or at least make sure to zoom the content without changing the aspect ratio. The default stretch behavior can easily be changed and you can read more about how to do this in the [Render manual](https://www.defold.com/manuals/render/#default-view-projection).
+
+
+## Retro/8-bit graphics
+
+Retro/8-bit graphics often refer to games emulating the graphical style of old game consoles or computers with their low resolution and limited color palette. As an example the Nintendo Entertainment System (NES) had a screen resolution of 256x240, the Commodore 64 had 320x200 and the Gameboy had 160x144, all of which are only a fraction of the size of modern screens. In order to make games emulating this graphical style and screen resolution playable on a modern high resolution screen the graphics has to be upscaled or zoomed several times. One simple way of doing this is to draw all of your graphics in the low resolution and style that you wish to emulate and zoom the graphics when it is rendered. This can easily be achieved in Defold using the render script and the [Fixed Projection](/manuals/render/#fixed-projection) set to a suitable zoom value.
+
+Let's take this tileset and player character ([source](https://ansimuz.itch.io/grotto-escape-game-art-pack)) and use them for an 8-bit retro game with a resolution of 320x200:
+
+
+
+
+
+Setting 320x200 in the *game.project* file and launching the game would look like this:
+
+
+
+The window is absolutely tiny on a modern high resolution screen! Increasing the window size four times to 1280x800 makes it more suitable for a modern screen:
+
+
+
+Now that the window size is more reasonable we also need to do something about the graphics. It's so small it's very hard to see what is going on in the game. We can use the render script to set a fixed and zoomed projection:
+
+```Lua
+msg.post("@render:", "use_fixed_projection", { zoom = 4 })
+```
+
+::: sidenote
+The same result can be achieved by attaching a [Camera component](manuals/camera/) to a game object and check *Orthographic Projection* and set *Orthographic Zoom* to 4.0:
+
+
+:::
+
+This will give the following result:
+
+
+
+This is better. The window and graphics both have a good size, but if we look closer there is an obvious problem:
+
+
+
+The graphics look blurred! This is caused by the way the zoomed in graphics is sampled from the texture when rendered by the GPU. The default setting in the *game.project* file under the Graphics section is *linear*:
+
+
+
+Changing this to *nearest* will give the result we are after:
+
+
+
+
+
+Now we have crisp pixel-perfect graphics for our retro game. There are even more things to consider, such as disabling sub-pixels for sprites in *game.project*:
+
+
+
+When the Subpixels option is disabled sprites will never get rendered on half pixels and instead always snap to the nearest full pixel.
+
+## High resolution graphics
+
+When dealing with high resolution graphics we need to approach project and content setup in a different way than for retro/8-bit graphics. With bitmap graphics you need to create your content in such a way that it looks good on a high resolution screen when shown at a 1:1 scale.
+
+Just like for retro/8-bit graphics you need to change the render script. In this case you want the graphics to scale with the screen size while maintaining the original aspect ratio:
+
+```Lua
+msg.post("@render:", "use_fixed_fit_projection")
+```
+
+This will make sure that the screen will resize to always show the same amount of content as specified in the *game.project* file, possibly with additional content shown above and below or to the sides, depending on if the aspect ratio differs or not.
+
+You should configure the width and height in the *game.project* file to a size that allows you to show your game content unscaled.
+
+### High DPI setting and retina screens
+
+If you also wish to support high resolution retina screens you can enable this in the *game.project* file in the Display section:
+
+
+
+This will create a high dpi back buffer on displays that support it. The game will render in double the resolution than what is set in the Width and Height settings, which will still be the logical resolution used in scripts and properties. This means that all measurements stay the same and any content that is rendered at 1x scale will look the same. But if you import high res images and scale them to 0.5x they will be high dpi on screen.
+
+
+## Creating an adaptive GUI
+
+The system for creating GUI components is built around a number of basic building blocks, or [nodes](/manuals/gui/#node-types), and while it may seem overly simple it can be used to create anything from buttons to complex menus and popups. The GUIs that you create can be configured to automatically adapt to screen size and orientation changes. You can for instance keep nodes anchored to the top, bottom or sides of the screen and nodes can either keep their size or stretch. The relationship between nodes as well as their size and appearance can also be configured to change when the screen size or orientation changes.
+
+### Node properties
+
+Each node in a gui has a pivot point, a horizontal and vertical anchor as well as an adjust mode.
+
+* The pivot point defines the center point of a node.
+* The anchor mode controls how the node’s vertical and horizontal position is altered when the scene boundaries, or the parent node’s boundaries are stretched to fit the physical screen size.
+* The adjust mode setting controls what happens to a node when the scene boundaries, or the parent node’s boundaries, are adjusted to fit the physical screen size.
+
+You can learn more about these properties [in the GUI manual](/manuals/gui/#node-properties).
+
+### Layouts
+
+Defold supports GUIs that automatically adapt to screen orientation changes on mobile devices. By using this feature you can design a GUI that can adapt to the orientation and aspect ratio of a range of screen sizes. It is also possible to create layouts that match particular device models. You can learn more about this system in the [GUI Layouts manual](/manuals/gui-layouts/)
+
+
+## Testing different screen sizes
+
+The Debug menu contains an option to simulate the resolution of either a certain device model resolution or a custom resolution. While the application is running you can select Debug->Simulate Resolution and pick one of the device models from the list. The running application window will resize and you'll be able to see how your game looks in a different resolution or with a different aspect ratio.
+
+
From bb670cf0081543539e5c4c52e7458ccf2d600131 Mon Sep 17 00:00:00 2001
From: Icaro Alves <33491428+Roxicaro@users.noreply.github.com>
Date: Fri, 10 Oct 2025 14:08:38 -0300
Subject: [PATCH 2/6] Update adapting-graphics-to-screen-size.md
---
.../adapting-graphics-to-screen-size.md | 75 +++++++++----------
1 file changed, 37 insertions(+), 38 deletions(-)
diff --git a/docs/pt/manuals/adapting-graphics-to-screen-size.md b/docs/pt/manuals/adapting-graphics-to-screen-size.md
index cbb086c1..38f6f249 100644
--- a/docs/pt/manuals/adapting-graphics-to-screen-size.md
+++ b/docs/pt/manuals/adapting-graphics-to-screen-size.md
@@ -18,89 +18,88 @@ Existem vários pontos a considerar ao adaptar seu jogo e gráficos a diferentes
Este manual abordará alguns desses pontos e sugerirá boas práticas.
-## How to change how your content is rendered
+## Como alterar a forma como seu conteúdo é renderizado
-The Defold render script give you total control over the entire rendering pipeline. The render script decides the order as well as what and how to draw things. The default behavior of the render script is to always draw the same area of pixels, defined by the width and height in the *game.project* file, regardless if the window is resized or the actual screen resolution doesn't match. This will result in the content being stretched if the aspect ratio changes and zoomed in or out if the window size changes. In some games this might be acceptable, but it is more likely that you want to show more or less game content if the screen resolution or aspect ratio is different, or at least make sure to zoom the content without changing the aspect ratio. The default stretch behavior can easily be changed and you can read more about how to do this in the [Render manual](https://www.defold.com/manuals/render/#default-view-projection).
+O render script do Defold dá controle total sobre todo o pipeline de renderização. O script de renderização decide a ordem, o que desenhar e como desenhar. O comportamento padrão do script de renderização é sempre desenhar a mesma área de pixels, definida pela largura e altura no arquivo *game.project*, independentemente se a janela é redimensionada ou se a resolução da tela real não corresponde. Isso fará com que o conteúdo seja esticado se a proporção da tela mudar e ampliado ou reduzido se o tamanho da janela mudar. Em alguns jogos isso pode ser aceitável, mas na maioria dos casos você vai querer mostrar mais ou menos conteúdo do jogo se a resolução da tela ou a proporção forem diferentes, ou pelo menos garantir que o conteúdo seja ampliado sem alterar a proporção. O comportamento padrão de esticamento pode ser facilmente alterado, e você pode ler mais sobre como fazer isso no [Render manual](https://www.defold.com/manuals/render/#default-view-projection).
-## Retro/8-bit graphics
+## Gráficos retrô/8-bit
-Retro/8-bit graphics often refer to games emulating the graphical style of old game consoles or computers with their low resolution and limited color palette. As an example the Nintendo Entertainment System (NES) had a screen resolution of 256x240, the Commodore 64 had 320x200 and the Gameboy had 160x144, all of which are only a fraction of the size of modern screens. In order to make games emulating this graphical style and screen resolution playable on a modern high resolution screen the graphics has to be upscaled or zoomed several times. One simple way of doing this is to draw all of your graphics in the low resolution and style that you wish to emulate and zoom the graphics when it is rendered. This can easily be achieved in Defold using the render script and the [Fixed Projection](/manuals/render/#fixed-projection) set to a suitable zoom value.
+Gráficos retrô/8-bit geralmente se referem a jogos que emulam o estilo gráfico de antigos consoles ou computadores, com baixa resolução e paleta de cores limitada. Por exemplo, o Nintendo Entertainment System (NES) tinha resolução de 256x240, o Commodore 64 tinha 320x200 e o Gameboy tinha 160x144, todos muito menores que telas modernas. Para tornar jogos com esse estilo gráfico jogáveis em telas modernas de alta resolução, os gráficos precisam ser ampliados várias vezes. Uma maneira simples de fazer isso é desenhar todos os gráficos na baixa resolução que você deseja emular e ampliá-los durante a renderização. Isso pode ser feito facilmente no Defold usando o *render script* e a [Projeção Fixa](/manuals/render/#fixed-projection) configurada com o valor de zoom adequado.
-Let's take this tileset and player character ([source](https://ansimuz.itch.io/grotto-escape-game-art-pack)) and use them for an 8-bit retro game with a resolution of 320x200:
+Vamos pegar este tileset e personagem ([fonte](https://ansimuz.itch.io/grotto-escape-game-art-pack)) para um jogo retrô 8-bit com resolução de 320x200:
-
+
-
+
-Setting 320x200 in the *game.project* file and launching the game would look like this:
+Definir 320x200 no arquivo *game.project* e executar o jogo ficaria assim:
-
+
-The window is absolutely tiny on a modern high resolution screen! Increasing the window size four times to 1280x800 makes it more suitable for a modern screen:
+A janela é minúscula em uma tela moderna de alta resolução! Aumentar a janela quatro vezes para 1280x800 torna mais adequado a uma tela moderna:
-
+
-Now that the window size is more reasonable we also need to do something about the graphics. It's so small it's very hard to see what is going on in the game. We can use the render script to set a fixed and zoomed projection:
+Agora que o tamanho da janela é mais razoável, precisamos ajustar os gráficos. Eles estão tão pequenos que é difícil ver o que acontece no jogo. Podemos usar o render script para configurar uma projeção fixa e ampliada:
```Lua
msg.post("@render:", "use_fixed_projection", { zoom = 4 })
```
-::: sidenote
-The same result can be achieved by attaching a [Camera component](manuals/camera/) to a game object and check *Orthographic Projection* and set *Orthographic Zoom* to 4.0:
+::: Observação
+O mesmo resultado pode ser obtido anexando um [Componente de câmera](manuals/camera/) a um objeto de jogo, marcando *Orthographic Projection* e ajustando *Orthographic Zoom* para 4.0:
-
+
:::
-This will give the following result:
+O que resultará nisto:
-
+
-This is better. The window and graphics both have a good size, but if we look closer there is an obvious problem:
+Assim está melhor. A janela e os gráficos têm um bom tamanho, mas se olharmos de perto, há um problema óbvio:
-
+
-The graphics look blurred! This is caused by the way the zoomed in graphics is sampled from the texture when rendered by the GPU. The default setting in the *game.project* file under the Graphics section is *linear*:
+Os gráficos ficam borrados! Isso ocorre devido à forma como a GPU amostra gráficos ampliados a partir da textura. A configuração padrão no arquivo *game.project* na seção *Graphics* é *linear*:
-
+
-Changing this to *nearest* will give the result we are after:
+Alterar essa opção para *nearest* dará o resultado que queremos:
-
+
-
+
-Now we have crisp pixel-perfect graphics for our retro game. There are even more things to consider, such as disabling sub-pixels for sprites in *game.project*:
+Agora temos gráficos nítidos, *pixel-perfect*, para nosso jogo retrô. Há outros pontos a considerar, como desabilitar subpixels para sprites em *game.project*:
-
+
-When the Subpixels option is disabled sprites will never get rendered on half pixels and instead always snap to the nearest full pixel.
+Quando a opção *Subpixels* está desabilitada, os sprites nunca são renderizados em meio pixel e sempre se ajustam ao pixel completo mais próximo.
-## High resolution graphics
+## Gráficos em alta resolução
-When dealing with high resolution graphics we need to approach project and content setup in a different way than for retro/8-bit graphics. With bitmap graphics you need to create your content in such a way that it looks good on a high resolution screen when shown at a 1:1 scale.
+Para gráficos em alta resolução, o projeto e a configuração do conteúdo devem ser tratados de forma diferente dos gráficos retrô/8-bit. Com gráficos bitmap, você precisa criar seu conteúdo de forma que fique bom em uma tela de alta resolução quando exibido em escala 1:1.
-Just like for retro/8-bit graphics you need to change the render script. In this case you want the graphics to scale with the screen size while maintaining the original aspect ratio:
+Assim como nos gráficos retrô, você precisa alterar o render script. Neste caso, você quer que os gráficos escalem com o tamanho da tela, mantendo a proporção original:
```Lua
msg.post("@render:", "use_fixed_fit_projection")
```
-This will make sure that the screen will resize to always show the same amount of content as specified in the *game.project* file, possibly with additional content shown above and below or to the sides, depending on if the aspect ratio differs or not.
+Isso garante que a tela seja redimensionada para sempre mostrar a mesma quantidade de conteúdo definida no arquivo *game.project*, possivelmente exibindo conteúdo adicional acima e abaixo ou nas laterais, dependendo da diferença de proporção.
-You should configure the width and height in the *game.project* file to a size that allows you to show your game content unscaled.
+Configure a largura e altura no arquivo *game.project* para permitir que o conteúdo do seu jogo seja exibido sem escalonamento.
-### High DPI setting and retina screens
+### Configuração de High DPI e telas Retina
-If you also wish to support high resolution retina screens you can enable this in the *game.project* file in the Display section:
+Se você deseja suportar telas Retina de alta resolução, pode ativar isso na seção Display do arquivo *game.project*:
-
+
-This will create a high dpi back buffer on displays that support it. The game will render in double the resolution than what is set in the Width and Height settings, which will still be the logical resolution used in scripts and properties. This means that all measurements stay the same and any content that is rendered at 1x scale will look the same. But if you import high res images and scale them to 0.5x they will be high dpi on screen.
+Isso cria um back buffer de alta DPI em displays que tenham suporte a isso. O jogo será renderizado com o dobro da resolução configurada em Largura e Altura, mantendo a resolução lógica usada em scripts e propriedades. Isso significa que todas as medidas permanecem iguais e qualquer conteúdo renderizado em escala 1x parecerá igual. Mas se você importar imagens de alta resolução e escalá-las para 0,5x, elas serão exibidas em alta DPI.
-
-## Creating an adaptive GUI
+## Criando uma GUI adaptativa
The system for creating GUI components is built around a number of basic building blocks, or [nodes](/manuals/gui/#node-types), and while it may seem overly simple it can be used to create anything from buttons to complex menus and popups. The GUIs that you create can be configured to automatically adapt to screen size and orientation changes. You can for instance keep nodes anchored to the top, bottom or sides of the screen and nodes can either keep their size or stretch. The relationship between nodes as well as their size and appearance can also be configured to change when the screen size or orientation changes.
From 436ab43540b9311a3f4a698cf888ac234c5c3918 Mon Sep 17 00:00:00 2001
From: Icaro Alves <33491428+Roxicaro@users.noreply.github.com>
Date: Fri, 10 Oct 2025 14:33:55 -0300
Subject: [PATCH 3/6] Fully translated adapting-graphics-to-screen-size.md to
pt-br
---
.../adapting-graphics-to-screen-size.md | 22 +++++++++----------
1 file changed, 11 insertions(+), 11 deletions(-)
diff --git a/docs/pt/manuals/adapting-graphics-to-screen-size.md b/docs/pt/manuals/adapting-graphics-to-screen-size.md
index 38f6f249..241d03ac 100644
--- a/docs/pt/manuals/adapting-graphics-to-screen-size.md
+++ b/docs/pt/manuals/adapting-graphics-to-screen-size.md
@@ -101,25 +101,25 @@ Isso cria um back buffer de alta DPI em displays que tenham suporte a isso. O jo
## Criando uma GUI adaptativa
-The system for creating GUI components is built around a number of basic building blocks, or [nodes](/manuals/gui/#node-types), and while it may seem overly simple it can be used to create anything from buttons to complex menus and popups. The GUIs that you create can be configured to automatically adapt to screen size and orientation changes. You can for instance keep nodes anchored to the top, bottom or sides of the screen and nodes can either keep their size or stretch. The relationship between nodes as well as their size and appearance can also be configured to change when the screen size or orientation changes.
+O sistema de criação de componentes GUI é baseado em blocos básicos, ou [nodes](/manuals/gui/#node-types), e embora pareça simples, ele permite criar desde botões até menus complexos e popups. As GUIs podem ser configuradas para se adaptarem automaticamente a mudanças de tamanho de tela e orientação. Você pode manter *nodes* ancorados ao topo, embaixo ou lados da tela, e eles podem manter seu tamanho ou se esticarem. A relação entre *nodes*, assim como seu tamanho e aparência, também pode mudar seguinfo mudanças na resolução ou orientação da tela.
-### Node properties
+### Propriedades dos *Nodes*
-Each node in a gui has a pivot point, a horizontal and vertical anchor as well as an adjust mode.
+Cada *node* em uma GUI possui um ponto de pivô, âncoras horizontais e verticais, e um modo de ajuste.
-* The pivot point defines the center point of a node.
-* The anchor mode controls how the node’s vertical and horizontal position is altered when the scene boundaries, or the parent node’s boundaries are stretched to fit the physical screen size.
-* The adjust mode setting controls what happens to a node when the scene boundaries, or the parent node’s boundaries, are adjusted to fit the physical screen size.
+* O ponto de pivô define o centro do *node*.
+* O modo de âncora controla como a posição vertical e horizontal do *node* muda quando os limites da cena ou do *node* pai são ajustados para caber na tela física.
+* O modo de ajuste define o que acontece com o *node* quando os limites da cena ou do *node* pai são ajustados para caber na tela física.
-You can learn more about these properties [in the GUI manual](/manuals/gui/#node-properties).
+Mais detalhes sobre essas propriedades estão [no Manual de GUI](/manuals/gui/#node-properties).
### Layouts
-Defold supports GUIs that automatically adapt to screen orientation changes on mobile devices. By using this feature you can design a GUI that can adapt to the orientation and aspect ratio of a range of screen sizes. It is also possible to create layouts that match particular device models. You can learn more about this system in the [GUI Layouts manual](/manuals/gui-layouts/)
+O Defold suporta GUIs que se adaptam automaticamente a mudanças de orientação em dispositivos móveis. Com isso, você pode criar uma GUI que se ajuste à orientação e proporção de vários tamanhos de tela. Também é possível criar layouts específicos para determinados modelos de dispositivos. Mais informações estão no [manual de Layouts de GUI](/manuals/gui-layouts/)
-## Testing different screen sizes
+## Testando diferentes tamanhos de tela
-The Debug menu contains an option to simulate the resolution of either a certain device model resolution or a custom resolution. While the application is running you can select Debug->Simulate Resolution and pick one of the device models from the list. The running application window will resize and you'll be able to see how your game looks in a different resolution or with a different aspect ratio.
+O menu *Debug* contém uma opção para simular a resolução de um modelo de dispositivo específico ou de uma resolução personalizada. Com o aplicativo em execução, selecione Debug->Simulate Resolution e escolha um modelo da lista. A janela do aplicativo será redimensionada e você poderá ver como o jogo se comporta em diferentes resoluções ou proporções de tela.
-
+
From 0e2860cf3200a23839f805fe28498a9348601f87 Mon Sep 17 00:00:00 2001
From: Icaro Alves <33491428+Roxicaro@users.noreply.github.com>
Date: Fri, 10 Oct 2025 14:38:02 -0300
Subject: [PATCH 4/6] Fixed special markup
---
docs/pt/manuals/adapting-graphics-to-screen-size.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/pt/manuals/adapting-graphics-to-screen-size.md b/docs/pt/manuals/adapting-graphics-to-screen-size.md
index 241d03ac..5a6d6ed4 100644
--- a/docs/pt/manuals/adapting-graphics-to-screen-size.md
+++ b/docs/pt/manuals/adapting-graphics-to-screen-size.md
@@ -47,7 +47,7 @@ Agora que o tamanho da janela é mais razoável, precisamos ajustar os gráficos
msg.post("@render:", "use_fixed_projection", { zoom = 4 })
```
-::: Observação
+::: sidenote
O mesmo resultado pode ser obtido anexando um [Componente de câmera](manuals/camera/) a um objeto de jogo, marcando *Orthographic Projection* e ajustando *Orthographic Zoom* para 4.0:
From 1e1986b4a456443788398a9aaaf78423c1690129 Mon Sep 17 00:00:00 2001
From: Icaro Alves <33491428+Roxicaro@users.noreply.github.com>
Date: Fri, 10 Oct 2025 14:55:07 -0300
Subject: [PATCH 5/6] Create ads.md already in pt-br
---
docs/pt/manuals/ads.md | 62 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 62 insertions(+)
create mode 100644 docs/pt/manuals/ads.md
diff --git a/docs/pt/manuals/ads.md b/docs/pt/manuals/ads.md
new file mode 100644
index 00000000..54e84051
--- /dev/null
+++ b/docs/pt/manuals/ads.md
@@ -0,0 +1,62 @@
+---
+title: Mostrando anúncios no Defold
+brief: Mostrar vários tipos de anúncios é uma maneira comum de monetizar jogos para web e mobile. Este manual mostra várias maneiras de monetizar seu jogo usando anúncios.
+---
+
+# Anúncios
+
+Os anúncios tornaram-se uma forma muito comum de monetizar jogos para web e mobile e se transformaram em uma indústria de bilhões de dólares. Como desenvolvedor, você é pago com base no número de pessoas que assistem aos anúncios que você exibe em seu jogo. Geralmente é tão simples quanto: mais visualizações equivalem a mais dinheiro, mas outros fatores também têm um impacto no quanto você é pago:
+
+* A qualidade do anúncio - anúncios relevantes têm maior chance de obter interação e atenção dos seus jogadores.
+* O formato do anúncio - anúncios de banner geralmente pagam menos, enquanto anúncios em tela cheia assistidos do início ao fim pagam mais.
+* A rede de anúncios - o valor que você recebe varia de uma rede de anúncios para outra.
+
+::: sidenote
+CPM = Custo por mil. O valor que um anunciante paga por mil visualizações. O CPM varia entre as redes de anúncios e os formatos de anúncio.
+:::
+
+## Formatos
+
+Existem muitos tipos diferentes de formatos de anúncio que podem ser usados em jogos. Alguns dos mais comuns são anúncios de banner, intersticiais e com recompensa:
+
+### Anúncios de banner
+
+Anúncios de banner são baseados em texto, imagem ou vídeo e cobrem uma parte relativamente pequena da tela, geralmente no topo ou na parte inferior. Os anúncios de banner são muito fáceis de implementar e se encaixam muito bem com jogos casuais de tela única, onde é fácil reservar uma área da tela para anúncios. Os anúncios de banner maximizam a exposição, pois os usuários jogam seu jogo sem interrupção.
+
+### Anúncios intersticiais
+
+Anúncios intersticiais são experiências grandes em tela cheia com animações e, às vezes, também conteúdo interativo de *rich media*. Os anúncios intersticiais são normalmente exibidos entre as fases ou sessões de jogo, pois é uma pausa natural na experiência do jogo. Os anúncios intersticiais normalmente geram menos visualizações do que os anúncios de banner, mas o custo (CPM) é muito maior do que o dos anúncios de banner, resultando em uma receita publicitária geral significativa.
+
+### Anúncios com recompensa
+
+Anúncios com recompensa (também conhecidos como anúncios com incentivos) são opcionais e, portanto, menos intrusivos do que muitas outras formas de anúncios. Os anúncios com recompensa são geralmente experiências em tela cheia, como os anúncios intersticiais. O usuário pode escolher uma recompensa em troca de visualizar o anúncio - por exemplo, *loot*, vidas, tempo ou alguma outra moeda ou benefício no jogo. Os anúncios com recompensa geralmente têm o custo mais alto (CPM), mas o número de visualizações está diretamente relacionado às taxas de aceitação do usuário. Os anúncios com recompensa só terão um ótimo desempenho se as recompensas forem valiosas o suficiente e oferecidas no momento certo.
+
+
+## Redes de anúncios
+
+O [Portal de Assets da Defold](/tags/stars/ads/) contém vários assets que se integram com provedores de anúncios:
+
+* [AdMob](https://defold.com/assets/admob-defold/) - Mostra anúncios usando a rede Google AdMob.
+* [Enhance](https://defold.com/assets/enhance/) - Suporta uma série de redes de anúncios diferentes. Requer uma etapa adicional de pós-build.
+* [Facebook Instant Games](https://defold.com/assets/facebookinstantgames/) - Mostra anúncios no seu Facebook Instant Game.
+* [IronSource](https://defold.com/assets/ironsource/) - Mostra anúncios usando a rede de anúncios IronSource.
+* [Unity Ads](https://defold.com/assets/defvideoads/) - Mostra anúncios usando a rede Unity Ads.
+
+
+# Como integrar anúncios no seu jogo
+
+Quando você decidir sobre uma rede de anúncios para integrar ao seu jogo, você precisa seguir as instruções de instalação e uso para aquele *asset* específico. O que você normalmente faz é primeiro adicionar a extensão como uma [dependência de projeto](/manuals/libraries/#setting-up-library-dependencies). Depois de adicionar o asset ao seu projeto, você pode prosseguir com a integração e chamar as funções específicas do asset para carregar e exibir anúncios.
+
+
+# Combinando anúncios e compras dentro do aplicativo
+
+É bastante comum em jogos mobile oferecer uma [compra dentro do aplicativo](/manuals/iap) para se livrar dos anúncios permanentemente.
+
+
+## Saiba mais
+
+Existem muitos recursos online para aprender quando se trata de otimizar a receita de anúncios:
+
+* Google AdMob [Monetize jogos mobile com anúncios](https://admob.google.com/home/resources/monetize-mobile-game-with-ads/)
+* Game Analytics [Formatos de anúncio populares e como usá-los](https://gameanalytics.com/blog/popular-mobile-game-ad-formats.html)
+* deltaDNA [Veiculação de anúncios em jogos: 10 dicas de especialistas](https://deltadna.com/blog/ad-serving-in-games-10-tips/)
From 17cf39cedf68b41c3276bdeb53cd2e944042e16f Mon Sep 17 00:00:00 2001
From: Icaro Alves <33491428+Roxicaro@users.noreply.github.com>
Date: Fri, 10 Oct 2025 15:03:39 -0300
Subject: [PATCH 6/6] Create optimization.md in PT-BR
---
docs/pt/manuals/optimization.md | 12 ++++++++++++
1 file changed, 12 insertions(+)
create mode 100644 docs/pt/manuals/optimization.md
diff --git a/docs/pt/manuals/optimization.md b/docs/pt/manuals/optimization.md
new file mode 100644
index 00000000..36353be6
--- /dev/null
+++ b/docs/pt/manuals/optimization.md
@@ -0,0 +1,12 @@
+---
+title: Otimizando um jogo Defold
+brief: Este manual descreve como otimizar um jogo Defold quanto ao seu tamanho e desempenho.
+---
+
+# Otimizando um jogo Defold
+É importante entender as restrições técnicas das suas plataformas de destino e projetar, implementar e otimizar seu jogo para atender a esses requisitos. Para a maioria das plataformas, há vários aspectos a considerar:
+
+* [Tamanho do jogo](/manuals/optimization-size) - Qual é o tamanho máximo aceitável do pacote do jogo e como você pode tornar o jogo o menor possível sem comprometer a qualidade?
+* [Velocidade de execução](/manuals/optimization-speed) - Qual é o desempenho da plataforma de destino e como você pode fazer o jogo rodar com uma taxa de quadros (FPS) estável com uso mínimo de CPU e/ou GPU?
+* [Uso de memória](/manuals/optimization-memory) - Quais são as restrições de memória da plataforma de destino e como você pode reduzir o uso de memória?
+* [Uso de bateria](/manuals/optimization-battery) - Esta é espcialmente uma área de foco se você está direcionando o lançamento para dispositivos móveis/portáteis.