
# game/tutorial_atl.rpy:205
translate portuguese tutorial_positions_a09a3fd1:

    # e "In this tutorial, I'll teach you how Ren'Py positions things on the screen. But before that, let's learn a little bit about how Python handles numbers."
    e "Neste tutorial, vou ensinar como o Ren'Py posiciona as coisas na tela. Mas antes disso, vamos aprender um pouco sobre como o Python lida com números."

# game/tutorial_atl.rpy:207
translate portuguese tutorial_positions_ba39aabc:

    # e "There are two main kinds of numbers in Python: integers and floating point numbers. An integer consists entirely of digits, while a floating point number has a decimal point."
    e "Há dois tipos principais de números em Python: inteiros e números de ponto flutuante. Um inteiro é composto apenas de dígitos, enquanto um número de ponto flutuante tem um ponto decimal."

# game/tutorial_atl.rpy:209
translate portuguese tutorial_positions_a60b775d:

    # e "For example, 100 is an integer, while 0.5 is a floating point number, or float for short. In this system, there are two zeros: 0 is an integer, and 0.0 is a float."
    e "Por exemplo, 100 é um número inteiro, enquanto 0.5 é um número de ponto flutuante, ou float, para abreviar. Nesse sistema, existem dois zeros: 0 é um inteiro, e 0.0 é um float."

# game/tutorial_atl.rpy:211
translate portuguese tutorial_positions_7f1a560c:

    # e "Ren'Py uses integers to represent absolute coordinates, and floats to represent fractions of an area with known size."
    e "O Ren'Py usa inteiros para representar coordenadas absolutas, e floats para representar frações de uma área com tamanho conhecido."

# game/tutorial_atl.rpy:213
translate portuguese tutorial_positions_8e7d3e52:

    # e "When we're positioning something, the area is usually the entire screen."
    e "Quando estamos posicionando algo, essa área geralmente é a tela inteira."

# game/tutorial_atl.rpy:215
translate portuguese tutorial_positions_fdcf9d8b:

    # e "Let me get out of the way, and I'll show you where some positions are."
    e "Deixe-me sair do caminho e vou mostrar onde ficam algumas posições."

# game/tutorial_atl.rpy:229
translate portuguese tutorial_positions_76d7a5bf:

    # e "The origin is the upper-left corner of the screen. That's where the x position (xpos) and the y position (ypos) are both zero."
    e "A origem é o canto superior esquerdo da tela. É onde tanto a posição x ('xpos') quanto a posição y ('ypos') são zero."

# game/tutorial_atl.rpy:235
translate portuguese tutorial_positions_be14c7c3:

    # e "When we increase xpos, we move to the right. So here's an xpos of .5, meaning half the width across the screen."
    e "Quando aumentamos 'xpos', nos movemos para a direita. Então aqui temos um xpos de .5, o que significa metade da largura da tela."

# game/tutorial_atl.rpy:240
translate portuguese tutorial_positions_9b91be6c:

    # e "Increasing xpos to 1.0 moves us to the right-hand border of the screen."
    e "Ao aumentar 'xpos' para 1.0, movemo-nos para a borda direita da tela."

# game/tutorial_atl.rpy:246
translate portuguese tutorial_positions_2b293304:

    # e "We can also use an absolute xpos, which is given in an absolute number of pixels from the left side of the screen. For example, since this window is 1280 pixels across, using an xpos of 640 will return the target to the center of the top row."
    e "Também podemos usar um 'xpos' absoluto, dado como um número absoluto de pixels a partir do lado esquerdo da tela. Por exemplo, como esta janela tem 1280 pixels de largura, usar um xpos de 640 colocará o alvo de volta no centro da linha superior."

# game/tutorial_atl.rpy:248
translate portuguese tutorial_positions_c4d18c0a:

    # e "The y-axis position, or ypos works the same way. Right now, we have a ypos of 0.0."
    e "A posição no eixo y, ou 'ypos', funciona da mesma forma. Neste momento, temos um 'ypos' de 0.0."

# game/tutorial_atl.rpy:254
translate portuguese tutorial_positions_16933a61:

    # e "Here's a ypos of 0.5."
    e "Aqui está um 'ypos' de 0.5."

# game/tutorial_atl.rpy:259
translate portuguese tutorial_positions_6eb36777:

    # e "A ypos of 1.0 specifies a position at the bottom of the screen. If you look carefully, you can see the position indicator spinning below the text window."
    e "Um 'ypos' de 1.0 especifica uma posição na parte inferior da tela. Se você olhar com atenção, pode ver o indicador de posição girando abaixo da janela de texto."

# game/tutorial_atl.rpy:261
translate portuguese tutorial_positions_a423050f:

    # e "Like xpos, ypos can also be an integer. In this case, ypos would give the total number of pixels from the top of the screen."
    e "Como 'xpos', 'ypos' também pode ser um número inteiro. Nesse caso, ypos daria o número total de pixels a partir do topo da tela."

# game/tutorial_atl.rpy:267
translate portuguese tutorial_positions_bc7a809a:

    # e "Can you guess where this position is, relative to the screen?" nointeract
    e "Você consegue adivinhar onde está essa posição, em relação à tela?" nointeract

# game/tutorial_atl.rpy:273
translate portuguese tutorial_positions_6f926e18:

    # e "Sorry, that's wrong. The xpos is .75, and the ypos is .25."
    e "Desculpe, isso está errado. O 'xpos' é .75, e o 'ypos' é .25."

# game/tutorial_atl.rpy:275
translate portuguese tutorial_positions_5d5feb98:

    # e "In other words, it's 75%% of the way from the left side, and 25%% of the way from the top."
    e "Em outras palavras, está a 75%% da distância a partir do lado esquerdo, e a 25%% da distância a partir do topo."

# game/tutorial_atl.rpy:279
translate portuguese tutorial_positions_77b45218:

    # e "Good job! You got that position right."
    e "Bom trabalho! Você acertou a posição."

# game/tutorial_atl.rpy:283
translate portuguese tutorial_positions_6f926e18_1:

    # e "Sorry, that's wrong. The xpos is .75, and the ypos is .25."
    e "Desculpe, está errado. O xpos é .75, e o ypos é .25."

# game/tutorial_atl.rpy:285
translate portuguese tutorial_positions_5d5feb98_1:

    # e "In other words, it's 75%% of the way from the left side, and 25%% of the way from the top."
    e "Em outras palavras, está a 75%% da distância a partir do lado esquerdo, e a 25%% da distância a partir do topo."

# game/tutorial_atl.rpy:299
translate portuguese tutorial_positions_e4380a83:

    # e "The second position we care about is the anchor. The anchor is a spot on the thing being positioned."
    e "A segunda posição que nos importa é a 'anchor' (âncora). A âncora é um ponto na imagem que está sendo posicionada."

# game/tutorial_atl.rpy:301
translate portuguese tutorial_positions_d1db1246:

    # e "For example, here we have an xanchor of 0.0 and a yanchor of 0.0. It's in the upper-left corner of the logo image."
    e "Por exemplo, aqui temos um 'xanchor' de 0.0 e um 'yanchor' de 0.0. Ele está no canto superior esquerdo da imagem do logotipo."

# game/tutorial_atl.rpy:306
translate portuguese tutorial_positions_6056873f:

    # e "When we increase the xanchor to 1.0, the anchor moves to the right corner of the image."
    e "Quando aumentamos o 'xanchor' para 1.0, a âncora se move para o canto direito da imagem."

# game/tutorial_atl.rpy:311
translate portuguese tutorial_positions_7cdb8dcc:

    # e "Similarly, when both xanchor and yanchor are 1.0, the anchor is the bottom-right corner."
    e "Da mesma forma, quando tanto 'xanchor' quanto 'yanchor' são 1.0, a âncora fica no canto inferior direito."

# game/tutorial_atl.rpy:318
translate portuguese tutorial_positions_03a07da8:

    # e "To place an image on the screen, we need both the position and the anchor."
    e "Para colocar uma imagem na tela, precisamos tanto da posição quanto da âncora."

# game/tutorial_atl.rpy:326
translate portuguese tutorial_positions_8945054f:

    # e "We then line them up, so that both the position and anchor are at the same point on the screen."
    e "Então alinhamos as duas, de forma que tanto a posição quanto a âncora fiquem no mesmo ponto da tela."

# game/tutorial_atl.rpy:336
translate portuguese tutorial_positions_2b184a93:

    # e "When we place both in the upper-left corner, the image moves to the upper-left corner of the screen."
    e "Quando colocamos ambas no canto superior esquerdo, a imagem se move para o canto superior esquerdo da tela."

# game/tutorial_atl.rpy:345
translate portuguese tutorial_positions_5aac4f3f:

    # e "With the right combination of position and anchor, any place on the screen can be specified, without even knowing the size of the image."
    e "Com a combinação certa de posição e âncora, qualquer lugar da tela pode ser especificado sem nem mesmo saber o tamanho da imagem."

# game/tutorial_atl.rpy:357
translate portuguese tutorial_positions_3b59b797:

    # e "It's often useful to set xpos and xanchor to the same value. We call that xalign, and it gives a fractional position on the screen."
    e "Muitas vezes é útil definir 'xpos' e 'xanchor' com o mesmo valor. Chamamos isso de 'xalign', e ele fornece uma posição fracionária na tela."

# game/tutorial_atl.rpy:362
translate portuguese tutorial_positions_b8ebf9fe:

    # e "For example, when we set xalign to 0.0, things are aligned to the left side of the screen."
    e "Por exemplo, quando definimos 'xalign' como 0.0, as coisas ficam alinhadas ao lado esquerdo da tela."

# game/tutorial_atl.rpy:367
translate portuguese tutorial_positions_8ce35d52:

    # e "When we set it to 1.0, then we're aligned to the right side of the screen."
    e "Quando definimos isso como 1.0, então estamos alinhados ao lado direito da tela."

# game/tutorial_atl.rpy:372
translate portuguese tutorial_positions_6745825f:

    # e "And when we set it to 0.5, we're back to the center of the screen."
    e "E quando definimos isso como 0.5, voltamos ao centro da tela."

# game/tutorial_atl.rpy:374
translate portuguese tutorial_positions_64428a07:

    # e "Setting yalign is similar, except along the y-axis."
    e "Definir 'yalign' é parecido, exceto pelo fato de acontecer ao longo do eixo y."

# game/tutorial_atl.rpy:376
translate portuguese tutorial_positions_cfb77d42:

    # e "Remember that xalign is just setting xpos and xanchor to the same value, and yalign is just setting ypos and yanchor to the same value."
    e "Lembre-se de que 'xalign' apenas define 'xpos' e 'xanchor' com o mesmo valor, e 'yalign' apenas define 'ypos' e 'yanchor' com o mesmo valor."

# game/tutorial_atl.rpy:381
translate portuguese tutorial_positions_cfc1723e:

    # e "The xcenter and ycenter properties position the center of the image. Here, with xcenter set to .75, the center of the image is three-quarters of the way to the right side of the screen."
    e "As propriedades 'xcenter' e 'ycenter' posicionam o centro da imagem. Aqui, com xcenter definido como .75, o centro da imagem está a três quartos do caminho até o lado direito da tela."

# game/tutorial_atl.rpy:386
translate portuguese tutorial_positions_7728dbf9:

    # e "The difference between xalign and xcenter is more obvious when xcenter is 1.0, and the image is halfway off the right side of the screen."
    e "A diferença entre 'xalign' e 'xcenter' fica mais óbvia quando 'xcenter' é 1.0, e a imagem fica metade para fora do lado direito da tela."

# game/tutorial_atl.rpy:394
translate portuguese tutorial_positions_1b1cedc6:

    # e "There are the xoffset and yoffset properties, which are applied after everything else, and offset things to the right or bottom, respectively."
    e "Existem as propriedades xoffset e yoffset, que são aplicadas depois de todo o resto, e deslocam as coisas para a direita ou para baixo, respectivamente."

# game/tutorial_atl.rpy:399
translate portuguese tutorial_positions_e6da2798:

    # e "Of course, you can use negative numbers to offset things to the left and top."
    e "Claro, você pode usar números negativos para deslocar as coisas para a esquerda e para cima."

# game/tutorial_atl.rpy:404
translate portuguese tutorial_positions_e0fe2d81:

    # e "Lastly, I'll mention that there are combined properties like align, pos, anchor, and center. Align takes a pair of numbers, and sets xalign to the first and yalign to the second. The others are similar."
    e "Por fim, vou mencionar que existem propriedades combinadas como 'align', 'pos', 'anchor' e 'center'. 'Align' recebe um par de números e define 'xalign' para o primeiro e 'yalign' para o segundo. As outras são parecidas."

# game/tutorial_atl.rpy:411
translate portuguese tutorial_positions_0f4ca2b6:

    # e "Once you understand positions, you can use transformations to move things around the Ren'Py screen."
    e "Depois que você entender posições, poderá usar transformações para mover coisas pela tela do Ren'Py."

# game/tutorial_atl.rpy:418
translate portuguese tutorial_atl_d5d6b62a:

    # e "Ren'Py uses transforms to animate, manipulate, and place images. We've already seen the very simplest of transforms in use:"
    e "O Ren'Py usa transformações para animar, manipular e posicionar imagens. Já vimos a mais simples das transformações em uso:"

# game/tutorial_atl.rpy:425
translate portuguese tutorial_atl_7e853c9d:

    # e "Transforms can be very simple affairs that place the image somewhere on the screen, like the right transform."
    e "Transformações podem ser coisas bem simples que posicionam a imagem em algum lugar da tela, como a transformação 'right'."

# game/tutorial_atl.rpy:429
translate portuguese tutorial_atl_87a6ecbd:

    # e "But transforms can also be far more complicated affairs, that introduce animation and effects into the mix. To demonstrate, let's have a Gratuitous Rock Concert!"
    e "Mas transformações também podem ser coisas bem mais complicadas, que adicionam animação e efeitos à mistura. Para demonstrar, vamos ter um Concerto de Rock Gratuito!"

# game/tutorial_atl.rpy:437
translate portuguese tutorial_atl_65badef3:

    # e "But first, let's have... a Gratuitous Rock Concert!"
    e "Mas primeiro, vamos ter... um Concerto de Rock Gratuito!"

# game/tutorial_atl.rpy:445
translate portuguese tutorial_atl_e0d3c5ec:

    # e "That was a lot of work, but it was built out of small parts."
    e "Isso deu bastante trabalho, mas foi construído a partir de pequenas partes."

# game/tutorial_atl.rpy:447
translate portuguese tutorial_atl_f2407514:

    # e "Most transforms in Ren'Py are built using the Animation and Transform Language, or ATL for short."
    e "A maioria das transformações no Ren'Py é criada usando a Animation and Transform Language, ou ATL, para abreviar."

# game/tutorial_atl.rpy:449
translate portuguese tutorial_atl_1f22f875:

    # e "There are currently three places where ATL can be used in Ren'Py."
    e "Atualmente existem três lugares onde ATL pode ser usada no Ren'Py."

# game/tutorial_atl.rpy:454
translate portuguese tutorial_atl_fd036bdf:

    # e "The first place ATL can be used is as part of an image statement. Instead of a displayable, an image may be defined as a block of ATL code."
    e "O primeiro lugar onde ATL pode ser usada é como parte de uma instrução 'image'. Em vez de um exibível, uma imagem pode ser definida como um bloco de código ATL."

# game/tutorial_atl.rpy:456
translate portuguese tutorial_atl_7cad2ab9:

    # e "When used in this way, we have to be sure that ATL includes one or more displayables to actually show."
    e "Quando usada dessa forma, temos que garantir que ATL inclua um ou mais exibíveis para realmente mostrar."

# game/tutorial_atl.rpy:461
translate portuguese tutorial_atl_c78b2a1e:

    # e "The second way is through the use of the transform statement. This assigns the ATL block to a python variable, allowing it to be used in at clauses and inside other transforms."
    e "A segunda forma é por meio da instrução 'transform'. Isso atribui o bloco ATL a uma variável Python, permitindo que ele seja usado em cláusulas 'at' e dentro de outras transformações."

# game/tutorial_atl.rpy:473
translate portuguese tutorial_atl_da7a7759:

    # e "Finally, an ATL block can be used as part of a show statement, instead of the at clause."
    e "Por fim, um bloco ATL pode ser usado como parte de uma instrução 'show', em vez da cláusula 'at'."

# game/tutorial_atl.rpy:480
translate portuguese tutorial_atl_1dd345c6:

    # e "When ATL is used as part of a show statement, values of properties exist even when the transform is changed. So even though your click stopped the motion, the image remains in the same place."
    e "Quando ATL é usada como parte de uma instrução 'show', os valores das propriedades continuam existindo mesmo quando a transformação muda. Então, mesmo que seu clique pare o movimento, a imagem permanece no mesmo lugar."

# game/tutorial_atl.rpy:488
translate portuguese tutorial_atl_98047789:

    # e "The key to ATL is what we call composability. ATL is made up of relatively simple commands, which can be combined together to create complicated transforms."
    e "A chave para ATL é o que chamamos de composabilidade. ATL é composta por comandos relativamente simples, que podem ser combinados para criar transformações complicadas."

# game/tutorial_atl.rpy:490
translate portuguese tutorial_atl_ed82983f:

    # e "Before I explain how ATL works, let me explain what animation and transformation are."
    e "Antes de explicar como ATL funciona, deixe-me explicar o que são animações e transformações."

# game/tutorial_atl.rpy:495
translate portuguese tutorial_atl_2807adff:

    # e "Animation is when the displayable being shown changes. For example, right now I am changing my expression."
    e "Animação é quando o exibível mostrado muda. Por exemplo, neste momento estou mudando minha expressão."

# game/tutorial_atl.rpy:522
translate portuguese tutorial_atl_3eec202b:

    # e "Transformation involves moving or distorting an image. This includes placing it on the screen, zooming it in and out, rotating it, and changing its opacity."
    e "Transformação envolve mover ou distorcer uma imagem. Isso inclui posicioná-la na tela, ampliar e reduzir, girá-la e mudar sua opacidade."

# game/tutorial_atl.rpy:530
translate portuguese tutorial_atl_fbc9bf83:

    # e "To introduce ATL, let's start by looking at at a simple animation. Here's one that consists of five lines of ATL code, contained within an image statement."
    e "Para apresentar ATL, vamos começar observando uma animação simples. Aqui está uma que consiste em cinco linhas de código ATL, contidas dentro de uma instrução image."

# game/tutorial_atl.rpy:532
translate portuguese tutorial_atl_bf92d973:

    # e "To change a displayable, simply mention it on a line of ATL. Here, we're switching back and forth between two images."
    e "Para mudar um exibível, basta mencioná-lo em uma linha de ATL. Aqui, estamos alternando entre duas imagens."

# game/tutorial_atl.rpy:534
translate portuguese tutorial_atl_51a41db4:

    # e "Since we're defining an image, the first line of ATL must give a displayable. Otherwise, there would be nothing to show."
    e "Como estamos definindo uma imagem, a primeira linha de ATL deve fornecer um exibível. Caso contrário, não haveria nada para mostrar."

# game/tutorial_atl.rpy:536
translate portuguese tutorial_atl_3d065074:

    # e "The second and fourth lines are pause statements, which cause ATL to wait half a second each before continuing. That's how we give the delay between images."
    e "A segunda e a quarta linhas são instruções 'pause', que fazem ATL esperar meio segundo em cada uma antes de continuar. É assim que damos o atraso entre as imagens."

# game/tutorial_atl.rpy:538
translate portuguese tutorial_atl_60f2a5e8:

    # e "The final line is a repeat statement. This causes the current block of ATL to be restarted. You can only have one repeat statement per block."
    e "A linha final é uma instrução 'repeat'. Isso faz o bloco atual de ATL reiniciar. Você só pode ter uma instrução 'repeat' por bloco."

# game/tutorial_atl.rpy:543
translate portuguese tutorial_atl_146cf4c4:

    # e "If we were to write repeat 2 instead, the animation would loop twice, then stop."
    e "Se escrevêssemos 'repeat 2' no lugar, a animação repetiria duas vezes e depois pararia."

# game/tutorial_atl.rpy:548
translate portuguese tutorial_atl_d90b1838:

    # e "Omitting the repeat statement means that the animation stops once we reach the end of the block of ATL code."
    e "Omitir a instrução 'repeat' significa que a animação para quando chegamos ao fim do bloco de código ATL."

# game/tutorial_atl.rpy:554
translate portuguese tutorial_atl_e5872360:

    # e "By default, displayables are replaced instantaneously. We can also use a with clause to give a transition between displayables."
    e "Por padrão, exibíveis são substituídos instantaneamente. Também podemos usar uma cláusula 'with' para fornecer uma transição entre exibíveis."

# game/tutorial_atl.rpy:561
translate portuguese tutorial_atl_2e9d63ea:

    # e "With animation done, we'll see how we can use ATL to transform images, starting with positioning an image on the screen."
    e "Com a animação concluída, vamos ver como podemos usar ATL para transformar imagens, começando pelo posicionamento de uma imagem na tela."

# game/tutorial_atl.rpy:570
translate portuguese tutorial_atl_ddc55039:

    # e "The simplest thing we can to is to statically position an image. This is done by giving the names of the position properties, followed by the property values."
    e "A coisa mais simples que podemos fazer é posicionar uma imagem estaticamente. Isso é feito fornecendo os nomes das propriedades de posição, seguidos pelos valores das propriedades."

# game/tutorial_atl.rpy:575
translate portuguese tutorial_atl_43516492:

    # e "With a few more statements, we can move things around on the screen."
    e "Com mais algumas instruções, podemos mover as coisas pela tela."

# game/tutorial_atl.rpy:577
translate portuguese tutorial_atl_fb979287:

    # e "This example starts the image off at the top-right of the screen, and waits a second. It then moves it to the left side, waits another second, and repeats."
    e "Este exemplo começa com a imagem no canto superior direito da tela e espera um segundo. Depois, move-a para o lado esquerdo, espera mais um segundo e repete."

# game/tutorial_atl.rpy:579
translate portuguese tutorial_atl_7650ec09:

    # e "The pause and repeat statements are the same statements we used in our animations. They work throughout ATL code."
    e "As instruções 'pause' e 'repeat' são as mesmas instruções que usamos em nossas animações. Elas funcionam em todo o código ATL."

# game/tutorial_atl.rpy:584
translate portuguese tutorial_atl_d3416d4f:

    # e "Having the image jump around on the screen isn't all that useful. That's why ATL has the interpolation statement."
    e "Fazer a imagem saltar pela tela não é tão útil. É por isso que ATL tem a instrução de interpolação."

# game/tutorial_atl.rpy:586
translate portuguese tutorial_atl_4e7512ec:

    # e "The interpolation statement allows you to smoothly vary the value of a transform property, from an old to a new value."
    e "A instrução de interpolação permite variar suavemente o valor de uma propriedade de transformação, de um valor antigo para um novo valor."

# game/tutorial_atl.rpy:588
translate portuguese tutorial_atl_685eeeaa:

    # e "Here, we have an interpolation statement on the second ATL line. It starts off with the name of a time function, in this case linear."
    e "Aqui, temos uma instrução de interpolação na segunda linha de ATL. Ela começa com o nome de uma função de tempo, neste caso 'linear'."

# game/tutorial_atl.rpy:590
translate portuguese tutorial_atl_c5cb49de:

    # e "That's followed by an amount of time, in this case three seconds. It ends with a list of properties, each followed by its new value."
    e "Depois disso vem uma quantidade de tempo, neste caso três segundos. Ela termina com uma lista de propriedades, cada uma seguida por seu novo valor."

# game/tutorial_atl.rpy:592
translate portuguese tutorial_atl_04b8bc1d:

    # e "The value of each property is interpolated from its value when the statement starts to the value at the end of the statement. This is done once per frame, allowing smooth animation."
    e "O valor de cada propriedade é interpolado desde o valor que ela tem quando a instrução começa até o valor no fim da instrução. Isso é feito uma vez por quadro, permitindo uma animação suave."

# game/tutorial_atl.rpy:603
translate portuguese tutorial_atl_2958f397:

    # e "ATL supports more complicated move types, like circle and spline motion. But I won't be showing those here."
    e "ATL oferece suporte a tipos de movimento mais complicados, como movimento em círculo e spline. Mas não vou mostrá-los aqui."

# game/tutorial_atl.rpy:607
translate portuguese tutorial_atl_d08fe8d9:

    # e "Apart from displayables, pause, interpolation, and repeat, there are a few other statements we can use as part of ATL."
    e "Além de exibíveis, pausas, interpolações e repetições, há algumas outras instruções que podemos usar como parte de ATL."

# game/tutorial_atl.rpy:619
translate portuguese tutorial_atl_84b22ac0:

    # e "ATL transforms created using the statement become ATL statements themselves. Since the default positions are also transforms, this means that we can use left, right, and center inside of an ATL block."
    e "Transformações ATL criadas usando a instrução tornam-se elas próprias instruções ATL. Como as posições padrão também são transformações, isso significa que podemos usar left, right e center dentro de um bloco ATL."

# game/tutorial_atl.rpy:635
translate portuguese tutorial_atl_331126c1:

    # e "Here, we have two new statements. The block statement allows you to include a block of ATL code. Since the repeat statement applies to blocks, this lets you repeat only part of an ATL transform."
    e "Aqui temos duas novas instruções. A instrução 'block' permite incluir um bloco de código ATL. Como a instrução 'repeat' se aplica a blocos, isso permite repetir apenas parte de uma transformação ATL."

# game/tutorial_atl.rpy:637
translate portuguese tutorial_atl_24f67b67:

    # e "We also have the time statement, which runs after the given number of seconds have elapsed from the start of the block. It will run even if another statement is running, stopping the other statement."
    e "Também temos a instrução 'time', que é executada depois que o número dado de segundos tiver passado desde o início do bloco. Ela será executada mesmo se outra instrução estiver rodando, interrompendo a outra instrução."

# game/tutorial_atl.rpy:639
translate portuguese tutorial_atl_b7709507:

    # e "So this example bounces the image back and forth for eleven and a half seconds, and then moves it to the right side of the screen."
    e "Então, este exemplo faz a imagem quicar de um lado para o outro por onze segundos e meio, e depois a move para o lado direito da tela."

# game/tutorial_atl.rpy:653
translate portuguese tutorial_atl_f903bc3b:

    # e "The parallel statement lets us run two blocks of ATL code at the same time."
    e "A instrução 'parallel' nos permite executar dois blocos de código ATL ao mesmo tempo."

# game/tutorial_atl.rpy:655
translate portuguese tutorial_atl_5d0f8f9d:

    # e "Here, the top block move the image in the horizontal direction, and the bottom block moves it in the vertical direction. Since they're moving at different speeds, it looks like the image is bouncing on the screen."
    e "Aqui, o bloco superior move a imagem na direção horizontal, e o bloco inferior a move na direção vertical. Como estão se movendo em velocidades diferentes, parece que a imagem está quicando na tela."

# game/tutorial_atl.rpy:669
translate portuguese tutorial_atl_28a7d27e:

    # e "Finally, the choice statement makes Ren'Py randomly pick a block of ATL code. This allows you to add some variation as to what Ren'Py shows."
    e "Por fim, a instrução 'choice' faz o Ren'Py escolher aleatoriamente um bloco de código ATL. Isso permite adicionar alguma variação ao que o Ren'Py mostra."

# game/tutorial_atl.rpy:675
translate portuguese tutorial_atl_2265254b:

    # e "This tutorial game has only scratched the surface of what you can do with ATL. For example, we haven't even covered the on and event statements. For more information, you might want to check out {a=https://renpy.org/doc/html/atl.html}the ATL chapter in the reference manual{/a}."
    e "Este jogo tutorial apenas arranhou a superfície do que você pode fazer com ATL. Por exemplo, nem sequer cobrimos as instruções on e event. Para mais informações, talvez você queira consultar {a=https://renpy.org/doc/html/atl.html}o capítulo de ATL no manual de referência{/a}."

# game/tutorial_atl.rpy:684
translate portuguese transform_properties_391169cf:

    # e "Ren'Py has quite a few transform properties that can be used with ATL, the Transform displayable, and the add Screen Language statement."
    e "O Ren'Py tem várias propriedades de transformação que podem ser usadas com ATL, com o exibível Transform e com a instrução add da Screen Language."

# game/tutorial_atl.rpy:685
translate portuguese transform_properties_fc895a1f:

    # e "Here, we'll show them off so you can see them in action and get used to what each does."
    e "Aqui, vamos mostrá-las para que você possa vê-las em ação e se acostumar com o que cada uma faz."

# game/tutorial_atl.rpy:701
translate portuguese transform_properties_88daf990:

    # e "First off, all of the position properties are also transform properties. These include the pos, anchor, align, center, and offset properties."
    e "Antes de tudo, todas as propriedades de posição também são propriedades de transformação. Isso inclui as propriedades 'pos', 'anchor', 'align', 'center' e 'offset'."

# game/tutorial_atl.rpy:719
translate portuguese transform_properties_d7a487f1:

    # e "The position properties can also be used to pan over a displayable larger than the screen, by giving xpos and ypos negative values."
    e "As propriedades de posição também podem ser usadas para deslocar uma imagem maior que a tela, dando valores negativos a 'xpos' e 'ypos'."

# game/tutorial_atl.rpy:729
translate portuguese transform_properties_89e0d7c2:

    # "The subpixel property controls how things are lined up with the screen. When False, images can be pixel-perfect, but there can be pixel jumping."
    "A propriedade 'subpixel' controla como as coisas são alinhadas com a tela. Quando é 'False', as imagens podem ficar perfeitas em pixels, mas pode haver saltos de pixel."

# game/tutorial_atl.rpy:736
translate portuguese transform_properties_4194527e:

    # "When it's set to True, movement is smoother at the cost of blurring images a little."
    "Quando é definida como 'True', o movimento fica mais suave, ao custo de deixar as imagens um pouco desfocadas."

# game/tutorial_atl.rpy:755
translate portuguese transform_properties_35934e77:

    # e "Transforms also support polar coordinates. The around property sets the center of the coordinate system to coordinates given in pixels."
    e "Transformações também oferecem suporte a coordenadas polares. A propriedade 'around' define o centro do sistema de coordenadas em coordenadas dadas em pixels."

# game/tutorial_atl.rpy:763
translate portuguese transform_properties_605ebd0c:

    # e "The angle property gives the angle in degrees. Angles run clockwise, with the zero angle at the top of the screen."
    e "A propriedade 'angle' fornece o ângulo em graus. Os ângulos seguem no sentido horário, com o ângulo zero no topo da tela."

# game/tutorial_atl.rpy:772
translate portuguese transform_properties_6d4555ed:

    # e "The radius property gives the distance in pixels from the anchor of the displayable to the center of the coordinate system."
    e "A propriedade 'radius' fornece a distância em pixels da âncora do exibível até o centro do sistema de coordenadas."

# game/tutorial_atl.rpy:786
translate portuguese transform_properties_7af037a5:

    # e "There are several ways to resize a displayable. The zoom property lets us scale a displayable by a factor, making it bigger and smaller."
    e "Há várias formas de redimensionar um exibível. A propriedade 'zoom' nos permite escalá-lo, deixando-o maior ou menor."

# game/tutorial_atl.rpy:799
translate portuguese transform_properties_b6527546:

    # e "The xzoom and yzoom properties allow the displayable to be scaled in the X and Y directions independently."
    e "As propriedades 'xzoom' e 'yzoom' permitem que o exibível seja escalado nas direções X e Y de forma independente."

# game/tutorial_atl.rpy:809
translate portuguese transform_properties_b98b780b:

    # e "By making xzoom or yzoom a negative number, we can flip the image horizontally or vertically."
    e "Ao tornar 'xzoom' ou 'yzoom' um número negativo, podemos inverter a imagem horizontal ou verticalmente."

# game/tutorial_atl.rpy:819
translate portuguese transform_properties_74d542ff:

    # e "Instead of zooming by a scale factor, the size transform property can be used to scale a displayable to a size in pixels."
    e "Em vez de aplicar zoom por fator de escala, a propriedade de transformação 'size' pode ser usada para escalar um exibível para um tamanho em pixels."

# game/tutorial_atl.rpy:834
translate portuguese transform_properties_438ed776:

    # e "The alpha property is used to change the opacity of a displayable. This can make it appear and disappear."
    e "A propriedade 'alpha' é usada para mudar a opacidade de um exibível. Isso pode fazer com que ele apareça e desapareça."

# game/tutorial_atl.rpy:847
translate portuguese transform_properties_aee19f86:

    # e "The rotate property rotates a displayable."
    e "A propriedade 'rotate' gira um exibível."

# game/tutorial_atl.rpy:858
translate portuguese transform_properties_57b3235a:

    # e "By default, when a displayable is rotated, Ren'Py will include extra space on all four sides, so the size doesn't change as it rotates. Here, you can see the extra space on the left and top, and it's also there on the right and bottom."
    e "Por padrão, quando um exibível é girado, o Ren'Py inclui espaço extra nos quatro lados, para que o tamanho não mude enquanto ele gira. Aqui, você pode ver o espaço extra à esquerda e em cima, e ele também está à direita e embaixo."

# game/tutorial_atl.rpy:870
translate portuguese transform_properties_66d29ee8:

    # e "By setting rotate_pad to False, we can get rid of the space, at the cost of the size of the displayable changing as it rotates."
    e "Ao definir 'rotate_pad' como False, podemos nos livrar desse espaço, ao custo de o tamanho do exibível mudar enquanto ele gira."

# game/tutorial_atl.rpy:881
translate portuguese transform_properties_7f32e8ad:

    # e "The tile transform properties, xtile and ytile, repeat the displayable multiple times."
    e "As propriedades de transformação 'tile', 'xtile' e 'ytile' repetem o exibível várias vezes."

# game/tutorial_atl.rpy:891
translate portuguese transform_properties_207b7fc8:

    # e "The crop property crops a rectangle out of a displayable, showing only part of it."
    e "A propriedade 'crop' recorta um retângulo de um exibível, mostrando apenas parte dele."

# game/tutorial_atl.rpy:905
translate portuguese transform_properties_e7e22d28:

    # e "When used together, crop and size can be used to focus in on specific parts of an image."
    e "Quando usados juntos, 'crop' e 'size' podem ser usados para focar em partes específicas de uma imagem."

# game/tutorial_atl.rpy:917
translate portuguese transform_properties_f34abd82:

    # e "The xpan and ypan properties can be used to pan over a displayable, given an angle in degrees, with 0 being the center."
    e "As propriedades 'xpan' e 'ypan' podem ser usadas para fazer panorâmica sobre um exibível, dado um ângulo em graus, sendo 0 o centro."

# game/tutorial_atl.rpy:924
translate portuguese transform_properties_bfa3b139:

    # e "Those are all the transform properties we have to work with. By putting them together in the right order, you can create complex things."
    e "Essas são todas as propriedades de transformação com as quais temos para trabalhar. Juntando-as na ordem certa, você pode criar coisas complexas."

translate portuguese strings:

    # tutorial_atl.rpy:267
    old "xpos 1.0 ypos .5"
    new "xpos 1.0 ypos .5"

    # tutorial_atl.rpy:267
    old "xpos .75 ypos .25"
    new "xpos .75 ypos .25"

    # tutorial_atl.rpy:267
    old "xpos .25 ypos .33"
    new "xpos .25 ypos .33"
