# Copyright (C) 2016 Free Software Foundation, Inc.
# This file is distributed under the same license as the PACKAGE package.
# José Robson Mariano Alves <jose.alves@ifto.edu.br>, 2018.
msgid ""
msgstr ""
"Project-Id-Version: colobot-data 0.1.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: DATE\n"
"PO-Revision-Date: 2018-04-17 10:38-0300\n"
"Last-Translator: José Robson Mariano Alves <jose.alves@ifto.edu.br>\n"
"Language-Team: Portuguese <kde-i18n-pt_BR@kde.org>\n"
"Language: pt_BR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Lokalize 2.0\n"

#. type: \b; header
#: ../E/abstime.txt:1
#, no-wrap
msgid "Instruction <code>abstime</code>"
msgstr "Instrução <code>abstime</code>"

#. type: Plain text
#: ../E/abstime.txt:2 ../E/deletef.txt:6 ../E/delinfo.txt:2 ../E/errmode.txt:5 ../E/flatgrnd.txt:2 ../E/readln.txt:8 ../E/send.txt:2 ../E/strfind.txt:4 ../E/strleft.txt:4 ../E/strlen.txt:4 ../E/strlower.txt:4 ../E/strmid.txt:4 ../E/strright.txt:4 ../E/strupper.txt:4 ../E/strval.txt:8 ../E/testinfo.txt:2 ../E/writeln.txt:8
#, no-wrap
msgid "Syntax:"
msgstr "Sintaxe:"

#. type: Source code
#: ../E/abstime.txt:3
#, no-wrap
msgid "<c/>abstime ( );<n/>"
msgstr "<c/>abstime ( );<n/>"

#. type: Plain text
#: ../E/abstime.txt:5
#, no-wrap
msgid "Return the time in seconds elapsed since the beginning of the mission."
msgstr "Retorna o tempo que passou em segundos desde o início da missão."

#. type: \t; header
#: ../E/abstime.txt:7
#, no-wrap
msgid "Return: <code><a cbot|float>float</a></code>"
msgstr "Retorna: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/abstime.txt:8
#, no-wrap
msgid "Time in seconds."
msgstr "Tempo em segundos."

#. type: \t; header
#: ../E/abstime.txt:10 ../E/acos.txt:11 ../E/aim.txt:23 ../E/array.txt:41 ../E/asin.txt:11 ../E/atan.txt:11 ../E/atan2.txt:16 ../E/bloc.txt:48 ../E/bool.txt:4 ../E/break.txt:24 ../E/build.txt:27 ../E/buildingenabled.txt:22 ../E/busy.txt:14 ../E/canbuild.txt:22 ../E/canresearch.txt:14 ../E/category.txt:114 ../E/ceil.txt:12 ../E/class.txt:120 ../E/close.txt:6 ../E/cond.txt:4 ../E/continue.txt:24 ../E/cos.txt:11 ../E/deletef.txt:9 ../E/delinfo.txt:13 ../E/destroy.txt:15 ../E/detect.txt:27 ../E/direct.txt:13 ../E/dist.txt:29 ../E/dist2d.txt:13 ../E/do.txt:27 ../E/drop.txt:28 ../E/eof.txt:13 ../E/errmode.txt:32 ../E/expr.txt:197 ../E/extends.txt:105 ../E/extern.txt:29 ../E/factory.txt:21 ../E/false.txt:4 ../E/file.txt:16 ../E/fire.txt:30 ../E/flatgrnd.txt:16 ../E/flatspace.txt:25 ../E/float.txt:24 ../E/floor.txt:12 ../E/for.txt:51 ../E/function.txt:165 ../E/goto.txt:34 ../E/grab.txt:28 ../E/if.txt:39 ../E/int.txt:18 ../E/jet.txt:14 ../E/message.txt:24 ../E/motor.txt:38 ../E/move.txt:21 ../E/nan.txt:14 ../E/new.txt:20 ../E/null.txt:4 ../E/object.txt:79 ../E/open.txt:19 ../E/openfile.txt:11 ../E/pencolor.txt:14 ../E/pendown.txt:17 ../E/penup.txt:11 ../E/penwidth.txt:14 ../E/point.txt:35 ../E/pointer.txt:51 ../E/pow.txt:14 ../E/private.txt:19 ../E/produce.txt:30 ../E/protected.txt:26 ../E/public.txt:49 ../E/radar.txt:80 ../E/radarall.txt:19 ../E/rand.txt:8 ../E/readln.txt:18 ../E/receive.txt:16 ../E/recycle.txt:12 ../E/research.txt:18 ../E/researched.txt:14 ../E/researches.txt:27 ../E/retobj.txt:13 ../E/return.txt:29 ../E/round.txt:12 ../E/search.txt:25 ../E/send.txt:17 ../E/shield.txt:18 ../E/sin.txt:11 ../E/sizeof.txt:21 ../E/sniff.txt:16 ../E/space.txt:22 ../E/sqrt.txt:11 ../E/static.txt:20 ../E/strfind.txt:18 ../E/string.txt:32 ../E/strleft.txt:14 ../E/strlen.txt:12 ../E/strlower.txt:10 ../E/strmid.txt:18 ../E/strright.txt:14 ../E/strupper.txt:10 ../E/strval.txt:17 ../E/super.txt:45 ../E/switch.txt:70 ../E/synchro.txt:23 ../E/takeoff.txt:15 ../E/tan.txt:11 ../E/term.txt:30 ../E/testinfo.txt:16 ../E/this.txt:52 ../E/thump.txt:12 ../E/topo.txt:13 ../E/true.txt:4 ../E/trunc.txt:12 ../E/turn.txt:32 ../E/type.txt:32 ../E/var.txt:66 ../E/void.txt:10 ../E/wait.txt:21 ../E/while.txt:46 ../E/writeln.txt:19
#, no-wrap
msgid "See also"
msgstr "Veja também"

#. type: Plain text
#: ../E/abstime.txt:11 ../E/aim.txt:24 ../E/array.txt:42 ../E/bool.txt:5 ../E/break.txt:25 ../E/busy.txt:15 ../E/cond.txt:5 ../E/continue.txt:25 ../E/deletef.txt:10 ../E/destroy.txt:16 ../E/detect.txt:28 ../E/direct.txt:14 ../E/dist.txt:30 ../E/dist2d.txt:14 ../E/drop.txt:29 ../E/errmode.txt:33 ../E/expr.txt:198 ../E/extern.txt:30 ../E/false.txt:5 ../E/fire.txt:31 ../E/flatgrnd.txt:17 ../E/flatspace.txt:26 ../E/float.txt:25 ../E/for.txt:52 ../E/function.txt:166 ../E/goto.txt:35 ../E/grab.txt:29 ../E/if.txt:40 ../E/int.txt:19 ../E/jet.txt:15 ../E/message.txt:25 ../E/move.txt:22 ../E/nan.txt:15 ../E/object.txt:80 ../E/openfile.txt:12 ../E/pencolor.txt:15 ../E/pendown.txt:18 ../E/penup.txt:12 ../E/penwidth.txt:15 ../E/point.txt:36 ../E/produce.txt:31 ../E/recycle.txt:13 ../E/retobj.txt:14 ../E/return.txt:30 ../E/search.txt:26 ../E/shield.txt:19 ../E/sizeof.txt:22 ../E/sniff.txt:17 ../E/space.txt:23 ../E/string.txt:33 ../E/switch.txt:71 ../E/takeoff.txt:16 ../E/term.txt:31 ../E/thump.txt:13 ../E/topo.txt:14 ../E/true.txt:5 ../E/turn.txt:33 ../E/type.txt:33 ../E/var.txt:67 ../E/void.txt:11 ../E/wait.txt:22
#, no-wrap
msgid "<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/aim.txt:1
#, no-wrap
msgid "Instruction <code>aim</code>"
msgstr "Instrução <code>aim</code>"

#. type: Plain text
#: ../E/break.txt:2 ../E/continue.txt:2 ../E/direct.txt:2 ../E/motor.txt:15 ../E/while.txt:20
#, no-wrap
msgid "Syntax :"
msgstr "Sintaxe:"

#. type: Bullet: 'o'
#: ../E/aim.txt:6 ../E/fire.txt:14
#, no-wrap
msgid "<a object|botfr>Shooter</a>"
msgstr "<a object|botfr>Atirador</a>"

#. type: Bullet: 'o'
#: ../E/aim.txt:7 ../E/fire.txt:15
#, no-wrap
msgid "<a object|botor>Orga shooter</a>"
msgstr "<a object|botor>Atirador orgânico</a>"

#. type: Bullet: 'o'
#: ../E/aim.txt:8 ../E/fire.txt:16
#, no-wrap
msgid "<a object|botphaz>Phazer shooter</a>"
msgstr "<a object|botphaz>Atirador phazer</a>"

#. type: Plain text
#: ../E/fire.txt:18
#, no-wrap
msgid "When controlling the robot through programming, the only way to turn the gun left or right is to turn the whole robot with the instruction <code><a cbot|turn>turn</a></code>."
msgstr "Enquanto controlando um robô através de programação, a única mandeira de girar a arma para a esquerda ou direita é girar todo o robô com a instrução <code><a cbot|turn>turn</a></code>."

#. type: \t; header
#: ../E/cos.txt:5 ../E/sin.txt:5 ../E/tan.txt:5 ../E/turn.txt:24
#, no-wrap
msgid "angle: <code><a cbot|float>float</a></code>"
msgstr "ângulo: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/aim.txt:13
#, no-wrap
msgid "Angle in degrees of the gun relative to the robot. A positive value orients the gun upward. For shooters and orga shooters, the angle must range from <code>-20</code> to <code>+20</code> degrees. For phazer shooters, the angle must range from <code>-20</code> to <code>45</code> degrees."
msgstr "Ângulo em graus da arma em relação ao robô. Um valor positivo orienta a arma para cima. Para atiradores e atiradores orgânicos, o ângulo deve ser entre <code>-20</code> e <code>+20</code> graus. Para atiradores phazer, o ângulo deve ser entre <code>-20</code> e <code>45</code> graus. "

#. type: \t; header
#: ../E/aim.txt:18 ../E/build.txt:22 ../E/destroy.txt:10 ../E/drop.txt:23 ../E/factory.txt:16 ../E/fire.txt:25 ../E/goto.txt:29 ../E/grab.txt:23 ../E/move.txt:16 ../E/pencolor.txt:9 ../E/pendown.txt:12 ../E/penup.txt:6 ../E/penwidth.txt:9 ../E/recycle.txt:7 ../E/research.txt:13 ../E/sniff.txt:11 ../E/takeoff.txt:10 ../E/thump.txt:7 ../E/turn.txt:27
#, no-wrap
msgid "Return value: <code><a cbot|int>int</a></code>"
msgstr "Valor de retorno: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/aim.txt:19
#, no-wrap
msgid ""
"Zero if everything is OK, a value different from zero if the rotation could not be performed: \n"
"<code>== 0 </code>The gun has now got the desired orientation\n"
"<code>!= 0 </code>rotation impossible"
msgstr ""
"Zero se tudo estiver OK, um valor diferente de zero se a rotação não puder ser realizada.\n"
"<code>== 0 </code>A arma tem agora a orientação desejada\n"
"<code>!= 0 </code>rotação impossível"

#. type: \b; header
#: ../E/array.txt:1
#, no-wrap
msgid "Arrays"
msgstr "Matrizes"

#. type: Plain text
#: ../E/array.txt:2
#, no-wrap
msgid "An array is basically a collection of variables of the same type or class. You can use N dimensionnal arrays in the CBOT language. Each dimension is limited to 9999 elements. You must use square brackets <code>[]</code> after the type name or the variable name to declare an array."
msgstr "Uma matriz é basicamente uma coleção de variáveis do mesmo tipo ou classe. Você pode usar matrizes de N dimensões na linguagem CBOT. Cada dimensão é limitada a 9999 elementos. Você deve usar colchetes <code>[]</code> depois do tipo ou nome da variável para declarar uma matriz."

#. type: Plain text
#: ../E/array.txt:9
#, no-wrap
msgid "Actually when the CBOT interpreter encounters an array declaration, it just creates a <code><a cbot|null>null</a></code> <a cbot|pointer>reference</a>:"
msgstr "Na verdade quando o interpretador CBOT encontra uma declaração de matriz, ele apenas cria uma  <a cbot|pointer>referência</a> <code><a cbot|null>nula</a></code>:"

#. type: Source code
#: ../E/array.txt:11
#, no-wrap
msgid "int a[5];  // a is now a null reference"
msgstr "int a[5];  // a é agora uma referência nula"

#. type: Plain text
#: ../E/array.txt:13
#, no-wrap
msgid "As soon as you put values into the array, the elements are created and the reference is initialized:"
msgstr "Assim que você coloca valores na matriz, os elementos são criados e a referência é inicializada."

#. type: Source code
#: ../E/array.txt:15
#, no-wrap
msgid ""
"a[2] = 213;  // a points to\n"
"             // 3 elements [0], [1] et [2]"
msgstr ""
"a[2] = 213;  // a aponta para\n"
"             // 3 elementos [0], [1] e [2]"

#. type: Plain text
#: ../E/array.txt:18
#, no-wrap
msgid "After this operation, <code>a</code> contains a reference to the elements of the array. Elements <code>[0]</code> and <code>[1]</code> are created but not initialized because an array cannot contain empty elements. The <code><a cbot|sizeof>sizeof</a></code> instruction allows you to obtain the number of elements contained in an array."
msgstr ""
"Depois dessa operação, <code>a</code> contém uma referência para os elementosda matriz. Os elementos <code>[0]</code> e <code>[1]</code> são criados porém não inicializados porque uma matriz não pode conter elementos vazios.\n"
"A instrução <code><a cbot|sizeof>sizeof</a></code> permite a você obter a quantidade de elementos contidos na matriz."

#. type: Plain text
#: ../E/array.txt:20
#, no-wrap
msgid "When an array is declared with a maximum size, the program will stop as soon as there is an access beyond the maximum array size. No error is signalled during compilation even if the error is obvious:"
msgstr "Quando uma matriz é declarada com um tamanho máximo, o programa irá parar assim que houver um acesso além do tamanho máximo da matriz. Nenhum erro é sinalizado durante a compilação, mesmo que o erro seja óbvio:"

#. type: Source code
#: ../E/array.txt:22
#, no-wrap
msgid ""
"{\n"
"\tint a[5];\n"
"\ta[7] = 123;  // no error at compile time\n"
"\t             // but error at run time\n"
"}"
msgstr ""
"{\n"
"\tint a[5];\n"
"\ta[7] = 123;  // nenhum erro ao compilar\n"
"\t             // porém com erros ao executar\n"
"}"

#. type: Plain text
#: ../E/array.txt:28
#, no-wrap
msgid "If you pass an array as parameter to a <a cbot|function>function</a>, the function only receives a <a cbot|pointer>reference</a> to the array. That means if you modify an array element in the function, the element of the array that has been passed the function will be actuallay modified."
msgstr "Se você passar uma matriz como parâmetro para uma <a cbot|function>função</a>, a função somente recebe uma <a cbot|pointer>referência</a> da matriz. Isto significa que se você modificar um elemento na função, o elemento da matriz que foi passada para a função será modificado."

#. type: \b; header
#: ../E/bloc.txt:1
#, no-wrap
msgid "Blocks"
msgstr "Blocos"

#. type: Plain text
#: ../E/bloc.txt:2
#, no-wrap
msgid "You can use braces <code>{ }</code> to group a number of instructions together in order to make one single block out of them, for example: "
msgstr "Você pode usar chaves <code>{ }</code> para agrupar um número de intruções em ordem para criar um bloco com elas, por exemplo:"

#. type: Source code
#: ../E/bloc.txt:4
#, no-wrap
msgid ""
"\t{\n"
"\t\tfloat  t;\n"
"\t\tt = a;\n"
"\t\ta = b;\n"
"\t\tb = t;  // switches round a and b\n"
"\t}"
msgstr ""
"\t{\n"
"\t\tfloat  t;\n"
"\t\tt = a;\n"
"\t\ta = b;\n"
"\t\tb = t;  // troca a e b\n"
"\t}"

#. type: Plain text
#: ../E/bloc.txt:11
#, no-wrap
msgid ""
"Every instruction in the block is followed by a <a cbot|term>semicolon</a>, but the block itself is not. \n"
"Let us take the following example with the instruction <code><a cbot|if>if</a></code> to illustrate the use of blocks in a program:"
msgstr ""
"Cada instrução no bloco é seguida por um <a cbot|term>ponto e vírgula</a>, mas o bloco em sí não.\n"
"Veja o exemplo a seguir com a instrução <code><a cbot|if>if</a></code> que ilustra o uso de blocos em um programa:"

#. type: Source code
#: ../E/bloc.txt:14
#, no-wrap
msgid ""
"\tif ( a < b )\n"
"\t\t<n/>instruction 1<c/>;\n"
"\t\t<n/>instruction 2<c/>;\n"
"\t<n/>instruction 3<c/>;"
msgstr ""
"\tif ( a < b )\n"
"\t\t<n/>instruction 1<c/>;\n"
"\t\t<n/>instruction 2<c/>;\n"
"\t<n/>instruction 3<c/>;"

#. type: Plain text
#: ../E/bloc.txt:19
#, no-wrap
msgid ""
"If the <a cbot|cond>condition</a> is true, instructions 1, 2 and 3 are performed. If the condition is false, only instruction 1 is ignored, instructions 2 and 3 are performed. The fact that instruction 2 is lined up with instruction 1 does not matter. \n"
"If you want to perform instructions 1 and 2 only if the condition is true, you have to bracket them together in a block: "
msgstr ""
"Se a <a cbot|cond>condição</a> for verdadeira, as instruções 1, 2 e 3 são executadas. Caso a condição seja falsa, somente a instrução 1 é ignorada, instruções 2 e 3 são executadas. O fato que a instrução 2 está alinhada com  a instrução 1 não significa nada.\n"
"Se você quer executar as instruções 1 e 2 somente se a condição for verdadeira,  você deve colocá-las em um bloco:"

#. type: Source code
#: ../E/bloc.txt:22
#, no-wrap
msgid ""
"\tif ( a < b )\n"
"\t{\n"
"\t\t<n/>instruction 1<c/>;\n"
"\t\t<n/>instruction 2<c/>;\n"
"\t}\n"
"\t<n/>instruction 3<c/>;"
msgstr ""
"\tif ( a < b )\n"
"\t{\n"
"\t\t<n/>instruction 1<c/>;\n"
"\t\t<n/>instruction 2<c/>;\n"
"\t}\n"
"\t<n/>instruction 3<c/>;"

#. type: Plain text
#: ../E/bloc.txt:29
#, no-wrap
msgid ""
"Blocks may be needed with instructions <code><a cbot|if>if</a></code>, <code><a cbot|while>while</a></code> and <code><a cbot|for>for</a></code>, in order to group several instructions that should be performed only if a condition is true, or repeated several times. \n"
"You can fit blocks into other blocks, on as many levels as you need. Here is an example of imbrication on two levels :"
msgstr ""
"Blocos podem ser necessários com instruções <code><a cbot|if>if</a></code>, <code><a cbot|while>while</a></code> e <code><a cbot|for>for</a></code>, a fim de  agrupar várias instruções que devem ser executadas somente se uma condição é verdadeira, ou que deve ser repetida várias vezes. \n"
"Você pode colocar blocos em outros blocos, em quantos níveis você necessitar. Aqui está um exemplo da sobreposição de 2 níveis:"

#. type: Source code
#: ../E/bloc.txt:32
#, no-wrap
msgid ""
"\tif ( a > b )\n"
"\t{\n"
"\t\tint  i = 0;\n"
"\t\twhile ( i < 18 )\n"
"\t\t{\n"
"\t\t\tmove(10);\n"
"\t\t\tturn(5);\n"
"\t\t\ti = i+1;\n"
"\t\t}\n"
"\t}"
msgstr ""
"\tif ( a > b )\n"
"\t{\n"
"\t\tint  i = 0;\n"
"\t\twhile ( i < 18 )\n"
"\t\t{\n"
"\t\t\tmove(10);\n"
"\t\t\tturn(5);\n"
"\t\t\ti = i+1;\n"
"\t\t}\n"
"\t}"

#. type: Plain text
#: ../E/bloc.txt:43
#, no-wrap
msgid "You had better line up the open brace <code>{</code> with the closing brace <code>}</code> in order to improve readability, but it is not compulsory. The following example takes less space, is equivalent to the previous example, but it is not advisable to write your programs in the following style : "
msgstr "É melhor você alinhar a chave de abertura <code>{</code> com a chave de fechamento <code>}</code> a fim de melhorar a legibilidade, porém não é obrigatório. O exemplo seguinte usa menos espaço, mas é equivalente ao exemplo anterior, porém não é aconselhável escrever seus programas neste estilo: "

#. type: Source code
#: ../E/bloc.txt:45
#, no-wrap
msgid ""
"\tif(a>b) { int i=0; while(i<18) {\n"
"\tmove(10);turn(5);i=i+1; }}"
msgstr ""
"\tif(a>b) { int i=0; while(i<18) {\n"
"\tmove(10);turn(5);i=i+1; }}"

#. type: Plain text
#: ../E/bloc.txt:49 ../E/do.txt:28 ../E/motor.txt:39 ../E/while.txt:47
#, no-wrap
msgid "<a cbot>Instructions</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot>Instruções</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/bool.txt:1
#, no-wrap
msgid "Type <code>bool</code>"
msgstr "Tipo <code>bool</code>"

#. type: Plain text
#: ../E/bool.txt:2
#, no-wrap
msgid "In a variable of this type you can put a boolean value, that is a value that can take only two states: true or false. "
msgstr "Uma variável deste tipo pode receber valores booleanos, isto significa que só pode ter dois valores: true ou false (verdadeiro ou falso)."

#. type: \b; header
#: ../E/break.txt:1
#, no-wrap
msgid "Instruction <code>break</code>"
msgstr "Instrução <code>break</code>"

#. type: Source code
#: ../E/break.txt:3
#, no-wrap
msgid ""
"<c/>while ( condition )\n"
"{\n"
"\tbreak;\n"
"}"
msgstr ""
"<c/>while ( condição )\n"
"{\n"
"\tbreak;\n"
"}"

#. type: Plain text
#: ../E/break.txt:8
#, no-wrap
msgid "With this instruction, you can get out immediately of a <code><a cbot|while>while</a></code> or <code><a cbot|for>for</a></code> loop."
msgstr "Com esta instrução, você pode sair imediatamente de um <code><a cbot|while>while</a></code> ou <code><a cbot|for>for</a></code>."

#. type: Plain text
#: ../E/break.txt:10 ../E/continue.txt:10
#, no-wrap
msgid "Here is an example:"
msgstr "Aqui está um exemplo:"

#. type: Source code
#: ../E/break.txt:11
#, no-wrap
msgid ""
"<c/>int i = 0;\n"
"while ( true )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"\ti = i+1;\n"
"\tif ( i >= 10 )\n"
"\t{\n"
"\t\tbreak;\n"
"\t}\n"
"\t<n/>more instructions ...<c/>\n"
"}"
msgstr ""
"<c/>int i = 0;\n"
"while ( true )\n"
"{\n"
"\t<n/>instruções …<c/>\n"
"\ti = i+1;\n"
"\tif ( i >= 10 )\n"
"\t{\n"
"\t\tbreak;\n"
"\t}\n"
"\t<n/>mais instruções…<c/>\n"
"}"

#. type: \b; header
#: ../E/category.txt:1
#, no-wrap
msgid "Value <code>Categories</code>"
msgstr "<code>Categorias</code> de valor"

#. type: Plain text
#: ../E/category.txt:2
#, no-wrap
msgid "Categories represent the names of objects in the CBOT language. Everything in COLOBOT is an object: robots, buildings, raw materials, etc., even yourself."
msgstr "As categorias representam nomes de objetos na linguagem CBOT. Tudo em COLOBOT é um objeto: robôs, edifícios, matéria prima, etc., até você mesmo."

#. type: Plain text
#: ../E/category.txt:34
#, no-wrap
msgid ""
"       <code><a object|titanore>TitaniumOre</a>          </code>Titanium Ore\n"
"       <code><a object|uranore>UraniumOre</a>           </code>Uranium Ore\n"
"       <code><a object|titan>Titanium</a>             </code>Cube of converted Titanium\n"
"       <code><a object|power>PowerCell</a>            </code>Regular Power Cell\n"
"       <code><a object|atomic>NuclearCell</a>          </code>Nuclear Power Cell\n"
"       <code><a object|bullet>OrgaMatter</a>           </code>Organic Matter\n"
"       <code><a object|bbox>BlackBox</a>             </code>Black Box\n"
"       <code><a object|tnt>TNT</a>                  </code>Explosive device\n"
"       <code><a object|key>KeyA..D</a>              </code>Keys A, B, C and D"
msgstr ""
"       <code><a object|titanore>TitaniumOre</a>    </code>Minério de titânio\n"
"       <code><a object|uranore>UraniumOre</a>     </code>Minério de urânio\n"
"       <code><a object|titan>Titanium</a>       </code>Cubo de titânio convertido\n"
"       <code><a object|power>PowerCell</a>      </code>Célula de energia normal\n"
"       <code><a object|atomic>NuclearCell</a>    </code>Célula de energia nuclear\n"
"       <code><a object|bullet>OrgaMatter</a>     </code>Matéria orgânica\n"
"       <code><a object|bbox>BlackBox</a>       </code>Caixa preta\n"
"       <code><a object|tnt>TNT</a>            </code>Dispositivo explosivo\n"
"       <code><a object|key>KeyA..D</a>        </code>Chaves A, B, C e D"

#. type: Plain text
#: ../E/category.txt:47
#, no-wrap
msgid ""
"<button 158/>   <code><a object|bottr>PracticeBot</a>            </code>Practice Bot\n"
"<button 173/>   <code><a object|bottarg>TargetBot</a>              </code>Target Bot"
msgstr ""
"<button 158/>   <code><a object|bottr>PracticeBot</a>            </code>Robô de prática\n"
"<button 173/>   <code><a object|bottarg>TargetBot</a>              </code>Robô alvo"

#. type: Plain text
#: ../E/category.txt:50
#, no-wrap
msgid ""
"<button 137/>   <code><a object|botgr>WheeledGrabber</a>         </code>Wheeled Grabber\n"
"<button 138/>   <code><a object|botgc>TrackedGrabber</a>         </code>Tracked Grabber\n"
"<button 139/>   <code><a object|botgj>WingedGrabber</a>          </code>Winged Grabber\n"
"<button 150/>   <code><a object|botgs>LeggedGrabber</a>          </code>Legged Grabber"
msgstr ""
"<button 137/>   <code><a object|botgr>WheeledGrabber</a>         </code>Agarrador com rodas\n"
"<button 138/>   <code><a object|botgc>TrackedGrabber</a>         </code>Agarrador com esteiras\n"
"<button 139/>   <code><a object|botgj>WingedGrabber</a>          </code>Agarrador alado\n"
"<button 150/>   <code><a object|botgs>LeggedGrabber</a>          </code>Agarrador com pernas"

#. type: Plain text
#: ../E/category.txt:55
#, no-wrap
msgid ""
"<button 140/>   <code><a object|botsr>WheeledSniffer</a>         </code>Wheeled Sniffer\n"
"<button 141/>   <code><a object|botsc>TrackedSniffer</a>         </code>Tracked Sniffer\n"
"<button 142/>   <code><a object|botsj>WingedSniffer</a>          </code>Winged Sniffer\n"
"<button 152/>   <code><a object|botss>LeggedSniffer</a>          </code>Legged Sniffer"
msgstr ""
"<button 140/>   <code><a object|botsr>WheeledSniffer</a>         </code>Farejador com rodas\n"
"<button 141/>   <code><a object|botsc>TrackedSniffer</a>         </code>Farejador com esteiras\n"
"<button 142/>   <code><a object|botsj>WingedSniffer</a>          </code>Farejador alado\n"
"<button 152/>   <code><a object|botss>LeggedSniffer</a>          </code>Farejador com pernas"

#. type: Plain text
#: ../E/category.txt:60
#, no-wrap
msgid ""
"<button 143/>   <code><a object|botfr>WheeledShooter</a>         </code>Wheeled Shooter\n"
"<button 144/>   <code><a object|botfc>TrackedShooter</a>         </code>Tracked Shooter\n"
"<button 145/>   <code><a object|botfj>WingedShooter</a>          </code>Winged Shooter\n"
"<button 151/>   <code><a object|botfs>LeggedShooter</a>          </code>Legged Shooter"
msgstr ""
"<button 143/>   <code><a object|botfr>WheeledShooter</a>         </code>Atirador com rodas\n"
"<button 144/>   <code><a object|botfc>TrackedShooter</a>         </code>Atirador com esteiras\n"
"<button 145/>   <code><a object|botfj>WingedShooter</a>          </code>Atirador alado\n"
"<button 151/>   <code><a object|botfs>LeggedShooter</a>          </code>Atirador com pernas"

#. type: Plain text
#: ../E/category.txt:65
#, no-wrap
msgid ""
"<button 153/>   <code><a object|botor>WheeledOrgaShooter</a>     </code>Wheeled Orga Shooter\n"
"<button 154/>   <code><a object|botoc>TrackedOrgaShooter</a>     </code>Tracked Orga Shooter\n"
"<button 155/>   <code><a object|botoj>WingedOrgaShooter</a>      </code>Winged Orga Shooter\n"
"<button 156/>   <code><a object|botos>LeggedOrgaShooter</a>      </code>Legged Orga Shooter"
msgstr ""
"<button 153/>   <code><a object|botor>WheeledOrgaShooter</a>     </code>Atirador orgânico com rodas\n"
"<button 154/>   <code><a object|botoc>TrackedOrgaShooter</a>     </code>Atirador orgânico com esteiras\n"
"<button 155/>   <code><a object|botoj>WingedOrgaShooter</a>      </code>Atirador orgânico alado\n"
"<button 156/>   <code><a object|botos>LeggedOrgaShooter</a>      </code>Atirador orgânico com pernas"

#. type: Plain text
#: ../E/category.txt:75
#, no-wrap
msgid ""
"<button 149/>   <code><a object|botsub>Subber</a>                 </code>Subber\n"
"<button 148/>   <code><a object|botrecy>Recycler</a>               </code>Recycler\n"
"<button 157/>   <code><a object|botshld>Shielder</a>               </code>Shielder\n"
"<button 146/>   <code><a object|bottump>Thumper</a>                </code>Thumper\n"
"<button 147/>   <code><a object|botphaz>PhazerShooter</a>          </code>Phazer Shooter"
msgstr ""
"<button 149/>   <code><a object|botsub>Subber</a>                 </code>Mergulhador\n"
"<button 148/>   <code><a object|botrecy>Recycler</a>               </code>Reciclador\n"
"<button 157/>   <code><a object|botshld>Shielder</a>               </code>Protetor\n"
"<button 146/>   <code><a object|bottump>Thumper</a>                </code>Batedor\n"
"<button 147/>   <code><a object|botphaz>PhazerShooter</a>          </code>Atirador phazer"

#. type: Plain text
#: ../E/category.txt:84
#, no-wrap
msgid ""
"       <code><a object|mother>AlienQueen</a>         </code>Alien Queen\n"
"       <code><a object|egg>AlienEgg</a>           </code>Alien Egg\n"
"       <code><a object|ant>AlienAnt</a>           </code>Ant\n"
"       <code><a object|spider>AlienSpider</a>        </code>Spider\n"
"       <code><a object|wasp>AlienWasp</a>          </code>Wasp\n"
"       <code><a object|worm>AlienWorm</a>          </code>Worm"
msgstr ""
"       <code><a object|mother>AlienQueen</a>         </code>Reinha alienígena\n"
"       <code><a object|egg>AlienEgg</a>           </code>Ovo alienígena\n"
"       <code><a object|ant>AlienAnt</a>           </code>Formiga\n"
"       <code><a object|spider>AlienSpider</a>        </code>Aranha\n"
"       <code><a object|wasp>AlienWasp</a>          </code>Vespa\n"
"       <code><a object|worm>AlienWorm</a>          </code>Verme"

#. type: Plain text
#: ../E/category.txt:94
#, no-wrap
msgid ""
"<button 136/>   <code><a object|human>Me</a>              </code>You!\n"
"       <code><a object|mine>Mine</a>            </code>Mine\n"
"       <code><a object|barrier>Barrier</a>         </code>Barrier\n"
"       <code><a object|wreck>Wreck</a>           </code>Derelict bot\n"
"       <code><a object|ruin>Ruin</a>            </code>Derelict building"
msgstr ""
"<button 136/>   <code><a object|human>Me</a>              </code>Você!\n"
"       <code><a object|mine>Mine</a>            </code>Mina\n"
"       <code><a object|barrier>Barrier</a>         </code>Barreira\n"
"       <code><a object|wreck>Wreck</a>           </code>Robô abandonado\n"
"       <code><a object|ruin>Ruin</a>            </code>Edifício abandonado"

#. type: Plain text
#: ../E/category.txt:115
#, no-wrap
msgid "<a cbot>CBOT Language</a> and <a cbot|type>Variables</a>."
msgstr "<a cbot>Linguagem CBOT</a> e <a cbot|type>variáveis</a>."

#. type: \b; header
#: ../E/class.txt:1
#, no-wrap
msgid "Instruction <code>class</code>"
msgstr "Instrução <code>class</code>"

#. type: Source code
#: ../E/class.txt:4
#, no-wrap
msgid ""
"public class ClassName\n"
"{\n"
"\tdeclarations;\n"
"}"
msgstr ""
"public class NomeDaClasse \n"
"{\n"
"\tdeclarações;\n"
"}"

#. type: \b; header
#: ../E/close.txt:1
#, no-wrap
msgid "Instruction <code>close</code>"
msgstr "Instrução <code>close</code>"

#. type: Plain text
#: ../E/close.txt:2
#, no-wrap
msgid "Close a file opened previously with <code><a cbot|open>open</a></code>. This is a method of the <code><a cbot|file>file</a></code> class; therefore you cannot write  <code>close()</code> but only <code>handle.close()</code>:"
msgstr "Fecha um arquivo aberto previamente comh <code><a cbot|open>open</a></code>. Este é um método da classe <code><a cbot|file>file</a></code>; Assim sendo você não pode escrevere  <code>close()</code> mas somente <code>handle.close()</code>:"

#. type: Source code
#: ../E/close.txt:4
#, no-wrap
msgid "\thandle.close();"
msgstr "\thandle.close();"

#. type: Plain text
#: ../E/close.txt:7
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> e <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/cond.txt:1
#, no-wrap
msgid "Conditions"
msgstr "Condições"

#. type: Plain text
#: ../E/expr.txt:116
#, no-wrap
msgid ""
"<code>a == b  </code><code>a</code> equals <code>b</code>\n"
"<code>a != b  </code><code>a</code> is different from <code>b</code>\n"
"<code>a <  b  </code><code>a</code> smaller than <code>b</code>\n"
"<code>a <= b  </code><code>a</code> smaller than or equal to <code>b</code>\n"
"<code>a >  b  </code><code>a</code> greater than <code>b</code>\n"
"<code>a >= b  </code><code>a</code> greater than or equal to <code>b</code>"
msgstr ""
"<code>a == b  </code><code>a</code> é igual a <code>b</code>\n"
"<code>a != b  </code><code>a</code> é diferente de <code>b</code>\n"
"<code>a <  b  </code><code>a</code> é menor que <code>b</code>\n"
"<code>a <= b  </code><code>a</code> é menor ou igual a <code>b</code>\n"
"<code>a >  b  </code><code>a</code> é maior que <code>b</code>\n"
"<code>a >= b  </code><code>a</code> é maior ou igual a <code>b</code>"

#. type: Plain text
#: ../E/expr.txt:124
#, no-wrap
msgid ""
"<code>12 == 12  </code>returns true\n"
"<code>45 != 47  </code>returns true \n"
"<code>99 == 98  </code>returns false\n"
"<code>12 <  -1  </code>returns false\n"
"<code>12 >= 10  </code>returns true \n"
"<code>12 >= 12  </code>returns true "
msgstr ""
"<code>12 == 12  </code>retorna true\n"
"<code>45 != 47  </code>retorna true \n"
"<code>99 == 98  </code>retorna false\n"
"<code>12 <  -1  </code>retorna false\n"
"<code>12 >= 10  </code>retorna true \n"
"<code>12 >= 12  </code>retorna true "

#. type: Plain text
#: ../E/expr.txt:132
#, no-wrap
msgid "Be careful not to confuse the equality comparison <code>==</code> with the assignment of a <a cbot|var>variable</a> <code>=</code>."
msgstr "Tenha cuidado para não confundir o operador de comparação <code>==</code> com o operadoratribuição de valor a <a cbot|var>variáveis</a> <code>=</code>."

#. type: Plain text
#: ../E/expr.txt:134
#, no-wrap
msgid ""
"<code>a == b</code> is an expression that compares <code>a</code> with <code>b</code>.\n"
"<code>a = b</code> is an expression that copies the value of <code>b</code> into <code>a</code>."
msgstr ""
"<code>a == b</code> é uma expressão que compara <code>a</code> com <code>b</code>.\n"
"<code>a = b</code> é uma expressão que copia o valor de <code>b</code> em <code>a</code>."

#. type: \b; header
#: ../E/continue.txt:1
#, no-wrap
msgid "Instruction <code>continue</code>"
msgstr "Instrução <code>continue</code>"

#. type: Source code
#: ../E/continue.txt:3
#, no-wrap
msgid ""
"<c/>while ( condition )\n"
"{\n"
"\tcontinue;\n"
"}"
msgstr ""
"<c/>while ( condição )\n"
"{\n"
"\tcontinue;\n"
"}"

#. type: Plain text
#: ../E/continue.txt:8
#, no-wrap
msgid "With this instruction, you can jump over the rest of instructions in the <code><a cbot|bloc>bloc</a></code> of a <code><a cbot|while>while</a></code> or <code><a cbot|for>for</a></code> loop: The execution will resume at the beginning of the bloc, the next time the loop is repeated."
msgstr "Com esta instrução você pode pular o resto das instruções no <code><a cbot|bloc>bloco</a></code> de uma estrutura de repetição <code><a cbot|while>while</a></code> ou <code><a cbot|for>for</a></code>: a execução será retomada noinicio do bloco na próxima vez que o laço for repetido."

#. type: Source code
#: ../E/continue.txt:11
#, no-wrap
msgid ""
"<c/>int i = 0;\n"
"while ( i < 5 )\n"
"{\n"
"\ti = i+1;\n"
"\tif ( i == 3 )\n"
"\t{\n"
"\t\tcontinue;\n"
"\t}\n"
"\t<n/>Instructions ...<c/>\n"
"}"
msgstr ""
"<c/>int i = 0;\n"
"while ( i < 5 )\n"
"{\n"
"\ti = i+1;\n"
"\tif ( i == 3 )\n"
"\t{\n"
"\t\tcontinue;\n"
"\t}\n"
"\t<n/>instruções...<c/>\n"
"}"

#. type: Plain text
#: ../E/continue.txt:22
#, no-wrap
msgid "The instructions will only be executed for the values of <code>i</code> 1, 2, 4 and 5."
msgstr "As instruções só serão executadas quando o valor de <code>i</code> for 1, 2, 4 ou 5."

#. type: \b; header
#: ../E/deletef.txt:1
#, no-wrap
msgid "Instruction <code>deletefile</code>"
msgstr "Instrução <code>deletefile</code>"

#. type: Plain text
#: ../E/deletef.txt:2
#, no-wrap
msgid "The deletefile instruction deletes an existing file in the files/ folder. "
msgstr "A instrução deletefile remove um arquivo existente na pasta files/. "

#. type: Plain text
#: ../E/deletef.txt:4
#, no-wrap
msgid "Files can only be deleted in the files/ folder which is located in the folder inside Colobot save directory. You cannot not delete files that are located elsewhere than in the files/ folder."
msgstr "Arquivos só podem ser excluídos na pasta files/ que fica localizada dentro do diretório save do Colobot. Você não pode excluir arquivos que não estão dentro da pasta files/."

#. type: Source code
#: ../E/deletef.txt:7
#, no-wrap
msgid "<c/>deletefile ( filename );<n/>"
msgstr "<c/>deletefile ( nome_do_arquivo );<n/>"

#. type: \b; header
#: ../E/delinfo.txt:1
#, no-wrap
msgid "Instruction <code>deleteinfo</code>"
msgstr "Instrução <code>deleteinfo</code>"

#. type: Source code
#: ../E/delinfo.txt:3
#, no-wrap
msgid "<c/>deleteinfo ( name, power );<n/>"
msgstr "<c/>deleteinfo ( nome, energia );<n/>"

#. type: Plain text
#: ../E/delinfo.txt:5
#, no-wrap
msgid "Delete an existing information in the closest <a object|exchange>information exchange post</a>."
msgstr "Deleta uma informação existente no <a object|exchange>posto de troca de informação</a> mais próximo."

#. type: \t; header
#: ../E/delinfo.txt:7 ../E/receive.txt:7 ../E/send.txt:7 ../E/testinfo.txt:7
#, no-wrap
msgid "name: <code>string</code>"
msgstr "nome: <code>string</code>"

#. type: Plain text
#: ../E/delinfo.txt:8
#, no-wrap
msgid "Name of the information to be deleted. This name is a string: it must be written in quotation marks \"\"."
msgstr "Nome da informação a ser deletada. Este nome é uma string: deve ser escrito entre aspas \"...\"."

#. type: \t; header
#: ../E/delinfo.txt:10 ../E/receive.txt:10 ../E/send.txt:14 ../E/testinfo.txt:10
#, no-wrap
msgid "power: <code>float</code>"
msgstr "energia: <code>float</code>"

#. type: Plain text
#: ../E/delinfo.txt:11
#, no-wrap
msgid "Power of the transmitter, which corresponds to the maximal distance between the sender and the exchange post. If the distance is longer, the information won't be deleted. Default value is 10 metres."
msgstr "Energia do transmissor, a qual corresponde a distância máxima entre o remetente e o posto de troca. Se a distância é longa, a informação não será deletada. O valor padrão é 10 metros."

#. type: Plain text
#: ../E/delinfo.txt:14
#, no-wrap
msgid ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> and <code><a cbot|testinfo>testinfo</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> e <code><a cbot|testinfo>testinfo</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/direct.txt:1
#, no-wrap
msgid "Instruction <code>direction</code>"
msgstr "Instrução <code>direction</code>"

#. type: Source code
#: ../E/direct.txt:3
#, no-wrap
msgid "<c/>direction ( pos );<n/>"
msgstr "<c/>direction ( pos );<n/>"

#. type: Plain text
#: ../E/direct.txt:5
#, no-wrap
msgid "Calculates the rotation that a robot must perform in order to point towards a given position. "
msgstr "Calcula a rotação que um robô deve fazer a fim de apontar para uma  posição informada."

#. type: \t; header
#: ../E/direct.txt:7 ../E/goto.txt:17
#, no-wrap
msgid "pos: <code><a cbot|point>point</a></code>"
msgstr "pos: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: ../E/direct.txt:8
#, no-wrap
msgid "Position towards which the robot must point."
msgstr "Posição que o robô deve apontar."

#. type: \t; header
#: ../E/acos.txt:8 ../E/asin.txt:8 ../E/atan.txt:8 ../E/atan2.txt:13 ../E/ceil.txt:9 ../E/cos.txt:8 ../E/direct.txt:10 ../E/dist.txt:26 ../E/dist2d.txt:10 ../E/flatgrnd.txt:13 ../E/floor.txt:9 ../E/pow.txt:11 ../E/rand.txt:5 ../E/receive.txt:13 ../E/round.txt:9 ../E/sin.txt:8 ../E/sqrt.txt:8 ../E/tan.txt:8 ../E/topo.txt:10 ../E/trunc.txt:9
#, no-wrap
msgid "Return value: <code><a cbot|float>float</a></code>"
msgstr "Valor de retorno: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/direct.txt:11
#, no-wrap
msgid "Angle of the rotation that must be performed. -90 means f. ex. a rotation of 90 degrees to the right. "
msgstr "Ângulo da rotação que deve ser realizada. -90 significa que deve rotacionar 90 graus a direita."

#. type: \b; header
#: ../E/dist.txt:1
#, no-wrap
msgid "Instruction <code>distance</code>"
msgstr "Instrução <code>distance</code>"

#. type: Plain text
#: ../E/dist.txt:2
#, no-wrap
msgid "With the instruction <code>distance( , )</code> you can calculate the distance between two positions."
msgstr "Com a instrução <code>distance( , )</code> você pode calcular a distância entre duas posições."

#. type: \b; header
#: ../E/build.txt:4 ../E/buildingenabled.txt:4 ../E/canbuild.txt:4 ../E/dist.txt:4 ../E/drop.txt:4 ../E/fire.txt:4 ../E/function.txt:16 ../E/goto.txt:4 ../E/grab.txt:4 ../E/if.txt:4 ../E/motor.txt:4 ../E/move.txt:4 ../E/radar.txt:4 ../E/switch.txt:4 ../E/turn.txt:4 ../E/wait.txt:4 ../E/while.txt:4
#, no-wrap
msgid "Basic use"
msgstr "Uso básico"

#. type: Plain text
#: ../E/dist.txt:5
#, no-wrap
msgid "If you write <code>position</code> alone, this gives you the position of the bot that executes the program. If you write the name of a variable followed by <code>.position</code>, this gives you the position of the object described in the variable."
msgstr "Se você escrever <code>position</code> sozinha, ela lhe dá a posição do robô que executa o programa. Se você escrever o nome de uma variável seguida por <code>.position</code>, ela lhe dá a posição do objeto descrito na variável."

#. type: Plain text
#: ../E/dist.txt:7
#, no-wrap
msgid "Here is a program that moves forward, covering exactly the distance between the bot and the closest ant:"
msgstr "Aqui está um programa que avança, cobrindo exatamente a distância entre o robô e a formiga mais próxima."

#. type: Source code
#: ../E/dist.txt:9
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
"\t<a cbot|move>move</a>(distance(position, item.position));"
msgstr ""
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
"\t<a cbot|move>move</a>(distance(position, item.position));"

#. type: Plain text
#: ../E/dist.txt:12
#, no-wrap
msgid "This is of course pure suicide. Better to stop 40 meters before, in order to be at shooting range:"
msgstr "Isto é claro, puro suicidio. Melhor parar 40 metros antes de forma a estar no alcance de tiro:"

#. type: Source code
#: ../E/dist.txt:14
#, no-wrap
msgid ""
"\titem = radar(AlienAnt);\n"
"\tmove(distance(position, item.position) - 40);"
msgstr ""
"\titem = radar(AlienAnt);\n"
"\tmove(distance(position, item.position) - 40);"

#. type: \b; header, \t; header
#: ../E/build.txt:13 ../E/buildingenabled.txt:12 ../E/canbuild.txt:12 ../E/detect.txt:4 ../E/dist.txt:17 ../E/drop.txt:11 ../E/errmode.txt:4 ../E/file.txt:10 ../E/fire.txt:9 ../E/float.txt:19 ../E/goto.txt:11 ../E/grab.txt:11 ../E/if.txt:22 ../E/int.txt:13 ../E/motor.txt:14 ../E/move.txt:7 ../E/radar.txt:13 ../E/radarall.txt:11 ../E/return.txt:9 ../E/switch.txt:46 ../E/turn.txt:18 ../E/wait.txt:9 ../E/while.txt:19
#, no-wrap
msgid "For specialists"
msgstr "Para especialistas"

#. type: Plain text, \t; header
#: ../E/abstime.txt:2 ../E/acos.txt:2 ../E/aim.txt:2 ../E/asin.txt:2 ../E/atan.txt:2 ../E/atan2.txt:2 ../E/build.txt:14 ../E/buildingenabled.txt:13 ../E/busy.txt:2 ../E/canbuild.txt:13 ../E/canresearch.txt:2 ../E/ceil.txt:2 ../E/cos.txt:2 ../E/deletef.txt:6 ../E/delinfo.txt:2 ../E/destroy.txt:2 ../E/detect.txt:5 ../E/dist.txt:18 ../E/dist2d.txt:2 ../E/do.txt:2 ../E/drop.txt:12 ../E/errmode.txt:5 ../E/factory.txt:2 ../E/fire.txt:10 ../E/flatgrnd.txt:2 ../E/flatspace.txt:2 ../E/floor.txt:2 ../E/for.txt:2 ../E/goto.txt:12 ../E/grab.txt:12 ../E/if.txt:23 ../E/jet.txt:2 ../E/message.txt:2 ../E/move.txt:8 ../E/pencolor.txt:2 ../E/pendown.txt:2 ../E/penup.txt:2 ../E/penwidth.txt:2 ../E/pow.txt:2 ../E/produce.txt:2 ../E/radar.txt:14 ../E/radarall.txt:12 ../E/rand.txt:2 ../E/readln.txt:8 ../E/receive.txt:2 ../E/recycle.txt:2 ../E/research.txt:2 ../E/researched.txt:2 ../E/retobj.txt:2 ../E/round.txt:2 ../E/search.txt:2 ../E/send.txt:2 ../E/shield.txt:2 ../E/sin.txt:2 ../E/sniff.txt:2 ../E/space.txt:2 ../E/sqrt.txt:2 ../E/strfind.txt:4 ../E/strleft.txt:4 ../E/strlen.txt:4 ../E/strlower.txt:4 ../E/strmid.txt:4 ../E/strright.txt:4 ../E/strupper.txt:4 ../E/strval.txt:8 ../E/switch.txt:47 ../E/takeoff.txt:2 ../E/tan.txt:2 ../E/testinfo.txt:2 ../E/thump.txt:2 ../E/topo.txt:2 ../E/trunc.txt:2 ../E/turn.txt:19 ../E/wait.txt:10 ../E/writeln.txt:8
#, no-wrap
msgid "Syntax:"
msgstr "Sintaxe:"

#. type: Source code
#: ../E/dist.txt:19
#, no-wrap
msgid "<c/>distance ( pos1, pos2 );<n/>"
msgstr "<c/>distance ( pos1, pos2 );<n/>"

#. type: Plain text
#: ../E/dist.txt:21
#, no-wrap
msgid "Calculates the distance between two positions. "
msgstr "Calcula a distância entre duas posições."

#. type: \t; header
#: ../E/dist.txt:23 ../E/dist2d.txt:7
#, no-wrap
msgid "pos1, pos2: <code><a cbot|point>point</a></code>"
msgstr "pos1, pos2: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: ../E/dist.txt:24 ../E/dist2d.txt:8
#, no-wrap
msgid "Coordinates of the two positions. "
msgstr "Coordenadas das duas posições."

#. type: Plain text
#: ../E/dist.txt:27 ../E/dist2d.txt:11
#, no-wrap
msgid "Distance between the two positions."
msgstr "A distância entre as duas posições."

#. type: \b; header
#: ../E/dist2d.txt:1
#, no-wrap
msgid "Instruction <code>distance2d</code>"
msgstr "Instrução <code>distance2d</code>"

#. type: Source code
#: ../E/dist2d.txt:3
#, no-wrap
msgid "<c/>distance2d ( pos1, pos2 );<n/>"
msgstr "<c/>distance2d ( pos1, pos2 );<n/>"

#. type: Plain text
#: ../E/dist2d.txt:5
#, no-wrap
msgid "Calculates the distance between two positions (ignores the z coordinate)."
msgstr "Calcula a distância entre duas posições (ignora a coordenada z)"

#. type: \b; header
#: ../E/do.txt:1
#, no-wrap
msgid "Instruction <code>do - while</code>"
msgstr "Instrução <code>do - while</code>"

#. type: Source code
#: ../E/do.txt:3
#, no-wrap
msgid ""
"<code>do\n"
"{\n"
"\t</code>Instructions ...<c/>\n"
"}\n"
"while ( condition );"
msgstr ""
"<code>do\n"
"{\n"
"\t</code>instruções...<c/>\n"
"}\n"
"while ( condição );"

#. type: Plain text
#: ../E/do.txt:9
#, no-wrap
msgid ""
"This instruction allows you to perform several times the instructions inside the <a cbot|bloc>block</a>. The instructions are executed at least once, because the condition is tested only afterwards.\n"
"Be careful not to confuse the instruction <c/>do { } while ( );<n/> with the instruction <code><a cbot|while>while</a> ( ) { }</code>; the latter tests the condition before the instructions in the block are executed. "
msgstr ""
"Esta instrução permite que você execute diversas vezes as instruções dentro do <a cbot|bloc>bloco</a>. As instruções são executadas pelo menos uma vez, porque a condição só é testada depois.\n"
"Cuidado para não confundir a instrução <c/>do { } while ( );<n/> com a instrução <code><a cbot|while>while</a> ( ) { }</code>; a última testaa condição antes das instruções no bloco serem executadas."

#. type: \t; header
#: ../E/do.txt:12 ../E/for.txt:13 ../E/while.txt:30
#, no-wrap
msgid "<code>condition</code>"
msgstr "<code>condição</code>"

#. type: Plain text
#: ../E/do.txt:13 ../E/while.txt:31
#, no-wrap
msgid "The instructions in the block are performed over and over again, as long as the <a cbot|cond>condition</a> is true. "
msgstr "As instruções no bloco são executadas de novo e de novo, enquanto a  <a cbot|cond>condição</a> é verdadeira. "

#. type: Plain text
#: ../E/do.txt:15 ../E/while.txt:33
#, no-wrap
msgid "Here is an example :"
msgstr "Veja aqui um exemplo:"

#. type: Source code
#: ../E/do.txt:16
#, no-wrap
msgid ""
"<c/>do\n"
"{\n"
"\tp = radar(TitaniumOre);\n"
"}\n"
"while ( p == null );"
msgstr ""
"<c/>do\n"
"{\n"
"\tp = radar(TitaniumOre);\n"
"}\n"
"while ( p == null );"

#. type: \t; header
#: ../E/do.txt:22 ../E/float.txt:11 ../E/for.txt:33 ../E/if.txt:36 ../E/int.txt:10 ../E/switch.txt:67 ../E/while.txt:41
#, no-wrap
msgid "Attention"
msgstr "Atenção"

#. type: Plain text
#: ../E/do.txt:23
#, no-wrap
msgid "Always put a <a cbot|term>semicolon</a> at the end of the line <code>while ( )</code>."
msgstr "Sempre coloque um <a cbot|term>ponto e vírgula</a> no fim da linha <code>while ( )</code>."

#. type: Plain text
#: ../E/do.txt:25
#, no-wrap
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>do { }</code>."
msgstr "As instruções <code><a cbot|break>break</a></code> e <code><a cbot|continue>continue</a></code> podem ser úteis dentro de um bloco seguindo a instrução <code>do { }</code>."

#. type: \b; header
#: ../E/drop.txt:1
#, no-wrap
msgid "Instruction <code>drop</code>"
msgstr "Instrução <code>drop</code>"

#. type: Plain text
#: ../E/drop.txt:2
#, no-wrap
msgid "The instruction <c/>drop();<n/> instructs the bot to drop whatever the operating arm is carrying on the ground, on the platform of a building or on the power cell location of a bot."
msgstr "A instrução <c/>drop();<n/>  instrui o robô a largar qualquer coisa que o braço operacional esteja carregando no chão, na plataforma de um edifício ou no local da célula de energia de um robô."

#. type: Plain text
#: ../E/drop.txt:5
#, no-wrap
msgid "The instruction <c/>drop();<n/> written in this form drops the object in front of the bot. Here is a short program that grabs an object in front of the bot and drops it 5 meters further:"
msgstr "A instrução <c/>drop();<n/> escrita desta forma larga o objeto na frente do robô. Aqui está um pequeno programa que pega um objeto na frente do robô e o larga 5 metros adiante."

#. type: Source code
#: ../E/drop.txt:7
#, no-wrap
msgid ""
"\t<a cbot|grab>grab</a>();\n"
"\t<a cbot|move>move</a>(5);\n"
"\tdrop();"
msgstr ""
"\t<a cbot|grab>grab</a>();\n"
"\t<a cbot|move>move</a>(5);\n"
"\tdrop();"

#. type: Source code
#: ../E/drop.txt:13
#, no-wrap
msgid "<c/>drop ( oper );<n/>"
msgstr "<c/>drop ( local );<n/>"

#. type: Plain text
#: ../E/drop.txt:15
#, no-wrap
msgid "This instruction appeals to the operating arm of a <a object|botgr>grabber bot</a>, in order to drop what it is holding."
msgstr "Esta instrução apela para o braço operacional de um <a object|botgr>robô agarrador </a>, a fim de largar o que ele estiver segurando."

#. type: \t; header
#: ../E/drop.txt:17 ../E/grab.txt:17
#, no-wrap
msgid "oper: <code><a cbot|int>int</a></code> (default value<code>InFront</code>)"
msgstr "local: <code><a cbot|int>int</a></code> (valor padrão: <code>InFront</code>)"

#. type: Plain text
#: ../E/drop.txt:18
#, no-wrap
msgid ""
"Oper indicates where the robot should drop the object. If no indication is given, the object is dropped in front of the bot. \n"
"<code>InFront   </code>  Drops in front (default value).\n"
"<code>Behind    </code>  Drops behind.\n"
"<code>EnergyCell</code>  Drops on the bot's own power cell location."
msgstr ""
"Local indica onde o robô deve largar o objeto. Se nenhuma indicação é dada, o objeto é largado em frente ao robô. \n"
"<code>InFront   </code>  Larga em frente (valor padrão).\n"
"<code>Behind    </code>  Larga atrás.\n"
"<code>EnergyCell</code>  Larga no local da célula de energia do robô."

#. type: Plain text
#: ../E/drop.txt:24
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>drop();<n/>.\n"
"<code>== 0 </code>object was dropped\n"
"<code>!= 0 </code>error, no object was dropped"
msgstr ""
"Normalmente um erro para o programa. Você pode prevenir o programa de parar em erros utilizando a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero se um erro ocorreu é retornado por <c/>drop();<n/>.\n"
"<code>== 0 </code>objeto foi largado com sucesso\n"
"<code>!= 0 </code>erro, nenhum objeto foi largado"

#. type: \b; header
#: ../E/eof.txt:1
#, no-wrap
msgid "Instruction <code>eof</code>"
msgstr "Instrução <code>eof</code>"

#. type: Plain text
#: ../E/eof.txt:2
#, no-wrap
msgid "Test the end of file condition of an open file. This is a method of the <code><a cbot|file>file</a></code> class; therefore you cannot write  <code>eof()</code> but only <code>handle.eof()</code>:"
msgstr "Testa a condição de fim do arquivo em um arquivo aberto. É um método da classe <code><a cbot|file>file</a></code>; sendo assim, você não pode escrever <code>eof()</code> mas somente <code>handle.eof()</code>:"

#. type: Source code
#: ../E/eof.txt:4
#, no-wrap
msgid "\tif ( handle.eof() )  "
msgstr "\tif ( handle.eof() )"

#. type: Plain text
#: ../E/eof.txt:6 ../E/readln.txt:11
#, no-wrap
msgid "Example:"
msgstr "Exemplo:"

#. type: Source code
#: ../E/eof.txt:8
#, no-wrap
msgid ""
"\twhile ( not handle.eof() )\n"
"\t{\n"
"\t\ts = handle.readln();\n"
"\t}"
msgstr ""
"\twhile ( not handle.eof() )\n"
"\t{\n"
"\t\ts = handle.readln();\n"
"\t}"

#. type: Plain text
#: ../E/eof.txt:14
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> and <code><a cbot|writeln>writeln</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> e <code><a cbot|writeln>writeln</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/errmode.txt:1
#, no-wrap
msgid "Instruction <code>errmode</code>"
msgstr "Instrução <code>errmode</code>"

#. type: Plain text
#: ../E/errmode.txt:2
#, no-wrap
msgid "The <c/>errmode();<n/> instruction allows you to chose if the program should stop when an error occurs in one of the following instructions: <code><a cbot|goto>goto</a></code>, <code><a cbot|move>move</a></code>, <code><a cbot|grab>grab</a></code>, <code><a cbot|drop>drop</a></code>, etc."
msgstr "A instrução <c/>errmode();<n/> permite a você escolher se o programa deverá parar quando um erro ocorrer em uma das seguintes instruções: <code><a cbot|goto>goto</a></code>, <code><a cbot|move>move</a></code>, <code><a cbot|grab>grab</a></code>, <code><a cbot|drop>drop</a></code>, etc."

#. type: Source code
#: ../E/errmode.txt:6
#, no-wrap
msgid "<c/>errmode ( mode );<n/>"
msgstr "<c/>errmode ( modo );<n/>"

#. type: Plain text
#: ../E/errmode.txt:8
#, no-wrap
msgid "Normally the program is stopped when an error occurs. If you use the instruction <c/>errmode(0);<n/> at the beginning of the program, the instructions listed above return a value different from zero if the instruction could not be performed."
msgstr "Normalmente o programa para quando um erro ocorre. Se você usar a instrução <c/>errmode(0);<n/> no começo do programa, as instruções listadas anteriormente retornarão um valor diferente de zero se  a instrução não puder ser executada."

#. type: \t; header
#: ../E/errmode.txt:10
#, no-wrap
msgid "mode: <code><a cbot|float>float</a></code> (<code>1</code> per default)"
msgstr "modo: <code><a cbot|float>float</a></code> (valor padrão: <code>1</code>)"

#. type: Plain text
#: ../E/errmode.txt:11
#, no-wrap
msgid ""
"Error treatment mode.\n"
"<code>0</code> -> continues program execution and returns a non zero value\n"
"<code>1</code> -> stops the program (default behavior)"
msgstr ""
"Modo de tratamento de erros.\n"
"<code>0</code> -> continua a execução do programa e retorna um valor diferente de zero\n"
"<code>1</code> -> para o programa (comportamento padrão)"

#. type: Plain text
#: ../E/errmode.txt:15
#, no-wrap
msgid "Example 1:"
msgstr "Exemplo 1:"

#. type: Source code
#: ../E/errmode.txt:16
#, no-wrap
msgid ""
"<c/>errmode(0);\n"
"while ( goto(pos) != 0 )\n"
"{\n"
"\twait(2);\n"
"}"
msgstr ""
"<c/>errmode(0);\n"
"while ( goto(pos) != 0 )\n"
"{\n"
"\twait(2);\n"
"}"

#. type: Plain text
#: ../E/errmode.txt:22
#, no-wrap
msgid "Example 2:"
msgstr "Exemplo 2:"

#. type: Source code
#: ../E/errmode.txt:23
#, no-wrap
msgid ""
"<c/>errmode(0);\n"
"int err;\n"
"err = goto(pos);\n"
"if ( err != 0 )\n"
"{\n"
"\t<n/>goto did not perform correctly ...<code>\n"
"\t</code>take some appropriate action ...<c/>\n"
"}"
msgstr ""
"<c/>errmode(0);\n"
"int erro;\n"
"erro = goto(pos);\n"
"if ( erro != 0 )\n"
"{\n"
"\t<n/>goto não executou corretamente...<code>\n"
"\t</code>tome uma ação apropriada...<c/>\n"
"}"

#. type: \b; header
#: ../E/expr.txt:1
#, no-wrap
msgid "Expressions"
msgstr "Expressões"

#. type: Plain text
#: ../E/expr.txt:86
#, no-wrap
msgid "is equivalent to"
msgstr "é equivalente a"

#. type: Plain text
#: ../E/expr.txt:90
#, no-wrap
msgid ""
"<code>+=</code>  addition\n"
"<code>-=</code>  subtraction\n"
"<code>*=</code>  multiplication\n"
"<code>/=</code>  division\n"
"<code>%=</code>  remainder of the division (only for the type <code><a cbot|int>int</a></code>)"
msgstr ""
"<code>+=</code>  adição\n"
"<code>-=</code>  subtração\n"
"<code>*=</code>  multiplicação\n"
"<code>/=</code>  divisão\n"
"<code>%=</code>  resto da divisão (somente para o tipo <code><a cbot|int>int</a></code>)"

#. type: Plain text
#: ../E/expr.txt:178
#, no-wrap
msgid "The operators <code>++</code> and <code>--</code> allow you to increment (++) or to decrement (--) a variable in very compact and efficient manner."
msgstr "Os operadores <code>++</code> e <code>--</code> permitem a você incrementar (++)ou decrementar (--) uma variável de uma maneira bem compacta e eficiente."

#. type: \b; header
#: ../E/extern.txt:1
#, no-wrap
msgid "Instruction <code>extern</code>"
msgstr "Instrução <code>extern</code>"

#. type: Plain text
#: ../E/extern.txt:2
#, no-wrap
msgid "The <code>extern</code> instruction  determines the <a cbot|function>function</a> that acts as main program of a robot. The name of the function declared with <code>extern</code> will apear in the program list in the lower left corner of the screen."
msgstr "A instrução <code>extern</code> determina a <a cbot|function>função</a> que age como o programa principal de um robô. O nome da função declarada com <code>extern</code> irá aparecer na lista de programas nocanto inferior esquerdo da tela."

#. type: Source code
#: ../E/extern.txt:4
#, no-wrap
msgid ""
"extern void object::MowDown( )\n"
"{\n"
"\twhile ( true )\n"
"\t{\n"
"\t\tfire(1);\n"
"\t\tturn(10);\n"
"\t}\n"
"}"
msgstr ""
"extern void object::Massacre( )\n"
"{\n"
"\twhile ( true )\n"
"\t{\n"
"\t\tfire(1);\n"
"\t\tturn(10);\n"
"\t}\n"
"}"

#. type: Plain text
#: ../E/extern.txt:13
#, no-wrap
msgid "If the program contains other functions, only the main function must be preceded by <code>extern</code>."
msgstr "Se o programa conter outras funções, somente a função principal deve ser precedidade por <code>extern</code>."

#. type: Source code
#: ../E/extern.txt:15
#, no-wrap
msgid ""
"extern void object::Square( )\n"
"{\n"
"\tfor ( int i=0 ; i<4 ; i++ )\n"
"\t{\n"
"\t\tLine(10);\n"
"\t}\n"
"}\n"
"\n"
"void object::Line(float dist)\n"
"{\n"
"\tmove(dist);\n"
"\tturn(90);\n"
"}"
msgstr ""
"extern void object::Quadrado( )\n"
"{\n"
"\tfor ( int i=0 ; i<4 ; i++ )\n"
"\t{\n"
"\t\tLinha(10);\n"
"\t}\n"
"}\n"
"\n"
"void object::Linha(float distancia)\n"
"{\n"
"\tmove(distancia);\n"
"\tturn(90);\n"
"}"

#. type: \b; header
#: ../E/false.txt:1
#, no-wrap
msgid "Type <code>false</code>"
msgstr "Tipo <code>false</code>"

#. type: Plain text
#: ../E/false.txt:2
#, no-wrap
msgid "This value means that a condition is not true; it is one of the two values that a <a cbot|bool>boolean</a> <a cbot|var>variable</a> can take."
msgstr " Este valor significa que uma condição não é verdadeira; é um dos dois valores que uma <a cbot|var>variável</a> <a cbot|bool>boleana</a> pode assumir."

#. type: \b; header
#: ../E/file.txt:1
#, no-wrap
msgid "Type <code>file</code>"
msgstr "Tipo <code>file</code>"

#. type: Plain text
#: ../E/file.txt:2
#, no-wrap
msgid "This type is used for accessing files in the files/ folder."
msgstr "Este tipo é usado para acessar arquivos na pasta files/."

#. type: Source code
#: ../E/file.txt:4
#, no-wrap
msgid "\tfile handle();"
msgstr "\tfile handle();"

#. type: Plain text
#: ../E/file.txt:6
#, no-wrap
msgid "Use the syntax above for declaring a file handle. You must use () to create an instance of the <code>file</code> class. Without the () the handle would have the value <code><a cbot|null>null</a></code>."
msgstr "Use a sintaxe acima para declarar um manipulador de arquivo. Você deve usar () para criar uma instância da classe <code>file</code>. Sem os () o manipulador terá o valor <code><a cbot|null>null</a></code>."

#. type: Plain text
#: ../E/file.txt:8
#, no-wrap
msgid "Files can only be created and opened in the files/ folder which is located in the folder inside Colobot save directory. You cannot not create or open files elsewhere than in the files/ folder."
msgstr "Arquivos só podem ser criados e abertos na pasta /files a qual está localizada em uma pasta dentro do diretório de salvamentos do Colobot. Você não pode criar ou abrir arquivos em outro lugar diferente da pasta files/."

#. type: Plain text
#: ../E/file.txt:11
#, no-wrap
msgid "<code>file</code> is actually not a simple type but a class. <code>open</code>, <code>close</code>, <code>writeln</code> etc. are methods of the <code>file</code> class. This is the reason why we always write <code>handle.method()</code>:"
msgstr "<code>file</code> é na verdade não um simples tipo, mas uma classe. <code>open</code>, <code>close</code>, <code>writeln</code> etc. são métodos da classe <code>file</code>. É por isso que sempre escrevemos <code>handle.metodo()</code>:"

#. type: Source code
#: ../E/file.txt:13
#, no-wrap
msgid ""
"\thandle.open(\"test.txt\", \"w\");\n"
"\thandle.close();"
msgstr ""
"\thandle.open(\"arquivo.txt\", \"w\");\n"
"\thandle.close();"

#. type: Plain text
#: ../E/file.txt:17
#, no-wrap
msgid ""
"<code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> e <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/fire.txt:1
#, no-wrap
msgid "Instruction <code>fire</code>"
msgstr "Instrução <code>fire</code>"

#. type: Plain text
#: ../E/fire.txt:2
#, no-wrap
msgid "The instruction <c/>fire();<n/> fires the bot's onboard cannon."
msgstr "A instrução <c/>fire();<n/> atira o canhão a bordo do robô."

#. type: Plain text
#: ../E/fire.txt:5
#, no-wrap
msgid "Generally this instruction is used to shoot one-second bursts:"
msgstr "Geralmente a instrução é utilizada para atirar rajadas de um segundo."

#. type: Source code
#: ../E/fire.txt:7
#, no-wrap
msgid "\tfire(1);"
msgstr "\tfire(1);"

#. type: Source code
#: ../E/fire.txt:11
#, no-wrap
msgid "<c/>fire ( time );<n/>"
msgstr "<c/>fire ( tempo );<n/>"

#. type: Plain text
#: ../E/fire.txt:13
#, no-wrap
msgid "Fires the gun, with a burst that lasts a certain time. The longer the burst, the more energy it needs. This instruction can be used with the following bot types: "
msgstr "Atira com a arma, com uma rajada que dura um certo tempo. Quanto mais longa a rajada, mais energia ela precisa. Esta instrução pode ser utilizada com os seguintes tipos de robôs:"

#. type: Plain text
#: ../E/fire.txt:20
#, no-wrap
msgid "In order to move the gun upward or downward, use the instruction <code><a cbot|aim>aim</a></code>."
msgstr "A fim de mover a arma para cima ou para baixo, use a instrução <code><a cbot|aim>aim</a></code>."

#. type: \t; header
#: ../E/fire.txt:22 ../E/wait.txt:15
#, no-wrap
msgid "time: <code><a cbot|float>float</a></code>"
msgstr "tempo: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/fire.txt:23
#, no-wrap
msgid "Duration of the burst. Generally, the value given is 1. Shorter bursts can also be performed in order to spare time and energy."
msgstr "Duração da rajada. Normalmente, o valor dado é 1. Rajadas curtas também podem ser realizadas a fim de economizar tempo e energia."

#. type: Plain text
#: ../E/fire.txt:26
#, no-wrap
msgid ""
"Zero if OK, or a value different from zero if an error occurred.\n"
"<code>== 0 </code>the cannon has been fired\n"
"<code>!= 0 </code>error, the cannon could not be fired"
msgstr ""
"Zero se OK, ou um valor diferente de zero se um erro ocorreu.\n"
"<code>== 0 </code>o canhão atirou\n"
"<code>!= 0 </code>erro, o canhão não pôde atirar"

#. type: \b; header
#: ../E/flatgrnd.txt:1
#, no-wrap
msgid "Instruction <code>flatground</code>"
msgstr "Instrução <code>flatground</code>"

#. type: Source code
#: ../E/flatgrnd.txt:3
#, no-wrap
msgid "<c/>flatground ( center, rmax );<n/>"
msgstr "<c/>flatground ( centro, raioMaximo );<n/>"

#. type: Plain text
#: ../E/flatgrnd.txt:5
#, no-wrap
msgid "Calculates the maximal radius of a flat zone on which a building ca be built."
msgstr "Calcula o raio máximo de um zona plana na qual um edifício pode ser construído."

#. type: \t; header
#: ../E/flatgrnd.txt:7 ../E/flatspace.txt:7
#, no-wrap
msgid "center: <code><a cbot|point>point</a></code>"
msgstr "centro: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: ../E/flatgrnd.txt:8
#, no-wrap
msgid "Center of the circlular zone."
msgstr "Centro da zona circular."

#. type: \t; header
#: ../E/flatgrnd.txt:10
#, no-wrap
msgid "rmax: <code><a cbot|float>float</a></code>"
msgstr "raioMaximo: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/flatgrnd.txt:11
#, no-wrap
msgid "Maximal radius."
msgstr "Raio máximo."

#. type: Plain text
#: ../E/flatgrnd.txt:14
#, no-wrap
msgid "Radius of the flat zone (always between 0 and rmax)."
msgstr "Raio da zona plana (sempre entre 0 e raioMaximo)"

#. type: \b; header
#: ../E/float.txt:1
#, no-wrap
msgid "Type <code>float</code>"
msgstr "Tipo <code>float</code>"

#. type: Plain text
#: ../E/float.txt:2
#, no-wrap
msgid "Use this type for most variables that contains numbers. Variables of this type can contain positive and negative numbers, whole or real numbers, for example: "
msgstr "Use este tipo para a maioria das variáveis que contém números. Variáveis deste tipo podem conter números positivos e negativos, inteiros ou reais, por exemplo:"

#. type: Source code
#: ../E/float.txt:4
#, no-wrap
msgid ""
"\t12.9\n"
"\t1.125\n"
"\t0.002\n"
"\t-4.1"
msgstr ""
"\t12.9\n"
"\t1.125\n"
"\t0.002\n"
"\t-4.1"

#. type: Plain text
#: ../E/float.txt:9
#, no-wrap
msgid "If you need only whole numbers (f. ex. 12 or -5000), you should rather use the type <code><a cbot|int>int</a></code>."
msgstr "Se você precisar somente de números inteiros (por exemplo: 12 ou -5000), você deveria usar o tipo <code><a cbot|int>int</a></code>."

#. type: Plain text
#: ../E/float.txt:12
#, no-wrap
msgid "Do not insert space or colon characters into a number. To separate the whole part from the fractional part, use a dot. "
msgstr "Não insira espaços ou vírgulas em um número. Para separar a parte inteira da parte fracionada, use um ponto."

#. type: Source code
#: ../E/float.txt:14
#, no-wrap
msgid ""
"   Write       and not\n"
"   12.56       12 . 56\n"
"  -54.34       -54,34\n"
"12895.69    12,895.69"
msgstr ""
"  Correto     Errado\n"
"   12.56       12 . 56\n"
"  -54.34       -54,34\n"
"12895.69    12,895.69"

#. type: Plain text
#: ../E/float.txt:20
#, no-wrap
msgid ""
"Floating point numbers are represented in Colobot with 32 bits.\n"
"The highest value that can be represented is 3.4E+38.\n"
"The smallest value that can be represented is 3.4E-38."
msgstr ""
"Números de ponto flutuantes são representados em Colobot com 32 bits.\n"
"O maior valor que pode ser representado é 3.4E+38.\n"
"O menor valor que pode ser representado é 3.4E-38."

#. type: \b; header
#: ../E/for.txt:1
#, no-wrap
msgid "Instruction <code>for</code>"
msgstr "Instrução <code>for</code>"

#. type: Source code
#: ../E/for.txt:3
#, no-wrap
msgid ""
"<c/>for ( before ; condition ; end )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"}"
msgstr ""
"<c/>for ( antes ; condição ; fim )\n"
"{\n"
"\t<n/>Instruções...<c/>\n"
"}"

#. type: Plain text
#: ../E/for.txt:8
#, no-wrap
msgid "This instruction allows you to execute a certain number of times the instructions contained in the <a cbot|bloc>block</a>."
msgstr "Esta instrução permite a você executar um certo número de vezes as instruções dentro de um <a cbot|bloc>bloco</a>."

#. type: \t; header
#: ../E/for.txt:10
#, no-wrap
msgid "<code>before</code>"
msgstr "<code>antes</code>"

#. type: Plain text
#: ../E/for.txt:14
#, no-wrap
msgid "This <a cbot|cond>condition</a> determines if another instance of the loop must be executed. It is tested before every instance of the loop. "
msgstr "Esta <a cbot|cond>condição</a> determina se outra instância do laço deve ser executada. Ela é testada antes de cada instância do laço. "

#. type: \t; header
#: ../E/for.txt:16
#, no-wrap
msgid "<code>end</code>"
msgstr "<code>fim</code>"

#. type: Source code
#: ../E/for.txt:21
#, no-wrap
msgid ""
"{\n"
"\tmessage(i) ;\n"
"}"
msgstr ""
"{\n"
"\tmessage(i) ;\n"
"}"

#. type: Plain text
#: ../E/for.txt:25
#, no-wrap
msgid "The following example is strictly equivalent to a <code>for</code>-loop, but it uses the instruction <code><a cbot|while>while</a></code>:"
msgstr "O exemplo seguinte é estritamente equivalente a um laço <code>for</code>, porém ele usa a instrução <code><a cbot|while>while</a></code>:"

#. type: Source code
#: ../E/for.txt:26
#, no-wrap
msgid ""
"<c/>before;\n"
"while ( condition )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"\tend;\n"
"}"
msgstr ""
"<c/>antes;\n"
"while ( condição )\n"
"{\n"
"\t<n/>Instruções...<c/>\n"
"\tfim;\n"
"}"

#. type: Plain text
#: ../E/for.txt:34
#, no-wrap
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>for ( )</code>."
msgstr "Não coloque um <a cbot|term>ponto e vírgula</a> no fim da linha <code>for ( )</code>."

#. type: Plain text
#: ../E/for.txt:36
#, no-wrap
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>for </code>."
msgstr "As instruções <code><a cbot|break>break</a></code> e <code><a cbot|continue>continue</a></code> podem ser úteis em um bloco da da instrução <code>for </code>."

#. type: \b; header
#: ../E/function.txt:1
#, no-wrap
msgid "Functions"
msgstr "Funções"

#. type: Plain text
#: ../E/function.txt:118
#, no-wrap
msgid "You can also declare a function <a cbot|public>public</a> so it can be used by other bots."
msgstr "Você também pode declarar uma função <a cbot|public>public</a>, desta forma ela poderá ser usada por outros robôs."

#. type: \b; header
#: ../E/goto.txt:1
#, no-wrap
msgid "Instruction <code>goto</code>"
msgstr "Instrução <code>goto</code>"

#. type: Plain text
#: ../E/goto.txt:2
#, no-wrap
msgid "The instruction <c/>goto();<n/> instructs the bot to reach a given position."
msgstr "A instrução <c/>goto();<n/> instrui o robô a alcançar uma determinada posição."

#. type: Plain text
#: ../E/goto.txt:5
#, no-wrap
msgid "The most current use consists in moving the bot to an object located with the instruction <c/><a cbot|radar>radar</a>();<n/>. If the information returned by the <c/><a cbot|radar>radar</a>();<n/> has been stored in a certain variable, write the name of the variable followed by <code>.position</code> in order to get the position of the object. Here is an example of a program that looks for a <a object|titan>titanium cube</a>, goes to the position and grabs it:"
msgstr "O uso mais comum consiste em mover o robô para um objeto localizado com a instrução <c/><a cbot|radar>radar</a>();<n/>. Se a informação retornada pelo <c/><a cbot|radar>radar</a>();<n/> foi armazenada em uma certa variável, escreva o nome da variável seguida por <code>.position</code> para obter a posição do objeto. Aqui está um exemplo de um programa que procura por um <a object|titan>cubo de titânio</a>, vai para a sua posição e o pega."

#. type: Source code
#: ../E/goto.txt:7
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(Titanium);\n"
"\tgoto(item.position);\n"
"\t<a cbot|grab>grab</a>();"
msgstr ""
"\tobject item;\n"
"\titem = <a cbot|radar>radar</a>(Titanium);\n"
"\tgoto(item.position);\n"
"\t<a cbot|grab>grab</a>();"

#. type: Source code
#: ../E/goto.txt:13
#, no-wrap
msgid "<c/>goto ( position, altitude, goal, crash );<n/>"
msgstr "<c/>goto ( posição, altitude, alvo, colisão );<n/>"

#. type: Plain text
#: ../E/goto.txt:15
#, no-wrap
msgid "Tells the robot to go to the given position, avoiding all the obstacles if this is possible. "
msgstr "Diz ao robô para ir a uma posição dada, evitando todos os obstáculos se possível."

#. type: Plain text
#: ../E/goto.txt:18
#, no-wrap
msgid "Coordinates of the goal position."
msgstr "Coordenadas da posição alvo."

#. type: \t; header
#: ../E/goto.txt:20
#, no-wrap
msgid "altitude: <code><a cbot|float>float</a></code>"
msgstr "altitude: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/goto.txt:21
#, no-wrap
msgid "Flight altitude for <a object|botgj>winged bots</a>. The altitude is useful only for <a object|botgj>winged bots</a>. From the initial altitude, the bot climbs higher until it reaches the specified hight. When arriving close to destination, it goes down to touch the ground at the given position. If no value is given, an altitude of 10 meters is the default value. On very short moves, even winged bot stay on the ground. For all bot except winged bots, this parameter is ignored. "
msgstr "Altitude de vôo para <a object|botgj>robôs alados</a> A altitude é útil somente para <a object|botgj>robôs alados</a>. Da altitude inicial, o robô sobe até que atinga a altura especificada. Quando chegar perto do destino, ele irá descer até tocar o chão na posição alvo. Se nenhum valor for informado, uma altitude de 10 metros será utilizada. Em movimentos muito pequenos, até robôs alados permanecerão no chão. Para todos os robôs, exceto robôs alados, este parâmetro é ignorado."

#. type: \t; header
#: ../E/goto.txt:23
#, no-wrap
msgid "goal: <code><a cbot|int>int</a></code> (default value <code>0</code>)"
msgstr "alvo: <code><a cbot|int>int</a></code> (valor padrão: <code>0</code>)"

#. type: Plain text
#: ../E/goto.txt:24
#, no-wrap
msgid ""
"This parameter tells the bot how it must reach the goal: \n"
"<code>0</code>  stops exactly at the goal position\n"
"<code>1</code>  goes close to the goal position, without stopping.\n"
"If no value is given, <code>0</code> (precision) is the default value."
msgstr ""
"Este parâmetro diz ao robô como ele deve atingir o alvo: \n"
"<code>0</code>  para exatamente na posição alvo\n"
"<code>1</code>  vai para perto da posição alvo, sem parar.\n"
"Se nenhum valor for dado, <code>0</code> (precisão) é o valor padrão"

#. type: Plain text
#: ../E/goto.txt:30
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>goto()</code>.\n"
"<code>== 0 </code>Goal position reached\n"
"<code>!= 0 </code>Goal position impossible to reach"
msgstr ""
"Normalmente um erro para o programa. Você pode prevenir o programa de parar nos erros utilizando a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>goto()</code> se um erro ocorrer.\n"
"<code>== 0 </code>Posição alvo atingida\n"
"<code>!= 0 </code>Posição alvo impossível de atingir"

#. type: \b; header
#: ../E/grab.txt:1
#, no-wrap
msgid "Instruction <code>grab</code>"
msgstr "Instrução <code>grab</code>"

#. type: Plain text
#: ../E/grab.txt:2
#, no-wrap
msgid "The instruction <c/>grab();<n/> instructs the bot to use the operating arm to grab an object located on the ground, on the platform of a building or on the power cell location of a bot."
msgstr "A instrução <c/>grab();<n/> instrui o robô a usar o braço operacional para  pegar um objeto que está no chão, em uma plataforma de um edifício ou em  um local de célula de energia de um robô."

#. type: Plain text
#: ../E/grab.txt:5
#, no-wrap
msgid "The instruction <c/>grab();<n/> written in this form grabs the object located in front of the bot. Here is a short program that grabs an object in front of the bot and drops it 5 meters further:"
msgstr "A instrução <c/>grab();<n/>  quando escrita desta forma pega o objeto que  está na frente do robô. Aqui está um pequeno programa que pega um objeto  na frente de um robô e o larga 5 metros adiante:"

#. type: Source code
#: ../E/grab.txt:7
#, no-wrap
msgid ""
"\tgrab();\n"
"\t<a cbot|move>move</a>(5);\n"
"\t<a cbot|drop>drop</a>();"
msgstr ""
"\tgrab();\n"
"\t<a cbot|move>move</a>(5);\n"
"\t<a cbot|drop>drop</a>();"

#. type: Source code
#: ../E/grab.txt:13
#, no-wrap
msgid "<c/>grab ( oper );<n/>"
msgstr "<c/>grab ( local );<n/>"

#. type: Plain text
#: ../E/grab.txt:15
#, no-wrap
msgid "This instruction appeals to the operating arm of a <a object|botgr>grabber bot</a>, in order to grab the closest object."
msgstr "A instrução apela para o braço operacional de um <a object|botgr>robô agarrador</a>, a fim de pegar o objeto mais próximo."

#. type: Plain text
#: ../E/grab.txt:18
#, no-wrap
msgid ""
"Oper indicates where the bot should look for an object to grab. If no indication is given, the object is picked up in front of the bot.\n"
"<code>InFront   </code>  Grabs in front (default value).\n"
"<code>Behind    </code>  Grabs behind.\n"
"<code>EnergyCell</code>  Grabs the bot's own power cell."
msgstr ""
"Local indica onde o robô deve procurar um objeto para pegar. Se nenhuma indicação é dada, o objeto a frente do robô será pego.\n"
"<code>InFront   </code>  Pega na frente (valor padrão).\n"
"<code>Behind    </code>  Pega atrás.\n"
"<code>EnergyCell</code>  Pega a célula de energia do robô."

#. type: Plain text
#: ../E/grab.txt:24
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>grab();<n/>.\n"
"<code>== 0 </code>an object was grabbed\n"
"<code>!= 0 </code>error, no object was grabbed"
msgstr ""
"Normalmente um erro para o programa. Você pode prevenir o programa de parar utilizando a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <c/>grab();<n/> se um erro ocorrer.\n"
"<code>== 0 </code>um objeto foi pego\n"
"<code>!= 0 </code>erro, nenhum objeto foi pego"

#. type: \b; header
#: ../E/if.txt:1
#, no-wrap
msgid "Instructions <code>if</code> and <code>else</code>"
msgstr "Instruções <code>if</code> e <code>else</code>"

#. type: Plain text
#: ../E/if.txt:2
#, no-wrap
msgid "With the instruction <code>if() {}</code> you can execute a set of instructions only if a certain condition is true. Write the condition in brackets <code>()</code>, and the instructions in braces <code>{}</code>."
msgstr "Com a instrução <code>if() {}</code> você pode executar um conjunto de instruções somente se uma certa condição for verdadeira. Escreva a condição nos parênteses <code>()</code>, e as instruções nas chaves <code>{}</code>."

#. type: Plain text
#: ../E/if.txt:5
#, no-wrap
msgid "Here is a concrete example: The bot will shoot only if the target is closer than 40 meters:"
msgstr "Aqui está um exemplo concreto: o robô irá atirar somente quando o alvo estiver  mais perto que 40 metros:"

#. type: Source code
#: ../E/if.txt:7
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(AlienAnt);\n"
"\tif (<a cbot|dist>distance</a>(position, item.position) < 40)\n"
"\t{\n"
"\t\tfire(1);\n"
"\t}"
msgstr ""
"\talvo = <a cbot|radar>radar</a>(AlienAnt);\n"
"\tif (<a cbot|dist>distance</a>(position, alvo.position) < 40)\n"
"\t{\n"
"\t\tfire(1);\n"
"\t}"

#. type: Plain text
#: ../E/if.txt:13
#, no-wrap
msgid "You can also test if an object exists at all. If the instruction <c/><a cbot|radar>radar</a>();<n/> does not find the requested object, it returns the value <code>null</code>. So you can test if an object does not exists with the condition  <code>(item == null)</code>, or test if it exists with  <code>(item != null)</code>. Two equal signs <code>==</code> test equality, an exclamation mark followed by an equal sign <code>!=</code> test inequality. Here is a test that will go to rechage the <a object|power>power cell</a> only if there is a <a object|station>power station</a>:"
msgstr "Você pode testar se um objeto existe. Se a instrução <c/><a cbot|radar>radar</a>();<n/> não encontra o objeto solicitado, ela retornará  o valor <code>null</code>. Então você pode testar se um objeto não existe com  a condição <code>(item == null)</code>, ou testar se ele existe com <code>(item != null)</code>.  Dois sinais de igual  <code>==</code> testam igualdade, uma exclamação seguida por um sinal de igual <code>!=</code> testam desigualdade. Aqui está um teste que irá recarregar uma <a object|power>célula de energia</a> somente se houver uma <a object|station>estação de energia</a>:"

#. type: Source code
#: ../E/if.txt:15
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(PowerStation);\n"
"\tif (item != null)\n"
"\t{\n"
"\t\t<a cbot|goto>goto</a>(item.position);\n"
"\t\t<a cbot|wait>wait</a>(5);\n"
"\t}"
msgstr ""
"\testacao = <a cbot|radar>radar</a>(PowerStation);\n"
"\tif (estacao!= null)\n"
"\t{\n"
"\t\t<a cbot|goto>goto</a>(estacao.position);\n"
"\t\t<a cbot|wait>wait</a>(5);\n"
"\t}"

#. type: Source code
#: ../E/if.txt:24
#, no-wrap
msgid ""
"<code>if ( condition )\n"
"{\n"
"\t</code>Instructions A ...<code>\n"
"}\n"
"else\n"
"{\n"
"\t</code>Instructions B ...<c/>\n"
"}"
msgstr ""
"<code>if ( condição )\n"
"{\n"
"\t</code>Instruções A ...<code>\n"
"}\n"
"else\n"
"{\n"
"\t</code>Instruções B ...<c/>\n"
"}"

#. type: Plain text
#: ../E/if.txt:33
#, no-wrap
msgid ""
"With this conditional structure you can execute a <a cbot|bloc>bloc</a> A or a <a cbot|bloc>bloc</a> B depending on a <a cbot|cond>condition</a>. If the condition is true, bloc A is executed. If the condition is false, bloc B is executed. \n"
"Part <code>else { }</code> is not compulsory. "
msgstr ""
"Com esta estrutura condicional você pode executar o <a cbot|bloc>bloco</a> A ou  o <a cbot|bloc>bloco</a> B dependendo da  <a cbot|cond>condição</a>. Se a  condição for verdadeira, o bloco A será executado. Se a condição for falsa, o bloco B será executado. \n"
"A parte <code>else { }</code> não é obrigatória."

#. type: Plain text
#: ../E/if.txt:37
#, no-wrap
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>if ( )</code>."
msgstr "Não coloque <a cbot|term>ponto e vírgula</a> no fim da linha  <code>if ( )</code>."

#. type: \b; header
#: ../E/int.txt:1
#, no-wrap
msgid "Type <code>int</code>"
msgstr "Tipo <code>int</code>"

#. type: Plain text
#: ../E/int.txt:2
#, no-wrap
msgid "Use this type for variables that contain only whole numbers, negative or positive. For example: "
msgstr "Use este tipo para variáveis que contenham somente números inteiros, negativos  ou positivos. Por exemplo:"

#. type: Source code
#: ../E/int.txt:4
#, no-wrap
msgid ""
"\t12\n"
"\t1000\n"
"\t-4"
msgstr ""
"\t12\n"
"\t1000\n"
"\t-4"

#. type: Plain text
#: ../E/int.txt:8
#, no-wrap
msgid "To represent real numbers like 12.05 or -0.005, use the type <code><a cbot|float>float</a></code>."
msgstr "Para representar números reais como 12.05 ou -0.005, use o tipo <code><a cbot|float>float</a></code>."

#. type: Plain text
#: ../E/int.txt:11
#, no-wrap
msgid "Do not put space or colon signs inside a number. "
msgstr "Não coloque espaços ou vírgulas dentro de um número."

#. type: Plain text
#: ../E/int.txt:14
#, no-wrap
msgid ""
"Numbers of the type <code>int</code> are represented with 32 bits.\n"
"The highest number that can be represented is (2^31)-1, that is 2'147'483'647.\n"
"The smallest number that can be represented is -(2^31), that is -2'147'483'648."
msgstr ""
"Números do tipo <code>int</code> são representados com 32 bits.\n"
"O valor mais alto que pode ser representado é (2^31)-1, isto é 2'147'483'647.\n"
"O valor mais baixo que pode ser representado é -(2^31), isto é -2'147'483'648."

#. type: \b; header
#: ../E/jet.txt:1
#, no-wrap
msgid "Instruction <code>jet</code>"
msgstr "Instrução <code>jet</code>"

#. type: Source code
#: ../E/jet.txt:3
#, no-wrap
msgid "<c/>jet ( power );<n/>"
msgstr "<c/>jet ( energia );<n/>"

#. type: Plain text
#: ../E/jet.txt:5
#, no-wrap
msgid "Direct control of the jet of a <a object|botgj>winged bot</a>. The jet is what makes the bot fly. Use this instruction in order to take off, climb, descend or land."
msgstr "Controla diretamento o jato de um <a object|botgj>robô alado</a>. O jato é  o que faz o robô voar. Use esta instrução para decolar, subir, descer ou pousar."

#. type: \t; header
#: ../E/jet.txt:7 ../E/produce.txt:21
#, no-wrap
msgid "power: <code><a cbot|float>float</a></code>"
msgstr "energia: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/jet.txt:8
#, no-wrap
msgid "Power of the jet, ranges between <code>-1</code> and <code>+1</code>. <c/>jet(1);<n/> instructs the bot to climb as fast as possible, <c/>jet(-1);<n/> descends as fast as possible, <c/>jet(0);<n/> stabilizes the altitude. In order to get slower altitude changes, use intermediate values, for example <c/>jet(0.3);<n/>."
msgstr "Energia do jato, valores entre <code>-1</code> e <code>+1</code>. <c/>jet(1);<n/> instrui o robô a subir o mais rápido possível, <c/>jet(-1);<n/> desce o mais rápido possível, <c/>jet(0);<n/> estabiliza a altitude. Para descer mais devagar, use valores intermediários, por exemplo: <c/>jet(0.3);<n/>."

#. type: \t; header
#: ../E/jet.txt:11 ../E/message.txt:21 ../E/motor.txt:35 ../E/shield.txt:15 ../E/wait.txt:18
#, no-wrap
msgid "Return value: <code><a cbot|void>void</a></code>"
msgstr "Valor de retorno: <code><a cbot|void>void</a></code>"

#. type: Plain text
#: ../E/jet.txt:12 ../E/message.txt:22 ../E/motor.txt:36 ../E/shield.txt:16 ../E/wait.txt:19
#, no-wrap
msgid "None."
msgstr "Nenhum."

#. type: \b; header
#: ../E/message.txt:1
#, no-wrap
msgid "Instruction <code>message</code>"
msgstr "Instrução <code>message</code>"

#. type: Source code
#: ../E/message.txt:3
#, no-wrap
msgid "<c/>message ( text, type );<n/>"
msgstr "<c/>message ( texto, tipo );<n/>"

#. type: Plain text
#: ../E/message.txt:5
#, no-wrap
msgid "Prints a message on top of the screen. After a few seconds, the message disappears automatically. "
msgstr "Imprime uma mensagem no topo da tela. Depois de alguns segundos, a mensagem desaparece automaticamente."

#. type: \t; header
#: ../E/message.txt:7
#, no-wrap
msgid "text: <code><a cbot|string>string</a></code>"
msgstr "texto: <code><a cbot|string>string</a></code>"

#. type: Plain text
#: ../E/message.txt:8
#, no-wrap
msgid ""
"Text that is to be displayed. It is possible to append several texts and/or values with the operator <code>+</code>:\n"
"<c/>message(\"Not found\");<n/> \n"
"<c/>message(angle);<n/> \n"
"<c/>message(n + \" object(s) found\");<n/> \n"
"<c/>message(\"Distance = \" + dist + \" meters\");<n/> "
msgstr ""
"Texto que será exibido. É possivel acrescentar vários texto e/ou valores com o operador <code>+</code>:\n"
"<c/>message(\"Não encontrado\");<n/> \n"
"<c/>message(angulo);<n/> \n"
"<c/>message(n + \" objeto(s) encontrado(s)\");<n/> \n"
"<c/>message(\"Distância = \" + dist + \" metros\");<n/> "

#. type: \t; header
#: ../E/message.txt:14
#, no-wrap
msgid "type: <code><a cbot|int>int</a></code> (default value <code>DisplayMessage</code>)"
msgstr "tipo: <code><a cbot|int>int</a></code> (valor padrão: <code>DisplayMessage</code>)"

#. type: Plain text
#: ../E/message.txt:15
#, no-wrap
msgid "Type of the message, that determines the background color. "
msgstr "Tipo da mensagem, determina a cor de fundo."

#. type: Bullet: 'o'
#: ../E/message.txt:16
#, no-wrap
msgid "<code>DisplayMessage</code>  Standard message on yellow background."
msgstr "<code>DisplayMessage</code>  Mensagem padrão com um fundo amarelo."

#. type: Bullet: 'o'
#: ../E/message.txt:17
#, no-wrap
msgid "<code>DisplayInfo   </code>  Information on green background."
msgstr "<code>DisplayInfo   </code>  Informação com fundo verde."

#. type: Bullet: 'o'
#: ../E/message.txt:18
#, no-wrap
msgid "<code>DisplayWarning</code>  Warning on blue background."
msgstr "<code>DisplayWarning</code>  Aviso com fundo azul."

#. type: Bullet: 'o'
#: ../E/message.txt:19
#, no-wrap
msgid "<code>DisplayError  </code>  Error on red background."
msgstr "<code>DisplayError  </code>  Erro com fundo vermelho."

#. type: \b; header
#: ../E/motor.txt:1
#, no-wrap
msgid "Instruction <code>motor</code>"
msgstr "Instrução <code>motor</code>"

#. type: Plain text
#: ../E/motor.txt:2
#, no-wrap
msgid "The instruction <c/>motor( , );<n/> sets the speed for the left-hand and the right-hand motor of the bot."
msgstr "A instrução <c/>motor( , );<n/> define a velocidade dos motores esquerdo e direito do robô."

#. type: Plain text
#: ../E/motor.txt:5
#, no-wrap
msgid "The speed given to the motors will remain constant during the execution of the following instructions. Thanks to this characteristic it is possible to perform a rotation during the instruction <c/><a cbot|fire>fire</a>();<n/>. This will sweep a whole zone with only one burst. Here is an example that will sweep the zone in front of the bot:"
msgstr "A velocidade dada aos motores permanecerá constante durante a execução das próximas instruções. Devido a esta característica, é possível realizar um rotação durante a instrução  <c/><a cbot|fire>fire</a>();<n/>. Isto irá varrer toda uma zona com apenas um tiro. Aqui está um exemplo que varre uma zona na frente do robô:"

#. type: Source code
#: ../E/motor.txt:7
#, no-wrap
msgid ""
"\t<a cbot|turn>turn</a>(45);         // turns 45 degrees left\n"
"\tmotor(0.5, -0.5); // slow rotation to the right\n"
"\t<a cbot|fire>fire</a>(2);          // fire\n"
"\tmotor(0,0);       // stops the rotation"
msgstr ""
"\t<a cbot|turn>turn</a>(45);         // gira 45 graus a esquerda\n"
"\tmotor(0.5, -0.5); // desacelera a rotação a direita\n"
"\t<a cbot|fire>fire</a>(2);          // atira\n"
"\tmotor(0,0);       // para a rotação"

#. type: Plain text
#: ../E/motor.txt:12
#, no-wrap
msgid "With the left-hand motor turning half-speed forward and the right-hand motor turning half-speed backward, the bot will turn slowly on itself during the 2-second-burst."
msgstr "Com o motor esquerdo girando a meia velocidade para frente o e motor direito girando a meia velocidade para trás, o robô irá girar lentamente em sí durante o tipo de 2 segundos."

#. type: Source code
#: ../E/motor.txt:16
#, no-wrap
msgid "<c/>motor ( left, right );<n/>"
msgstr "<c/>motor ( esquerdo, direito );<n/>"

#. type: Plain text
#: ../E/motor.txt:18
#, no-wrap
msgid "Gives speed instructions to the right and left motors of the robot. The motors will keep this speed until a new motor instruction is performed, or until a <code><a cbot|move>move</a></code>, <code><a cbot|turn>turn</a></code> or <code><a cbot|goto>goto</a></code> instruction is performed."
msgstr "Dá instruções de velocidade para os motores esquerdo e direito do robô. Os motores manterão a velocidade até que uma nova instrução motor seja realizada, ou até que uma instrução <code><a cbot|move>move</a></code>, <code><a cbot|turn>turn</a></code> ou <code><a cbot|goto>goto</a></code> seja realizada."

#. type: \t; header
#: ../E/motor.txt:20
#, no-wrap
msgid "left: <code><a cbot|float>float</a></code>"
msgstr "esquerdo: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/motor.txt:21
#, no-wrap
msgid "Speed instruction for the left motor; the value must range between -1 and 1. "
msgstr "Instrução de velocidade para o motor esquerdo; o valor deve ser entre -1 e 1."

#. type: \t; header
#: ../E/motor.txt:23
#, no-wrap
msgid "right: <code><a cbot|float>float</a></code>"
msgstr "direito: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/motor.txt:24
#, no-wrap
msgid "Speed instruction for the right motor; the value must range between -1 and 1. "
msgstr "Instrução de velocidade para o motor direito; o valor deve ser entre -1 e 1."

#. type: Plain text
#: ../E/motor.txt:26
#, no-wrap
msgid ""
"Examples :\n"
"<c/>motor(1, 1);<n/> moves forward with highest possible speed.\n"
"<c/>motor(-0.5, -0.5);<n/> moves backward with half speed.\n"
"<c/>motor(1, -1);<n/> turns right as fast as possible. "
msgstr ""
"Exemplos:\n"
"<c/>motor(1, 1);<n/> move para frente com a maior velocidade possível.\n"
"<c/>motor(-0.5, -0.5);<n/> move para trás com meia velocidade.\n"
"<c/>motor(1, -1);<n/> gira para a direita o mais rápido possível. "

#. type: Plain text
#: ../E/motor.txt:31
#, no-wrap
msgid ""
"Note :\n"
"<c/>motor(2, 2);<n/> will not move forward any faster than <code>motor(1, 1)</code> \n"
"<c/>motor(-2, -2);<n/> will not move backward any faster than <code>motor(-1, -1)</code>"
msgstr ""
"Nota:\n"
"<c/>motor(2, 2);<n/> não moverá para frente mais rápido que <code>motor(1, 1)</code> \n"
"<c/>motor(-2, -2);<n/> não moverá para trás mais rápido que <code>motor(-1, -1)</code>"

#. type: \b; header
#: ../E/move.txt:1
#, no-wrap
msgid "Instruction <code>move</code>"
msgstr "Instrução <code>move</code>"

#. type: Plain text
#: ../E/move.txt:2
#, no-wrap
msgid "The instruction <c/>move();<n/> instructs the bot to move forward or backward while keeping the same orientation. In brackets you must specify the length of the move in meters."
msgstr "A instrução <c/>move();<n/> intrui o robô a mover para frente ou para trás enquanto mantém a mesma orientação. Nos parênteses você deve informar a distância do movimento em metros."

#. type: Plain text
#: ../E/move.txt:5
#, no-wrap
msgid "If you want the bot to move forward 30 meters, write <c/>move(30);<n/>. In order to move the bot backward after it dropped a chunk of <a object|titanore>titanium ore</a> on the <a object|convert>converter</a>, write <c/>move(-2.5);<n/>."
msgstr "Se você desejar que o robô mova 30 metros, escreva <c/>move(30);<n/>. Para mover o robô para trás depois que ele largou um pedaço de <a object|titanore>minério de titânio</a> no <a object|convert>conversor</a>, escreva <c/>move(-2.5);<n/>."

#. type: Source code
#: ../E/move.txt:9
#, no-wrap
msgid "<c/>move ( length );<n/>"
msgstr "<c/>move ( distância );<n/>"

#. type: Plain text
#: ../E/move.txt:11
#, no-wrap
msgid "Moves forward or backward of a given distance, always keeping the current orientation of the bot. "
msgstr "Move para frente ou para trás dada um distância, sempre mantendo a orientação atual do robô."

#. type: \t; header
#: ../E/move.txt:13
#, no-wrap
msgid "length: <code><a cbot|float>float</a></code>"
msgstr "distância: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/move.txt:14
#, no-wrap
msgid "Length of the move, in meters. A negative value makes the bot move backward. "
msgstr "Distância do movimento, em metros. Um valor negativo significa que o robô se moverá para trás."

#. type: Plain text
#: ../E/move.txt:17
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>move()</code>.\n"
"<code>== 0 </code>Move executed\n"
"<code>!= 0 </code>error, the instruction was not performed correctly"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>move()</code> se um erro ocorrer.\n"
"<code>== 0 </code>movimento executado\n"
"<code>!= 0 </code>erro, a instrução não foi executada corretamente"

#. type: \b; header
#: ../E/nan.txt:1
#, no-wrap
msgid "Type <code>nan</code>"
msgstr "Tipo <code>nan</code>"

#. type: Plain text
#: ../E/nan.txt:2
#, no-wrap
msgid ""
"This special value indicates that a <a cbot|var>variable</a> of type <code><a cbot|int>int</a></code> or <code><a cbot|float>float</a></code> contains no number, but \"nothing\". \n"
"For example, if the instruction <code><a cbot|receive>receive</a></code> can not get the requested information, it returns <code>nan</code> :"
msgstr ""
"Este valor especial indica que uma <a cbot|var>variável</a> do tipo <code><a cbot|int>int</a></code> ou <code><a cbot|float>float</a></code> não contém números, mas sim \"nada\". \n"
"Por exemplo, se a instrução <code><a cbot|receive>receive</a></code> não pode obter a informação requerida, ela retorna <code>nan</code>:"

#. type: Source code
#: ../E/nan.txt:5
#, no-wrap
msgid ""
"\tvalue = receive(\"Length\");\n"
"\tif ( value == nan )  // not found ?\n"
"\t{\n"
"\t\t\n"
"\t}"
msgstr ""
"\tresposta = receive(\"Length\");\n"
"\tif ( resposta == nan )  // não encontrado?\n"
"\t{\n"
"\t}"

#. type: \t; header
#: ../E/nan.txt:11
#, no-wrap
msgid "Dictionnary"
msgstr "Dicionário inglês-português"

#. type: Plain text
#: ../E/nan.txt:12
#, no-wrap
msgid "<code>nan</code> = Not A Number "
msgstr "<code>nan</code> = Not A Number (Não é um Número)"

#. type: \b; header
#: ../E/new.txt:1
#, no-wrap
msgid "Instruction <code>new</code> (for specialists)"
msgstr "Instrução <code>new</code> (para especialistas)"

#. type: Plain text
#: ../E/new.txt:2
#, no-wrap
msgid ""
"The <code>new</code> operator creates a <a cbot|class>class</a> instance:\n"
"<c/><s/>\tMyClass item;    // now item is a null reference"
msgstr ""
"O operador <code>new</code> cria uma instância de uma <a cbot|class>classe</a>:\n"
"<c/><s/>\tMinhaClasse item;    // agora item é uma referência nula"

#. type: Source code
#: ../E/new.txt:4
#, no-wrap
msgid ""
"\titem = new MyClass(); // now item is a reference\n"
"\t                      // to a new class instance"
msgstr ""
"\titem = new MinhaClasse(); // agora item é uma referência\n"
"\t                      // para uma nova instância de classe"

#. type: Plain text
#: ../E/new.txt:7
#, no-wrap
msgid "If you want to create a new instance at declaration time you can ommit the new <code>new</code> operator by putting () after the declaration:"
msgstr "Se você deseja criar uma nova instância na hora da declaração, você pode omitir o operador <code>new</code> colocando () depois da declaração:"

#. type: Plain text
#: ../E/new.txt:9
#, no-wrap
msgid ""
"Instead of:\n"
"<c/><s/>\tMyClass item = new MyClass();\n"
"<n/>you can write:\n"
"<c/><s/>\tMyClass item();"
msgstr ""
"Em vez de escrever:\n"
"<c/><s/>\tMinhaClasse item = new MinhaClasse();\n"
"<n/>você pode escrever:\n"
"<c/><s/>\tMinhaClasse item();"

#. type: Plain text
#: ../E/new.txt:14
#, no-wrap
msgid ""
"If your class has a constructor with parameters you can write:\n"
"<c/><s/>\tMyClass item = new MyClass(2, 3);\n"
"<n/>or:\n"
"<c/><s/>\tMyClass item(2, 3);"
msgstr ""
"Se sua classe tem um construtor com parâmetros você pode escrever:\n"
"<c/><s/>\tMinhaClasse item = new MinhaClasse(2, 3);\n"
"<n/>ou:\n"
"<c/><s/>\tMinhaClasse item(2, 3);"

#. type: Plain text
#: ../E/new.txt:21
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|pointer>reference</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|pointer>reference</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/null.txt:1
#, no-wrap
msgid "Type <code>null</code>"
msgstr "Tipo <code>null</code>"

#. type: Plain text
#: ../E/null.txt:2
#, no-wrap
msgid "This special value indicates that the variable containing it does not reference an instance."
msgstr "Este valor especial indica que a variável que o contém não faz referência a uma instância."

#. type: Plain text
#: ../E/null.txt:5
#, no-wrap
msgid ""
"<a cbot|pointer>References</a>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<a cbot|pointer>Referências</a>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/object.txt:1
#, no-wrap
msgid "Type <code>object</code>"
msgstr "Tipo <code>object</code>"

#. type: Source code
#: ../E/object.txt:21
#, no-wrap
msgid "<code>category</code>"
msgstr "<code>category</code>"

#. type: Source code
#: ../E/object.txt:24
#, no-wrap
msgid "<code>position</code>"
msgstr "<code>position</code>"

#. type: Plain text
#: ../E/object.txt:25
#, no-wrap
msgid "Position of the object on the planet, in meters. The coordinates <code>x</code> and <code>y</code> correspond to the location on a map, the <code>z</code> coordinate corresponds to the altitude above (respectively below) sea level. "
msgstr "Posição do objeto no planeta, em metros. As coordenadas <code>x</code> e <code>y</code> correspondem ao local no mapa, a coordenada <code>z</code> corresponde a altitude acima (respectivamente abaixo) no nível do mar."

#. type: Source code
#: ../E/object.txt:27
#, no-wrap
msgid "<code>orientation</code>"
msgstr "<code>orientation</code>"

#. type: Plain text
#: ../E/object.txt:28
#, no-wrap
msgid "Orientation of the object, in degrees. The orientation tells you what direction the object is facing. An orientation of <code>0</code> corresponds to an object facing eastwards, thus following the positive <code>x</code> axis. The orientation is measured counterclockwise. "
msgstr "Orientação do objeto, em graus. A orientação diz a você qual a direção que o objeto está apontando. Uma orientação de <code>0</code>corresponde a um objeto virado para o leste, sendo assim, seguindo o eixo positivo <code>x</code>. A orientação é medida em sentido anti-horário. "

#. type: Source code
#: ../E/object.txt:30
#, no-wrap
msgid "<code>pitch</code>"
msgstr "<code>pitch</code>"

#. type: Plain text
#: ../E/object.txt:31
#, no-wrap
msgid "Forward/backward angle of the robot. A pitch of <code>0</code> means that the bot is standing on flat ground. A positive inclination means that it is facing upwards, a negative inclination means that it is facing downwards. "
msgstr "Ângulo para frente / para trás do robô. Um pitch de <code>0</code> significa que o robô está em solo plano. Uma inclinação positiva significa que ele está olhando para cima, uma inclinação negativa significa que ele está olhando para baixo."

#. type: Source code
#: ../E/object.txt:33
#, no-wrap
msgid "<code>roll</code>"
msgstr "<code>roll</code>"

#. type: Plain text
#: ../E/object.txt:34
#, no-wrap
msgid "Left/right angle of the bot, in degrees. A positive value means that the bot is leaning to the left side, a negative value means that it is leaning to the right side. "
msgstr "Ângulo direito / esquerdo do robô, em graus. Um valor positivo significa que o robô está inclinado para o lado esquerdo, um valor negativo significa que o robô está inclinado para o lado direito."

#. type: Source code
#: ../E/object.txt:36
#, no-wrap
msgid "<code>energyLevel</code>"
msgstr "<code>energyLevel</code>"

#. type: Plain text
#: ../E/object.txt:37
#, no-wrap
msgid "Energy level, between 0 and 1. A normal <a object|power>power cell</a> that is fully charged returns the value <code>1</code>. A <a object|atomic>nuclear power cell</a> never returns a value higher than 1, it just lasts longer. Attention: The energy level of a bot is always zero, because the energy is not contained in the bot, but in the power cell. To know the energy level of the power cell of a bot, you must write <code>energyCell.energyLevel</code>. "
msgstr "Nível de energia, entre 0 e 1. Uma <a object|power>célula de energia</a> normal que está totalmente carregada retorna o valor <code>1</code>. Uma <a object|atomic>célula de energia nuclear</a>  nunca retorna um valor maior que 1, ela apenas dura mais. Atenção: o nível de energia de um robô é sempre zero, porque a energia não está no robô, mas sim na célula de energia. Para saber o nível de energia que resta na célula de um robô, você deve escrever <code>energyCell.energyLevel</code>. "

#. type: Source code
#: ../E/object.txt:39
#, no-wrap
msgid "<code>shieldLevel</code>"
msgstr "<code>shieldLevel</code>"

#. type: Plain text
#: ../E/object.txt:40
#, no-wrap
msgid ""
"Shield level of a robot or building. A level <code>1</code> indicates that the shield is still perfect. Every time that the bot or building gets a bullet or collides with another object, the shield level decreases. When the level reaches <code>0</code>, the next bullet or collision will destroy the bot or building. \n"
"Bots can re-energize their shield on a <a object|repair>repair center</a>. The shield of a building is repaired if it lays inside the protection sphere of a <a object|botshld>shielder</a>."
msgstr ""
"Nível de escudo de um robô ou edifício. Um nível com valor <code>1</code> indica que o escudo está perfeito. Cada vez que um robô ou edifício leva dano por balas ou colisão com outros objetos. o nível do escudo diminui. Quando o nível atinge  <code>0</code>, a próxima bala ou colisão destruirá o robô ou edifício. \n"
"Robôs podem reenergizar seus escudos em um <a object|repair>centro de reparo</a>. O escudo de um edifício é reparado se ele estiver dentro da esfera de proteção de um  <a object|botshld>protetor</a>."

#. type: Source code
#: ../E/object.txt:43
#, no-wrap
msgid "<code>temperature</code>"
msgstr "<code>temperature</code>"

#. type: Plain text
#: ../E/object.txt:44
#, no-wrap
msgid "Temperature of the jet of <a object|botgj>winged bots</a>. <code>0</code> corresponds to a cold jet. When used, the temperature increases progressively. When it reaches the value <code>1</code>, the jet is overheated and stops working, until it cooled down a little. "
msgstr "Temperatura do jato de <a object|botgj>robôs alados</a>. <code>0</code> corresponde a um jato frio. Quando usado, a temperatura aumenta progressivamente. Quando ela atinge o valor <code>1</code>, o jato está superaquecido e para de funcionar, até que ele esfrie um pouco."

#. type: Source code
#: ../E/object.txt:46
#, no-wrap
msgid "<code>altitude</code>"
msgstr "<code>altitude</code>"

#. type: Plain text
#: ../E/object.txt:47
#, no-wrap
msgid "The <code>z</code> coordinate of the position indicates the altitude above sea level, whereas the <code>altitude</code> indicates the height above ground. This value is meaningful only for <a object|botgj>winged bots</a> and for <a object|wasp>wasps</a>. For all other objects, this value is zero. "
msgstr "A coordenada <code>z</code> da posição indica a altitude acima do nível do mar, enquando a  <code>altitude</code> indica a altura acima do chão. Este valor só é útil para <a object|botgj>robôs alados</a> e para <a object|wasp>vespas</a>.  Para todos os outros objetos, este valor é zero."

#. type: Source code
#: ../E/object.txt:49
#, no-wrap
msgid "<code>lifeTime</code>"
msgstr "<code>lifeTime</code>"

#. type: Plain text
#: ../E/object.txt:50
#, no-wrap
msgid "The age of the object in seconds since it's creation."
msgstr "A idade de um objeto em segundos desde a sua criação."

#. type: Source code
#: ../E/object.txt:52
#, no-wrap
msgid "<code>energyCell</code>"
msgstr "<code>energyCell</code>"

#. type: Plain text
#: ../E/object.txt:53
#, no-wrap
msgid ""
"This information is special, because it returns the information about another object, in this case the power pack. This means that energyCell contains all the characteristics of a normal object, for example <code>category</code> (PowerCell or NuclearCell), <code>position</code> (the position of the cell), etc.\n"
"If you want to know the energy level of a robot, you must not check <code>energyLevel</code>, but <code>energyCell.energyLevel</code>.\n"
"If the bot has bot no power cell, <code>energyCell</code> returns <code>null</code>."
msgstr ""
"Está informação é especial, porque ela retorna a informação sobre outro objeto, neste caso o pacote de energia. Isto significa que uma energyCell contém todas as características de um objeto normal, por exemplo <code>category</code> (PowerCell ou NuclearCell), <code>position</code> (a posição da célula), etc.\n"
"Se você quer saber o nível de energia de um robô, você deve checar o <code>energyLevel</code>, escrevendo <code>energyCell.energyLevel</code>.\n"
"Se o robô não tiver uma célula de energia, <code>energyCell</code> retorna <code>null</code>."

#. type: Source code
#: ../E/object.txt:57
#, no-wrap
msgid "<code>load</code>"
msgstr "<code>load</code>"

#. type: Plain text
#: ../E/object.txt:58
#, no-wrap
msgid "This information also returns the description of a whole object: the description of the object carried by a <a object|botgr>grabber</a>. If it carries nothing, <code>load</code> returns <code>null</code>."
msgstr "Esta informação também retorna a descrição de um objeto completo: a descrição do objeto carregado por um <a object|botgr>agarrador</a>. Se ele não carrega nada, <code>load</code> retorna <code>null</code>."

#. type: \t; header, \b; header
#: ../E/expr.txt:99 ../E/expr.txt:123 ../E/expr.txt:145 ../E/expr.txt:170 ../E/expr.txt:187 ../E/object.txt:66
#, no-wrap
msgid "Examples"
msgstr "Exemplos"

#. type: Plain text
#: ../E/object.txt:67
#, no-wrap
msgid "The type <code>object</code> returns the special value <code><a cbot|null>null</a></code> when the object does not exist. For example:"
msgstr "O tipo <code>object</code> retorna o valor especial <code><a cbot|null>null</a></code>quando o objeto não existe. Por exemplo:"

#. type: Source code
#: ../E/object.txt:69
#, no-wrap
msgid ""
"\tobject a;\n"
"\ta = radar(BotGrabberRoller);\n"
"\tif ( a == null )  // object does not exist ?\n"
"\t{\n"
"\t}\n"
"\tif ( a.position.z > 50 )  // is it on a mountain ?\n"
"\t{\n"
"\t}"
msgstr ""
"\tobject a;\n"
"\ta = radar(BotGrabberRoller);\n"
"\tif ( a == null )  // objeto não existe?\n"
"\t{\n"
"\t}\n"
"\tif ( a.position.z > 50 )  // está em uma montanha?\n"
"\t{\n"
"\t}"

#. type: \b; header
#: ../E/open.txt:1
#, no-wrap
msgid "Instruction <code>open</code>"
msgstr "Instrução <code>open</code>"

#. type: Plain text
#: ../E/open.txt:2
#, no-wrap
msgid "Open a text file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.open()</code>:"
msgstr "Abre um arquivo de texto do diretório files/. Este é um método da classe <code><a cbot|file>file</a></code>. Esta é a razão porque sempre escrevemos <code>handle.open()</code>:"

#. type: Source code
#: ../E/open.txt:4
#, no-wrap
msgid "\thandle.open(\"test.txt\", \"w\");"
msgstr "\thandle.open(\"arquivo.txt\", \"w\");"

#. type: Plain text
#: ../E/open.txt:6
#, no-wrap
msgid "To open a file, proceed as follows:"
msgstr "Para abrir um arquivo, proceda da seguinte forma:"

#. type: Source code
#: ../E/open.txt:8
#, no-wrap
msgid ""
"\tfile handle();\n"
"\thandle.open(\"filename\", \"w\");\n"
"\thandle.writeln(\"abc\");\n"
"\thandle.close();"
msgstr ""
"\tfile handle();\n"
"\thandle.open(\"nomeArquivo\", \"w\");\n"
"\thandle.writeln(\"abc\");\n"
"\thandle.close();"

#. type: Plain text
#: ../E/open.txt:17
#, no-wrap
msgid "Files can only be created and opened in the files/ folder which is located in the folder inside Colobot save directory. You cannot not create or open files that are located elsewhere than in the files/ folder."
msgstr "Arquivos só podem ser criados e abertos na pasta files/ a qual se localiza dentro do diretório de salvamentos do Colobot. Você não pode criar ou abrir arquivos que estão em outro lugar que não na pasta files/."

#. type: Plain text
#: ../E/open.txt:20
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|file>file</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code>, <code><a cbot|writeln>writeln</a></code> e <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/openfile.txt:1
#, no-wrap
msgid "Instruction <code>openfile</code>"
msgstr "Instrução <code>openfile</code>"

#. type: Source code
#: ../E/openfile.txt:4
#, no-wrap
msgid "file handle = openfile(\"filename\", \"r\");"
msgstr "file handle = openfile(\"nomeArquivo\", \"r\");"

#. type: \b; header
#: ../E/point.txt:1
#, no-wrap
msgid "Type <code>point</code>"
msgstr "Tipo <code>point</code>"

#. type: Plain text
#: ../E/point.txt:2
#, no-wrap
msgid ""
"Variables of this type contain the coordinates of a point in space. This type is made of three values that represent the <code>x</code>, <code>y</code> and <code>z</code> coordinates.\n"
"<code>x</code> and <code>y</code> correspond to the place on the ground. The positive <code>x</code> axis faces towards east, the positive <code>y</code> axis faces towards north. \n"
"The <code>z</code> value corresponds to the altitude above sea level. "
msgstr ""
"Variáveis deste tipo contém as coordenadas para um ponto no espaço. Este tipo é feito de três valores que representam as coordenadas <code>x</code>, <code>y</code> e <code>z</code>.\n"
"<code>x</code> e <code>y</code> correspondem ao lugar no chão. O <code>x</code> positivo aponta para o leste, o <code>y</code> positivo aponta para o norte.\n"
"O valor de <code>z</code> corresponde a altitude acima do nível do mar."

#. type: Plain text
#: ../E/point.txt:6
#, no-wrap
msgid "If you want to declare a variable of type point, you can write: "
msgstr "Se você deseja declarar uma variável do tipo point, você pode escrever:"

#. type: Source code
#: ../E/point.txt:8
#, no-wrap
msgid "\tpoint a (10, 20, 30);"
msgstr "\tpoint a (10, 20, 30);"

#. type: Plain text
#: ../E/point.txt:10
#, no-wrap
msgid "You can also set the variable taking one value after another:"
msgstr "Você também pode definir a variável informando um valor por vez:"

#. type: Source code
#: ../E/point.txt:12
#, no-wrap
msgid ""
"\tpoint b;\n"
"\tb.x = 10;\n"
"\tb.y = 20;\n"
"\tb.z = 30;"
msgstr ""
"\tpoint b;\n"
"\tb.x = 10;\n"
"\tb.y = 20;\n"
"\tb.z = 30;"

#. type: Plain text
#: ../E/point.txt:17
#, no-wrap
msgid "With these examples, the following <a cbot|cond>condition</a> is true:"
msgstr "Com estes exemplos, a seguinte <a cbot|cond>condição</a>  é verdadeira:"

#. type: Source code
#: ../E/point.txt:19
#, no-wrap
msgid ""
"\tif ( a == b )\n"
"\t{\n"
"\t}"
msgstr ""
"\tif ( a == b )\n"
"\t{\n"
"\t}"

#. type: Plain text
#: ../E/point.txt:22
#, no-wrap
msgid ""
"<n/> \n"
"The following declaration :"
msgstr ""
"<n/> \n"
"A seguinte declaração:"

#. type: Source code
#: ../E/point.txt:25
#, no-wrap
msgid "\tpoint c (4, 7);"
msgstr "\tpoint c (4, 7);"

#. type: Plain text
#: ../E/point.txt:27
#, no-wrap
msgid "Is equivalent to :"
msgstr "É equivalente a:"

#. type: Source code
#: ../E/point.txt:29
#, no-wrap
msgid ""
"\tpoint c;\n"
"\tc.x = 4;\n"
"\tc.y = 7;\n"
"\tc.z = 0;"
msgstr ""
"\tpoint c;\n"
"\tc.x = 4;\n"
"\tc.y = 7;\n"
"\tc.z = 0;"

#. type: \b; header
#: ../E/pointer.txt:1
#, no-wrap
msgid "References (for specialists)"
msgstr "Referências (para especialistas)"

#. type: Plain text
#: ../E/pointer.txt:2
#, no-wrap
msgid "CBOT uses references for <a cbot|class>classes</a> and <a cbot|array>arrays</a>. Any class variable actually contains a reference to the instance. The instance actually contains the class fields. Several references can reference the same instance. A <code><a cbot|null>null</a></code> reference references nothing. You can compare an instance to a suitcase and a reference to a carrier. Each time we need a new suitcase we create a new instance with a carrier. But a suitcase can be carried by more than one carrier. A carrier who carries no suitcase is a <code><a cbot|null>null</a></code> reference."
msgstr "CBOT usa referências para  <a cbot|class>classes</a> e <a cbot|array>matrizes</a>. Qualquer variável de classe contém uma referência para a instância. A instância contém os campos da classe. Várias referências podem referenciar a mesma instância. Uma referência <code><a cbot|null>nula</a></code> não referencia nada. Você pode comparar uma instância a uma mala e uma referência a um portador. Uma mala pode ser carregada por mais de um portador. Um portador que não carrega malas é uma referência <code><a cbot|null>nula</a></code>."

#. type: Plain text
#: ../E/pointer.txt:4
#, no-wrap
msgid ""
"Example:\n"
"<c/><s/>{"
msgstr ""
"Exemplos:\n"
"<c/><s/>{"

#. type: Source code
#: ../E/pointer.txt:6
#, no-wrap
msgid ""
"\tMyClass item1(); // create a new instance\n"
"\t                 // referenced by item1\n"
"\tMyClass item2;   // create a null reference\n"
"\titem2 = item1;   // copy the reference,\n"
"\t                 // item2 and item1 now reference\n"
"\t                 // the same instance\n"
"\titem1.a = 12;    // modifies the instance\n"
"\t                 // referenced by item1 (and item2)\n"
"\tmessage(item2.a);// displays 12\n"
"}"
msgstr ""
"\tMinhaClasse item1(); // cria uma nova instância\n"
"\t                 // referenciada por item1\n"
"\tMinhaClasse item2;   // cria uma referência nula\n"
"\titem2 = item1;   // copia a referência,\n"
"\t                 // item2 e item1 agora referenciam\n"
"\t                 // a mesma instância\n"
"\titem1.a = 12;    // modifica a instância\n"
"\t                 // referênciada por item1 (e item2)\n"
"\tmessage(item2.a);// exibe 12\n"
"}"

#. type: Plain text
#: ../E/pointer.txt:17
#, no-wrap
msgid "If you pass a <a cbot|class>class</a> instance as parameter to a function, the function only receives a reference to the instance. That means if you modify the instance in the function, the instance that has been specified by the caller will be actuallay modified."
msgstr "Se você passar uma instância de <a cbot|class>classe</a> como parâmetro para uma função, a função somente recebe a referência para a instância. Isto significa que se você modificar a instância na função, a instância que foi informada na chamada da função também será modificada."

#. type: Plain text
#: ../E/pointer.txt:19
#, no-wrap
msgid "<c/><s/>void Test( MyClass item )"
msgstr "<c/><s/>void Teste( MinhaClasse item )"

#. type: Source code
#: ../E/pointer.txt:20
#, no-wrap
msgid ""
"{\n"
"\titem.a = 12;          // modify the original instance\n"
"\titem = new MyClass(); // new local instance\n"
"\titem.a = 33;          // modifie the local instance\n"
"}"
msgstr ""
"{\n"
"\titem.a = 12;          // modifica a instância original\n"
"\titem = new MinhaClasse(); // nova instância local\n"
"\titem.a = 33;          // modifica a instância local\n"
"}"

#. type: Plain text
#: ../E/pointer.txt:26
#, no-wrap
msgid ""
"Calling the fucntion <code>Test()</code>:\n"
"<c/><s/>{"
msgstr ""
"Chamando a função <code>Teste()</code>:\n"
"<c/><s/>{"

#. type: Source code
#: ../E/pointer.txt:28
#, no-wrap
msgid ""
"\tMyClass toto();\n"
"\tTest(toto);\n"
"\tmessage(toto.a);  // displays 12\n"
"}"
msgstr ""
"\tMinhaClasse toto();\n"
"\tTeste(toto);\n"
"\tmessage(toto.a);  // displays 12\n"
"}"

#. type: Plain text
#: ../E/pointer.txt:33
#, no-wrap
msgid "The instance containing the field <code>a = 33</code> is referenced only by the newly created instance <code>item</code> inside the fucntion <code>Test</code>. At the end of <code>Test</code> this newly created instance referenced by <code>item</code> is automatically deleted."
msgstr "A instância contendo o campo <code>a = 33</code> é referenciada somente pela nova instância criada (<code>item</code>) dentro da função <code>Teste</code>. No fim de <code>Teste</code>  esta nova instância referênciada por <code>item</code> é automaticamente excluída."

#. type: Plain text
#: ../E/pointer.txt:35
#, no-wrap
msgid ""
"A function can return an instance:\n"
"<c/><s/>MyClass Test2( )"
msgstr ""
"Uma função pode retornar uma instância:\n"
"<c/><s/>MinhaClasse Teste2( )"

#. type: Source code
#: ../E/pointer.txt:37
#, no-wrap
msgid ""
"{\n"
"\tMyClass item = new MyClass();\n"
"\titem.x = 33;\n"
"\treturn item;\n"
"}"
msgstr ""
"{\n"
"\tMinhaClasse item = new MinhaClasse();\n"
"\titem.x = 33;\n"
"\treturn item;\n"
"}"

#. type: Plain text
#: ../E/pointer.txt:43
#, no-wrap
msgid ""
"Call the function like this:\n"
"<c/><s/>{"
msgstr ""
"Chame a função deste jeito:\n"
"<c/><s/>{"

#. type: Source code
#: ../E/pointer.txt:45
#, no-wrap
msgid ""
"\tMyClass toto;\n"
"\ttoto = Test2(); // toto will contain a reference to\n"
"\t                // the instance created by Test2()\n"
"\tmessage(toto.a); // displays 33\n"
"}"
msgstr ""
"\tMinhaClasse toto;\n"
"\ttoto = Teste2(); // toto irá conter uma referência\n"
"\t                // a instância criada por Teste2()\n"
"\tmessage(toto.a); // exibe 33\n"
"}"

#. type: Plain text
#: ../E/pointer.txt:52
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|new>new</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|new>new</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/private.txt:1
#, no-wrap
msgid "Instruction <code>private</code> (for specialists)"
msgstr "Instrução <code>private</code> (para especialistas)"

#. type: Source code
#: ../E/private.txt:6
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint    b;                // public by default\n"
"\tpublic int a;            // also public \n"
"\tprivate point position;  // private\n"
"}\n"
"void Test()\n"
"{\n"
"\tMyClass item;\n"
"\titem.a = item.b = 12;      // ok\n"
"\tmessage( item.position );  // this is an error\n"
"}"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tint    b;                // público por padrão\n"
"\tpublic int a;            // também público \n"
"\tprivate point posicao;  // privado\n"
"}\n"
"void Teste()\n"
"{\n"
"\tMinhaClasse item;\n"
"\titem.a = item.b = 12;      // ok\n"
"\tmessage( item.posicao );  // isso é um erro\n"
"}"

#. type: \b; header
#: ../E/public.txt:1
#, no-wrap
msgid "Instruction <code>public</code> (for specialists)"
msgstr "Instrução <code>public</code> (para especialistas)"

#. type: Plain text
#: ../E/public.txt:2
#, no-wrap
msgid "This instruction has two distinct purposes:"
msgstr "Esta instrução tem dois propósitos distintos:"

#. type: Bullet: '1)'
#: ../E/public.txt:4
#, no-wrap
msgid "Make a function available to other bots."
msgstr "Tornar uma função disponível para outros robôs."

#. type: Bullet: '2)'
#: ../E/public.txt:5
#, no-wrap
msgid "Make a class member accessible from outside the class definition."
msgstr "Tornar um membro de uma classe acessível fora da definição da classe."

#. type: \b; header
#: ../E/public.txt:7
#, no-wrap
msgid "Instruction <code>public</code> for functions"
msgstr "Instrução <code>public</code> para funções"

#. type: Plain text
#: ../E/public.txt:8
#, no-wrap
msgid "If you put <code>public</code> before a <a cbot|function>function</a> definition, you can make the function available to programs in other bots in the same mission."
msgstr "Se você colocar <code>public</code> antes da definição de uma <a cbot|function>função</a> , você disponibilizar a função para programas em outros robôs na mesma missão."

#. type: Plain text
#: ../E/public.txt:10
#, no-wrap
msgid "For example in the first bot we would have:"
msgstr "Por exemplo, no primeiro robô nós teriamos:"

#. type: Source code
#: ../E/public.txt:12
#, no-wrap
msgid ""
"public void object::Segment(float dist, float angle)\n"
"{\n"
"\tmove(dist);\n"
"\tturn(angle);\n"
"}"
msgstr ""
"public void object::Segmento(float distancia, float angulo)\n"
"{\n"
"\tmove(distancia);\n"
"\tturn(angulo);\n"
"}"

#. type: Plain text
#: ../E/public.txt:18
#, no-wrap
msgid "And in another bot we would have:"
msgstr "E em outro robô teriamos:"

#. type: Source code
#: ../E/public.txt:20
#, no-wrap
msgid ""
"extern void object::Square( )\n"
"{\n"
"\tfor ( int i=0 ; i<4 ; i++ )\n"
"\t{\n"
"\t\tSegment(10, 90);\n"
"\t\tfire(1);\n"
"\t}\n"
"}"
msgstr ""
"extern void object::Quadrado( )\n"
"{\n"
"\tfor ( int i=0 ; i<4 ; i++ )\n"
"\t{\n"
"\t\tSegmento(10, 90);\n"
"\t\tfire(1);\n"
"\t}\n"
"}"

#. type: Plain text
#: ../E/public.txt:29
#, no-wrap
msgid "If you have declared a function <code>public</code>, you cannot define a function with the same name and arguments in another bot of the same mission."
msgstr "Se você tiver declarado uma função <code>public</code>, você não pode definir uma função com o mesmo nome e argumentos em outro robô da mesma missão."

#. type: Plain text
#: ../E/public.txt:31
#, no-wrap
msgid "If a bot containing a <code>public</code> function is destroyed, the other bots that make use of this function will be stopped with an error."
msgstr "Se um robô contendo uma função <code>public</code> é destruido, os outros robôs que usam esta função irão parar com um erro."

#. type: \b; header
#: ../E/public.txt:33
#, no-wrap
msgid "Instruction <code>public</code> for classes"
msgstr "Instrução <code>public</code> para classes"

#. type: Source code
#: ../E/public.txt:36
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint    b;                // public by default\n"
"\tpublic int a;            // also public \n"
"\tprivate point position;  // privat\n"
"}\n"
"void Test()\n"
"{\n"
"\tMyClass item;\n"
"\titem.a = item.b = 12;      // ok\n"
"\tmessage( item.position );  // this is an error\n"
"}"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tint    b;                // público por padrão\n"
"\tpublic int a;            // também público \n"
"\tprivate point posicao;  // privado\n"
"}\n"
"void Teste()\n"
"{\n"
"\tMinhaClasse item;\n"
"\titem.a = item.b = 12;      // ok\n"
"\tmessage( item.posicao );  // isto é um erro\n"
"}"

#. type: \b; header
#: ../E/radar.txt:1
#, no-wrap
msgid "Instruction <code>radar</code>"
msgstr "Instrução <code>radar</code>"

#. type: Plain text
#: ../E/radar.txt:5
#, no-wrap
msgid "Write in brackets the <a cbot|category>name of the object</a> that you look for. Put the result in a variable of the <a cbot|type>type</a> <code>object</code>. Here is an example that looks for the closest ant:"
msgstr "Escreva entre os parênteses o <a cbot|category>nome do objeto</a> que você está procurando. Coloque o resultado em uma variável do <a cbot|type>tipo</a> <code>object</code>. Aqui está um exemplo que procura pela formiga (ant) mais próxima:"

#. type: Source code
#: ../E/radar.txt:7
#, no-wrap
msgid ""
"// At the beginning of the program:\n"
"object  item; // variable declaration\n"
"\n"
"// Look for the closest ant\n"
"item = radar(AlienAnt);"
msgstr ""
"// No começo do programa:\n"
"object  item; // declaração da variável\n"
"\n"
"// Procurando pela formiga (AlienAnt) mais próxima\n"
"item = radar(AlienAnt);"

#. type: Plain text
#: ../E/radar.txt:17
#, no-wrap
msgid "Detects an object according to several parameters. "
msgstr "Detecta um objeto de acordo com vários parâmetros."

#. type: Image filename
#: ../E/radar.txt:19
#, no-wrap
msgid "radar1"
msgstr "radar1"

#. type: Plain text
#: ../E/radar.txt:20
#, no-wrap
msgid "Seen from above, the purple zone corresponds to the zone where objects will be detected. "
msgstr "Visto de cima, a zona roxa representa a zona onde os objetos serão detectados."

#. type: \t; header
#: ../E/produce.txt:15 ../E/search.txt:7
#, no-wrap
msgid "category: <code><a cbot|int>int</a></code>"
msgstr "categoria: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/radar.txt:34
#, no-wrap
msgid ""
"Direction that the radar is facing, in degrees. \n"
"<code>  0</code> -> radar is facing straight ahead\n"
"<code>-90</code> -> radar is facing a quarter turn right\n"
"<code> 90</code> -> radar is facing a quarter turn left"
msgstr ""
"Direção que o radar está apontando, em graus. \n"
"<code>  0</code> -> o radar virado para a frente\n"
"<code>-90</code> -> o radar está virado um quarto a direita\n"
"<code> 90</code> -> o radar está virado um quarto a esquerda"

#. type: Plain text
#: ../E/radar.txt:40
#, no-wrap
msgid "Opening angle of the radar, in degrees. "
msgstr "Abertura do ângulo do radar, em graus"

#. type: Plain text
#: ../E/radar.txt:43
#, no-wrap
msgid "Minimum detection distance, in meters. Objects that are closer than the minimum distance will not be detected. "
msgstr "Distância mínima de detecção, em metros. Objetos que estão mais perto do que a distância mínima não serão detectados."

#. type: Plain text
#: ../E/radar.txt:46
#, no-wrap
msgid "Maximum detection distance, in meters. Objects that are farther away than the maximum distance will not be detected. "
msgstr "Distância máxima de detecção, em metros. Objetos que estão mais longe do que a distância máxima não serão detectados."

#. type: Plain text
#: ../E/radar.txt:49
#, no-wrap
msgid "Determines which way the objects are detected. With value <code>1</code>, returns the closest object found in the specified zone. With value <code>-1</code>, the farthest object in the zone will be returned. "
msgstr "Determina de que mandeira os objetos serão detectados. Com o valor <code>1</code>, retorna o objeto mais próximo encontrado na zona especificada. Com o valor <code>-1</code>, o objeto mais longe na zona será retornado."

#. type: \t; header
#: ../E/radar.txt:65 ../E/retobj.txt:10 ../E/search.txt:22
#, no-wrap
msgid "Return value: <code><a cbot|object>object</a></code>"
msgstr "Valor de retorno: <code><a cbot|object>object</a></code>"

#. type: Plain text
#: ../E/radar.txt:66
#, no-wrap
msgid "Returns the first object found that corresponds to the specified category in the specified zone. If no object was found, returns the value <code><a cbot|null>null</a></code>."
msgstr "Retorna o primeiro objeto encontrado que corresponda a categoria na zona especificada. Se nenhum objeto for encontrado, retorna o valor <code><a cbot|null>null</a></code>."

#. type: \t; header
#: ../E/expr.txt:131 ../E/radar.txt:68
#, no-wrap
msgid "Remark"
msgstr "Observação"

#. type: Plain text
#: ../E/radar.txt:69
#, no-wrap
msgid "You do not have to give all the parameters. Here are two examples of instructions that are equivalent: "
msgstr "Você não precisa necessariamente informar todos os parâmetros. Aqui estão dois exemplos de instruções equivalentes:"

#. type: Source code
#: ../E/radar.txt:71
#, no-wrap
msgid ""
"\tradar(Titanium, 0, 360, 0, 1000);\n"
"\tradar(Titanium);  // equivalent"
msgstr ""
"\tradar(Titanium, 0, 360, 0, 1000);\n"
"\tradar(Titanium);  // equivalente"

#. type: Source code
#: ../E/radar.txt:74
#, no-wrap
msgid ""
"\tradar(Titanium, 0, 90, 0, 1000);\n"
"\tradar(Titanium, 0, 90);  // equivalent"
msgstr ""
"\tradar(Titanium, 0, 90, 0, 1000);\n"
"\tradar(Titanium, 0, 90);  // equivalente"

#. type: Plain text
#: ../E/radar.txt:77
#, no-wrap
msgid ""
"When one or more parameters are not specified, the default values indicated above are used instead; only the first parameter is compulsory.\n"
"Generally, only the first parameter is specified: f. ex. <code>radar (AlienAnt)</code> detects the closest ant, wherever it may be. "
msgstr ""
"Quando um ou mais parâmetros não são informados, os valores padrões indicados acima são utilizados; somente o primeiro parâmetro é obrigatório.\n"
"Geralmente, somente o primeiro parâmetro é utilizado, por exemplo: <code>radar (AlienAnt)</code> detecta a formiga mais próxima, onde quer que esteja."

#. type: \b; header
#: ../E/readln.txt:1
#, no-wrap
msgid "Instruction <code>readln</code>"
msgstr "Instrução <code>readln</code>"

#. type: Plain text
#: ../E/readln.txt:2
#, no-wrap
msgid "Read one line from an open file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.readln()</code>:"
msgstr "Lê uma linha de um arquivo aberto da pasta files/. Este é um método da classe <code><a cbot|file>file</a></code>. Este é o motivo porque sempre escrevemos <code>handle.readln()</code>:"

#. type: Source code
#: ../E/readln.txt:4
#, no-wrap
msgid "\ts = handle.readln();"
msgstr "\ts = handle.readln();"

#. type: Plain text
#: ../E/readln.txt:6
#, no-wrap
msgid "The file must have been opened for reading (<code>\"r\"</code>) with the <code><a cbot|open>open</a></code> instruction. <code>readln</code> returns the string containing the whole line but without the end of line characters 0x0D (CR) and 0x0A (LF)."
msgstr "O arquivo deve ter sido aberto para leitura (<code>\"r\"</code>) com a instrução <code><a cbot|open>open</a></code>. <code>readln</code>  retorna a string contendo a linha inteira, porém sem os caracteres de fim de linha 0x0D (CR) e 0x0A (LF)."

#. type: Source code
#: ../E/readln.txt:9
#, no-wrap
msgid "<c/>string = handle.readln ( );<n/>"
msgstr "<c/>string = handle.readln ( );<n/>"

#. type: Source code
#: ../E/readln.txt:13
#, no-wrap
msgid ""
"\tstring s;\n"
"\ts = handle.readln();\n"
"\tif ( s == \"abc\" )\n"
"\t..."
msgstr ""
"\tstring s;\n"
"\ts = handle.readln();\n"
"\tif ( s == \"abc\" )\n"
"\t..."

#. type: Plain text
#: ../E/readln.txt:19
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|writeln>writeln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|writeln>writeln</a></code> e <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/receive.txt:1
#, no-wrap
msgid "Instruction <code>receive</code>"
msgstr "Instrução <code>receive</code>"

#. type: Source code
#: ../E/receive.txt:3
#, no-wrap
msgid "<c/>receive ( name, power );<n/>"
msgstr "<c/>receive ( nome, energia );<n/>"

#. type: Plain text
#: ../E/receive.txt:5
#, no-wrap
msgid "Retrieves an information from the closest <a object|exchange>information exchange post</a>."
msgstr "Recebe uma informação do <a object|exchange>posto de troca de informação</a> mais próximo."

#. type: Plain text
#: ../E/receive.txt:8
#, no-wrap
msgid "Name of the information required from the exchange post. This name is a string: it must be written in quotation marks \"\"."
msgstr "Nome da informação requerida do posto de troca. Este nome é uma string: deve ser escrito entre aspas \" \"."

#. type: Plain text
#: ../E/receive.txt:11
#, no-wrap
msgid "Power of the receiver, which corresponds to maximal distance between the receiver and the exchange post. If the distance is longer, no information is received. Default value is 10 metres."
msgstr "Energia do receptor. a qual corresponde a distância máxima entre o receptor e o posto de troca. Se a distância é longa, nenhuma informação será recebida. O valor padrão é 10 metros."

#. type: Plain text
#: ../E/receive.txt:14
#, no-wrap
msgid "Value of the retrieved information. If no exchange post is close enough, or if the name of the requested information does not exist in the exchange post, the value <code>nan</code> is returned."
msgstr "Valor da informação recebida. Se nenhum posto de troca está perto o suficiente, ou se o nome da informação não existe no posto de troca, o valor <code>nan</code> é retornado."

#. type: Plain text
#: ../E/receive.txt:17
#, no-wrap
msgid ""
"<code><a cbot|send>send</a></code>, <code><a cbot|testinfo>testinfo</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|send>send</a></code>, <code><a cbot|testinfo>testinfo</a></code> e <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/recycle.txt:1
#, no-wrap
msgid "Instruction <code>recycle</code>"
msgstr "Instrução <code>recycle</code>"

#. type: Source code
#: ../E/recycle.txt:3
#, no-wrap
msgid "<c/>recycle ( );<n/>"
msgstr "<c/>recycle ( );<n/>"

#. type: Plain text
#: ../E/recycle.txt:5
#, no-wrap
msgid "Recycles the derelict bot in front of the <a object|botrecy>recycler</a> into a <a object|titan>titanium cube</a>."
msgstr "Recicla o robô abandonado na frente do <a object|botrecy>reciclador</a> em um <a object|titan>cubo de titânio</a>."

#. type: Plain text
#: ../E/recycle.txt:8
#, no-wrap
msgid ""
"Zero if OK, or a value different from zero if an error occurred.\n"
"<code>== 0 </code>the derelict bot has been recycled\n"
"<code>!= 0 </code>error, no derelict bot could be recycled"
msgstr ""
"Zero se OK, ou um valor diferente de zero que um erro ocorreu.\n"
"<code>== 0 </code>o robô abandonado foi reciclado\n"
"<code>!= 0 </code>erro, nenhum robô abandonado pôde ser reciclado"

#. type: \b; header
#: ../E/retobj.txt:1
#, no-wrap
msgid "Instruction <code>retobject</code>"
msgstr "Instrução <code>retobject</code>"

#. type: Source code
#: ../E/retobj.txt:3
#, no-wrap
msgid "<c/>retobject ( number );<n/>"
msgstr "<c/>retobject ( ranque );<n/>"

#. type: Plain text
#: ../E/retobj.txt:5
#, no-wrap
msgid "Returns the object corresponding to the given number."
msgstr "Retorna o objeto correspondente ao número informado."

#. type: \t; header
#: ../E/retobj.txt:7
#, no-wrap
msgid "number: <code><a cbot|int>int</a></code>"
msgstr "ranque: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/retobj.txt:8
#, no-wrap
msgid "Number of the object, between 0 and n. \"n\" represents the total number of objects in the scene. "
msgstr "Número do objeto, entre 0 e n, \"n\" representa o número total de objetos em cena."

#. type: Plain text
#: ../E/retobj.txt:11
#, no-wrap
msgid "Object corresponding to the number. The return value <code><a cbot|null>null</a></code> means that no object corresponds to this number, because the number was too high, and there are not so many objects in the scene. "
msgstr "Objeto correspondente ao número. O valor retornado <code><a cbot|null>null</a></code> significa que nenhum objeto corresponde a este número, porque o número é muito alto e não há tantos objetos na cena."

#. type: \b; header
#: ../E/return.txt:1
#, no-wrap
msgid "Instruction <code>return</code>"
msgstr "Instrução <code>return</code>"

#. type: Plain text
#: ../E/return.txt:2
#, no-wrap
msgid "Returns from a function. Syntax:"
msgstr "Retorno de uma <a cbot|function>função</a>. Sintaxe:"

#. type: Source code
#: ../E/return.txt:4
#, no-wrap
msgid ""
"void function ( )\n"
"{\n"
"\treturn;\n"
"}"
msgstr ""
"<c/>void funcao ( )\n"
"{\n"
"\treturn;\n"
"}"

#. type: Plain text
#: ../E/return.txt:10
#, no-wrap
msgid "If the <a cbot|function>function</a> has a return type, the <code>return</code> instruction must be followed by the value to be returned:"
msgstr " Se a <a cbot|function>função</a>  tem um tipo de retorno, a instrução <code>return</code> deve ser seguida pelo valor a ser retornado:"

#. type: Source code
#: ../E/return.txt:12
#, no-wrap
msgid ""
"float Pi ( )\n"
"{\n"
"\treturn 3.1415;\n"
"}"
msgstr ""
"float Pi ( )\n"
"{\n"
"\treturn 3.1415;\n"
"}"

#. type: Source code
#: ../E/return.txt:17
#, no-wrap
msgid ""
"float Mean (float a, float b)\n"
"{\n"
"\treturn (a+b)/2;\n"
"}"
msgstr ""
"float Media (float a, float b)\n"
"{\n"
"\treturn (a+b)/2;\n"
"}"

#. type: Source code
#: ../E/return.txt:22
#, no-wrap
msgid ""
"string Sign (float a)\n"
"{\n"
"\tif ( a > 0 )  return \"positive\";\n"
"\tif ( a < 0 )  return \"negative\";\n"
"\treturn \"null\";\n"
"}"
msgstr ""
"string Sinal (float a)\n"
"{\n"
"\tif ( a > 0 )  return \"positivo\";\n"
"\tif ( a < 0 )  return \"negativo\";\n"
"\treturn \"null\";\n"
"}"

#. type: \b; header
#: ../E/search.txt:1
#, no-wrap
msgid "Instruction <code>search</code>"
msgstr "Instrução <code>search</code>"

#. type: Source code
#: ../E/search.txt:3
#, no-wrap
msgid "<c/>search ( category, position );<n/>"
msgstr "<c/>search ( categoria, posicao );<n/>"

#. type: \t; header
#: ../E/produce.txt:9 ../E/topo.txt:7
#, no-wrap
msgid "position: <code><a cbot|point>point</a></code>"
msgstr "posicao: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: ../E/search.txt:20
#, no-wrap
msgid "<code>search</code> returns the object of the given category that is closest to the position indicated here. "
msgstr "<code>search</code> retorna o objeto da categoria dada que está mais próximo da posição indicada."

#. type: Plain text
#: ../E/search.txt:23
#, no-wrap
msgid "Characteristics of the object that has been found. The value <code><a cbot|null>null</a></code> means that no object of this category has been found. "
msgstr "Características do objeto que foi encontrado. O valor <code><a cbot|null>null</a></code>  significa que nenhum objeto desta categoria foi encontrado."

#. type: \b; header
#: ../E/send.txt:1
#, no-wrap
msgid "Instruction <code>send</code>"
msgstr "Instrução <code>send</code>"

#. type: Source code
#: ../E/send.txt:3
#, no-wrap
msgid "<c/>send ( name, value, power );<n/>"
msgstr "<c/>send ( nome, valor, energia );<n/>"

#. type: Plain text
#: ../E/send.txt:5
#, no-wrap
msgid "Sends an information to the closest <a object|exchange>information exchange post</a>."
msgstr "Envia uma informação para o <a object|exchange>posto de troca de informação</a> mais próximo."

#. type: Plain text
#: ../E/send.txt:8
#, no-wrap
msgid ""
"Name of the information to be sent to the exchange post. This name is a string: it must be written in quotation marks \"\".\n"
"If there is any information having this name, a new entry is created, as far as the total number of entries does not exceed 10. If there is already an information having this name, value is simply replaced by the new."
msgstr ""
"Nome da informação a ser enviada ao posto de troca. Este nome é uma string: deve ser escrita entre aspas \" \".\n"
"Se não há nenhuma informação com este nome, uma nova entrada é criada, desde que o total de entradas não exceda 10. Se já houver uma entrada com este nome, o valor antigo será substituido pelo novo valor."

#. type: \t; header
#: ../E/send.txt:11
#, no-wrap
msgid "value: <code>float</code>"
msgstr "valor: <code>float</code>"

#. type: Plain text
#: ../E/send.txt:12
#, no-wrap
msgid "Value of the information to be sent."
msgstr "Valor da informação a ser enviada."

#. type: Plain text
#: ../E/send.txt:15
#, no-wrap
msgid "Power of the transmitter, which corresponds to the maximal distance to where information can be the sent. Default value is 10 metres."
msgstr "Energia do transmissor, a qual corresponde a distância máxima para onde a informação pode ser enviada. O valor padrão é 10 metros."

#. type: Plain text
#: ../E/send.txt:18
#, no-wrap
msgid ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|testinfo>testinfo</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|testinfo>testinfo</a></code> e <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/shield.txt:1
#, no-wrap
msgid "Instruction <code>shield</code>"
msgstr "Instrução <code>shield</code>"

#. type: Source code
#: ../E/shield.txt:3
#, no-wrap
msgid "<c/>shield ( oper, radius );<n/>"
msgstr "<c/>shield ( operacao, raio );<n/>"

#. type: Plain text
#: ../E/shield.txt:5
#, no-wrap
msgid "Activates or deactivates the shield of the <a object|botshld>ahielder</a>. You can of course move the shielder when the shield is active. It protects all objects that are inside the shielded sphere from enemy fire. The radius of the sphere can range between 10 and 25 meters."
msgstr "Ativa ou desativa o escudo de um <a object|botshld>protetor</a>. Você pode, claro, mover o protetor quando o escudo está ativo. Ele protege todos os objetos que estão dentro da esfera de proteção contra fogo inimigo. O raio da esfera pode ter entre 10 e 25 metros."

#. type: \t; header
#: ../E/shield.txt:7
#, no-wrap
msgid "oper: <code><a cbot|float>float</a></code>"
msgstr "operacao: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/shield.txt:8
#, no-wrap
msgid ""
"<code>1</code> activates the shield.\n"
"<code>0</code> deactivates the shield\n"
"A normal <a object|power>power cell</a> fully charged can maintain the shield active during 20 seconds. When the cell is empty, the shield deactivates."
msgstr ""
"<code>1</code> ativa o escudo.\n"
"<code>0</code> desativa o escudo\n"
"Uma <a object|power>célula de energial</a> normal completamente carregada pode manter o escudo ativo durante 20 segundos. Quando a célula descarrega, o escudo é desativado."

#. type: \t; header
#: ../E/shield.txt:12
#, no-wrap
msgid "radius: <code><a cbot|float>float</a></code>"
msgstr "raio: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/shield.txt:13
#, no-wrap
msgid "Radius of the shield, ranging between 10 and 25 meters."
msgstr "Raio do escudo, variando entre 10 e 25 metros."

#. type: \b; header
#: ../E/sizeof.txt:1
#, no-wrap
msgid "Instruction <code>sizeof</code>"
msgstr "Instrução <code>sizeof</code>"

#. type: Plain text
#: ../E/sizeof.txt:2
#, no-wrap
msgid ""
"The sizeof function lets you know the number of elements contained in an <a cbot|array>array</a>.\n"
"That is the index of the last element plus one (\"empty\" elements are counted)."
msgstr ""
"A função sizeof permite a você conhecer o número de elementos contidos em uma <a cbot|array>matriz</a>.\n"
"Isto é o índice do último elemento mais 1 (elementos \"vazios\" também são contados)."

#. type: Source code
#: ../E/sizeof.txt:5
#, no-wrap
msgid ""
"{\n"
"\tint a[12];\n"
"\ta[5] = 345;\n"
"\tmessage( sizeof(a) );  // will display 6\n"
"}"
msgstr ""
"{\n"
"\tint a[12];\n"
"\ta[5] = 345;\n"
"\tmessage( sizeof(a) );  // irá exibir 6\n"
"}"

#. type: Plain text
#: ../E/sizeof.txt:11
#, no-wrap
msgid "In this example we have 6 elements in the array after <code>a[5]=345</code>. The non initialized elements <code>[0]</code>, <code>[1]</code>, <code>[2]</code>, <code>[3]</code> and <code>[4]</code> will be counted."
msgstr "Neste exemplo nós temos 6 elementos na matriz depois de <code>a[5]=345</code>. Os elementos não inicializados <code>[0]</code>, <code>[1]</code>, <code>[2]</code>, <code>[3]</code> and <code>[4]</code> serão contados."

#. type: Plain text
#: ../E/sizeof.txt:13
#, no-wrap
msgid "With multidimensionnal arrays you can get the size of a sub array:"
msgstr "Com matrizes multidimensionais você pode pegar o tamanho de uma sub-matriz:"

#. type: Source code
#: ../E/sizeof.txt:15
#, no-wrap
msgid ""
"float xy[][];  // 2 dimensionnal array\n"
"xy[5][10] = 67;\n"
"message( sizeof(xy)    );  // will display 6\n"
"message( sizeof(xy[5]) );  // will display 11\n"
msgstr ""
"float xy[][];  // matriz de 2 dimensões\n"
"xy[5][10] = 67;\n"
"message( sizeof(xy)    );  // irá exibir 6\n"
"message( sizeof(xy[5]) );  // irá exibir 11\n"

#. type: \b; header
#: ../E/sniff.txt:1
#, no-wrap
msgid "Instruction <code>sniff</code>"
msgstr "Instrução <code>sniff</code>"

#. type: Source code
#: ../E/sniff.txt:3
#, no-wrap
msgid "<c/>sniff ( );<n/>"
msgstr "<c/>sniff ( );<n/>"

#. type: Plain text
#: ../E/sniff.txt:5
#, no-wrap
msgid "Sounds the underground in front of the <a object|botsr>sniffer</a>. According to what raw materials were detected, the following objects will be created: "
msgstr "Sonda o subsolo a frente do <a object|botsr>farejador</a>. De acordo com as matérias primas encontradas, o seguintes objetos serão criados:"

#. type: Plain text
#: ../E/sniff.txt:7
#, no-wrap
msgid ""
"<code>TitaniumSpot</code>  ->  <a object|stonspot>Red cross</a>\n"
"<code>UraniumSpot </code>  ->  <a object|uranspot>Yellow circle</a>\n"
"<code>PowerSpot   </code>  ->  <a object|enerspot>Green cross</a>"
msgstr ""
"<code>TitaniumSpot</code>  ->  <a object|stonspot>Cruz vermelha</a>\n"
"<code>UraniumSpot </code>  ->  <a object|uranspot>Circulo amarelo</a>\n"
"<code>PowerSpot   </code>  ->  <a object|enerspot>Cruz verde</a>"

#. type: Plain text
#: ../E/sniff.txt:12
#, no-wrap
msgid ""
"Zero if everything is OK, or a value different from zero if an error occurred. \n"
"<code>== 0 </code>sounding performed\n"
"<code>!= 0 </code>sounding impossible"
msgstr ""
"Zero se tudo está OK, ou um valor diferente de zero se um erro ocorreu.\n"
"<code>== 0 </code>sondagem realizada\n"
"<code>!= 0 </code>sondagem impossível"

#. type: \b; header
#: ../E/space.txt:1
#, no-wrap
msgid "Instruction <code>space</code>"
msgstr "Instrução <code>space</code>"

#. type: Source code
#: ../E/space.txt:3
#, no-wrap
msgid "<c/>space ( center, rmin, rmax, dist );<n/>"
msgstr "<c/>space ( centro, rminimo, rmaximo, distancia );<n/>"

#. type: Plain text
#: ../E/space.txt:5
#, no-wrap
msgid "Determines the position of the nearest free space around a given position."
msgstr "Determina a posição do espaço livre mais próximo de uma posição dada."

#. type: \t; header
#: ../E/space.txt:7
#, no-wrap
msgid "center: <code><a cbot|point>point</a></code> (default: bot position)"
msgstr "centro: <code><a cbot|point>point</a></code> (padrão: posição do robô)"

#. type: Plain text
#: ../E/flatspace.txt:8 ../E/space.txt:8
#, no-wrap
msgid "Desired position of the free space."
msgstr "Ponto desejado do espaço livre."

#. type: \t; header
#: ../E/flatspace.txt:13 ../E/space.txt:10
#, no-wrap
msgid "rmin: <code><a cbot|float>float</a></code> (default value: <code>8</code>)"
msgstr "rminimo: <code><a cbot|float>float</a></code> (valor padrão: <code>10</code>)"

#. type: Plain text
#: ../E/flatspace.txt:14 ../E/space.txt:11
#, no-wrap
msgid "Minimum distance from the desired position."
msgstr "Distância mínima da posição desejada."

#. type: \t; header
#: ../E/flatspace.txt:16 ../E/space.txt:13
#, no-wrap
msgid "rmax: <code><a cbot|float>float</a></code> (default value: <code>50</code>)"
msgstr "rmaxima: <code><a cbot|float>float</a></code> (valor padrão: <code>50</code>)"

#. type: Plain text
#: ../E/flatspace.txt:17 ../E/space.txt:14
#, no-wrap
msgid "Maximum distance from the desired position."
msgstr "Distância máxima da posição desejada."

#. type: \t; header
#: ../E/flatspace.txt:19 ../E/space.txt:16
#, no-wrap
msgid "dist: <code><a cbot|float>float</a></code> (default value: <code>4</code>)"
msgstr "distancia: <code><a cbot|float>float</a></code> (valor padrão: <code>4</code>)"

#. type: Plain text
#: ../E/flatspace.txt:20 ../E/space.txt:17
#, no-wrap
msgid "Required distance between two free spaces."
msgstr "Distância requerida entre dois espaços livres."

#. type: \t; header
#: ../E/flatspace.txt:22 ../E/space.txt:19
#, no-wrap
msgid "Return: <code><a cbot|point>point</a></code>"
msgstr "Valor de retorno: <code><a cbot|point>point</a></code>"

#. type: Plain text
#: ../E/flatspace.txt:23 ../E/space.txt:20
#, no-wrap
msgid "Position of the free space."
msgstr "Posição do espaço livre."

#. type: \b; header
#: ../E/static.txt:1
#, no-wrap
msgid "Instruction <code>static</code> (for specialists)"
msgstr "Instrução <code>static</code> (para especialistas)"

#. type: Plain text
#: ../E/static.txt:2
#, no-wrap
msgid "<a cbot|class>Class</a> members declared with <code>static</code> are shared between all instances of the class."
msgstr "Membros de uma <a cbot|class>classe</a> declarados com <code>static</code> são compartilhados entre todas as instâncias da classe."

#. type: Source code
#: ../E/static.txt:4
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tstatic int nb = 1;\n"
"\tstatic string [ ] list = null;\n"
"}\n"
"void Test ()\n"
"{\n"
"\tMyClasse item1();\n"
"\tMyClasse item2();\n"
"\titem1.nb = 3;\n"
"\titem1.list[item1.nb] = \"Hello\";\n"
"\tmessage( item2.list[item2.nb] ); // display \"Hello\"\n"
"}"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tstatic int numero = 1;\n"
"\tstatic string [ ] lista = null;\n"
"}\n"
"void Teste ()\n"
"{\n"
"\tMinhaClasse item1();\n"
"\tMinhaClasse item2();\n"
"\titem1.numero = 3;\n"
"\titem1.lista[item1.numero] = \"Olá\";\n"
"\tmessage( item2.lista[item2.numero] ); // exibe \"Olá\"\n"
"}"

#. type: Plain text
#: ../E/static.txt:18
#, no-wrap
msgid "<code>Static</code> members can be declared <code><a cbot|private>private</a></code> so they will be only acessible from within class members (including constructors and destructors)."
msgstr "Membros <code>static</code> podem ser declarados com <code><a cbot|private>private</a></code>, desta forma só serão acessíveis entre membros da própria classe (incluindo construtures e destrutores)."

#. type: Plain text
#: ../E/static.txt:21
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|synchro>synchronized</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|synchro>synchronized</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/strfind.txt:1
#, no-wrap
msgid "Instruction <code>strfind</code>"
msgstr "Instrução <code>strfind</code>"

#. type: Plain text
#: ../E/strfind.txt:2
#, no-wrap
msgid "Find a substring in a string and returns the position of the first substring found or <a cbot|nan>nan</a> if the substring has not been found."
msgstr "Encontra um texto em uma string e retorna a posição da primeira ocorrência ou <a cbot|nan>nan</a> se nenhuma ocorrência for encontrada."

#. type: Source code
#: ../E/strfind.txt:5
#, no-wrap
msgid "<c/>strfind ( string, sub );<n/>"
msgstr "<c/>strfind ( string, texto );<n/>"

#. type: \t; header
#: ../E/strfind.txt:7
#, no-wrap
msgid "string: <code><a cbot|string>string</a></code>"
msgstr "string: <code><a cbot|string>string</a></code>"

#. type: Plain text
#: ../E/strfind.txt:8
#, no-wrap
msgid "String we are searching in."
msgstr "String onde o texto será buscado."

#. type: \t; header
#: ../E/strfind.txt:10
#, no-wrap
msgid "sub: <code><a cbot|string>string</a></code>"
msgstr "texto: <code><a cbot|string>string</a></code>"

#. type: Plain text
#: ../E/strfind.txt:11
#, no-wrap
msgid "Substring we are searching for."
msgstr "Texto que estamos procurando."

#. type: Plain text
#: ../E/array.txt:35 ../E/strfind.txt:13 ../E/strleft.txt:10 ../E/strlen.txt:7 ../E/strlower.txt:7 ../E/strmid.txt:13 ../E/strright.txt:10 ../E/strupper.txt:7 ../E/strval.txt:4 ../E/strval.txt:11 ../E/writeln.txt:11
#, no-wrap
msgid "Examples:"
msgstr "Exemplos:"

#. type: Source code
#: ../E/strfind.txt:14
#, no-wrap
msgid ""
"<c/>\tint pos = strfind(\"abcdef\", \"ab\"); // pos will be 0\n"
"\tint pos = strfind(\"abcdef\", \"de\"); // pos will be 3\n"
"\tint pos = strfind(\"abcdef\", \"xy\"); // pos will be <a cbot|nan>nan</a>"
msgstr ""
"<c/>\tint posicao = strfind(\"abcdef\", \"ab\"); // posicao será 0\n"
"\tint posicao = strfind(\"abcdef\", \"de\"); // posicao será 3\n"
"\tint posicao = strfind(\"abcdef\", \"xy\"); // posicao será <a cbot|nan>nan</a>"

#. type: Plain text
#: ../E/strfind.txt:19
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/string.txt:1
#, no-wrap
msgid "Type <code>string</code>"
msgstr "Tipo <code>string</code>"

#. type: Plain text
#: ../E/string.txt:2
#, no-wrap
msgid "Use a variable of this type for storing characters or strings."
msgstr "Use uma variável deste tipo para armazenar carácteres ou cadeias de carácteres."

#. type: Plain text
#: ../E/string.txt:4
#, no-wrap
msgid "For example: "
msgstr "Por exemplo:"

#. type: Source code
#: ../E/string.txt:5
#, no-wrap
msgid ""
"<c/>\t\"Hello!\"\n"
"\t\"This is a string\"\n"
"\t\"x\"\n"
"\t\"\"  // empty string"
msgstr ""
"<c/>\t\"Olá!\"\n"
"\t\"Isto é uma string\"\n"
"\t\"x\"\n"
"\t\"\"  // string vazia"

#. type: Plain text
#: ../E/string.txt:10
#, no-wrap
msgid "You can append two strings with the <code>+</code> operator :"
msgstr "Você pode concatenar duas strings com o operador <code>+</code>:"

#. type: Source code
#: ../E/string.txt:11
#, no-wrap
msgid "<c/>\t\"Good morning,\" + \" \" + \"Sir\""
msgstr "<c/>\t\"Bom dia,\" + \" \" + \"Senhor\""

#. type: Plain text
#: ../E/string.txt:13
#, no-wrap
msgid "Returns the string:"
msgstr "Retorna a string:"

#. type: Source code
#: ../E/string.txt:14
#, no-wrap
msgid "<c/>\t\"Good morning, Sir\""
msgstr "<c/>\t\"Bom dia, Senhor\""

#. type: Plain text
#: ../E/string.txt:16
#, no-wrap
msgid "If you want to put a quotation mark (\") or a backslash (\\) in a string you must write:"
msgstr "Se você quiser colocar uma aspa (\") ou uma barra invertida (\\) em uma string você deve escrever:"

#. type: Source code
#: ../E/string.txt:17
#, no-wrap
msgid "<c/>\"This is \\\"very\\\" important\""
msgstr "<c/>\"Isto é \\\"muito\\\" importante\""

#. type: Plain text
#: ../E/string.txt:18
#, no-wrap
msgid "<n/>which will result in the string <c/> This is \"very\" important."
msgstr "<n/>o qual resultará na string <c/> Iso é \"muito\" importante."

#. type: Source code
#: ../E/string.txt:19
#, no-wrap
msgid "<c/>\"%user%\\\\ant.txt\""
msgstr "<c/>\"%user%\\\\formiga.txt\""

#. type: Plain text
#: ../E/string.txt:20
#, no-wrap
msgid "<n/>will result in <c/>%user%\\ant.txt"
msgstr "<n/>resultará em <c/>%user%\\formiga.txt"

#. type: Plain text
#: ../E/string.txt:22
#, no-wrap
msgid ""
"Following instructions can be used with strings:\n"
"<code><a cbot|strlen>strlen</a>     </code>Get string length\n"
"<code><a cbot|strleft>strleft</a>    </code>Extract left part\n"
"<code><a cbot|strright>strright</a>   </code>Extract right part\n"
"<code><a cbot|strmid>strmid</a>     </code>Extract center part\n"
"<code><a cbot|strfind>strfind</a>    </code>Find a substring.\n"
"<code><a cbot|strval>strval</a>     </code>Convert string to number\n"
"<code><a cbot|strupper>strupper</a>   </code>Convert to upper case\n"
"<code><a cbot|strlower>strlower</a>   </code>Convert to lower case"
msgstr ""
"As instruções abaixo podem ser usadas com strings:\n"
"<code><a cbot|strlen>strlen</a>     </code>Pega o tamanho da string\n"
"<code><a cbot|strleft>strleft</a>    </code>Extrair parte esquerda\n"
"<code><a cbot|strright>strright</a>   </code>Extrair parte direita\n"
"<code><a cbot|strmid>strmid</a>     </code>Extrair parte central\n"
"<code><a cbot|strfind>strfind</a>    </code>Encontrar texto.\n"
"<code><a cbot|strval>strval</a>     </code>Converter string para número\n"
"<code><a cbot|strupper>strupper</a>   </code>Converter para maiúsculas\n"
"<code><a cbot|strlower>strlower</a>   </code>Converter para minúsculas"

#. type: \b; header
#: ../E/strleft.txt:1
#, no-wrap
msgid "Instruction <code>strleft</code>"
msgstr "Instrução <code>strleft</code>"

#. type: Plain text
#: ../E/strleft.txt:2
#, no-wrap
msgid "Extracts the first (that is, leftmost) characters from a string."
msgstr "Extrai os primeiros (isto é, mais a esquerda) carácteres de uma string."

#. type: Source code
#: ../E/strleft.txt:5
#, no-wrap
msgid "<c/>strleft ( string, len );<n/>"
msgstr "<c/>strleft ( string, tamanho );<n/>"

#. type: \t; header
#: ../E/strleft.txt:7 ../E/strmid.txt:10 ../E/strright.txt:7
#, no-wrap
msgid "len: <code><a cbot|int>int</a></code>"
msgstr "tamanho: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/strleft.txt:8 ../E/strmid.txt:11 ../E/strright.txt:8
#, no-wrap
msgid "Number of characters to be extracted."
msgstr "Número de carácteres a serem extraídos."

#. type: Source code
#: ../E/strleft.txt:11
#, no-wrap
msgid ""
"<c/>\tstring s = strleft(\"abcdef\", 2);  // s is \"ab\"\n"
"\tstring s = strleft(\"abc\", 10);  // s is \"abc\""
msgstr ""
"<c/>\tstring s = strleft(\"abcdef\", 2);  // s é \"ab\"\n"
"\tstring s = strleft(\"abc\", 10);  // s é \"abc\""

#. type: Plain text
#: ../E/strleft.txt:15
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/strlen.txt:1
#, no-wrap
msgid "Instruction <code>strlen</code>"
msgstr "Instrução <code>strlen</code>"

#. type: Plain text
#: ../E/strlen.txt:2
#, no-wrap
msgid "Get the length of a string."
msgstr "Pega o tamanho de uma string."

#. type: Source code
#: ../E/strlen.txt:5
#, no-wrap
msgid "<c/>strlen ( string );<n/>"
msgstr "<c/>strlen ( string );<n/>"

#. type: Source code
#: ../E/strlen.txt:8
#, no-wrap
msgid ""
"<c/>\tint len = strlen(\"abc\");  // len is 3\n"
"\tint len = strlen(\"\");  // len is 0\n"
"\tif ( strlen(s) == 0 )  // is string empty ?"
msgstr ""
"<c/>\tint tamanho = strlen(\"abc\");  // tamanho recebe 3\n"
"\tint tamanho = strlen(\"\");  // tamanho recebe 0\n"
"\tif ( strlen(s) == 0 )  // esta string está vazia?"

#. type: Plain text
#: ../E/strlen.txt:13
#, no-wrap
msgid ""
"<code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/strlower.txt:1
#, no-wrap
msgid "Instruction <code>strlower</code>"
msgstr "Instrução <code>strlower</code>"

#. type: Plain text
#: ../E/strlower.txt:2
#, no-wrap
msgid "Convert all characters in a string to lowercase."
msgstr "Converte todos os carácteres de uma string para minúsculas."

#. type: Source code
#: ../E/strlower.txt:5
#, no-wrap
msgid "<c/>strlower ( string );<n/>"
msgstr "<c/>strlower ( string );<n/>"

#. type: Source code
#: ../E/strlower.txt:8
#, no-wrap
msgid "<c/>\tstring s = strlower(\"Abc\");  // s is \"abc\""
msgstr "<c/>\tstring s = strlower(\"Abc\");  // s recebe \"abc\""

#. type: Plain text
#: ../E/strlower.txt:11
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/strmid.txt:1
#, no-wrap
msgid "Instruction <code>strmid</code>"
msgstr "Instrução <code>strmid</code>"

#. type: Plain text
#: ../E/strmid.txt:2
#, no-wrap
msgid "Extracts a substring of a given length starting at a given position from a string."
msgstr "Extrai um pedaço (com tamanho definido) de uma string a partir da posição dada."

#. type: Source code
#: ../E/strmid.txt:5
#, no-wrap
msgid "<c/>strmid ( string, pos, len );<n/>"
msgstr "<c/>strmid ( string, posicao, tamanho );<n/>"

#. type: \t; header
#: ../E/strmid.txt:7
#, no-wrap
msgid "pos: <code><a cbot|int>int</a></code>"
msgstr "posicao: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/strmid.txt:8
#, no-wrap
msgid "The index of the first character that is to be included in the extracted substring."
msgstr "Índice do primeiro carácter que deve ser incluído no texto a extrair."

#. type: Source code
#: ../E/strmid.txt:14
#, no-wrap
msgid ""
"<c/>\tstring s = strmid(\"abcdef\", 1, 2);  // s is \"bc\"\n"
"\tstring s = strmid(\"abcdef\", 4, 5);  // s is \"ef\"\n"
"\tstring s = strmid(\"abcdef\", 9, 2);  // s is \"\""
msgstr ""
"<c/>\tstring s = strmid(\"abcdef\", 1, 2);  // s recebe \"bc\"\n"
"\tstring s = strmid(\"abcdef\", 4, 5);  // s recebe \"ef\"\n"
"\tstring s = strmid(\"abcdef\", 9, 2);  // s recebe \"\""

#. type: Plain text
#: ../E/strmid.txt:19
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/strright.txt:1
#, no-wrap
msgid "Instruction <code>strright</code>"
msgstr "Instrução <code>strright</code>"

#. type: Plain text
#: ../E/strright.txt:2
#, no-wrap
msgid "Extracts the last (that is, rightmost) characters from a string."
msgstr "Extrai os últimos (isto é, mais a direita) carácteres de uma string."

#. type: Source code
#: ../E/strright.txt:5
#, no-wrap
msgid "<c/>strright ( string, len );<n/>"
msgstr "<c/>strright ( string, tamanho );<n/>"

#. type: Source code
#: ../E/strright.txt:11
#, no-wrap
msgid ""
"<c/>\tstring s = strright(\"abcdef\", 2);  // s is \"ef\"\n"
"\tstring s = strright(\"abc\", 10);  // s is \"abc\""
msgstr ""
"<c/>\tstring s = strright(\"abcdef\", 2);  // s recebe \"ef\"\n"
"\tstring s = strright(\"abc\", 10);  // s recebe \"abc\""

#. type: Plain text
#: ../E/strright.txt:15
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>. "

#. type: \b; header
#: ../E/strupper.txt:1
#, no-wrap
msgid "Instruction <code>strupper</code>"
msgstr "Instrução <code>strupper</code>"

#. type: Plain text
#: ../E/strupper.txt:2
#, no-wrap
msgid "Convert all characters in a string to uppercase."
msgstr "Converte todos os carácteres de uma string para maiúsculas."

#. type: Source code
#: ../E/strupper.txt:5
#, no-wrap
msgid "<c/>strupper ( string );<n/>"
msgstr "<c/>strupper ( string );<n/>"

#. type: Source code
#: ../E/strupper.txt:8
#, no-wrap
msgid "<c/>\tstring s = strupper(\"Abc\");  // s is \"ABC\""
msgstr "<c/>\tstring s = strupper(\"Abc\");  // s recebe \"ABC\""

#. type: Plain text
#: ../E/strupper.txt:11
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strval>strval</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/strval.txt:1
#, no-wrap
msgid "Instruction <code>strval</code>"
msgstr "Instrução <code>strval</code>"

#. type: Plain text
#: ../E/strval.txt:2
#, no-wrap
msgid "Convert a string to a number. Don't confuse the string <code>\"45\"</code> that contains actually the two characters <code>4</code> and <code>5</code> and the number <code>45</code>."
msgstr "Converte uma string para número. Não confunda a string <code>\"45\"</code> que contém os carácteres <code>4</code> e <code>5</code> com o número <code>45</code>."

#. type: Source code
#: ../E/strval.txt:5
#, no-wrap
msgid ""
"<c/>\tstring s = \"45\"+\"12\";  // s contains \"4512\"\n"
"\tfloat  n =  45 + 12;   // n contains 67"
msgstr ""
"<c/>\tstring s = \"45\"+\"12\";  // s contém \"4512\"\n"
"\tfloat  n =  45 + 12;   // n contém 67"

#. type: Source code
#: ../E/strval.txt:9
#, no-wrap
msgid "<c/>strval ( string );<n/>"
msgstr "<c/>strval ( string );<n/>"

#. type: Source code
#: ../E/strval.txt:12
#, no-wrap
msgid ""
"<c/>\tfloat n = strval(\"1.23\");     // n is 1.23\n"
"\tfloat n = strval(\"12abc45\");  // n is 12\n"
"\tfloat n = strval(\"abc\");      // n is 0\n"
"\tfloat n = strval(\"100\")+2;    // n is 102"
msgstr ""
"<c/>\tfloat n = strval(\"1.23\");     // n recebe 1.23\n"
"\tfloat n = strval(\"12abc45\");  // n recebe 12\n"
"\tfloat n = strval(\"abc\");      // n recebe 0\n"
"\tfloat n = strval(\"100\")+2;    // n recebe 102"

#. type: Plain text
#: ../E/strval.txt:18
#, no-wrap
msgid ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|strlen>strlen</a></code>, <code><a cbot|strleft>strleft</a></code>, <code><a cbot|strright>strright</a></code>, <code><a cbot|strmid>strmid</a></code>, <code><a cbot|strfind>strfind</a></code>, <code><a cbot|strupper>strupper</a></code>, <code><a cbot|strlower>strlower</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/synchro.txt:1
#, no-wrap
msgid "Instruction <code>synchronized</code> (for specialists)"
msgstr "Instrução <code>synchronized</code> (para especialistas)"

#. type: Plain text
#: ../E/synchro.txt:2
#, no-wrap
msgid "A <a cbot|class>class</a> method can be declared <code>synchronized</code>. This is to make sure that the method is never being executed by more than one bot at the same time."
msgstr "Um método de uma <a cbot|class>classe</a> pode ser declarado com  <code>synchronized</code>. Isto é para ter certeza de que o método nunca está sendo executado por mais de um robô ao mesmo tempo."

#. type: Plain text
#: ../E/synchro.txt:4
#, no-wrap
msgid "The following example illustrates the problem:"
msgstr "O seguinte exemplo ilustra o problema:"

#. type: Source code
#: ../E/synchro.txt:6
#, no-wrap
msgid ""
"class blocking\n"
"{\n"
"\tstatic int nb = 33;\n"
"\tsynchronized int inc( )\n"
"\t{\n"
"\t\tint val = nb;\n"
"\t\twait ( 2 );  // wait 2 sec.\n"
"\t\tnb = nb + 1;\n"
"\t\treturn val;\n"
"\t}\n"
"}"
msgstr ""
"class bloqueio\n"
"{\n"
"\tstatic int numero = 33;\n"
"\tsynchronized int incrementar( )\n"
"\t{\n"
"\t\tint valor = numero;\n"
"\t\twait ( 2 );  // espere 2 segundos.\n"
"\t\tnumero = numero + 1;\n"
"\t\treturn valor;\n"
"\t}\n"
"}"

#. type: Plain text
#: ../E/synchro.txt:18
#, no-wrap
msgid ""
"What happens if two bots execute the <code>inc</code> method at the same time?\n"
"Both of them will execute <code>val=nb</code> and wait 2 seconds so both of them will have <code>val=33</code>. With <code>synchronized</code> the first bot starts execution with <code>val=33</code> and then waits 2 seconds and returns. Only once the first bot has returned from the <code>inc</code> method, the second bot will be allowed to enter the <code>inc</code> method and therefore the second bot will always have <code>val=34</code>."
msgstr ""
"O que aconteceria se dois robôs executassemo método <code>incrementar</code> ao mesmo tempo?\n"
"Ambos iriam executar <code>valor=numero</code> e esperariam 2 segundos, então ambos teriam <code>valor=33</code>. Com <code>synchronized</code>  o primeiro robô iniciaria a execução com <code>valor=33</code> e esperaria 2 segundos e retornaria. Somente depois que o primeiro robô retornar do método <code>incrementar</code>, o segundo robô teria permissão para entrar no método <code>incrementar</code> e após isso o segundo robô teria  <code>valor=34</code>."

#. type: Plain text
#: ../E/synchro.txt:21
#, no-wrap
msgid "You can have more than one synchronized method in your <a cbot|class>class</a> in order to prevent simultaneous execution across more than one method. In other words: as long as a bot's program is inside a synchronized method, no other bot can enter any synchronized method of the same class."
msgstr "Você pode ter mais de um método sincronizado na sua <a cbot|class>classe</a> de forma a prevenir execuções simultaneas sobre um ou mais métodos. Em outras palavras: desde que o programa de um robô está dentro de um método sincronizado, nenhum outro robô pode entrar em nenhum outro método sincronizado da mesma classe."

#. type: Plain text
#: ../E/synchro.txt:24
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|static>static</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|static>static</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/term.txt:1
#, no-wrap
msgid "Semicolon"
msgstr "Ponto e vírgula"

#. type: Plain text
#: ../E/term.txt:2
#, no-wrap
msgid "Always use a semicolon <c/>;<n/> after a simple expression. For example: "
msgstr "Sempre use ponto e vírgula <c/>;<n/> após uma expressão simples. Por exemplo:"

#. type: Source code
#: ../E/term.txt:4
#, no-wrap
msgid "\tint counter = 0;"
msgstr "\tint contador = 0;"

#. type: Plain text
#: ../E/term.txt:6
#, no-wrap
msgid "However, after a <a cbot|bloc>bloc</a>, never put a semicolon:"
msgstr "Entretando, após um <a cbot|bloc>bloco</a>, nunca ponha um ponto e vírgula:"

#. type: Source code
#: ../E/term.txt:8
#, no-wrap
msgid ""
"\t{\n"
"\t\tfloat dist;\n"
"\t\tdist = distance(p1, p2);\n"
"\t} <n/>// no semicolon here!<c/>"
msgstr ""
"\t{\n"
"\t\tfloat distancia;\n"
"\t\tdistancia = distance(p1, p2);\n"
"\t} <n/>// nenhum ponto e vírgula aqui!<c/>"

#. type: Plain text
#: ../E/term.txt:13
#, no-wrap
msgid "Do not use a semicolon either immediately after the instructions <code><a cbot|while>while</a></code>, <code><a cbot|if>if</a></code> or <code><a cbot|for>for</a></code>:"
msgstr "Não use ponto e vírgula imediatamente após as instruções <code><a cbot|while>while</a></code>, <code><a cbot|if>if</a></code> ou <code><a cbot|for>for</a></code>:"

#. type: Source code
#: ../E/term.txt:15
#, no-wrap
msgid ""
"\tif ( a < b ) <n/>// no semicolon here!<c/>\n"
"\t{\n"
"\t\tb = 100-a;\n"
"\t}"
msgstr ""
"\tif ( a < b ) <n/>// nenhum ponto e vírgula aqui!<c/>\n"
"\t{\n"
"\t\tb = 100-a;\n"
"\t}"

#. type: Plain text
#: ../E/term.txt:20
#, no-wrap
msgid "An instruction is always ended by a semicolon, and not by the end of the line. So you can very well put several instructions on the same line: "
msgstr "Uma instrução sempre termina com um ponto e vírgula, e não pelo fim da linha. Então você pode muito bem colocar várias instruções na mesma linha."

#. type: Source code
#: ../E/term.txt:22
#, no-wrap
msgid ""
"\tint d=20;\n"
"\tmove(d);\n"
"\tturn(90);"
msgstr ""
"\tint d=20;\n"
"\tmove(d);\n"
"\tturn(90);"

#. type: Plain text
#: ../E/term.txt:26
#, no-wrap
msgid "Is equivalent to:"
msgstr "É equivalente a:"

#. type: Source code
#: ../E/term.txt:28
#, no-wrap
msgid "\tint d=20; move(d); turn(90);"
msgstr "\tint d=20; move(d); turn(90);"

#. type: \b; header
#: ../E/testinfo.txt:1
#, no-wrap
msgid "Instruction <code>testinfo</code>"
msgstr "Instrução <code>testinfo</code>"

#. type: Source code
#: ../E/testinfo.txt:3
#, no-wrap
msgid "<c/>testinfo ( name, power );<n/>"
msgstr "<c/>testinfo ( nome, energia );<n/>"

#. type: Plain text
#: ../E/testinfo.txt:5
#, no-wrap
msgid "Tests if an information exists in the closest <a object|exchange>information exchange post</a>."
msgstr "Testa se uma informação existe no <a object|exchange>posto de troca de informação</a> mais perto."

#. type: Plain text
#: ../E/testinfo.txt:8
#, no-wrap
msgid "Name of the information to be tested in the exchange post. This name is a string: it must be written in quotation marks \"\"."
msgstr "Nome da informação a ser testada no posto de troca. Este nome é uma string: deve vir entre aspas \" \"."

#. type: Plain text
#: ../E/testinfo.txt:11
#, no-wrap
msgid "Power of the transmitter, which corresponds to the maximal distance between the transmitter and the exchange post. If the distance is longer, the function returns <code>false</code>. Default value is 10 metres."
msgstr "Energia do transmissor, a qual corresponde a distância máxima entre o transmissor e o posto de troca. Se a distância é longa, a função retorna  <code>false</code>. O valor padrão é 10 metros."

#. type: \t; header
#: ../E/testinfo.txt:13
#, no-wrap
msgid "Return: <code><a cbot|bool>bool</a></code>"
msgstr "Valor de retorno: <code><a cbot|bool>bool</a></code>"

#. type: Plain text
#: ../E/testinfo.txt:14
#, no-wrap
msgid "Return <code>true</code> if the information exists. Return and <code>false</code> if the information does not exist or if the receiver is too far away from the exchange post."
msgstr "Retorna <code>true</code> se a informação existe. Retorna <code>false</code> se a informação não existe ou se o receptor estiver muito longe do posto de troca."

#. type: Plain text
#: ../E/testinfo.txt:17
#, no-wrap
msgid ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> et <code><a cbot|delinfo>deleteinfo</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/this.txt:1
#, no-wrap
msgid "Instruction <code>this</code>"
msgstr "Instrução <code>this</code>"

#. type: Plain text
#: ../E/this.txt:2
#, no-wrap
msgid "Occasionally, a <a cbot|class>class</a> method needs to know the reference to the instance it is acting upon. For example the instance might want to pass it's own reference to another function. An implicit reference name <code>this</code> is available to methods and <code>this</code> is a reference to the current instance."
msgstr "Ocasionalmente, um método de uma <a cbot|class>classe</a> precisa conhecer a referência para a instância que está agindo sobre. Por exemplo a instância pode querer passar sua própria referência para outra função. Uma referência implicita de nome <code>this</code> é disponível para os métodos, <code>this</code> é uma referência para a instância atual."

#. type: Source code
#: ../E/this.txt:4
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint    m_int;\n"
"\tstring m_str;\n"
"\tvoid MyFunction()\n"
"\t{\n"
"\t\tOtherFunction(this);\n"
"\t\tm_int = 2;\n"
"\t}\n"
"}\n"
"\n"
"void OtherFunction(MyClass obj)\n"
"{\n"
"\tmessage(obj.m_str);\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tMyClass item();\n"
"\titem.m_str = \"Hello\";\n"
"\titem.MyFunction();  // display \"Hello\"\n"
"}"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tint    m_int;\n"
"\tstring m_str;\n"
"\tvoid MinhaFuncao()\n"
"\t{\n"
"\t\tOutraFuncao(this);\n"
"\t\tm_int = 2;\n"
"\t}\n"
"}\n"
"\n"
"void OutraFuncao(MinhaClasse obj)\n"
"{\n"
"\tmessage(obj.m_str);\n"
"}\n"
"\n"
"extern void object::Teste()\n"
"{\n"
"\tMinhaClasse item();\n"
"\titem.m_str = \"Olá\";\n"
"\titem.MinhaFuncao();  // exibe \"Olá\"\n"
"}"

#. type: Plain text
#: ../E/this.txt:27
#, no-wrap
msgid "You can also put <code>this</code> before a field name in a method but this is not necessary. In the example above in the method <code>MyFunction()</code> following two lines have strictly the same meaning:"
msgstr "Você também pode colocar <code>this</code> antes do nome de um campo em um método, porém isso não é necessário. No exemplo acima no método <code>MinhaFuncao()</code> as seguintes duas linhas tem estritamente o mesmo significado:"

#. type: Source code
#: ../E/this.txt:29
#, no-wrap
msgid ""
"\tm_int = 2;\n"
"\tthis.m_int = 2;  // identical"
msgstr ""
"\tm_int = 2;\n"
"\tthis.m_int = 2;  // identico"

#. type: Plain text
#: ../E/this.txt:32
#, no-wrap
msgid "In a method of the <code><a cbot|object>object</a></code> class, you can also use <code>this.</code> before a fieldname."
msgstr "Em um método da classe <code><a cbot|object>object</a></code>, você também pode usar <code>this</code> antes de um campo."

#. type: Source code
#: ../E/this.txt:34
#, no-wrap
msgid ""
"extern void object::Display()\n"
"{\n"
"\tmessage(orientation);\n"
"\tmessage(this.orientation); // same thing but\n"
"\t                           // more explicit\n"
"}"
msgstr ""
"extern void object::Exibir()\n"
"{\n"
"\tmessage(orientation);\n"
"\tmessage(this.orientation); // mesma coisa\n"
"\t                           // porém mais explicito\n"
"}"

#. type: Plain text
#: ../E/this.txt:41
#, no-wrap
msgid "However if a field name is hidden by a parameter declaration or a variable declaration you must use <code>this</code>. In the following example the name <code>value</code> of the parameter is the same as the name of the field <code>value</code> of the <a cbot|class>class</a> <code>MyClass</code>, we must therefore write <code>this.value</code> in order to distinguish the field from the parameter."
msgstr "Entretando se o nome de um campo é oculto por uma declaração de parâmetro ou variável você deve usar <code>this</code>. No exemplo seguinte o nome <code>valor</code> do parâmetro é o mesmo que o nome do campo <code>valor </code> da <a cbot|class>classe</a> <code>MinhaClasse</code>, nós devemos então escrever <code>this.valor</code> a fim de distinguir o campo do parâmetro."

#. type: Source code
#: ../E/this.txt:43
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint  value;\n"
"\tvoid Put( int value )\n"
"\t{\n"
"\t\tthis.value = value;\n"
"\t}\n"
"}"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tint  valor;\n"
"\tvoid Colocar( int valor )\n"
"\t{\n"
"\t\tthis.valor = valor;\n"
"\t}\n"
"}"

#. type: \b; header
#: ../E/thump.txt:1
#, no-wrap
msgid "Instruction <code>thump</code>"
msgstr "Instrução <code>thump</code>"

#. type: Source code
#: ../E/thump.txt:3
#, no-wrap
msgid "<c/>thump ( );<n/>"
msgstr "<c/>thump ( );<n/>"

#. type: Plain text
#: ../E/thump.txt:5
#, no-wrap
msgid "Activates the weapon system of the <a object|bottump>thumper</a>, that turns ants and spiders belly up and makes them completely harmless for a while."
msgstr "Ativa o sistema de armas do <a object|bottump>batedor</a>, o que gira formigas e aranhas de barriga para cima deixando-as completamente inofensivas por um momento."

#. type: Plain text
#: ../E/thump.txt:8
#, no-wrap
msgid ""
"Zero if everything is OK, a value different from zero if an error occurred. \n"
"<code>== 0 </code>Thumping performed\n"
"<code>!= 0 </code>Operation impossible"
msgstr ""
"Zero se tudo está OK, um valor diferente de zero se um erro ocorreu.\n"
"<code>== 0 </code>Batida realizada\n"
"<code>!= 0 </code>Operação impossível"

#. type: \b; header
#: ../E/topo.txt:1
#, no-wrap
msgid "Instruction <code>topo</code>"
msgstr "Instrução <code>topo</code>"

#. type: Source code
#: ../E/topo.txt:3
#, no-wrap
msgid "<c/>topo ( position );<n/>"
msgstr "<c/>topo ( posicao );<n/>"

#. type: Plain text
#: ../E/topo.txt:5
#, no-wrap
msgid "Returns the altitude of the ground at a give position. The altitude zero corresponds to sea level. A negative value indicates that at this position ground is covered with water. "
msgstr "Retorna a altitude do chão na posição dada. A altitude zero corresponde ao nível do mar. Um valor negativo indica que o chão está coberto com água."

#. type: Plain text
#: ../E/topo.txt:8
#, no-wrap
msgid "Coordinates of the position whose altitude you want to know. "
msgstr "Coordenadas da posição da qual a altitude você quer conhecer."

#. type: Plain text
#: ../E/topo.txt:11
#, no-wrap
msgid "Altitude of the ground at the given position."
msgstr "Altitude do chão na posição dada."

#. type: \b; header
#: ../E/true.txt:1
#, no-wrap
msgid "Type <code>true</code>"
msgstr "Tipo <code>true</code>"

#. type: Plain text
#: ../E/true.txt:2
#, no-wrap
msgid "This value means that a condition is true; it is one of the two values that a <a cbot|bool>boolean</a> <a cbot|var>variable</a> can take."
msgstr "Este valor significa que uma condição é verdadeira; é um dos dois valores que uma  <a cbot|var>variável</a> <a cbot|bool>boolean</a> pode assumir."

#. type: \b; header
#: ../E/turn.txt:1
#, no-wrap
msgid "Instruction <code>turn</code>"
msgstr "Instrução <code>turn</code>"

#. type: Plain text
#: ../E/turn.txt:2
#, no-wrap
msgid "Use the instruction <c/>turn();<n/> to instruct the bot to perform a rotation on itself of a certain number of degrees."
msgstr "Use a instrução <c/>turn();<n/> para instruir o robô a realizar uma rotação em sí mesmo em um certo número de graus."

#. type: Plain text
#: ../E/turn.txt:5
#, no-wrap
msgid "90 degreed means a quarter turn, 180 degrees means a half turn. A positive angle will perform a counterclockwise rotation, a negative angle means a clockwise rotation. Here are some examples with <c/>turn();<n/>:"
msgstr "90 graus significa girar um quarto, 180 graus significa digar metade. Um ângulo positivo irá girar no setindo anti-horário, um ângulo negativo significa girar no sentido horário. Aqui estão alguns exemplos com <c/>turn();<n/>:"

#. type: Plain text
#: ../E/turn.txt:7
#, no-wrap
msgid ""
"<c/>turn(90);<n/>  quarter turn to the left\n"
"<c/>turn(-90);<n/> quarter turn to the right (negative angle)\n"
"<c/>turn(180);<n/> half turn"
msgstr ""
"<c/>turn(90);<n/>  gira um quarto para a esquerda\n"
"<c/>turn(-90);<n/> gira um quarto para a direita (ângulo negativo)\n"
"<c/>turn(180);<n/> gira metade"

#. type: Plain text
#: ../E/turn.txt:11
#, no-wrap
msgid "In order to turn the bot towards an object found with the instruction <c/><a cbot|radar>radar</a>();<n/>, you must calculate the rotation angle with the instruction <code><a cbot|direct>direction</a>()</code>:"
msgstr "A fim de girar o robô em direção a um objeto encontrado com a instrução <c/><a cbot|radar>radar</a>();<n/>, você deve calcular o ângulo do rotação com a instrução <code><a cbot|direct>direction</a>()</code>:"

#. type: Source code
#: ../E/turn.txt:13
#, no-wrap
msgid ""
"\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
"\tturn(<a cbot|direct>direction</a>(item.position));"
msgstr ""
"\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
"\tturn(<a cbot|direct>direction</a>(item.position));"

#. type: Plain text
#: ../E/turn.txt:16
#, no-wrap
msgid "After these lines, just fire the cannon, and there is one hostile element less."
msgstr "Depois dessa linhas, apenas atire com o canhão, e haverá um elemento hostil a menos."

#. type: Source code
#: ../E/turn.txt:20
#, no-wrap
msgid "<c/>turn ( angle );<n/>"
msgstr "<c/>turn ( angulo );<n/>"

#. type: Plain text
#: ../E/turn.txt:22
#, no-wrap
msgid "Turns the bot with a given angle, right or left, without moving either forward or backward. "
msgstr "Gira o robô com o ângulo dado, direita ou esquerda, sem mover para frente ou para trás."

#. type: Plain text
#: ../E/turn.txt:25
#, no-wrap
msgid "Angle of the required rotation, in degrees. A positive value turns left, a negative value turns right. <code>turn(180)</code> turns round completely. "
msgstr "Ângulo da rotação requerida, em graus. Um valor positivo gira a esquerda, um valor negativo gira a direita. <code>turn(180)</code> gira completamente."

#. type: Plain text
#: ../E/turn.txt:28
#, no-wrap
msgid ""
"Zero if everything is OK, or a value different from zero if an error occurred. \n"
"<code>== 0 </code>rotation performed\n"
"<code>!= 0 </code>rotation impossible"
msgstr ""
"Zero se está tudo OK, um valor diferente de zero se um erro ocorreu.\n"
"<code>== 0 </code>rotação realizada\n"
"<code>!= 0 </code>rotação impossível"

#. type: \b; header
#: ../E/type.txt:1
#, no-wrap
msgid "Variable types"
msgstr "Tipos de variáveis"

#. type: Plain text
#: ../E/type.txt:2
#, no-wrap
msgid "When you define a <a cbot|var>variable</a>, you must give two elements: "
msgstr "Quando você define uma <a cbot|var>variável</a>, você deve informar dois elementos:"

#. type: Bullet: '1)'
#: ../E/type.txt:4
#, no-wrap
msgid "a name"
msgstr "um nome"

#. type: Bullet: '2)'
#: ../E/type.txt:5
#, no-wrap
msgid "a type"
msgstr "um tipo"

#. type: Plain text
#: ../E/type.txt:7
#, no-wrap
msgid "Once you defined a variable, you can use it to put information in it. However, the information that a variable can contain must always be of the correct type: a variable of type <a cbot|float>float</a> can not contain a string, etc."
msgstr "Assim que você define uma variável, você pode colocar informação nela. Entretanto, a informação que a variável pode obter deve ser sempre do tipo correto: uma variável do tipo <a cbot|float>float</a> não pode conter uma string, etc."

#. type: Source code
#: ../E/type.txt:11
#, no-wrap
msgid "<code><a cbot|int>int</a></code>"
msgstr "<code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/type.txt:12
#, no-wrap
msgid "For a whole number (12, -500, etc.)."
msgstr "Para um número inteiro (12, -500, etc)."

#. type: Source code
#: ../E/type.txt:14
#, no-wrap
msgid "<code><a cbot|float>float</a></code>"
msgstr "<code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/type.txt:15
#, no-wrap
msgid "For a real number (12, 3.14, 0.2, -99.98, etc.)."
msgstr "Para números reais (12, 3.14, 0.2, -99.98, etc.)."

#. type: Source code
#: ../E/type.txt:17
#, no-wrap
msgid "<code><a cbot|bool>bool</a></code>"
msgstr "<code><a cbot|bool>bool</a></code>"

#. type: Plain text
#: ../E/type.txt:18
#, no-wrap
msgid "For a boolean variable, that can only take the values <code>true</code> or <code>false</code>."
msgstr "Uma variável booleana só pode conter os valores <code>true</code> ou <code>false</code> (verdadeiro ou falso)."

#. type: Source code
#: ../E/type.txt:20
#, no-wrap
msgid "<code><a cbot|string>string</a></code>"
msgstr "<code><a cbot|string>string</a></code>"

#. type: Plain text
#: ../E/type.txt:21
#, no-wrap
msgid "For texts (\"Hello!\", \"No object found\", etc.)"
msgstr "Para textos (\"Olá!\", \"Nenhum objeto encontrado\", etc.)"

#. type: Source code
#: ../E/type.txt:23
#, no-wrap
msgid "<code><a cbot|point>point</a></code>"
msgstr "<code><a cbot|point>point</a></code>"

#. type: Plain text
#: ../E/type.txt:24
#, no-wrap
msgid "For the coordinates of a point in space; a variable of this type consists of three parts named x, y and z."
msgstr "Para as coordenadas de um ponto no espaço; uma variável deste tipo consiste de três partes nomeadas x, y e z."

#. type: Source code
#: ../E/type.txt:26
#, no-wrap
msgid "<code><a cbot|object>object</a></code>"
msgstr "<code><a cbot|object>object</a></code>"

#. type: Plain text
#: ../E/type.txt:27
#, no-wrap
msgid "A variable of this type contains the information about an object (bot, building, enemy, etc.)."
msgstr "Uma variável deste tipo contém informação sobre um objeto (robô, edifício, inimigo, etc)."

#. type: Source code
#: ../E/type.txt:29
#, no-wrap
msgid "<code><a cbot|void>void</a></code>"
msgstr "<code><a cbot|void>void</a></code>"

#. type: Plain text
#: ../E/type.txt:30
#, no-wrap
msgid "This type is an \"empty type\", that you use when you do not want to specify a type."
msgstr "Este tipo é um \"tipo vazio\", que você usa quando não quer especificar um tipo."

#. type: \b; header
#: ../E/var.txt:1
#, no-wrap
msgid "Variables"
msgstr "Variáveis"

#. type: Plain text
#: ../E/var.txt:2
#, no-wrap
msgid "A variable is like a box, where you can put some information. The content of the variable can change during the execution of the program."
msgstr "Uma variável é como uma caixa, onde você pode colocar alguma informação. O conteúdo da variável pode mudar durante a execução do programa."

#. type: Plain text
#: ../E/var.txt:4
#, no-wrap
msgid "For example, you can use a variable to count the number of titanium ore units that the grabber has collected and carried to the converter. First, you must find a name for it: the name should not be too long, but explain by itself what the variable is used for. Let's call it <code>countTit</code>. This variable must contain only whole numbers, so choose the type <code>int</code>. At the beginning of the program, you must declare the variable. Then you put the value <code>0</code> into the variable, and every time you grab a titanium ore, you increase the variable by <code>1</code>. At every moment, the variable contains the number of titanium ore units that the grabber collected."
msgstr "Por exemplo, você pode usar uma variável para conter o número de unidades de minério de titânio que o agarrador coletou e carregou para o conversor. Primeiro, você deve encontrar um nome para ela: o nome não deve ser muito longo, porém deve explicar explicar por sí mesmo o propósito da variável. Vamos chamá-la de <code>contadorTit</code>. Esta variável deve conter somente números inteiros, então escolha o tipo <code>int</code>. No começo do programa você deve declarar a variável, depois você coloca o valor <code>0</code> na variável, e toda vez que você pegar um minério de titânio, você incrementa a variável por <code>1</code>. A todo momento, a variável contém o número de unidades de minério de titânio que o agarrador coletou."

#. type: Plain text
#: ../E/var.txt:6
#, no-wrap
msgid ""
"For the declaration of the variable, write the following line: \n"
"<c/><s/>\tint  countTit;<n/>"
msgstr ""
"Para a declaração da variável escreva a seguinte linha: \n"
"<c/><s/>\tint  contadorTit;<n/>"

#. type: Plain text
#: ../E/var.txt:9
#, no-wrap
msgid ""
"To put <code>0</code> into the variable, write:\n"
"<c/><s/>\tcountTit = 0;<n/>"
msgstr ""
"Para colocar <code>0</code> na variável, escreva:\n"
"<c/><s/>\tcontadorTit = 0;<n/>"

#. type: Plain text
#: ../E/var.txt:12
#, no-wrap
msgid ""
"At every titanium ore grabbed, write:\n"
"<c/><s/>\tcountTit = countTit + 1<n/>"
msgstr ""
"Toda vez que um minério de titânio for pego, escreva:\n"
"<c/><s/>\tcontadorTit = contadorTit + 1<n/>"

#. type: Plain text
#: ../E/var.txt:15
#, no-wrap
msgid ""
"You have much freedom in the choice of the name for a variable, you can call them by any name, f. ex.: <code>dist</code>, <code>direct</code>, <code>p2</code>, <code>a</code>, <code>x</code>, <code>nothing_2_shoot_at</code>, etc.\n"
"A variable name must always begin with a letter. It can be followed by any combination of letters, digits or the underscore character <code>_</code>. You can of course not use the keywords of the CBOT language like <code><a cbot|for>for</a></code>, <code><a cbot|while>while</a></code>, <code><a cbot|break>break</a></code>, <code><a cbot|continue>continue</a></code>, <code>do</code>, etc.\n"
"You should be careful about the choice of the names that you give to variables; writing a program can become very difficult if you forget the names of variables or if you do not remember what they are used for. Elaborate your own system to find variable names, and do not use names like <code>Bmo45</code>, <code>a</code> or <code>tgBinX</code>."
msgstr ""
"Você tem muita liberdade na escolha do nome de uma variável, você pode chamá-la por qualquer nome. por exemplo: <code>distancia</code>, <code>direcao </code>, <code>p2</code>, <code>a</code>, <code>x</code>, <code>nada_para_atirar</code>, etc.\n"
"Um nome de variável deve sempre começar com uma letra. Ele pode ser seguido por qualquer combinação de letras, números ou o carácter underline <code>_</code>. Você pode, claro, não usar palavras-chave da linguagem CBOT como <code><a cbot|for>for</a></code>, <code><a cbot|while>while</a></code>, <code><a cbot|break>break</a></code>, <code><a cbot|continue>continue</a></code>, <code>do</code>, etc.\n"
"Você deve ter cuidado ao escolher o nome que você dá as variáveis;  escrever um programa pode se tornar muito difícil se você esquecer o nome das variáveis ou se você não lembrar para que elas servem. Elabore seu próprio sistema para encontrar nome nome de variáveis, e não use nomes como <code>Bmo45</code>, <code>a</code> ou <code>tgBinX</code>."

#. type: Plain text
#: ../E/var.txt:19
#, no-wrap
msgid "In the example above, the keyword <code>int</code> indicates that this variable can contain only whole numbers, which is adequate to counting objects. If you want to measure a distance, better use a variable that can contain also real numbers, with a fractional part (like 3.45 or 0.034): in this case, use the type <code>float</code>."
msgstr "No exemplo acima, a palavra-chave  <code>int</code> indica que esta variável pode conter somente números inteiros, os quais são adequados para contar objetos. Se você quer medir distância, melhor usar uma variável que pode conter números reais também, com uma parte fracional (como 3.45 ou 0.034): neste caso, use o tipo <code>float</code>."

#. type: Plain text
#: ../E/var.txt:21
#, no-wrap
msgid "In fact, a variable is made up of three parts:"
msgstr "Em fato, uma variável é composta por três partes:"

#. type: Bullet: '1)'
#: ../E/var.txt:22
#, no-wrap
msgid "the name,"
msgstr "o nome,"

#. type: Bullet: '2)'
#: ../E/var.txt:23
#, no-wrap
msgid "the type of the information stored inside,"
msgstr "o tipo da informação armazenada,"

#. type: Bullet: '3)'
#: ../E/var.txt:24
#, no-wrap
msgid "the content, i.e. the information itself."
msgstr "o conteúdo, ou seja, a informação em sí"

#. type: \t; header
#: ../E/var.txt:26
#, no-wrap
msgid "the name"
msgstr "o nome"

#. type: Plain text
#: ../E/var.txt:27
#, no-wrap
msgid "You need the name to be able to distinguish the different variables from each other."
msgstr "Você precisa do nome para conseguir distinguir as diferentes variáveis entre sí."

#. type: \t; header
#: ../E/var.txt:29
#, no-wrap
msgid "the type"
msgstr "o tipo"

#. type: Plain text
#: ../E/var.txt:30
#, no-wrap
msgid ""
"The <a cbot|type>type</a> determines what kind of information the variable can contain. According to the type, a variable can contain a whole number, a real number, a string, the coordinates of a point, information about an object, etc. \n"
"Here is a list of the most common variable types:"
msgstr ""
"O <a cbot|type>tipo</a> determina que tipo de informação a variável pode conter. De acordo com o tipo, a variável pode conter um número inteiro, um número real, uma cadeia de carácteres, as coordenadas de um ponto, informação sobre um objeto, etc. \n"
"Aqui está uma lista dos tipos mais comuns de variáveis:"

#. type: Bullet: 'o'
#: ../E/var.txt:32
#, no-wrap
msgid "<code><a cbot|int>int</a></code> for a whole number (12, -500, etc.)"
msgstr "<code><a cbot|int>int</a></code> para um número inteiro (12, -500, etc.)"

#. type: Bullet: 'o'
#: ../E/var.txt:33
#, no-wrap
msgid "<code><a cbot|float>float</a></code> for a real number (3.14, 0.2, -99.98, etc.)"
msgstr "<code><a cbot|float>float</a></code> para um número real (3.14, 0.2, -99.98, etc.)"

#. type: Bullet: 'o'
#: ../E/var.txt:34
#, no-wrap
msgid "<code><a cbot|string>string</a></code> for a character string (\"Hello!\", \"No object found\", etc.)"
msgstr "<code><a cbot|string>string</a></code> para uma cadeia de carácteres (\"Olá!\", \"Nenhum objeto encontrado\", etc.)"

#. type: Bullet: 'o'
#: ../E/var.txt:35
#, no-wrap
msgid "<code><a cbot|point>point</a></code> for a x,y,z-coordinate in space"
msgstr "<code><a cbot|point>point</a></code> para coordenadas x, y e z no espaço"

#. type: Bullet: 'o'
#: ../E/var.txt:36
#, no-wrap
msgid "<code><a cbot|object>object</a></code> for information about an object (bot, building, etc.)"
msgstr "<code><a cbot|object>object</a></code> para informação sobre um objeto (robô, edifício, etc.)"

#. type: \t; header
#: ../E/var.txt:38
#, no-wrap
msgid "The content"
msgstr "O conteúdo"

#. type: Plain text
#: ../E/var.txt:39
#, no-wrap
msgid "The content of a variable is an information of the kind specified in the type. It can change during the execution of the program. "
msgstr "O conteúdo de uma variável é uma informação da natureza especificada no tipo. Ela pode mudar durante a execução do programa."

#. type: Plain text
#: ../E/var.txt:41
#, no-wrap
msgid ""
"Once you declared a variable, it still does not contain any value. Before you can use it, you must put a value inside: \n"
"<c/><s/>\tint  i, j;"
msgstr ""
"Assim que você declara uma variável, ela ainda não possui nenhum valor. Antes de você poder usá-la, você deve colocar um valor dentro: \n"
"<c/><s/>\tint  i, j;"

#. type: Source code
#: ../E/var.txt:43
#, no-wrap
msgid ""
"\tj = 25;  // j takes the value 25\n"
"\tj = i;   // can not write this, because i has got no content yet."
msgstr ""
"\tj = 25;  // j pega o valor 25\n"
"\tj = i;   // não pode escrever isso, porque i ainda não tem conteúdo"

#. type: Plain text
#: ../E/var.txt:46
#, no-wrap
msgid ""
"You can also declare a variable and put a value inside in the same line, writing: \n"
"<c/><s/>\tint  countTit = 0;"
msgstr ""
"Você também pode declarar uma variável e colocar um valor dentro na mesma linha, escrevendo: \n"
"<c/><s/>\tint  contadorTit = 0;"

#. type: Plain text
#: ../E/var.txt:49
#, no-wrap
msgid ""
"When you assign a value to a variable with the equals sign <code>=</code>, the value on the right side is copied into the value on the left side. Consider the following example: \n"
"<c/><s/>\tint  i, j;"
msgstr ""
"Quando você atribui um valor a uma variável com o sinal de igual <code>=</code>, o valor a direita é copiado para o valor a esquerda. Considere o seguinte exemplo: \n"
"<c/><s/>\tint  i, j;"

#. type: Source code
#: ../E/var.txt:51
#, no-wrap
msgid ""
"\ti = 5+2;  // i takes the value 7\n"
"\tj = i+6;  // j takes the value of i plus 6, this is 13\n"
"\ti = j;    // i takes the value of j, this is 13"
msgstr ""
"\ti = 5+2;  // i pega o valor 7\n"
"\tj = i+6;  // j pega o valor de i + 6, que é 13\n"
"\ti = j;    // i pega o valor de j, que é 13"

#. type: Plain text
#: ../E/var.txt:55
#, no-wrap
msgid "At the end of this example, both variables <code>i</code> and <code>j</code> contain the value <code>13</code>."
msgstr "No fim deste exemplo, ambas as variáveis <code>i</code> e <code>j</code> contém o valor <code>13</code>."

#. type: Plain text
#: ../E/var.txt:57
#, no-wrap
msgid ""
"The following assignment is not correct, because on the left side of the equals sign <code>=</code>, there can be only a variable name:\n"
"<c/><s/>\ti+2 = j;  // impossible"
msgstr ""
"A seguinte atribuição não está correta, porque no lado esquerdo no sinal de igual <code>=</code>, só pode haver um único nome de variável:\n"
"<c/><s/>\ti+2 = j;  // impossível"

#. type: Plain text
#: ../E/var.txt:60
#, no-wrap
msgid ""
"If you want to exchange the values of two variables, you must use a third variable. Here is an example to exchange the content of two variables <code>a</code> and <code>b</code> :\n"
"<c/><s/>\tint temp;"
msgstr ""
"Se você quer trocar o valor de duas variáveis, você precisa usar uma terceira variável. Aqui está um exemplo que troca o conteúdo de duas variáveis: <code>a</code> e <code>b</code> :\n"
"<c/><s/>\tint temporario;"

#. type: Source code
#: ../E/var.txt:62
#, no-wrap
msgid ""
"\ttemp = a;  // temp takes the value of a\n"
"\ta = b;     // the content of b is copied into a\n"
"\tb = temp;  // the content of temp is copied into b"
msgstr ""
"\ttemporario = a;  // temporario recebe o valor de a\n"
"\ta = b;     // o conteúdo de b é copiado para a\n"
"\tb = temp;  // o conteúdo de temporario é copiado para b"

#. type: \b; header
#: ../E/void.txt:1
#, no-wrap
msgid "Type <code>void</code>"
msgstr "Tipo <code>void</code>"

#. type: Plain text
#: ../E/void.txt:2
#, no-wrap
msgid "Use this type when you want to declare a function that returns nothing."
msgstr "Use este tipo quando você quiser declarar uma função que não retorna nada."

#. type: Plain text
#: ../E/void.txt:4
#, no-wrap
msgid ""
"Example:\n"
"<c/><s/>void MyFunction(int a)"
msgstr ""
"Exemplo:\n"
"<c/><s/>void MinhaFuncao(int a)"

#. type: Source code
#: ../E/void.txt:6
#, no-wrap
msgid ""
"{\n"
"\t...\n"
"}"
msgstr ""
"{\n"
"\t...\n"
"}"

#. type: \b; header
#: ../E/wait.txt:1
#, no-wrap
msgid "Instruction <code>wait</code>"
msgstr "Instrução <code>wait</code>"

#. type: Plain text
#: ../E/wait.txt:2
#, no-wrap
msgid "The instruction <c/>wait();<n/> instructs the bot to wait for some seconds, according to the value written in brackets."
msgstr "A instrução <c/>wait();<n/> instrui o robô a esperar alguns segundos de acordo com o valor escrito entre os parênteses."

#. type: Plain text
#: ../E/wait.txt:5
#, no-wrap
msgid "In order to wait until the <a object|power>power cell</a> is recharged on a power station, wait 5 seconds with <c/>wait(5);<n/>."
msgstr "A fim de esperar até que uma <a object|power>célula de energia</a> esteja carregada em uma estação de energia, espere 5 segundos com <c/>wait(5);<n/>."

#. type: Plain text
#: ../E/wait.txt:7
#, no-wrap
msgid "In order to wait until the <a object|convert>converter</a> finished transforming some <a object|titanore>titanium ore</a> in a <a object|titan>titanium cube</a>, wait 15 seconds with <c/>wait(15);<n/>."
msgstr "A fim de esperar até que um  <a object|convert>conversor</a> termine de transformar algum <a object|titanore>minério de titânio</a> em um <a object|titan>cubo de titânio</a>, espere 15 segundos com <c/>wait(15);<n/>."

#. type: Source code
#: ../E/wait.txt:11
#, no-wrap
msgid "<c/>wait ( time );<n/>"
msgstr "<c/>wait ( tempo );<n/>"

#. type: Plain text
#: ../E/wait.txt:13
#, no-wrap
msgid "Waits for a moment."
msgstr "Espera por um momento."

#. type: Plain text
#: ../E/wait.txt:16
#, no-wrap
msgid "Specifies the time that the bot must wait."
msgstr "Especifica o tempo que o robô deve esperar."

#. type: \b; header
#: ../E/while.txt:1
#, no-wrap
msgid "Instruction <code>while</code>"
msgstr "Instrução <code>while</code>"

#. type: Plain text
#: ../E/while.txt:2
#, no-wrap
msgid "The instruction <code>while () {}</code> is used to repeat a set of instructions several times."
msgstr "A instrução <code>while () {}</code> é usada para repetir um conjunto de instruções varias vezes."

#. type: Plain text
#: ../E/while.txt:5
#, no-wrap
msgid "The most frequent use of <code>while</code> consists in repeating a set of instructions again and again. In order to achieve this, write <code>while (true) {}</code> and put the instructions to be repeated in braces <code>{}</code>. As an example, here is a program that repeats again and again the following actions:"
msgstr "O uso mais frequente de <code>while</code> consiste em repetir um conjunto de instruções de novo e de novo. A fim de conseguir isto, escreva <code>while (true) {}</code> e coloque as instruções a serem repetidas entre as chaves <code>{}</code>. Como um exemplo, aqui está um programa que repete de novo e de novo as seguintes ações:"

#. type: Bullet: 'o'
#: ../E/while.txt:6
#, no-wrap
msgid "look for a spider,"
msgstr "procurar por uma aranha,"

#. type: Bullet: 'o'
#: ../E/while.txt:7
#, no-wrap
msgid "turn towards it,"
msgstr "virar para ela,"

#. type: Bullet: 'o'
#: ../E/while.txt:8
#, no-wrap
msgid "shoot."
msgstr "atirar."

#. type: Source code
#: ../E/while.txt:10
#, no-wrap
msgid ""
"\twhile (true)\n"
"\t{\n"
"\t\titem = <a cbot|radar>radar</a>(AlienSpider);\n"
"\t\t<a cbot|turn>turn</a>(direction(item.position));\n"
"\t\t<a cbot|fire>fire</a>(1);\n"
"\t}"
msgstr ""
"\twhile (true)\n"
"\t{\n"
"\t\talvo = <a cbot|radar>radar</a>(AlienSpider);\n"
"\t\t<a cbot|turn>turn</a>(direction(alvo.position));\n"
"\t\t<a cbot|fire>fire</a>(1);\n"
"\t}"

#. type: Plain text
#: ../E/while.txt:17
#, no-wrap
msgid "Just execute this program once, and it will kill all spiders around it."
msgstr "Apenas execute este programa uma vez, e ele irá matar todas as aranhas ao redor dele."

#. type: Source code
#: ../E/while.txt:21
#, no-wrap
msgid ""
"<code>while ( condition )\n"
"{\n"
"\t</code>Instructions ...<c/>\n"
"}"
msgstr ""
"<code>while ( condição )\n"
"{\n"
"\t</code>Instruções...<c/>\n"
"}"

#. type: Plain text
#: ../E/while.txt:26
#, no-wrap
msgid "This instruction allows you to perform the instructions inside the <a cbot|bloc>block</a> several times."
msgstr "Esta instrução permite a você executar as instruções dentro do <a cbot|bloc>bloco</a> varias vezes."

#. type: Plain text
#: ../E/while.txt:28
#, no-wrap
msgid "Be careful not to confuse the instruction <code>while( ) { }</code> with the instruction <c/><a cbot|do>do</a> { } while( );<n/>; the latter tests the condition only after the instructions in the block have been performed a first time. "
msgstr "Tenha cuidado para não confundir a instrução <code>while( ) { }</code> com a instrução <c/><a cbot|do>do</a> { } while( );<n/>; a última testa a condição somente após as instruções no bloco terem sido executadas pela primeira vez."

#. type: Source code
#: ../E/while.txt:34
#, no-wrap
msgid ""
"<c/>int i = 0;\n"
"while ( i < 10 )\n"
"{\n"
"\t<n/>Instructions ...<c/>\n"
"\ti = i+1;\n"
"}"
msgstr ""
"<c/>int i = 0;\n"
"while ( i < 10 )\n"
"{\n"
"\t<n/>Instruções...<c/>\n"
"\ti = i+1;\n"
"}"

#. type: Plain text
#: ../E/while.txt:42
#, no-wrap
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the line <code>while ( )</code>."
msgstr "Não coloque um <a cbot|term>ponto e vírgula</a> no fim da linha <code>while ( )</code>."

#. type: Plain text
#: ../E/while.txt:44
#, no-wrap
msgid "The instructions <code><a cbot|break>break</a></code> and <code><a cbot|continue>continue</a></code> can be useful inside a block following the instruction <code>while { }</code>."
msgstr "As instruções <code><a cbot|break>break</a></code> e <code><a cbot|continue>continue</a></code> podem ser úteis dentro de um bloco da instrução <code>while { }</code>."

#. type: \b; header
#: ../E/writeln.txt:1
#, no-wrap
msgid "Instruction <code>writeln</code>"
msgstr "Instrução <code>writeln</code>"

#. type: Plain text
#: ../E/writeln.txt:2
#, no-wrap
msgid "Write one line of text to an open file in the files/ folder. This is a method of the <code><a cbot|file>file</a></code> class. This is the reason why we always write <code>handle.writeln()</code>:"
msgstr "Escreve uma linha de texto em um arquivo aberto na pasta files/. Este é um método da classe <code><a cbot|file>file</a></code>. Esta é a razão porque sempre escrevemos <code>handle.writeln()</code>:"

#. type: Source code
#: ../E/writeln.txt:4
#, no-wrap
msgid "\thandle.writeln(\"abc\");"
msgstr "\thandle.writeln(\"abc\");"

#. type: Plain text
#: ../E/writeln.txt:6
#, no-wrap
msgid "The file must have been opened for writing (<code>\"w\"</code>) with the <code><a cbot|open>open</a></code> instruction. The line will automatically be terminated by the end of line characters 0x0D (CR) and 0x0A (LF)."
msgstr "O arquivo deve ter sido aberto para escrita (<code>\"w\"</code>) com a instrução  <code><a cbot|open>open</a></code>. A linha será automaticamente terminada pelos carácteres de fim de linha 0x0D (CR) e 0x0A (LF)."

#. type: Source code
#: ../E/writeln.txt:9
#, no-wrap
msgid "<c/>handle.writeln ( string );<n/>"
msgstr "<c/>handle.writeln ( string );<n/>"

#. type: Source code
#: ../E/writeln.txt:13
#, no-wrap
msgid "\twriteln(\"Line of text\");"
msgstr "\twriteln(\"Linha de texto\");"

#. type: Source code
#: ../E/writeln.txt:15
#, no-wrap
msgid ""
"\tstring s1 = \"abc\";\n"
"\tstring s2 = \"def\";\n"
"\twriteln(s1 + \" \" + s2);"
msgstr ""
"\tstring s1 = \"abc\";\n"
"\tstring s2 = \"def\";\n"
"\twriteln(s1 + \" \" + s2);"

#. type: Plain text
#: ../E/writeln.txt:20
#, no-wrap
msgid ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> and <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|file>file</a></code>, <code><a cbot|open>open</a></code>, <code><a cbot|close>close</a></code>, <code><a cbot|readln>readln</a></code> e <code><a cbot|eof>eof</a></code>.\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/acos.txt:1
#, no-wrap
msgid "Instruction <code>acos</code>"
msgstr "Instrução <code>acos</code>"

#. type: Source code
#: ../E/acos.txt:3
#, no-wrap
msgid "<c/>acos ( value );<n/>"
msgstr "<c/>acos( valor );</n>"

#. type: \t; header
#: ../E/acos.txt:5 ../E/asin.txt:5 ../E/atan.txt:5 ../E/ceil.txt:6 ../E/floor.txt:6 ../E/round.txt:6 ../E/sqrt.txt:5 ../E/trunc.txt:6
#, no-wrap
msgid "value: <code><a cbot|float>float</a></code>"
msgstr "valor: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/acos.txt:6 ../E/asin.txt:6
#, no-wrap
msgid "Number between -1 and 1 (including both)."
msgstr "Número entre -1 e 1 (incluindo ambos)"

#. type: Plain text
#: ../E/acos.txt:9
#, no-wrap
msgid "Arcus cosine (in degrees) of the value."
msgstr "Arco cosseno (em graus) do valor."

#. type: Plain text
#: ../E/acos.txt:12 ../E/asin.txt:12 ../E/atan.txt:12 ../E/atan2.txt:17 ../E/cos.txt:12 ../E/pow.txt:15 ../E/rand.txt:9 ../E/sin.txt:12 ../E/sqrt.txt:12 ../E/tan.txt:12
#, no-wrap
msgid "<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
msgstr "<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|expr>expressões</a>."

#. type: Source code
#: ../E/aim.txt:3
#, no-wrap
msgid "<c/>aim ( y, x );<n/>"
msgstr "<c/>aim ( y, x );<n/>"

#. type: Plain text
#: ../E/aim.txt:5
#, no-wrap
msgid "This instruction sets the vertical and the horizontal angle of the cannon. The following robots are equipped with a cannon: "
msgstr "Esta instrução define o ângulo vertical e horizontal de um canhão. Os seguintes robôs são equipados com um canhão:"

#. type: Plain text
#: ../E/aim.txt:10
#, no-wrap
msgid "When controlling the robot through programming, the gun can be also turned left or right by turning the whole robot with the instruction <code><a cbot|turn>turn</a></code>."
msgstr "Enquanto controlar um robô através de programação, a arma também pode ser girada para esquerda ou direita ao virar o robô inteiro com a instrução <code><a cbot|turn>turn</a></code>."

#. type: \t; header
#: ../E/aim.txt:12 ../E/atan2.txt:7 ../E/pow.txt:8
#, no-wrap
msgid "y: <code><a cbot|float>float</a></code>"
msgstr "y: <code><a cbot|float>float</a></code>"

#. type: \t; header
#: ../E/aim.txt:15
#, no-wrap
msgid "x: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
msgstr "x: <code><a cbot|float>float</a></code> (valor padrão: <code>0</code>)"

#. type: Plain text
#: ../E/aim.txt:16
#, no-wrap
msgid "Angle in degrees of the gun relative to the robot. A positive value orients the gun to the right. The angle must range from <code>-40</code> to <code>+40</code> degrees for all shooters."
msgstr "Ângulo em graus da arma relativa ao robô. Um valor positivo orienta a arma para a direita. O ângulo deve estar entre <code>-40</code> e <code>+40</code> graus para todos os atiradores."

#. type: \b; header
#: ../E/asin.txt:1
#, no-wrap
msgid "Instruction <code>asin</code>"
msgstr "Instrução <code>asin</code>"

#. type: Source code
#: ../E/asin.txt:3
#, no-wrap
msgid "<c/>asin ( value );<n/>"
msgstr "<c/>asin ( valor );<n/>"

#. type: Plain text
#: ../E/asin.txt:9
#, no-wrap
msgid "Arcus sine (in degrees) of the value."
msgstr "Arco seno (em graus) do valor."

#. type: \b; header
#: ../E/atan.txt:1
#, no-wrap
msgid "Instruction <code>atan</code>"
msgstr "Instrução <code>atan</code>"

#. type: Source code
#: ../E/atan.txt:3
#, no-wrap
msgid "<c/>atan ( value );<n/>"
msgstr "<c/>atan ( valor );<n/>"

#. type: Plain text
#: ../E/atan.txt:6 ../E/atan2.txt:8 ../E/atan2.txt:11 ../E/ceil.txt:7 ../E/floor.txt:7 ../E/round.txt:7 ../E/trunc.txt:7
#, no-wrap
msgid "Number."
msgstr "Número."

#. type: Plain text
#: ../E/atan.txt:9
#, no-wrap
msgid "Arcus tangent (in degrees) of the value."
msgstr "Arco tangente (em graus) do valor."

#. type: \b; header
#: ../E/atan2.txt:1
#, no-wrap
msgid "Instruction <code>atan2</code>"
msgstr "Instrução <code>atan2</code>"

#. type: Source code
#: ../E/atan2.txt:3
#, no-wrap
msgid "<c/>atan2 ( y, x );<n/>"
msgstr "<c/>atan2 ( y, x );<n/>"

#. type: Plain text
#: ../E/atan2.txt:5
#, no-wrap
msgid "The purpose of using two arguments instead of one is to gather information on the signs of the inputs in order to return the appropriate quadrant of the computed angle, which is not possible for the single-argument <c/><a cbot|atan>atan();</a><n/> function. For example, consider a point <code>(-1, -1)</code>: <c/>atan(-1/-1);<n/> is <code>45.00</code> degrees, whereas <c/>atan2(-1, -1);<n/> is <code>-135.00</code> degrees, which is obviously more correct in this case."
msgstr "O propósito de usar dois argumentos em vez de um é para reunir informação dos sinais das entradas a fim de retornar um quadrante apropriado do ângulo calculado, o qual não é possível para a função de um-argumento <c/><a cbot|atan>atan();</a><n/>. Por exemplo, considere um ponto  <code>(-1, -1)</code>: <c/>atan(-1/-1);<n/> é <code>45.00</code> graus, enquanto <c/>atan2(-1, -1);<n/> é <code>-135.00</code> graus, o qual é obviamente mais correto neste caso,"

#. type: \t; header
#: ../E/atan2.txt:10 ../E/pow.txt:5
#, no-wrap
msgid "x: <code><a cbot|float>float</a></code>"
msgstr "x: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/atan2.txt:14
#, no-wrap
msgid "Arcus tangent (in degrees) of <code>y/x</code>."
msgstr "Arco tangente (em graus) de <code>y/x</code>."

#. type: \b; header
#: ../E/build.txt:1
#, no-wrap
msgid "Instruction <code>build</code>"
msgstr "Instrução <code>build</code>"

#. type: Plain text
#: ../E/build.txt:2
#, no-wrap
msgid "The instruction <c/>build();<n/> instructs the bot to build a building of the given <a cbot|category>category</a>. Currently works for <a object|botgc>Grabbers</a>, <a object|human>Me</a> and <a object|tech>Tech</a>."
msgstr "A instrução <c/>build();<n/> instrui o robô a construir um edifício da  <a cbot|category>categoria</a> dada. Atualmente funciona para <a object|botgc>Agarradores</a>, <a object|human>Eu</a> e <a object|tech>Techs</a>."

#. type: Plain text
#: ../E/build.txt:5
#, no-wrap
msgid "This command is mostly useful in an attempt to build a fully automatised base, where an <a object|human>astronaut</a> does not need to do anything except starting a program and watching bots working. What is more, it makes beating the game by using only programming a possible task (however, it is a challenge rather for experienced gamers, who beat the whole game at least once)."
msgstr "Este comando é mais útil quando se está construindo uma base totalmente automatizada, quando um  <a object|human>astronauta</a> não precisa fazer nada exceto iniciar um programa e assistir os robôs trabalharem. O que é interessante, pois possibilita terminar o jogo usando somente programação (entretanto, é um desafio para jogadores experientes, que terminaram o jogo todo pelo menos uma vez)"

#. type: Plain text
#: ../E/build.txt:7
#, no-wrap
msgid "Here is an example of a program that looks for the nearest <a object|titan>titanium cube</a>, goes to the position and builds a <a object|factory>bot factory</a>."
msgstr "Aqui está um exemplo de um programa que procura pelo <a object|titan>cubo de titânio</a> mais próximo, vai para uma posição e constroi uma <a object|factory> fábrica de robôs</a>."

#. type: Source code
#: ../E/build.txt:9
#, no-wrap
msgid ""
" <a cbot|object>object</a> item = <a cbot|radar>radar</a>(<a object|titan>Titanium</a>);\n"
" <a cbot|goto>goto</a>(item.position);\n"
" build(<a object|factory>BotFactory</a>);"
msgstr ""
" <a cbot|object>objeto</a> item = <a cbot|radar>radar</a>(<a object|titan>Titanium</a>);\n"
" <a cbot|goto>goto</a>(item.position);\n"
" build(<a object|factory>BotFactory</a>);"

#. type: Source code
#: ../E/build.txt:15
#, no-wrap
msgid "<c/>build ( cat );<n/>"
msgstr "<c/>build ( categoria );<n/>"

#. type: Plain text
#: ../E/build.txt:17
#, no-wrap
msgid "Tells the robot to build a building using a titanium cube placed on a flat ground nearby."
msgstr "Diz ao robô para construir um edifício usando um cubo de titânio colocado em uma superfície plana perto."

#. type: \t; header
#: ../E/build.txt:19 ../E/buildingenabled.txt:16 ../E/canbuild.txt:16 ../E/detect.txt:11 ../E/factory.txt:10 ../E/radar.txt:22
#, no-wrap
msgid "cat: <code><a cbot|int>int</a></code>"
msgstr "categoria: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/build.txt:20 ../E/buildingenabled.txt:17 ../E/canbuild.txt:17
#, no-wrap
msgid "<a cbot|category>Category</a> of a building."
msgstr "<a cbot|category>Categoria</a> de um edifício."

#. type: Plain text
#: ../E/build.txt:23
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>build()</code>.\n"
"<code>== 0 </code>Successfully built\n"
"<code>!= 0 </code>Impossible to build (for example, the nearest titanium cube is too far away or the specified building is not available in the mission)"
msgstr ""
"Normalmente um erro para o programa. Você pode prevenir o programa de parar em erros usando a instrução <code><a cbot|errmode>errmode</a>(0)</code>. Um valor diferente de zero é retornado por <code>build()</code> se um erro ocorrer.\n"
"<code>== 0 </code>Construído com sucesso\n"
"<code>!= 0 </code>Impossível construir (por exemplo, o cubo de titâno mais próximo está muito longe ou o edifício especificado não está disponível na missão)"

#. type: Plain text
#: ../E/build.txt:28
#, no-wrap
msgid "<a cbot|canbuild>canbuild</a>, <a cbot|buildingenabled>buildingenabled</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot|canbuild>canbuild</a>, <a cbot|buildingenabled>buildingenabled</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/buildingenabled.txt:1
#, no-wrap
msgid "Instruction <code>buildingenabled</code>"
msgstr "Instrução <code>buildingenabled</code>"

#. type: Plain text
#: ../E/buildingenabled.txt:2
#, no-wrap
msgid "The instruction <c/>buildingenabled();<n/> lets you know if a building of the given <a cbot|category>category</a> can be built in the level."
msgstr "A instrução <c/>buildingenabled();<n/> permite a você descobrir se um prédio de uma <a cbot|category>categoria</a> dada pode ser construido neste nível."

#. type: Plain text
#: ../E/buildingenabled.txt:5
#, no-wrap
msgid "It is similar to the <c/><a cbot|canbuild>canbuild();</a><n/> instruction. However, it does not check if a required research has been done."
msgstr "É similar a instrução <c/><a cbot|canbuild>canbuild();</a><n/>. Entretanto, ela não checa se uma pesquisa necessária foi realizada."

#. type: Source code
#: ../E/buildingenabled.txt:7
#, no-wrap
msgid ""
" <a cbot|if>if</a> (buildingenabled(<a object|factory>BotFactory</a>))\n"
" {\n"
" \tbuild(<a object|factory>BotFactory</a>);\n"
" }"
msgstr ""
" <a cbot|if>if</a> (buildingenabled(<a object|factory>BotFactory</a>))\n"
" {\n"
" \tbuild(<a object|factory>BotFactory</a>);\n"
" }"

#. type: Source code
#: ../E/buildingenabled.txt:14
#, no-wrap
msgid "<c/>buildingenabled ( cat );<n/>"
msgstr "<c/>buildingenabled ( categoria );<n/>"

#. type: \t; header
#: ../E/buildingenabled.txt:19 ../E/busy.txt:10 ../E/canbuild.txt:19 ../E/canresearch.txt:10 ../E/detect.txt:23 ../E/researched.txt:10
#, no-wrap
msgid "Return value: <code><a cbot|bool>bool</a></code>"
msgstr "Valor de retorno: <code><a cbot|bool>bool</a></code>"

#. type: Plain text
#: ../E/buildingenabled.txt:20
#, no-wrap
msgid "<code>true</code> if the building can be built in the level even if required research has not been done, <code>false</code> otherwise."
msgstr "<code>true</code> se o edifício pode ser construído neste nível mesmo se a pesquisa necessária ainda não foi realizada, <code>false</code> caso constrário."

#. type: Plain text
#: ../E/buildingenabled.txt:23
#, no-wrap
msgid "<a cbot|build>build</a>, <a cbot|canbuild>canbuild</a>, <a object|research>ResearchCenter</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot|build>build</a>, <a cbot|canbuild>canbuild</a>, <a object|research>centro de pesquisa</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/busy.txt:1
#, no-wrap
msgid "Instruction <code>busy</code>"
msgstr "Instrução <code>busy</code>"

#. type: Source code
#: ../E/busy.txt:3
#, no-wrap
msgid "<c/><a cbot|object>object</a>.busy ( );<n/>"
msgstr "<c/><a cbot|object>object</a>.busy ( );<n/>"

#. type: Plain text
#: ../E/busy.txt:5
#, no-wrap
msgid "Checks if the object is busy."
msgstr "Checa se o objeto está ocupado."

#. type: \t; header
#: ../E/busy.txt:7 ../E/destroy.txt:7 ../E/factory.txt:7 ../E/research.txt:7 ../E/takeoff.txt:7
#, no-wrap
msgid "<a cbot|object>object</a>"
msgstr "<a cbot|object>object</a>"

#. type: Plain text
#: ../E/busy.txt:8
#, no-wrap
msgid "Any building which can take some action (e.g. <a cbot|convert>Converter</a>)."
msgstr "Qualquer edifício que pode tomar alguma ação (por exemplo: <a cbot|convert>Conversor</a>)."

#. type: Plain text
#: ../E/busy.txt:11
#, no-wrap
msgid ""
"<code><format const>true</format></code> if the object is doing something (e.g. converting)\n"
"<code><format const>false</format></code> if the object is not doing anything"
msgstr ""
"<code><format const>true</format></code> se o objeto está fazendo algo (por exemplo: convertendo)\n"
"<code><format const>false</format></code> se o objeto não está fazendo nada"

#. type: \b; header
#: ../E/canbuild.txt:1
#, no-wrap
msgid "Instruction <code>canbuild</code>"
msgstr "Instrução <code>canbuild</code>"

#. type: Plain text
#: ../E/canbuild.txt:2
#, no-wrap
msgid "The instruction <c/>canbuild();<n/> lets you know if <a object|botgc>Grabbers</a>, <a object|human>Me</a> or <a object|human>Tech</a> can build a building of the given <a cbot|category>category</a>. "
msgstr "A instrução  <c/>canbuild();<n/> permite a você conhecer se um <a object|botgc>Agarrador</a>, <a object|human>Humano</a> ou <a object|human>Tech</a> pode construir um edificio da <a cbot|category>categoria</a> dada. "

#. type: Plain text
#: ../E/canbuild.txt:5
#, no-wrap
msgid "It helps to prevent errors in programs using the <c/><a cbot|build>build();</a><n/> instruction. Here is an example:"
msgstr "Ela ajuda a prevenir erros em programas que usam a instrução <c/><a cbot|build>build();</a><n/>. Aqui está um exemplo:"

#. type: Source code
#: ../E/canbuild.txt:7
#, no-wrap
msgid ""
" <a cbot|if>if</a> (canbuild(<a object|factory>BotFactory</a>))\n"
" {\n"
" \tbuild(<a object|factory>BotFactory</a>);\n"
" }"
msgstr ""
" <a cbot|if>if</a> (canbuild(<a object|factory>BotFactory</a>))\n"
" {\n"
" \tbuild(<a object|factory>BotFactory</a>);\n"
" }"

#. type: Source code
#: ../E/canbuild.txt:14
#, no-wrap
msgid "<c/>canbuild ( cat );<n/>"
msgstr "<c/>canbuild ( categoria );<n/>"

#. type: Plain text
#: ../E/canbuild.txt:20
#, no-wrap
msgid "<code>true</code> if the building can be built, <code>false</code> otherwise."
msgstr "<code>true</code> se o edifício pode ser construído, <code>false</code> caso contrário."

#. type: Plain text
#: ../E/canbuild.txt:23
#, no-wrap
msgid "<a cbot|build>build</a>, <a cbot|buildingenabled>buildingenabled</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot|build>build</a>, <a cbot|buildingenabled>buildingenabled</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/canresearch.txt:1
#, no-wrap
msgid "Instruction <code>canresearch</code>"
msgstr "Instrução <code>canresearch</code>"

#. type: Source code
#: ../E/canresearch.txt:3
#, no-wrap
msgid "<c/>canresearch ( research );<n/>"
msgstr "<c/>canresearch ( pesquisa );<n/>"

#. type: Plain text
#: ../E/canresearch.txt:5
#, no-wrap
msgid "Checks if the <a cbot|researches>research</a> can be done in the level."
msgstr "Checa se a <a cbot|researches>pesquisa</a> pode ser realizada neste nível."

#. type: \t; header
#: ../E/canresearch.txt:7 ../E/researched.txt:7
#, no-wrap
msgid "research: <code><a cbot|int>int</a></code>"
msgstr "pesquisa: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/canresearch.txt:8 ../E/research.txt:11 ../E/researched.txt:8
#, no-wrap
msgid "<a cbot|researches>Research name</a>."
msgstr "<a cbot|researches>Nome da pesquisa</a>."

#. type: Plain text
#: ../E/canresearch.txt:11
#, no-wrap
msgid ""
"<format const>true</format> if the research can be done (even if it is already done, to check that, use the <a cbot|researched>researched</a> instruction)\n"
"<format const>false</format> if the research cannot be done"
msgstr ""
"<format const>true</format> se a pesquisa pode ser realizada (mesmo se ela já foi feita, para checar isso, use a instrução <a cbot|researched>researched</a>)\n"
"<format const>false</format> se a pesquisa não pode ser realizada"

#. type: Plain text
#: ../E/canresearch.txt:15
#, no-wrap
msgid "<a cbot|researches>Research names</a>, <a cbot|research>research</a>, <a cbot|researched>researched</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot|researches>Nomes de pesquisa</a>, <a cbot|research>research</a>, <a cbot|researched>researched</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: Plain text
#: ../E/category.txt:6
#, no-wrap
msgid "Below are the different categories available:"
msgstr "Abaixo estão as diferentes categorias disponíveis:"

#. type: \t; header
#: ../E/category.txt:8
#, no-wrap
msgid "Buildings:"
msgstr "Edifícios:"

#. type: \t; header
#: ../E/category.txt:32
#, no-wrap
msgid "Portable Objects:"
msgstr "Objetos portáteis:"

#. type: \t; header
#: ../E/category.txt:45
#, no-wrap
msgid "Robots:"
msgstr "Robôs:"

#. type: \t; header
#: ../E/category.txt:82
#, no-wrap
msgid "Enemies:"
msgstr "Inimigos:"

#. type: \t; header
#: ../E/category.txt:92
#, no-wrap
msgid "Miscellaneous:"
msgstr "Variados:"

#. type: \t; header
#: ../E/category.txt:101
#, no-wrap
msgid "Flags and Other Indicators:"
msgstr "Bandeiras e outros indicadores:"

#. type: \b; header
#: ../E/ceil.txt:1
#, no-wrap
msgid "Instruction <code>ceil</code>"
msgstr "Instrução <code>ceil</code>"

#. type: Source code
#: ../E/ceil.txt:3
#, no-wrap
msgid "<c/>ceil ( value );<n/>"
msgstr "<c/>ceil ( valor );<n/>"

#. type: Plain text
#: ../E/ceil.txt:4
#, no-wrap
msgid "Rounds up a number."
msgstr "Arredonda um número para cima."

#. type: Plain text
#: ../E/ceil.txt:10
#, no-wrap
msgid "Ceiling of the value, i.e. the smallest integer not less than <code>value</code>. For example, <code>ceil(2.1)</code> is <code>3.0</code>."
msgstr "Teto do valor, isto é, o menor inteiro não menor que <code>valor</code>. Por exemplo, <code>ceil(2.1)</code> é <code>3.0</code>."

#. type: Plain text
#: ../E/ceil.txt:13 ../E/floor.txt:13 ../E/trunc.txt:13
#, no-wrap
msgid "<a cbot|round>round</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
msgstr "<a cbot|round>round</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|expr>expressões</a>."

#. type: \b; header
#: ../E/colors.txt:1
#, no-wrap
msgid "Value <code>Colors</code>"
msgstr "Valor <code>Cores</code>"

#. type: Plain text
#: ../E/colors.txt:2
#, no-wrap
msgid "Color names are used to define a specific color to use. They can be passed to functions like <a cbot|pendown>pendown</a> or <a cbot|pencolor>pencolor</a>."
msgstr "Nomes de cores são usados para definir uma cor específica para usar. Eles podem ser passados para funções como <a cbot|pendown>pendown</a> ou  <a cbot|pencolor>pencolor</a>."

#. type: Plain text
#: ../E/colors.txt:4
#, no-wrap
msgid "In a program, colors are always displayed on a <format const>red background</format>. If a color isn't highlighted in red, it is misspelled. Caps and lower cases should be kept as is."
msgstr "Em um programa, cores sempre são exibidas em um <format const>fundo vermelho</format>. Se uma cor não está destacada em vermelho, ela está mal escrita. Maiúsculas e minúsculas devem ser mantidos como são."

#. type: Plain text
#: ../E/colors.txt:6
#, no-wrap
msgid "Below are the different colors available:"
msgstr "Abaixo estão as diferentes cores disponíveis:"

#. type: Plain text
#: ../E/colors.txt:8
#, no-wrap
msgid ""
"<code><format const>White</format></code>\n"
"<code><format const>Black</format></code>\n"
"<code><format const>Gray</format></code>\n"
"<code><format const>LightGray</format></code>\n"
"<code><format const>Red</format></code>\n"
"<code><format const>Pink</format></code>\n"
"<code><format const>Purple</format></code>\n"
"<code><format const>Orange</format></code>\n"
"<code><format const>Yellow</format></code>\n"
"<code><format const>Beige</format></code>\n"
"<code><format const>Brown</format></code>\n"
"<code><format const>Skin</format></code>\n"
"<code><format const>Green</format></code>\n"
"<code><format const>LightGreen</format></code>\n"
"<code><format const>Blue</format></code>\n"
"<code><format const>LightBlue</format></code>"
msgstr ""
"<code><format const>White</format></code> // Branco\n"
"<code><format const>Black</format></code> // Preto\n"
"<code><format const>Gray</format></code> // Cinza\n"
"<code><format const>LightGray</format></code> // Cinza claro\n"
"<code><format const>Red</format></code> // Vermelho\n"
"<code><format const>Pink</format></code> // Rosa\n"
"<code><format const>Purple</format></code> // Roxo\n"
"<code><format const>Orange</format></code> // Laranja\n"
"<code><format const>Yellow</format></code> // Amarelo\n"
"<code><format const>Beige</format></code> // Bege\n"
"<code><format const>Brown</format></code> // Marrom\n"
"<code><format const>Skin</format></code> // Pele\n"
"<code><format const>Green</format></code> // Verde\n"
"<code><format const>LightGreen</format></code> // Verde claro\n"
"<code><format const>Blue</format></code> // Azul\n"
"<code><format const>LightBlue</format></code> // Azul claro"

#. type: Plain text
#: ../E/colors.txt:25
#, no-wrap
msgid "You can also draw colored symbols:"
msgstr "Você também pode desenhar simbolos coloridos:"

#. type: Plain text
#: ../E/colors.txt:27
#, no-wrap
msgid ""
"<code><format const>BlackArrow</format></code>\n"
"<code><format const>RedArrow</format></code>"
msgstr ""
"<code><format const>BlackArrow</format></code> // Flecha negra\n"
"<code><format const>RedArrow</format></code> // Flecha vermelha"

#. type: \b; header
#: ../E/cos.txt:1
#, no-wrap
msgid "Instruction <code>cos</code>"
msgstr "Instrução <code>cos</code>"

#. type: Source code
#: ../E/cos.txt:3
#, no-wrap
msgid "<c/>cos ( angle );<n/>"
msgstr "<c/>cos ( angulo );<n/>"

#. type: Plain text
#: ../E/cos.txt:6 ../E/sin.txt:6
#, no-wrap
msgid "Angle in degrees."
msgstr "Ângulo em graus."

#. type: Plain text
#: ../E/cos.txt:9
#, no-wrap
msgid "Cosine of the angle."
msgstr "Coseno do ângulo."

#. type: \b; header
#: ../E/destroy.txt:1
#, no-wrap
msgid "Instruction <code>destroy</code>"
msgstr "Instrução <code>destroy</code>"

#. type: Source code
#: ../E/destroy.txt:3
#, no-wrap
msgid "<c/><a cbot|object>object</a>.destroy ( );<n/>"
msgstr "<c/><a cbot|object>object</a>.destroy ( );<n/>"

#. type: Plain text
#: ../E/destroy.txt:5
#, no-wrap
msgid "Destroys an object."
msgstr "Destroi um objeto."

#. type: Plain text
#: ../E/destroy.txt:8
#, no-wrap
msgid "<a object|destroy>Destroyer</a>."
msgstr "<a object|destroy>Destroyer</a>."

#. type: Plain text
#: ../E/destroy.txt:11
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>destroy()</code>.\n"
"<code>== 0 </code>The operation of destroying of an object was started\n"
"<code>!= 0 </code>The instruction could not be done (e.g. nothing to destroy)"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>destroy()</code> se um erro ocorrer.\n"
"<code>== 0 </code>A operação de destruição de um objeto foi iniciada\n"
"<code>!= 0 </code>A instrução não pode ser realizada (ex.: nada a destruir)"

#. type: \b; header
#: ../E/detect.txt:1
#, no-wrap
msgid "Instruction <code>detect</code>"
msgstr "Instrução <code>detect</code>"

#. type: Plain text
#: ../E/detect.txt:2
#, no-wrap
msgid "With the instruction <c/>detect();<n/>, you can look for objects like <a object|mother>enemies</a>, bots, buildings or raw materials, which are in front of the bot. It is a simpler version of <c/><a cbot|radar>radar</a>();<n/>."
msgstr "Com a instrução <c/>detect();<n/>, você pode procurar por objetos como <a object|mother>inimigos</a>, robôs, edifícios ou matéria prima, que estão na frente do robô. É uma versão simplificada de <c/><a cbot|radar>radar</a>();<n/>."

#. type: Source code
#: ../E/detect.txt:6
#, no-wrap
msgid "<c/>detect ( cat );<n/>"
msgstr "<c/>detect ( categoria );<n/>"

#. type: Plain text
#: ../E/detect.txt:8
#, no-wrap
msgid "Detects the nearest object of the specified <a cbot|category>category</a> being in front of the bot. It is similar to the following instruction:"
msgstr "Detecta o objeto mais próximo da <a cbot|category>categoria</a> especificada na frente do robô. É similar a seguinte instrução:"

#. type: Source code
#: ../E/detect.txt:9
#, no-wrap
msgid "<c/>radar(cat, 0, 45, 0, 20);<n/>"
msgstr "<c/>radar(categoria, 0, 45, 0, 20);<n/>"

#. type: Bullet: 'o'
#: ../E/detect.txt:12 ../E/radar.txt:23
#, no-wrap
msgid "<a cbot|category>Category</a> of the objects that should be detected. For example, when you are looking for an ant, write <code>radar(AlienAnt)</code>. "
msgstr "<a cbot|category>Categoria</a> do objeto que deve ser detectado. Por exemplo, quando você estiver procurando por uma formiga, escreva <code>radar(AlienAnt)</code>. "

#. type: Bullet: 'o'
#: ../E/detect.txt:13
#, no-wrap
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers:<c/>"
msgstr "<a cbot|array>Matriz</a> de categorias dos objetos que devem ser detectados. Por exemplo, quando você estiver procurando por agarradores:<c/>"

#. type: Source code
#: ../E/detect.txt:14
#, no-wrap
msgid ""
"int bots[4];\n"
"bots[0] = WheeledGrabber;\n"
"bots[1] = TrackedGrabber;\n"
"bots[2] = WingedGrabber;\n"
"bots[3] = LeggedGrabber;\n"
"object nearestGrabber = radar(bots);"
msgstr ""
"int robos[4];\n"
"robos[0] = WheeledGrabber;\n"
"robos[1] = TrackedGrabber;\n"
"robos[2] = WingedGrabber;\n"
"robos[3] = LeggedGrabber;\n"
"object agarradoresProximos = radar(robos);"

#. type: Bullet: 'o'
#: ../E/detect.txt:21 ../E/search.txt:17
#, no-wrap
msgid "Keyword <format const>Any</format> if you are looking for any object (including even plants and so on)."
msgstr "Palavra-chave <format const>Any</format> se você estiver procurando por qualquer objeto (incluindo até plantas e assim por diante)."

#. type: Plain text
#: ../E/detect.txt:24
#, no-wrap
msgid ""
"<format const>true</format> if the object was found\n"
"<format const>false</format> if the object was not found"
msgstr ""
"<format const>true</format> se o objeto foi encontrado\n"
"<format const>false</format> se o objeto não foi encontrado"

#. type: \b; header
#: ../E/factory.txt:1
#, no-wrap
msgid "Instruction <code>factory</code>"
msgstr "Instrução <code>factory</code>"

#. type: Source code
#: ../E/factory.txt:3
#, no-wrap
msgid "<c/><a cbot|object>object</a>.factory ( cat, program );<n/>"
msgstr "<c/><a cbot|object>object</a>.factory ( categoria, programa );<n/>"

#. type: Plain text
#: ../E/factory.txt:5
#, no-wrap
msgid "Starts a construction of a bot of the given <a cbot|category>category</a> and runs the specified program on it after the construction is finished."
msgstr "Inicia a construção de um robô da <a cbot|category>categoria</a> dada e executa o programa especificado após o fim da construção."

#. type: Plain text
#: ../E/factory.txt:8
#, no-wrap
msgid "<a object|factory>BotFactory</a>"
msgstr "<a object|factory>BotFactory</a>"

#. type: Plain text
#: ../E/factory.txt:11
#, no-wrap
msgid "<a cbot|category>Category</a> of the robot to construct."
msgstr "<a cbot|category>Categoria</a> do robô para construir."

#. type: \t; header
#: ../E/factory.txt:13
#, no-wrap
msgid "program: <code><a cbot|string>string</a></code> (default value: <code>\"\"</code>)"
msgstr "programa: <code><a cbot|string>string</a></code> (valor padrão: <code>\"\"</code>)"

#. type: Plain text
#: ../E/factory.txt:14
#, no-wrap
msgid "Program that will be run on the bot after factory finishes the construction. This can be either a <a cbot|public>public</a> <a cbot|function>function</a>, a <a cbot|file>filename</a> or just a raw source code."
msgstr "Programa que será executado após a fábrica finalizar a construção. Este pode ser tanto uma <a cbot|function>função</a> <a cbot|public>pública</a>, um <a cbot|file>arquivo</a> ou apenas um código fonte bruto."

#. type: Plain text
#: ../E/factory.txt:17
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>factory()</code>.\n"
"<code>== 0 </code>The construction successfully started\n"
"<code>!= 0 </code>The construction could not be started (e.g. no <a object|titan>Titanium</a> in the factory, the bot is not researched)"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>factory()</code> se um erro ocorrer.\n"
"<code>== 0 </code>A construção foi iniciada com sucesso\n"
"<code>!= 0 </code>A construção não pode ser iniciada (ex.: nenhum <a object|titan>Titânio</a> na fábrica, o robô não pode ser pesquisado)"

#. type: Plain text
#: ../E/factory.txt:22
#, no-wrap
msgid "<a cbot|researched>researched</a>, <a cbot|>wait</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot|researched>researched</a>, <a cbot|>wait</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/flatspace.txt:1
#, no-wrap
msgid "Instruction <code>flatspace</code>"
msgstr "Instrução <code>flatspace</code>"

#. type: Source code
#: ../E/flatspace.txt:3
#, no-wrap
msgid "<c/>flatspace ( center, flatmin, rmin, rmax, dist );<n/>"
msgstr "<c/>flatspace ( centro, flatmin, rmin, rmax, distancia );<n/>"

#. type: Plain text
#: ../E/flatspace.txt:5
#, no-wrap
msgid "Determines the position of the nearest free space with at least <code>flatmin</code> of flat ground around a given position. Works similar to <c/><a cbot|space>space();</a><n/>. Useful for finding a place for a <a cbot|category>building</a>."
msgstr "Determina a posição do espaço livre mais próximo com pelo menos <code>flatmin</code> de solo plano ao redor da posição dada. Funciona similar a <c/><a cbot|space>space();</a><n/>. Útil para encontrar um lugar para um  <a cbot|category>edifício</a>."

#. type: \t; header
#: ../E/flatspace.txt:10
#, no-wrap
msgid "flatmin: <code><a cbot|float>float</a></code>"
msgstr "flatmin: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/flatspace.txt:11
#, no-wrap
msgid "Minimum radius of flat ground around the desired position."
msgstr "Raio mínimo de solo plano ao redor da posição desejada."

#. type: \b; header
#: ../E/floor.txt:1
#, no-wrap
msgid "Instruction <code>floor</code>"
msgstr "Instrução <code>floor</code>"

#. type: Source code
#: ../E/floor.txt:3
#, no-wrap
msgid "<c/>floor ( value );<n/>"
msgstr "<c/>floor ( valor );<n/>"

#. type: Plain text
#: ../E/floor.txt:4
#, no-wrap
msgid "Rounds down a number."
msgstr "Arredonda um número para baixo."

#. type: Plain text
#: ../E/floor.txt:10
#, no-wrap
msgid "Floor of the value, i.e. the largest integer not greater than <code>value</code>. For example, <code>floor(2.9)</code> is <code>2.00</code>."
msgstr "Piso do valor, isto é, o maior inteiro não maior que <code>valor</code>. Por exemplo, <code>floor(2.9)</code> é <code>2.00</code>."

#. type: Plain text
#: ../E/for.txt:19
#, no-wrap
msgid ""
"Example: count from 1 to 4\n"
"<c/><s/><c/>for ( i = 1 ; i <= 4 ; i++ )"
msgstr ""
"Exemplo: contar de 1 até 4\n"
"<c/><s/><c/>for ( i = 1 ; i <= 4 ; i++ )"

#. type: Plain text
#: ../E/function.txt:2
#, no-wrap
msgid "Function, simply put, is an instruction created by you."
msgstr "Função, em termos simples, é uma instrução criada por você."

#. type: \b; header
#: ../E/function.txt:4
#, no-wrap
msgid "Main function"
msgstr "Função principal"

#. type: Plain text
#: ../E/function.txt:5
#, no-wrap
msgid "You probably already know how to create a function. Every program in CBOT must have a main function, which looks like this:"
msgstr "Você provavelmente já sabe como criar uma função. Todo programa em CBOT deve ter uma função principal, que parece como isto:"

#. type: Source code
#: ../E/function.txt:7
#, no-wrap
msgid ""
"extern void object::ProgramName()\n"
"{\n"
"\t\n"
"\t// instructions\n"
"\t\n"
"}"
msgstr ""
"extern void object::NomePrograma()\n"
"{\n"
"\t\n"
"\t// instruções\n"
"\t\n"
"}"

#. type: Plain text
#: ../E/function.txt:17
#, no-wrap
msgid "With functions you can divide your program into several parts. Each of them will execute a specific task. For example, see the following program:"
msgstr "Com funções você pode dividir seu programa em diversas partes. Cada uma delas executará uma tarefa especifica. Por exemplo, veja o programa abaixo:"

#. type: Source code
#: ../E/function.txt:19
#, no-wrap
msgid ""
"extern void object::Remote()\n"
"{\n"
"\tsend(\"order\", 1, 100);\n"
"\twait(5);\n"
"\tsend(\"order\", 3, 100);\n"
"\twait(5);\n"
"\tsend(\"order\", 2, 100);\n"
"\twait(5);\n"
"\tsend(\"order\", 4, 100);\n"
"\twait(5);\n"
"}"
msgstr ""
"extern void object::Remoto()\n"
"{\n"
"\tsend(\"ordem\", 1, 100);\n"
"\twait(5);\n"
"\tsend(\"ordem\", 3, 100);\n"
"\twait(5);\n"
"\tsend(\"ordem\", 2, 100);\n"
"\twait(5);\n"
"\tsend(\"ordem\", 4, 100);\n"
"\twait(5);\n"
"}"

#. type: Plain text
#: ../E/function.txt:31
#, no-wrap
msgid "<code><a cbot|send>send</a></code> and <code><a cbot|wait>wait</a></code> are repeated several times. So it would be a good thing if we created a function that executes these two instructions:"
msgstr "<code><a cbot|send>send</a></code> e <code><a cbot|wait>wait</a></code> são repetidos diversas vezes. Então seria uma boa ideia se nós criassemos uma função que executa estas duas instruções:"

#. type: Source code
#: ../E/function.txt:33
#, no-wrap
msgid ""
"void SendToPost(float op)\n"
"{\n"
"\tsend(\"order\", op, 100);\n"
"\twait(5);\n"
"}\n"
"\n"
"extern void object::Remote()\n"
"{\n"
"\tSendToPost(1);\n"
"\tSendToPost(3);\n"
"\tSendToPost(2);\n"
"\tSendToPost(4);\n"
"}"
msgstr ""
"void EnviarParaPosto(float op)\n"
"{\n"
"\tsend(\"ordem\", op, 100);\n"
"\twait(5);\n"
"}\n"
"\n"
"extern void object::Remoto()\n"
"{\n"
"\tEnviarParaPosto(1);\n"
"\tEnviarParaPosto(3);\n"
"\tEnviarParaPosto(2);\n"
"\tEnviarParaPosto(4);\n"
"}"

#. type: Plain text
#: ../E/function.txt:47
#, no-wrap
msgid "Now the program is much easier to read. It is a good practice to split the program into several functions with self-describing names."
msgstr "Agora o programa está muito mais fácil para ler. É uma boa prática dividir o programa em várias instruções com nomes autodescritivos."

#. type: \b; header
#: ../E/function.txt:49
#, no-wrap
msgid "Syntax"
msgstr "Sintaxe"

#. type: Source code
#: ../E/function.txt:51
#, no-wrap
msgid ""
"result_type FunctionName(optional_parameters)\n"
"{\n"
"\tbody\n"
"}"
msgstr ""
"tipo_resultado NomeFuncao(parametros_opcionais)\n"
"{\n"
"\tCorpo\n"
"}"

#. type: Plain text
#: ../E/function.txt:56
#, no-wrap
msgid "Result <a cbot|type>type</a> should be <a cbot/void>void</a> if the function does not give any. Body is just a set of instructions. Function name must be created with the exact same rules applied to <a cbot|var>variables</a>."
msgstr "O <a cbot|type>tipo</a> do resultado deve ser <a cbot/void>void</a> se a função não retornar nada. Corpo é apenas um conjunto de intruções. Nome da função deve criado com as mesmas regras aplicadas para <a cbot|var>variáveis</a>."

#. type: \t; header
#: ../E/function.txt:58
#, no-wrap
msgid "Parameters"
msgstr "Parâmetros"

#. type: Plain text
#: ../E/function.txt:59
#, no-wrap
msgid "A function can have parameters:"
msgstr "Uma função pode ter parâmetros:"

#. type: Source code
#: ../E/function.txt:61
#, no-wrap
msgid ""
"void Example(int a, float x, string s)\n"
"{\n"
"\tmessage(a);\n"
"\tmessage(x);\n"
"\tmessage(s);\n"
"}"
msgstr ""
"void Exemplo(int a, float x, string s)\n"
"{\n"
"\tmessage(a);\n"
"\tmessage(x);\n"
"\tmessage(s);\n"
"}"

#. type: Plain text
#: ../E/function.txt:68
#, no-wrap
msgid "The <code>Example</code> function will receive an <a cbot|int>integer</a> <code>a</code>, a <a cbot|float>floating point number</a> <code>x</code> and a <a cbot|string>string</a> <code>s</code>. Parameters are \"passed by value\", that is the values of parameter variables in a function are copies of the values the caller specified as variables. If you pass an <code><a cbot|int>int</a></code> to a function, its parameter is a copy of whatever value was being passed as the argument, and the function can change its parameter value without affecting values in the code that invoked the function."
msgstr "A função  <code>Exemplo</code> irá receber um <a cbot|int>inteiro</a> <code>a</code>, um <a cbot|float>número de ponto flutuante</a> <code>x</code> e uma <a cbot|string>cadeia de carácteres</a> <code>s</code>. Parâmetros são \"passados por valor\", isto é, o valor das variáveis de parâmetro em uma função são cópias dos valores que a chamada especificou como variáveis. Se você passar um <code><a cbot|int>int</a></code> para uma função, seus parâmetros serão uma cópia de qualquer valor que está sendo passado como argumento, e a função pode alterar seu parâmetro sem afetar os valores no código que invocou a função."

#. type: Plain text
#: ../E/function.txt:70
#, no-wrap
msgid "If you pass a <a cbot|class>class</a> instance or an <a cbot|array>array</a> as parameter to a function, the function only receives a <a cbot|pointer>reference</a> to the instance or the array. That means if you modify the instance or the array in the function, the instance or the array that has been specified by the caller will be actually modified."
msgstr "Se você passar uma instância de uma <a cbot|class>classe</a> ou uma <a cbot|array>matriz</a> para uma função, a função somente recebe uma <a cbot|pointer>referência</a> para a instância ou a matriz. Isto significa que se você modificar a instância ou a matriz na função, a instância ou a matriz que foi passada na chamada também será modificada."

#. type: \t; header
#: ../E/function.txt:72
#, no-wrap
msgid "Result"
msgstr "Resultado"

#. type: Plain text
#: ../E/function.txt:73
#, no-wrap
msgid "A function can also return a result with the <code><a cbot|return>return</a></code> instruction. Therefore the function must be declared no longer as <code><a cbot|void>void</a></code> but as an other <a cbot|type>type</a>:"
msgstr "Uma função também pode retornar um resultado com a instrução  <code><a cbot|return> return</a></code>. Entretando a função não deve ser declarada como <code><a cbot|void> void</a></code>, mas sim com outro <a cbot|type>tipo</a>:"

#. type: Source code
#: ../E/function.txt:75
#, no-wrap
msgid ""
"float Average(float a, float b)\n"
"{\n"
"\treturn (a+b)/2;\n"
"}\n"
"\n"
"extern void object::Test( )\n"
"{\n"
"\tfloat value;\n"
"\tvalue = Average(2, 6);\n"
"\tmessage(value);  // will display 4\n"
"}"
msgstr ""
"float Media(float a, float b)\n"
"{\n"
"\treturn (a+b)/2;\n"
"}\n"
"\n"
"extern void object::Teste( )\n"
"{\n"
"\tfloat valor;\n"
"\tvalor = Media(2, 6);\n"
"\tmessage(valor);  // irá exibir 4\n"
"}"

#. type: Plain text
#: ../E/function.txt:87
#, no-wrap
msgid "Some other examples:"
msgstr "Alguns outros exemplos:"

#. type: Source code
#: ../E/function.txt:89
#, no-wrap
msgid ""
"float Pi()\n"
"{\n"
"\treturn 3.1415;\n"
"}\n"
"\n"
"string Sign(float a)\n"
"{\n"
"\tif (a > 0)  return \"positive\";\n"
"\tif (a < 0)  return \"negative\";\n"
"\treturn \"null\";\n"
"}"
msgstr ""
"float Pi()\n"
"{\n"
"\treturn 3.1415;\n"
"}\n"
"\n"
"string Sinal(float a)\n"
"{\n"
"\tif (a > 0)  return \"positivo\";\n"
"\tif (a < 0)  return \"negativo\";\n"
"\treturn \"null\";\n"
"}"

#. type: \b; header
#: ../E/function.txt:102
#, no-wrap
msgid "Overloading"
msgstr "Sobrecarregar"

#. type: Plain text
#: ../E/function.txt:103
#, no-wrap
msgid "You can declare several functions with the same name but different parameters:"
msgstr "Você pode declarar várias funções com o mesmo nome, porém com parâmetros diferentes:"

#. type: Source code
#: ../E/function.txt:105
#, no-wrap
msgid ""
"float Pythagoras(float a, float b)\n"
"{\n"
"\treturn sqrt((a*a)+(b*b));\n"
"}\n"
"\n"
"float Pythagoras(float a, float b, float c)\n"
"{\n"
"\treturn sqrt((a*a)+(b*b)+(c*c));\n"
"}"
msgstr ""
"float Pitagoras(float a, float b)\n"
"{\n"
"\treturn sqrt((a*a)+(b*b));\n"
"}\n"
"\n"
"float Pitagoras(float a, float b, float c)\n"
"{\n"
"\treturn sqrt((a*a)+(b*b)+(c*c));\n"
"}"

#. type: Plain text
#: ../E/function.txt:115
#, no-wrap
msgid "CBOT will call either the one or the other function depending on the parameters passed. They must be distinguishable, i.e. you can't declare two functions with the same name and parameter types in the exact same order, e.g. declaring <code>int Pythagoras(float b, float a)</code> will result in error. Note that result type does not matter."
msgstr "CBOT irá chamar uma ou outra função dependendo dos parâmetros passados. Eles devem ser distinguíveis, isto é, você não pode declarar duas funções com o mesmo nome e tipos de parâmetros com a mesma ordem, por exemplo, declarar <code>int Pitagoras(float b, float a)</code> irá resultar em erro. Note que o tipo de resultado não faz diferença."

#. type: \b; header
#: ../E/function.txt:120
#, no-wrap
msgid "object::"
msgstr "object::"

#. type: Plain text
#: ../E/function.txt:121
#, no-wrap
msgid "Declaring a function as a part of the <a cbot|object>object</a> namespace gives it access to <code><a cbot|this>this</a></code> <a cbot|pointer>pointer</a>, in other words, to all available properties of the robot which the program is run on."
msgstr "Declarar uma função como parte do espaço de nomes <a cbot|object>object</a> da acesso ao <a cbot|pointer>ponteiro</a> <code><a cbot|this>this</a></code>, em outras palavras, a todas as propriedades disponíveis do robô que está rodando o programa."

#. type: Source code
#: ../E/function.txt:123
#, no-wrap
msgid ""
"void object::Example()\n"
"{\n"
"\tmessage(this.category);\n"
"}"
msgstr ""
"void object::Exemplo()\n"
"{\n"
"\tmessage(this.category);\n"
"}"

#. type: Plain text
#: ../E/object.txt:2
#, no-wrap
msgid "Use this type for variables that contain the characteristics of an object, be it a bot, a building, some raw material, an enemy, etc. Here are all properties of an object: "
msgstr "Use este tipo para variáveis que contém as características de um objeto, seja ele um robô, um edifício, alguma matéria prima, um inimigo, etc. Aqui estão todas as propriedades de um objeto:"

#. type: Plain text
#: ../E/object.txt:4
#, no-wrap
msgid ""
"<code><a cbot|int>int</a>    object.category     </code><a cbot|category>Category</a> of the object\n"
"<code><a cbot|point>point</a>  object.position     </code>Position of the object (x,y,z)\n"
"<code><a cbot|float>float</a>  object.orientation  </code>Orientation of the object (0..360)\n"
"<code><a cbot|float>float</a>  object.pitch        </code>Forward/backward angle of the object\n"
"<code><a cbot|float>float</a>  object.roll         </code>Right/left angle of the object \n"
"<code><a cbot|float>float</a>  object.energyLevel  </code>Energy level (0..1)\n"
"<code><a cbot|float>float</a>  object.shieldLevel  </code>Shield level (0..1)\n"
"<code><a cbot|float>float</a>  object.temperature  </code>Jet temperature (0..1)\n"
"<code><a cbot|float>float</a>  object.altitude     </code>Altitude above ground\n"
"<code><a cbot|float>float</a>  object.lifeTime     </code>Lifetime of the object\n"
"<code>object object.energyCell   </code>Power cell on the bot\n"
"<code>object object.load         </code>Object carried by the bot\n"
"<code><a cbot|int>int</a>    object.team         </code>The object's team (see <a battles>code battles</a>)\n"
"<code><a cbot|point>point</a>  object.velocity     </code>Velocity of the object"
msgstr ""
"<code><a cbot|int>int</a>    object.category     </code><a cbot|category>Categoria</a> do objeto\n"
"<code><a cbot|point>point</a>  object.position     </code>Posição do objeto (x,y,z)\n"
"<code><a cbot|float>float</a>  object.orientation  </code>Orientação do objeto (0..360)\n"
"<code><a cbot|float>float</a>  object.pitch        </code>Ângulo de avanço / retrocesso do objeto\n"
"<code><a cbot|float>float</a>  object.roll         </code>Ângulo direito / esquerdo do objeto \n"
"<code><a cbot|float>float</a>  object.energyLevel  </code>Nível de energia (0..1)\n"
"<code><a cbot|float>float</a>  object.shieldLevel  </code>Nível do escudo (0..1)\n"
"<code><a cbot|float>float</a>  object.temperature  </code>Temperatura do jato (0..1)\n"
"<code><a cbot|float>float</a>  object.altitude     </code>Altitude acima do chão\n"
"<code><a cbot|float>float</a>  object.lifeTime     </code>Tempo de vida do objeto\n"
"<code>object object.energyCell   </code>Célula de energia do robô\n"
"<code>object object.load         </code>Objeto carregado pelo robô\n"
"<code><a cbot|int>int</a>    object.team         </code>A equipe do objeto (veja <a battles>códigos de batalhas</a>)\n"
"<code><a cbot|point>point</a>  object.velocity     </code>Velocidade do objeto"

#. type: Plain text
#: ../E/object.txt:19
#, no-wrap
msgid "Also, some objects have additional methods (instructions). See them in <a cbot>the main list</a> in the <c/>\"Instructions specific for some objects\" section."
msgstr "Além diso, alguns objetos possuem métodos adicionais (instruções). Veja eles na <a cbot>lista principal</a>, na seção <c/>\"Instruções especificas para alguns objetos\"."

#. type: Plain text
#: ../E/object.txt:22
#, no-wrap
msgid "The <n/><a cbot|category>category</a> of an object allows you to know what it is, f. ex. what kind of bot, building, enemy, etc."
msgstr "A <n/><a cbot|category>categoria</a> de um objeto permite a você conhecer o que ele é, por exemplo, qual tipo de robô, edifício, inimigo, etc."

#. type: Source code
#: ../E/object.txt:60
#, no-wrap
msgid "<code>team</code>"
msgstr "<code>team</code>"

#. type: Plain text
#: ../E/object.txt:61
#, no-wrap
msgid "The bot's team. Used in <a battles>code battles</a>. If the object has no team assigned (e.g. in no team-based levels, the object being a resource), this is equal to <code>0</code>."
msgstr "A equipe do robô. Usada em <a battles>batalhas de código</a>. Se o objeto não tem equipe atribuída (isto é, em nenhum nível de equipe, o objeto sendo um recurso), isto é igual a <code>0</code>."

#. type: Source code
#: ../E/object.txt:63
#, no-wrap
msgid "<code>velocity</code>"
msgstr "<code>velocity</code>"

#. type: Plain text
#: ../E/object.txt:64
#, no-wrap
msgid "Current velocity of the object. Should be treated as a three-dimensional vector."
msgstr "Velocidade atual do objeto. Deve ser tratada como um vetor de três dimensões."

#. type: \b; header
#: ../E/pencolor.txt:1
#, no-wrap
msgid "Instruction <code>pencolor</code>"
msgstr "Instrução <code>pencolor</code>"

#. type: Source code
#: ../E/pencolor.txt:3
#, no-wrap
msgid "<c/>pencolor ( color );<n/>"
msgstr "<c/>pencolor ( cor );<n/>"

#. type: Plain text
#: ../E/pencolor.txt:4
#, no-wrap
msgid "The instruction <c/>pencolor();<n/> instructs the bot to change the color of the pencil."
msgstr "A instrução <c/>pencolor();<n/> instruí o robô a mudar a cor do pincel."

#. type: \t; header
#: ../E/pencolor.txt:6 ../E/pendown.txt:6
#, no-wrap
msgid "color: <code><a cbot|int>int</a></code> (default value: <code>Black</code>)"
msgstr "cor: <code><a cbot|int>int</a></code> (valor padrão: <code>Black</code>)"

#. type: Plain text
#: ../E/pencolor.txt:7 ../E/pendown.txt:7
#, no-wrap
msgid "<a cbot|colors>Color name</a>."
msgstr "<a cbot|colors>Nome da cor</a>."

#. type: Plain text
#: ../E/pencolor.txt:10
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>pencolor();<n/>.\n"
"<code>== 0 </code>The color was changed\n"
"<code>!= 0 </code>The instruction did not work"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>pencolor()</code> se um erro ocorrer.\n"
"<code>== 0 </code>A cor foi alterada\n"
"<code>!= 0 </code>A instrução não funcionou"

#. type: \b; header
#: ../E/pendown.txt:1
#, no-wrap
msgid "Instruction <code>pendown</code>"
msgstr "Instrução <code>pendown</code>"

#. type: Source code
#: ../E/pendown.txt:3
#, no-wrap
msgid "<c/>pendown ( color, width );<n/>"
msgstr "<c/>pendown ( cor, largura );<n/>"

#. type: Plain text
#: ../E/pendown.txt:4
#, no-wrap
msgid "The instruction <c/>pendown();<n/> instructs the bot to have the pen down, so it starts drawing."
msgstr "A instrução <c/>pendown();<n/> instruí o robô a baixar a caneta, iniciando assim a escrita."

#. type: \t; header
#: ../E/pendown.txt:9
#, no-wrap
msgid "width: <code><a cbot|float>float</a></code> (default value: <code>0.5</code>)"
msgstr "largura: <code><a cbot|float>float</a></code> (valor padrão: <code>0.5</code>)"

#. type: Plain text
#: ../E/pendown.txt:10 ../E/penwidth.txt:7
#, no-wrap
msgid "Width of the pen. The width cannot be higher than <code>1.0</code> and cannot be lower than <code>0.0</code>. Passing a higher value will result in the width being the highest possible and passing a lower value will result in the width being the lowest possible."
msgstr "Largura da caneta. A largura não pode ser maior que <code>1.0</code>, nem menor que que <code>0.0</code>. Passar um valor maior resultará na largura sendo a maior possível e passar um valor menor resultará na largura sendo a menor possível."

#. type: Plain text
#: ../E/pendown.txt:13
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>pendown();<n/>.\n"
"<code>== 0 </code>The pen is now down\n"
"<code>!= 0 </code>The instruction did not work"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>pendown()</code> se um erro ocorrer.\n"
"<code>== 0 </code>A caneta está baixada agora\n"
"<code>!= 0 </code>A instrução não funcionou"

#. type: \b; header
#: ../E/penup.txt:1
#, no-wrap
msgid "Instruction <code>penup</code>"
msgstr "Instrução <code>penup</code>"

#. type: Source code
#: ../E/penup.txt:3
#, no-wrap
msgid "<c/>penup ( );<n/>"
msgstr "<c/>penup ( );<n/>"

#. type: Plain text
#: ../E/penup.txt:4
#, no-wrap
msgid "The instruction <c/>penup();<n/> instructs the bot to have the pen up, so it stops drawing. The pen is up by default, so it should be used only after using <code><a cbot|pendown>pendown</a></code>."
msgstr "A instrução <c/>penup();<n/> instruí o robô a levantar a caneta, parando assim a escrita. A caneta está levantada por padrão, sendo assim deve ser usada somente após <code><a cbot|pendown>pendown</a></code>."

#. type: Plain text
#: ../E/penup.txt:7
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>penup();<n/>.\n"
"<code>== 0 </code>The pen is now up\n"
"<code>!= 0 </code>The instruction did not work"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>penup()</code> se um erro ocorrer.\n"
"<code>== 0 </code>A caneta está levantada agora\n"
"<code>!= 0 </code>A instrução não funcionou"

#. type: \b; header
#: ../E/penwidth.txt:1
#, no-wrap
msgid "Instruction <code>penwidth</code>"
msgstr "Instrução <code>penwidth</code>"

#. type: Source code
#: ../E/penwidth.txt:3
#, no-wrap
msgid "<c/>penwidth ( color );<n/>"
msgstr "<c/>penwidth ( largura );<n/>"

#. type: Plain text
#: ../E/penwidth.txt:4
#, no-wrap
msgid "The instruction <c/>penwidth();<n/> instructs the bot to change the width of the pencil."
msgstr "A instrução <c/>penwidth();<n/> instruí o robô a mudar a largura da caneta."

#. type: \t; header
#: ../E/penwidth.txt:6
#, no-wrap
msgid "width: <code><a cbot|float>float</a></code>"
msgstr "largura: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/penwidth.txt:10
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <c/>penwidth();<n/>.\n"
"<code>== 0 </code>The width was changed\n"
"<code>!= 0 </code>The instruction did not work"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>penwidth()</code> se um erro ocorrer.\n"
"<code>== 0 </code>A largura foi alterada\n"
"<code>!= 0 </code>A instrução não funcionou"

#. type: \b; header
#: ../E/pow.txt:1
#, no-wrap
msgid "Instruction <code>pow</code>"
msgstr "Instrução <code>pow</code>"

#. type: Source code
#: ../E/pow.txt:3
#, no-wrap
msgid "<c/>pow ( x, y );<n/>"
msgstr "<c/>pow ( x, y );<n/>"

#. type: Plain text
#: ../E/pow.txt:6
#, no-wrap
msgid "Base."
msgstr "Base."

#. type: Plain text
#: ../E/pow.txt:9
#, no-wrap
msgid "Exponent."
msgstr "Expoente"

#. type: Plain text
#: ../E/pow.txt:12
#, no-wrap
msgid "x to the y (x raised to the yth power)."
msgstr "x para y (x elevado a potência y)"

#. type: Source code
#: ../E/radar.txt:15
#, no-wrap
msgid "<c/>radar ( cat, angle, focus, min, max, sens, filter );<n/>"
msgstr "<c/>radar ( cat, angle, focus, min, max, sens, filter );<n/>"

#. type: Bullet: 'o'
#: ../E/radar.txt:24
#, no-wrap
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers:"
msgstr "<a cbot|array>Matriz</a> de categorias dos objetos que devem ser detectados. Por exemplo, quando você estiver procurando por agarradores:"

#. type: Plain text
#: ../E/radar.txt:25 ../E/search.txt:10
#, no-wrap
msgid "<c/><s/>int bots[4];"
msgstr "<c/><s/>int robos[4];"

#. type: Source code
#: ../E/radar.txt:26
#, no-wrap
msgid ""
"bots[0] = WheeledGrabber;\n"
"bots[1] = TrackedGrabber;\n"
"bots[2] = WingedGrabber;\n"
"bots[3] = LeggedGrabber;\n"
"object nearestGrabber = radar(bots);<n/>"
msgstr ""
"robos[0] = WheeledGrabber;\n"
"robos[1] = TrackedGrabber;\n"
"robos[2] = WingedGrabber;\n"
"robos[3] = LeggedGrabber;\n"
"object agarradorMaisProximo = radar(robos);<n/>"

#. type: Bullet: 'o'
#: ../E/radar.txt:31
#, no-wrap
msgid "Keyword <format const>Any</format> if you are looking for any object (including even plants and so on). Filters may be useful to use with this keyword."
msgstr "Palavra-chave <format const>Any</format> se estiver procurando qualquer objeto (incluindo até plantas e assim por diante). Filtros podem ser uteis se utilizados com esta palavra-chave."

#. type: \t; header
#: ../E/radar.txt:33
#, no-wrap
msgid "angle: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
msgstr "angle: <code><a cbot|float>float</a></code> (valor padrão: <code>0</code>)"

#. type: \t; header
#: ../E/radar.txt:39
#, no-wrap
msgid "focus: <code><a cbot|float>float</a></code> (default value: <code>360</code>)"
msgstr "focus: <code><a cbot|float>float</a></code> (valor padrão: <code>360</code>)"

#. type: \t; header
#: ../E/radar.txt:42
#, no-wrap
msgid "min: <code><a cbot|float>float</a></code> (default value: <code>0</code>)"
msgstr "min: <code><a cbot|float>float</a></code> (valor padrão: <code>0</code>)"

#. type: \t; header
#: ../E/radar.txt:45
#, no-wrap
msgid "max: <code><a cbot|float>float</a></code> (default value: <code>1000</code>)"
msgstr "max: <code><a cbot|float>float</a></code> (valor padrão: <code>1000</code>)"

#. type: \t; header
#: ../E/radar.txt:48
#, no-wrap
msgid "sens: <code><a cbot|float>float</a></code> (default value: <code>1</code>)"
msgstr "sens: <code><a cbot|float>float</a></code> (valor padrão: <code>1</code>)"

#. type: \t; header
#: ../E/radar.txt:51
#, no-wrap
msgid "filter: <code><a cbot|int>int</a></code> (default value: <code><format const>FilterNone</format></code>)"
msgstr "filter: <code><a cbot|int>int</a></code> (valor padrão: <code><format const>FilterNone</format></code>)"

#. type: Plain text
#: ../E/radar.txt:52
#, no-wrap
msgid "Determines which type of objects should be detected. Especially useful in use with an <a cbot|array>array</a> or <format const>Any</format>. The following filters are available:"
msgstr "Determina quais tipos de objetos devem ser detectados. Especialmente útil quando usado com uma <a cbot|array>matriz</a> ou a palavra-chave <format const>Any</format>. Os seguintes filtros estão disponíveis:"

#. type: Plain text
#: ../E/radar.txt:54
#, no-wrap
msgid ""
"<code><format const>FilterNone</format>        </code>Detects everything (default)\n"
"<code><format const>FilterOnlyLanding</format> </code>Detects only objects being on the ground\n"
"<code><format const>FilterOnlyFlying</format>  </code>Detects only objects not being on the ground\n"
"<code><format const>FilterFriendly</format>    </code>Detects only allies (objects in the same team)\n"
"<code><format const>FilterEnemy</format>       </code>Detects only enemies (objects in an other team except neutral)\n"
"<code><format const>FilterNeutral</format>     </code>Detects only neutral objects (e.g. resources)"
msgstr ""
"<code><format const>FilterNone</format>        </code>Detecta tudo (default)\n"
"<code><format const>FilterOnlyLanding</format> </code>Detecta somente  objetos no chão\n"
"<code><format const>FilterOnlyFlying</format>  </code>Detecta somente objetos que não estão no chão\n"
"<code><format const>FilterFriendly</format>    </code>Detecta somente aliados (objetos que estão na mesma equipe)\n"
"<code><format const>FilterEnemy</format>       </code>Detecta somente inimigos (objetos em outra equipe, exceto neutros)\n"
"<code><format const>FilterNeutral</format>     </code>Detecta somente objetos neutros (isto é, recursos)"

#. type: Plain text
#: ../E/radar.txt:61
#, no-wrap
msgid "The last three are mainly useful in <a battles>code battles</a>. You can also pass a team ID to search only for objects from a specific team. Attention: you should use <format const>FilterNeutral</format> instead of <code>0</code> or else it will not work."
msgstr "Os últimos três são frequentemente usados em <a battles>batalhas de código</a>. Você também pode passar um ID de equipe para pesquisar somente por objetos de uma equipe específica. Atenção: você deve usar <format const>FilterNeutral</format> em vez de <code>0</code> senão não irá funcionar."

#. type: Plain text
#: ../E/radar.txt:63
#, no-wrap
msgid "Filters and IDs can be mixed using bitwise OR operator <code>|</code>, for example <c/>radar(Any, 0, 360, 0, 1000, 1, 2 | FilterOnlyLanding);<n/> will only detect an object from team <code>2</code> that is on the ground. Attention: you can specify only one team ID at once, but you can specify several filters at once."
msgstr "Filtros e IDs podem ser misturados usando o operador bit a bit OR <code>|</code>, por exemplo, <c/>radar(Any, 0, 360, 0, 1000, 1, 2 | FilterOnlyLanding);<n/> só irá detectar um objeto da equipe <code>2</code> que está no chão. Atenção: você só pode especificar um ID de equipe por vez, porém você pode especificar vários filtros."

#. type: \b; header
#: ../E/rand.txt:1
#, no-wrap
msgid "Instruction <code>rand</code>"
msgstr "Instrução <code>rand</code>"

#. type: Source code
#: ../E/rand.txt:3
#, no-wrap
msgid "<c/>rand ( );<n/>"
msgstr "<c/>rand ( );<n/>"

#. type: Plain text
#: ../E/rand.txt:6
#, no-wrap
msgid "Pseudorandom number between 0 and 1 (including 0, but excluding 1)."
msgstr "Número aleatório entre 0 e 1 (incluindo 0, porém excluindo 1)."

#. type: \b; header
#: ../E/research.txt:1
#, no-wrap
msgid "Instruction <code>research</code>"
msgstr "Instrução <code>research</code>"

#. type: Source code
#: ../E/research.txt:3
#, no-wrap
msgid "<c/><a cbot|object>object</a>.research ( type );<n/>"
msgstr "<c/><a cbot|object>object</a>.research ( tipo );<n/>"

#. type: Plain text
#: ../E/research.txt:5
#, no-wrap
msgid "Starts a <a cbot|researches>research</a> of the given type."
msgstr "Inicia uma <a cbot|researches>pesquisa</a> do tipo dado."

#. type: Plain text
#: ../E/research.txt:8
#, no-wrap
msgid "<a object|research>ResearchCenter</a> or <a object|labo>AutoLab</a>."
msgstr "<a object|research>ResearchCenter</a> ou <a object|labo>AutoLab</a>."

#. type: \t; header
#: ../E/research.txt:10
#, no-wrap
msgid "type: <code><a cbot|int>int</a></code>"
msgstr "tipo: <code><a cbot|int>int</a></code>"

#. type: Plain text
#: ../E/research.txt:14
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>research()</code>.\n"
"<code>== 0 </code>The research successfully started\n"
"<code>!= 0 </code>The research could not be started (e.g. the research is disabled in the level, no power cell)"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>research()</code> se um erro ocorrer.\n"
"<code>== 0 </code>A pesquisa foi iniciada com sucesso\n"
"<code>!= 0 </code>A pesquisa não pode ser iniciada (isto é, a pesquisa está desativada neste nível, sem célula de energia)"

#. type: Plain text
#: ../E/research.txt:19
#, no-wrap
msgid "<a cbot|researches>Research names</a>, <a cbot|canresearch>canresearch</a>, <a cbot|researched>researched</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot|researches>Nomes de pesquisa</a>, <a cbot|canresearch>canresearch</a>, <a cbot|researched>researched</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/researched.txt:1
#, no-wrap
msgid "Instruction <code>researched</code>"
msgstr "Instrução <code>researched</code>"

#. type: Source code
#: ../E/researched.txt:3
#, no-wrap
msgid "<c/>researched ( research );<n/>"
msgstr "<c/>researched ( pesquisa );<n/>"

#. type: Plain text
#: ../E/researched.txt:5
#, no-wrap
msgid "Checks if the <a cbot|researches>research</a> was done in the level."
msgstr "Checa se a <a cbot|researches>pesquisa</a> foi realizada neste nível."

#. type: Plain text
#: ../E/researched.txt:11
#, no-wrap
msgid ""
"<format const>true</format> if the research was done\n"
"<format const>false</format> if the research was not done"
msgstr ""
"<format const>true</format> se a pesquisa foi realizada\n"
"<format const>false</format> se a pesquisa não foi realizada"

#. type: Plain text
#: ../E/researched.txt:15
#, no-wrap
msgid "<a cbot|researches>Research names</a>, <a cbot|research>research</a>, <a cbot|canresearch>canresearch</a>, <a cbot|canbuild>canbuild</a> <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<a cbot|researches>Nomes de pesquisa</a>, <a cbot|research>research</a>, <a cbot|canresearch>canresearch</a>, <a cbot|canbuild>canbuild</a> <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/researches.txt:1
#, no-wrap
msgid "Value <code>Research names</code>"
msgstr "Valor de <code>nomes de pesquisa</code>"

#. type: Plain text
#: ../E/researches.txt:2
#, no-wrap
msgid "Research names represent the types of available researches in the CBOT language. You can use them to control <a object|research>ResearchCenter</a> by passing them to appropriate instructions (e.g. <a cbot|research>research</a>, <a cbot|canresearch>canresearch</a>, <a cbot|researched>researched</a>)."
msgstr "Nomes de pesquisa representam os tipos de pesquisas disponíveis na linguagem CBOT. Você pode usá-los para controlar o <a object|research>ResearchCenter</a>  passando instruções apropriadas (isto é, <a cbot|research>research</a>, <a cbot|canresearch>canresearch</a>, <a cbot|researched>researched</a>)."

#. type: Plain text
#: ../E/researches.txt:4
#, no-wrap
msgid "In a program, research names are always displayed on a <format const>red background</format>. If a research name is not highlighted in red, it is misspelled. Caps and lower cases should be kept as is."
msgstr "Em um programa, nomes de pesquisa sempre são exibidos em um <format const>fundo vermelho</format>. Se um nome de pesquisa não está realçado em vermelho, ele está escrito errado. Maiúsculas e minúsculas devem ser mantidas como são."

#. type: Plain text
#: ../E/researches.txt:6
#, no-wrap
msgid "Below are the different research names available."
msgstr "Abaixo estão os diferentes nomes de pesquisa disponíveis."

#. type: \t; header
#: ../E/researches.txt:8
#, no-wrap
msgid "Done by <a object|research>ResearchCenter</a>:"
msgstr "Realizado por <a object|research>ResearchCenter</a>:"

#. type: Plain text
#: ../E/researches.txt:9
#, no-wrap
msgid ""
"<code><format const>ResearchTracked</format>       </code>Tracked bots (e.g. <a object|botgc>tracked grabber</a>)\n"
"<code><format const>ResearchWinged</format>        </code>Winged bots (e.g. <a object|botgj>winged grabber</a>)\n"
"<code><format const>ResearchShooter</format>       </code>Bots with cannon (e.g. <a object|botfc>tracked shooter</a>)\n"
"<code><format const>ResearchPhazerShooter</format> </code><a object|botphaz>Phazer shooter</a>\n"
"<code><format const>ResearchThumper</format>       </code><a object|bottump>Thumper</a>\n"
"<code><format const>ResearchShielder</format>      </code><a object|botshld>Shielder</a>\n"
"<code><format const>ResearchDefenseTower</format>  </code><a object|tower>Defense tower</a>\n"
"<code><format const>ResearchNuclearPlant</format>  </code><a object|nuclear>Nuclear plant</a>"
msgstr ""
"<code><format const>ResearchTracked</format>       </code>Robôs com esteira (por exemplo: <a object|botgc>agarrador com esteira</a>)\n"
"<code><format const>ResearchWinged</format>        </code>Robôs alados (por exemplo: <a object|botgj>agarrador alado</a>)\n"
"<code><format const>ResearchShooter</format>       </code>Robôs com canhão (por exemplo: <a object|botfc>atirador com esteira</a>)\n"
"<code><format const>ResearchPhazerShooter</format> </code><a object|botphaz>Atirador phazer</a>\n"
"<code><format const>ResearchThumper</format>       </code><a object|bottump>Batedor</a>\n"
"<code><format const>ResearchShielder</format>      </code><a object|botshld>Defensor</a>\n"
"<code><format const>ResearchDefenseTower</format>  </code><a object|tower>Torre de defesa</a>\n"
"<code><format const>ResearchNuclearPlant</format>  </code><a object|nuclear>Planta nuclear</a>"

#. type: \t; header
#: ../E/researches.txt:18
#, no-wrap
msgid "Done by <a object|labo>AutoLab</a>:"
msgstr "Realizado por <a object|labo>AutoLab</a>:"

#. type: Plain text
#: ../E/researches.txt:19
#, no-wrap
msgid ""
"<code><format const>ResearchLegged</format>        </code>Legged bots (e.g. <a object|botgs>legged grabber</a>)\n"
"<code><format const>ResearchOrgaShooter</format>   </code>Bots with orgaball cannon (e.g. <a object|botoc>tracked orga shooter</a>)"
msgstr ""
"<code><format const>ResearchLegged</format>        </code>Robôs com perna (por exemplo: <a object|botgs>agarrador com pernas</a>)\n"
"<code><format const>ResearchOrgaShooter</format>   </code>Robôs com canhão orgânico (por exemplo: <a object|botoc>atirador orgânico com esteiras</a>)"

#. type: \t; header
#: ../E/researches.txt:22
#, no-wrap
msgid "Impossible to research:"
msgstr "Impossível de pesquisar:"

#. type: Plain text
#: ../E/researches.txt:23
#, no-wrap
msgid ""
"<code><format const>ResearchSniffer</format>       </code>Sniffers (e.g. <a object|botsc>tracked sniffer</a>)\n"
"<code><format const>ResearchSubber</format>        </code><a object|botsub>Subber</a>\n"
"<code><format const>ResearchRecycler</format>      </code><a object|botrecy>Recycler</a>"
msgstr ""
"<code><format const>ResearchSniffer</format>       </code>Farejadores (por exemplo: <a object|botsc>farejador com rodas</a>)\n"
"<code><format const>ResearchSubber</format>        </code><a object|botsub>Mergulhador</a>\n"
"<code><format const>ResearchRecycler</format>      </code><a object|botrecy>Reciclador</a>"

#. type: Plain text
#: ../E/researches.txt:28
#, no-wrap
msgid "<a cbot>CBOT Language</a>, <a cbot|type>variables</a> and <a cbot|category>categories</a>."
msgstr "<a cbot>Linguagem CBOT</a>, <a cbot|type>variáveis</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/round.txt:1
#, no-wrap
msgid "Instruction <code>round</code>"
msgstr "Instrução <code>round</code>"

#. type: Source code
#: ../E/round.txt:3
#, no-wrap
msgid "<c/>round ( value );<n/>"
msgstr "<c/>round ( valor );<n/>"

#. type: Plain text
#: ../E/round.txt:4
#, no-wrap
msgid "Rounds a number."
msgstr "Arredonda um número."

#. type: Plain text
#: ../E/round.txt:10
#, no-wrap
msgid "Rounded <code>value</code>. For example, <code>round(2.5)</code> is <code>3.0</code>, whereas <code>round(2.4)</code> is <code>2.0</code>."
msgstr "<code>Valor</code> arredondado. Por exemplo, <code>round(2.5)</code> é <code>3.0</code>, enquanto <code>round(2.4)</code> é <code>2.0</code>."

#. type: Plain text
#: ../E/round.txt:13
#, no-wrap
msgid "<a cbot|trunc>trunc</a>, <a cbot|floor>floor</a>, <a cbot|ceil>ceil</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>."
msgstr "<a cbot|trunc>trunc</a>, <a cbot|floor>floor</a>, <a cbot|ceil>ceil</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|expr>expressões</a>."

#. type: Plain text
#: ../E/search.txt:5
#, no-wrap
msgid "Detects the object of the given category that is closest to the given position. Similar to <c/><a cbot|radar>radar();</a><n/>, but can search starting from the specific point instead of the actual bot's position."
msgstr "Detecta o objeto da categoria dada que está mais próximo da posição dada. Similar a <c/><a cbot|radar>radar();</a><n/>, porém pode pesquisar iniciando de um ponto específico em vez da posição atual do robô."

#. type: Bullet: 'o'
#: ../E/search.txt:8
#, no-wrap
msgid "<a cbot|category>Category</a> of the objects that should be detected. For example, when you are looking for an ant, write <code>search(AlienAnt)</code>. "
msgstr "<a cbot|category>Categoria</a> dos objetos que devem ser detectados. Por exemplo, quando você estiver procurando por uma formiga, escreva <code>search(AlienAnt)</code>. "

#. type: Bullet: 'o'
#: ../E/search.txt:9
#, no-wrap
msgid "<a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers, starting from a certain point in the level:"
msgstr "<a cbot|array>Matriz</a> de categorias dos objetos que devem ser detectados. Por exemplo, quando você estiver procurando por agarradores, iniciando de um certo ponto no nível:"

#. type: Source code
#: ../E/search.txt:11
#, no-wrap
msgid ""
"bots[0] = WheeledGrabber;\n"
"bots[1] = TrackedGrabber;\n"
"bots[2] = WingedGrabber;\n"
"bots[3] = LeggedGrabber;\n"
"point p(50, 24, 0);\n"
"object grabberNearestThePoint = search(bots, p);<n/>"
msgstr ""
"robos[0] = WheeledGrabber;\n"
"robos[1] = TrackedGrabber;\n"
"robos[2] = WingedGrabber;\n"
"robos[3] = LeggedGrabber;\n"
"point ponto(50, 24, 0);\n"
"object agarradoresProximosAoPonto = search(robos, ponto);<n/>"

#. type: \t; header
#: ../E/search.txt:19
#, no-wrap
msgid "position: <code><a cbot|point>point</a></code> (default value: <code><a cbot|this>this</a>.<a cbot|object>position</a></code>)"
msgstr "position: <code><a cbot|point>point</a></code> (valor padrão: <code><a cbot|this>this</a>.<a cbot|object>position</a></code>)"

#. type: \b; header
#: ../E/sin.txt:1
#, no-wrap
msgid "Instruction <code>sin</code>"
msgstr "Instrução <code>sin</code>"

#. type: Source code
#: ../E/sin.txt:3
#, no-wrap
msgid "<c/>sin ( angle );<n/>"
msgstr "<c/>sin ( angulo );<n/>"

#. type: Plain text
#: ../E/sin.txt:9
#, no-wrap
msgid "Sine of the angle."
msgstr "Seno do ângulo."

#. type: \b; header
#: ../E/sqrt.txt:1
#, no-wrap
msgid "Instruction <code>sqrt</code>"
msgstr "Instrução <code>sqrt</code>"

#. type: Source code
#: ../E/sqrt.txt:3
#, no-wrap
msgid "<c/>sqrt ( value );<n/>"
msgstr "<c/>sqrt ( valor );<n/>"

#. type: Plain text
#: ../E/sqrt.txt:6
#, no-wrap
msgid "Non-negative number."
msgstr "Número não negativo."

#. type: Plain text
#: ../E/sqrt.txt:9
#, no-wrap
msgid "Square root of the value."
msgstr "Raiz quadrada do valor."

#. type: \b; header
#: ../E/switch.txt:1
#, no-wrap
msgid "Instructions <code>switch</code>, <code>case</code> and <code>default</code>"
msgstr "Instruções <code>switch</code>, <code>case</code> e <code>default</code>"

#. type: Plain text
#: ../E/switch.txt:2
#, no-wrap
msgid "With the instruction <code>switch() {}</code> you can execute a proper set of instructions (a case) basing on some value."
msgstr "Com a instrução <code>switch() {}</code> você pode executar um conjunto adequado de instruções (um caso) baseado em algum valor."

#. type: Plain text
#: ../E/switch.txt:5
#, no-wrap
msgid "Note: the <a cbot|busy>busy</a> instruction might be much better to use in this scenario."
msgstr "Nota: a instrução <a cbot|busy>busy</a> pode ser muito boa para usar neste cenário."

#. type: Plain text
#: ../E/switch.txt:7
#, no-wrap
msgid "See the following <a cbot|function>function</a>: the bot will be <a cbot|wait>waiting</a> a proper amount of time for a certain task to be completed:"
msgstr "Veja a seguinte  <a cbot|function>função</a>: o robô estará <a cbot|wait>esperando</a> um certo tempo para uma certa tarefa finalizar:"

#. type: Source code
#: ../E/switch.txt:9
#, no-wrap
msgid ""
"public void WaitForTaskCompleted(object building)\n"
"{\n"
"\tint cat = building.category;\n"
"\t<a cbot|if>if</a> (cat == Converter) wait(15);\n"
"\telse if (cat == BotFactory) wait(15);\n"
"\telse if (cat == PowerPlant) wait(12);\n"
"\telse message(\"Undefined wait time\", DisplayError);\n"
"}"
msgstr ""
"public void EsperarFimTarefa(object edificio)\n"
"{\n"
"\tint cat = edificio.category;\n"
"\t<a cbot|if>if</a> (cat == Converter) wait(15);\n"
"\telse if (cat == BotFactory) wait(15);\n"
"\telse if (cat == PowerPlant) wait(12);\n"
"\telse message(\"Tempo de espera indefinido\", DisplayError);\n"
"}"

#. type: Plain text
#: ../E/switch.txt:18
#, no-wrap
msgid "This function can be also written using the <code>switch() {}</code> instruction:"
msgstr "Esta função também pode ser escrita usando a instrução <code>switch() {}</code>:"

#. type: Source code
#: ../E/switch.txt:20
#, no-wrap
msgid ""
"public void WaitForTaskCompleted(object building)\n"
"{\n"
"\tswitch (building.category)\n"
"\t{\n"
"\t\tcase Converter: wait(15); break;\n"
"\t\tcase BotFactory: wait(15); break;\n"
"\t\tcase PowerPlant: wait(12); break;\n"
"\t\tdefault: message(\"Undefined wait time\", DisplayError);\n"
"\t}\n"
"}"
msgstr ""
"public void EsperarFimTarefa(object edificio)\n"
"{\n"
"\tswitch (edificio.category)\n"
"\t{\n"
"\t\tcase Converter: wait(15); break;\n"
"\t\tcase BotFactory: wait(15); break;\n"
"\t\tcase PowerPlant: wait(12); break;\n"
"\t\tdefault: message(\"Tempo de espera indefinido\", DisplayError);\n"
"\t}\n"
"}"

#. type: Plain text
#: ../E/switch.txt:31
#, no-wrap
msgid "Which way to write this kind of choice structures, is a matter of taste."
msgstr "De qual maneira escrever estes tipos de estruturas de escolhas, é uma questão de gosto."

#. type: Plain text
#: ../E/switch.txt:33
#, no-wrap
msgid "You can also make cases like this:"
msgstr "Você também pode fazer casos assim:"

#. type: Source code
#: ../E/switch.txt:35
#, no-wrap
msgid ""
"switch (building.category)\n"
"{\n"
"\tcase Converter:\n"
"\tcase BotFactory:\n"
"\t\twait(15); break;\n"
"\tcase PowerPlant: wait(12); break;\n"
"\tdefault: message(\"Undefined wait time\", DisplayError);\n"
"}"
msgstr ""
"switch (edificio.category)\n"
"{\n"
"\tcase Converter:\n"
"\tcase BotFactory:\n"
"\t\twait(15); break;\n"
"\tcase PowerPlant: wait(12); break;\n"
"\tdefault: message(\"Tempo de espera indefinido\", DisplayError);\n"
"}"

#. type: Plain text
#: ../E/switch.txt:44
#, no-wrap
msgid "<a object|convert>Converter</a> and <a object|factory>bot factory</a> have the same waiting time, so in order to not write the same instructions twice, we made multiple cases run the same code. In fact, all code after the highest case used will be executed if we do not <code><a cbot|break>break</a></code> it."
msgstr "O <a object|convert>conversor</a> e <a object|factory>a fábrica de robôs</a> tem o mesmo tempo de espera, então a fim de não escrever as mesmas instruções duas vezes, fizemos múltilpos casos rodarem o mesmo código. De fato, todo código depois do caso mais alto utilizado será executado se nós não executarmos um <code><a cbot|break>break</a></code>."

#. type: Source code
#: ../E/switch.txt:48
#, no-wrap
msgid ""
"<c/>switch ( value )\n"
"{\n"
"\tcase value1: instructions1\n"
"\tcase value2: instructions2\n"
"\t...\n"
"\tcase valueN: instructionsN\n"
"\tdefault: instructionsDefault\n"
"}"
msgstr ""
"<c/>switch ( valor )\n"
"{\n"
"\tcase valor1: instruções1\n"
"\tcase valor2: instruções2\n"
"\t...\n"
"\tcase valorN: instruçõesN\n"
"\tdefault: instruçõesPadrão\n"
"}"

#. type: Plain text
#: ../E/switch.txt:57
#, no-wrap
msgid "With this conditional structure you can execute <code>instructions1</code> or <code>instructions2</code> ... or <code>instructionsN</code> or <code>instructionsDefault</code> depending on the <code>value</code>."
msgstr "Com esta estrutura condicional você pode executar <code>instruções1</code> ou <code>instruções2</code> ... ou <code>instruçõesN</code> ou <code>instruçõesPadrão</code> dependendo do <code>valor</code>."

#. type: Plain text
#: ../E/switch.txt:59
#, no-wrap
msgid ""
"If the <code>value</code> is equal to <code>value1</code>, <code>instructions1</code> to <code>N</code> (including <code>instructionsDefault</code>) are executed.\n"
"If the <code>value</code> is equal to <code>value2</code>, <code>instructions2</code> to <code>N</code> (including <code>instructionsDefault</code>) are executed.\n"
"And so on.\n"
"If the <code>value</code> is equal to <code>valueN</code>, <code>instructionsN</code> and <code>instructionsDefault</code> are executed.\n"
"If the <code>value</code> is not equal to any value in the given cases, <code>instructionsDefault</code> are executed."
msgstr ""
"Se o <code>valor</code> é igual a <code>valor1</code>, <code>instruções1</code> a <code>N</code> (incluindo <code>instruçõesPadrão</code>) são executadas.\n"
"Se o <code>valor</code>é igual a <code>valor2</code>, <code>instruções2</code> a <code>N</code> (incluindo <code>instruçõesPadrão</code>) são executadas.\n"
"E assim por diante.\n"
"Se o <code>valor</code> é igual a <code>valorN</code>, <code>instruçõesN</code> e <code>instruçõesPadrão</code> são executadas.\n"
"Se o <code>valor</code> não é igual a nenhum valor dos casos dados, <code>instruçõesPadrão</code> são executadas."

#. type: Plain text
#: ../E/switch.txt:65
#, no-wrap
msgid "You can exit from the the <code>switch() {}</code> instruction using <code><a cbot|break>break</a></code>."
msgstr "Você pode sair da instrução <code>switch() {}</code> usando <code><a cbot|break>break</a></code>."

#. type: Plain text
#: ../E/switch.txt:68
#, no-wrap
msgid "Do not put a <a cbot|term>semicolon</a> at the end of the <code>switch ( ) { }</code> instruction."
msgstr "Não coloque um <a cbot|term>ponto e vírgula</a> no fim da instrução <code>switch ( ) { }</code>."

#. type: \b; header
#: ../E/takeoff.txt:1
#, no-wrap
msgid "Instruction <code>takeoff</code>"
msgstr "Instrução <code>takeoff</code>"

#. type: Source code
#: ../E/takeoff.txt:3
#, no-wrap
msgid "<c/><a cbot|object>object</a>.takeoff ( );<n/>"
msgstr "<c/><a cbot|object>objeto</a>.takeoff ( );<n/>"

#. type: Plain text
#: ../E/takeoff.txt:5
#, no-wrap
msgid "Takes off the spaceship."
msgstr "Decola a espaçonave."

#. type: Plain text
#: ../E/takeoff.txt:8
#, no-wrap
msgid "<a object|base>SpaceShip</a>"
msgstr "<a object|base>Espaçonave</a>"

#. type: Plain text
#: ../E/takeoff.txt:11
#, no-wrap
msgid ""
"Normally an error stops the program. You can prevent the program from stopping on errors by using the <code><a cbot|errmode>errmode</a>(0)</code> instruction. A value different from zero if an error occurred is then returned by <code>takeoff()</code>.\n"
"<code>== 0 </code>Spaceship takes off\n"
"<code>!= 0 </code>Spaceship could not take off (e.g. mission is not finished yet)"
msgstr ""
"Normalmente um erro para o programa. Se você quiser que o programa não pare ao ocorrer erros use a instrução <code><a cbot|errmode>errmode</a>(0)</code>.  Um valor diferente de zero é retornado por <code>takeoff()</code> se um erro ocorrer.\n"
"<code>== 0 </code>A nave decolou\n"
"<code>!= 0 </code>A nave não pode decolar (por exemplo, a missão ainda não foi finalizada)"

#. type: \b; header
#: ../E/tan.txt:1
#, no-wrap
msgid "Instruction <code>tan</code>"
msgstr "Instrução <code>tan</code>"

#. type: Source code
#: ../E/tan.txt:3
#, no-wrap
msgid "<c/>tan ( angle );<n/>"
msgstr "<c/>tan ( angulo );<n/>"

#. type: Plain text
#: ../E/tan.txt:6
#, no-wrap
msgid "Angle in degrees (except multiples of 90)."
msgstr "Ângulo em graus (exceto múltiplos de 90)."

#. type: Plain text
#: ../E/tan.txt:9
#, no-wrap
msgid "Tangent of the angle."
msgstr "Tangente do ângulo."

#. type: \b; header
#: ../E/trunc.txt:1
#, no-wrap
msgid "Instruction <code>trunc</code>"
msgstr "Instrução <code>trunc</code>"

#. type: Source code
#: ../E/trunc.txt:3
#, no-wrap
msgid "<c/>trunc ( value );<n/>"
msgstr "<c/>trunc ( valor );<n/>"

#. type: Plain text
#: ../E/trunc.txt:4
#, no-wrap
msgid "Truncation is a method of approximating a decimal number by dropping all decimal places past a certain point without rounding. For positive numbers, it works like the <c/><a cbot|floor>floor();</a><n/> function, and for negative numbers, it works like the <c/><a cbot|ceil>ceil();</a><n/> function. It can be said that it rounds towards zero."
msgstr "Truncamento é um método de aproximação de um número decimal pelo descarte de todas as casas decimais até um certo ponto sem arredondar. Para números positivos ele funciona como a função  <c/><a cbot|floor>floor();</a><n/>, e para número negativos, ele funciona como a função <c/><a cbot|ceil>ceil();</a><n/>. Pode ser dito que ele arredonda em direção a zero."

#. type: Plain text
#: ../E/trunc.txt:10
#, no-wrap
msgid "Truncated <code>value</code>. For example, <code>trunc(-2.5)</code> is <code>-2.00</code>."
msgstr "<code>Valor</code> truncado . Por exemplo, <code>trunc(-2.5)</code> é <code>-2.00</code>."

#. type: Plain text
#: ../E/category.txt:4
#, no-wrap
msgid "In a program, categories are always displayed like that: <format const>category</format>. If a category isn't highlighted, it is misspelled. Caps and lower cases should be kept as is."
msgstr "Em um programa, categorias são sempre exibidas desta forma: <format const>categoria</format>. Se uma categoria não está destacada, está escrita incorretamente. Maiúsculas e minúsculas devem ser mantidas como são."

#. type: Plain text
#: ../E/type.txt:9
#, no-wrap
msgid "In a program, the name of a type is always displayed like that: <format type>type</format>. If the name of a type is not highlighted, this means that the name is misspelled. Type names are always written with lower case characters. Here is a list of the different types: "
msgstr "Em um programa, o nome de um tipo é sempre exibido desta forma: <format const>tipo</format>. Se o nome de um tipo não está destacado, está escrito incorretamente. Nomes de tipo são sempre escritos em letras minúsculas. Aqui está uma lista dos diferentes tipos:"

#. type: \b; header
#: ../E/produce.txt:1
#, no-wrap
msgid "Instruction <code>produce</code>"
msgstr "Instrução <code>produce</code>"

#. type: Source code
#: ../E/produce.txt:3
#, no-wrap
msgid "<c/>produce ( position, orientation, category, program, power );<n/>"
msgstr "<c/>produce ( posicao, orientacao, categoria, programa, energia );<n/>"

#. type: Bullet: 'o'
#: ../E/produce.txt:4
#, no-wrap
msgid "r"
msgstr "r"

#. type: Source code
#: ../E/produce.txt:5
#, no-wrap
msgid "<c/>produce ( category, power );<n/>"
msgstr "<c/>produce ( categoria, energia );<n/>"

#. type: Plain text
#: ../E/produce.txt:7
#, no-wrap
msgid "Immediately creates an <a cbot|category>object</a>."
msgstr "Imediatamente cria um <a cbot|category>objeto</a>."

#. type: \t; header
#: ../E/produce.txt:12
#, no-wrap
msgid "orientation: <code><a cbot|float>float</a></code>"
msgstr "orientacao: <code><a cbot|float>float</a></code>"

#. type: Plain text
#: ../E/produce.txt:13
#, no-wrap
msgid "Orientation (angle) of the object."
msgstr "Orientação (ângulo) do objeto."

#. type: Plain text
#: ../E/produce.txt:16
#, no-wrap
msgid "<a cbot|category>Category</a> of the object."
msgstr "<a cbot|category>Categoria</a> do objeto."

#. type: \t; header
#: ../E/produce.txt:18
#, no-wrap
msgid "program: <code><a cbot|string>string</a></code>"
msgstr "programa: <code><a cbot|string>string</a></code>"

#. type: Plain text
#: ../E/produce.txt:22
#, no-wrap
msgid "Energy level."
msgstr "Nível de energia."

#. type: \t; header
#: ../E/produce.txt:24
#, no-wrap
msgid "Return: <code><a cbot|void>void</a></code>"
msgstr "Retorna: <code><a cbot|void>void</a></code>"

#. type: Plain text
#: ../E/produce.txt:25
#, no-wrap
msgid "Nothing."
msgstr "Nada."

#. type: \b; header
#: ../E/produce.txt:27
#, no-wrap
msgid "Example usage"
msgstr "Exemplo de uso"

#. type: Plain text
#: ../E/produce.txt:28
#, no-wrap
msgid "It is used by <a object|mother>AlienQueen</a> to produce <a object|egg>AlienEggs</a>."
msgstr "É utilizado pela <a object|mother>AlienQueen</a> para produzir <a object|egg>AlienEggs</a>."

#. type: Plain text
#: ../E/produce.txt:10
#, no-wrap
msgid "Where object will be created. The second syntax creates the object at the current bot's position."
msgstr "Onde o objeto será criado. A segunda sintaxe cria o objeto na posição atual do robô."

#. type: Plain text
#: ../E/produce.txt:19
#, no-wrap
msgid "Program for the object. Will have effect only for programmable objects like robots or aliens."
msgstr "Programa para o objeto. Só terá efeitos em objetos programáveis como robôs ou alienígenas."

#. type: Plain text
#: ../E/expr.txt:2
#, no-wrap
msgid "Expressions are used for various calculations with many different variables, which return the desired result. What distinguishes them from standard instructions are operators, which are described below."
msgstr "Expressões são usadas para vários cálculos com muitas variáveis diferentes, as quais retornam o resultado desejado. O que dinstingue elas de instruções padrões são os operadores que estão descritos abaixo:"

#. type: \b; header
#: ../E/expr.txt:8
#, no-wrap
msgid "Binary operations"
msgstr "Operações binárias"

#. type: Plain text
#: ../E/expr.txt:9
#, no-wrap
msgid "Assuming that <code>a</code>, <code>b</code> can be values of declared and initialized variables of types <code>t1</code> and <code>t2</code>, the binary operations can be described as follows:"
msgstr "Assumindo que <code>a</code> e <code>b</code> podem ser valores de variáveis declaradas e inicializadas dos tipos <code>t1</code> e <code>t2</code>, as operações binárias podem ser descritas da seguinte forma:"

#. type: Source code
#: ../E/expr.txt:10
#, no-wrap
msgid "<code>r = a op b</code>"
msgstr "<code>r = a op b</code>"

#. type: Plain text
#: ../E/expr.txt:11
#, no-wrap
msgid "Where <code>r</code> is the result of the operation and <code>op</code> is a binary operator which works with values of types <code>t1</code> and <code>t2</code>."
msgstr "Onde <code>r</code> é o resultado da operação e <code>op</code> é um operador binário que funciona com os valores do tipos <code>t1</code> e <code>t2</code>."

#. type: \t; header
#: ../E/expr.txt:13
#, no-wrap
msgid "Order of operations"
msgstr "Ordem das operações"

#. type: Plain text
#: ../E/expr.txt:14
#, no-wrap
msgid "Let <code>a op1 b op2 c</code> be a legal expression, then the following rules apply:"
msgstr "Deixe <code>a op1 b op2 c</code> ser uma expressão legal, então as seguintes regras se aplicam:"

#. type: Bullet: 'o'
#: ../E/expr.txt:15
#, no-wrap
msgid "If <code>op1 == op2</code> or <code>op1</code> is as strong as <code>op2</code> or <code>op1</code> is stronger than <code>op2</code>, first calculate <code>a op1 b</code> and store its result in a temporary variable <code>r</code>, then calculate <code>r op2 c</code>, which is the final result of the expression."
msgstr "Se <code>op1 == op2</code> ou <code>op1</code> é tão forte quanto <code>op2</code> ou <code>op1</code> é mais forte que <code>op2</code>, primeiro calcule <code>a op1 b</code> e armazene o resultado em uma variável temporária <code>r</code>, depois calcule <code>r op2 c</code>, o qual será o resultado final da expressão."

#. type: Bullet: 'o'
#: ../E/expr.txt:16
#, no-wrap
msgid "If <code>op1</code> is weaker than <code>op2</code>, first calculate <code>b op2 c</code> and store its result in a temporary variable <code>r</code>, then calculate <code>a op1 r</code>, which is the final result of the expression."
msgstr "Se <code>op1</code> é mais fraco que <code>op2</code>, primeiro calcule <code>b op2 c</code> e armazene o resultado em uma variável temporária <code>r</code>, então calcule <code>a op1 r</code>, o qual será o resultado final da expressão."

#. type: Plain text
#: ../E/expr.txt:18
#, no-wrap
msgid "Note: an operation can be made stronger by surrounding it in brackets, so for example assuming that <code>op1</code> is weaker than <code>op2</code>, in an expression <code>(a op1 b) op2 c</code> the <code>a op1 b</code> operation will be executed first."
msgstr "Nota: uma operação pode se tornar mais forte se rodeada por parênteses, então por exemplo, assumindo que <code>op1</code> é mais fraco que <code>op2</code>, em uma expressão <code>(a op1 b) op2 c</code>, a operação <code>a op1 b</code> será executada primeiro."

#. type: Plain text
#: ../E/expr.txt:20
#, no-wrap
msgid "Tip: always use brackets if you are not sure about the order of operations, do not try to remember how strong are each of the operators. Generally it should be fairly obvious."
msgstr "Dica: sempre use parênteses se você não tem certeza sobre a ordem das operações, não tente se lembrar o quão forte é cada um dos operadores. Normalmente deve ser bastante óbvio."

#. type: Plain text
#: ../E/expr.txt:22
#, no-wrap
msgid ""
"Here is a complicated example, which uses arithemtic operations described below, showing how expressions are calculated:\n"
"<c/>Assume a, b, c, d, x, y, z, e are all initialized variables of type float or int. Then the following expression should be calculated the following way:\n"
"  a * b + c - d / x % (y * z) - e =\n"
"= r1 + c - d / x % (y * z) - e    = , r1 = a * b\n"
"= r2 - d / x % (y * z) - e        = , r2 = r1 + c\n"
"= r2 - r3 % (y * z) - e           = , r3 = d / x\n"
"= r2 - r3 % r4 - e                = , r4 = y * z\n"
"= r2 - r5 - e                     = , r5 = r3 % r4\n"
"= r6 - e                          = , r6 = r2 - r5\n"
"= r7                                , r7 = r6 - e\n"
"r7 is the final result of this expression."
msgstr ""
"Aqui está um exemplo complicado, o qual usa operações aritméticas descritas abaixo, mostrando como as expressões são calculadas:\n"
"<c/>Assuma que a, b, c, d, x, y, z, e são variáveis inicializadas do tipo float ou int. Então a seguinte expressão deveria ser calculada da seguinte forma:\n"
"  a * b + c - d / x % (y * z) - e =\n"
"= r1 + c - d / x % (y * z) - e    = , r1 = a * b\n"
"= r2 - d / x % (y * z) - e        = , r2 = r1 + c\n"
"= r2 - r3 % (y * z) - e           = , r3 = d / x\n"
"= r2 - r3 % r4 - e                = , r4 = y * z\n"
"= r2 - r5 - e                     = , r5 = r3 % r4\n"
"= r6 - e                          = , r6 = r2 - r5\n"
"= r7                                , r7 = r6 - e\n"
"r7 é o resultado final desta expressão."

#. type: \b; header
#: ../E/expr.txt:35
#, no-wrap
msgid "Assignment operator"
msgstr "Operador de atribuição"

#. type: Plain text
#: ../E/expr.txt:36
#, no-wrap
msgid "<code>=</code> is the assignment operator. It is used to store the result of an expression in a variable."
msgstr "<code>=</code> é o operador de atribuição. Ele é usado para armazenar o resultado de uma expressão em uma variável."

#. type: Plain text
#: ../E/expr.txt:38
#, no-wrap
msgid "On the left side of this operator there must be so called l-value and on the right side - r-value. L-values are just <a cbot|var>variables</a><n/>, r-values are expressions or just usual values. This makes the assignment operator kind of special, because what is l-value is pretty restrictive (it cannot be an expression, constant and so on, only single variable). Also, the type of l-value must match the type of r-value (unless a conversion is possible, for example assigning a <code><a cbot|float>float</a></code> to <code><a cbot|int>int</a></code>)."
msgstr "Do lado esquerdo do operador deve haver o chamado valor-L e do lado direito o valor-R. Valores-L são apenas <a cbot|var>variáveis</a><n/>, valores-R são expressões ou apenas valores usuais. Isto torna o operador de atribuição um pouco especial, porque o que pode ser valor-L é bem restritivo (não pode ser uma expressão, constante e assim por diante, somente uma única variável). Também, o tipo do valor-L deve bater com o tipo do valor-R (a menos que uma conversão seja possível, por exemplo, atribuir um <code><a cbot|float>float</a></code> para um <code><a cbot|int>int</a></code>)."

#. type: Source code
#: ../E/expr.txt:42
#, no-wrap
msgid ""
" float a;\n"
" float b = 2.0 * (a = 4.0); // b == 8.0"
msgstr ""
" float a;\n"
" float b = 2.0 * (a = 4.0); // b == 8.0"

#. type: Plain text
#: ../E/expr.txt:45
#, no-wrap
msgid "This example is actually really confusing, but this property is actually useful, because it lets doing something like this:"
msgstr "Este exemplo é realmente confuso, porém este uso é atualmente útil, porque ele está fazendo algo como isso:"

#. type: Source code
#: ../E/expr.txt:47
#, no-wrap
msgid ""
" float a, b, c, d, e;\n"
" a = b = c = d = e = 1.0; // a == b == c == d == e == 1.0"
msgstr ""
" float a, b, c, d, e;\n"
" a = b = c = d = e = 1.0; // a == b == c == d == e == 1.0"

#. type: \b; header
#: ../E/expr.txt:50
#, no-wrap
msgid "Basic arithmetic operations"
msgstr "Operações aritméticas básicas"

#. type: Plain text
#: ../E/expr.txt:51
#, no-wrap
msgid "Binary operators below are working with fundamental number types (<code><a cbot|int>int</a></code>, <code><a cbot|float>float</a></code>)."
msgstr "As operações binárias abaixo funcionam com os tipos numéricos fundamentais (<code><a cbot|int>int</a></code>, <code><a cbot|float>float</a></code>)."

#. type: \t; header
#: ../E/expr.txt:53 ../E/expr.txt:89 ../E/expr.txt:115 ../E/expr.txt:140 ../E/expr.txt:163
#, no-wrap
msgid "List"
msgstr "Lista"

#. type: Plain text
#: ../E/expr.txt:54
#, no-wrap
msgid ""
"<code>+</code>  addition\n"
"<code>-</code>  subtraction\n"
"<code>*</code>  multiplication\n"
"<code>/</code>  division\n"
"<code>%</code>  remainder of the division (only for the type <code><a cbot|int>int</a></code>)"
msgstr ""
"<code>+</code>  adição\n"
"<code>-</code>  subtração\n"
"<code>*</code>  multiplicação\n"
"<code>/</code>  divisão\n"
"<code>%</code>  resto da divisão (somente para o tipo <code><a cbot|int>int</a></code>)"

#. type: \t; header
#: ../E/expr.txt:60
#, no-wrap
msgid "Notes"
msgstr "Notas"

#. type: Bullet: 'o'
#: ../E/expr.txt:61
#, no-wrap
msgid "The <code>*</code>, <code>/</code>, <code>%</code> are all stronger than <code>+</code> and <code>-</code>."
msgstr "Os operadores <code>*</code>, <code>/</code>, <code>%</code> são mais fortes que <code>+</code> e <code>-</code>."

#. type: Bullet: 'o'
#: ../E/expr.txt:62
#, no-wrap
msgid "The result <a cbot|type>type</a> is always <code><a cbot|float>float</a></code>. If <code>a</code> or <code>b</code> are of type <code><a cbot|int>int</a></code>, they are automatically converted to <code><a cbot|float>float</a></code>. Note: this means that results of intermediate calculations tends to be as precise as possible, the precision is lost only during converting the final (<code><a cbot|float>float</a></code>) result to <code><a cbot|int>int</a></code>, for example by the assignment <code>=</code> operator."
msgstr "O <a cbot|type>tipo</a> do resultado é sempre <code><a cbot|float>float</a></code>. Se <code>a</code> ou <code>b</code> são do tipo <code><a cbot|int>int</a></code>, eles são automaticamente convertidos para <code><a cbot|float>float</a></code>. Nota: isto significa que os resultados de cálculos intermediários tendem a ser tão precisos quanto possivel, a precisão é perdida somente durante a conversão final (<code><a cbot|float>float</a></code>)  do resultado para <code><a cbot|int>int</a></code>, por exemplo, pela atribuição do operador <code>=</code>."

#. type: \t; header
#: ../E/expr.txt:64
#, no-wrap
msgid "Real life examples"
msgstr "Exemplos da vida real"

#. type: \t; header
#: ../E/expr.txt:81
#, no-wrap
msgid "Compound assignment operators"
msgstr "Operadores de atribuição compostos"

#. type: Plain text
#: ../E/expr.txt:82
#, no-wrap
msgid "Besides the <code>=</code> operator for variable assignment there are several compound-assignment operators."
msgstr "Além do operador <code>=</code> para atribuição a variáveis, existem muitos outros operadores de atribuição compostos."

#. type: Plain text
#: ../E/expr.txt:84
#, no-wrap
msgid "The compound-assignment operators combine the <code>=</code> assignment operator with another binary operator such as <code>+</code> or <code>-</code>. Compound-assignment operators perform the operation specified by the additional operator and then assign the result to the left operand. For example, a compound-assignment expression such as"
msgstr "Os operadores de atribuição compostos combinam o operador de atribuição  <code>=</code> com outro operador binário como <code>+</code> ou <code>-</code>. Operadores de atribuição compostos realizam a operação especificada pelo operador adicional e depois atribuem o resultado a esquerda do operador. Por exemplo, uma expressão de atribuição composta como"

#. type: Source code
#: ../E/expr.txt:85
#, no-wrap
msgid "<code>lvalue += expression</code>"
msgstr "<code>valor-L += expressao</code>"

#. type: Source code
#: ../E/expr.txt:87
#, no-wrap
msgid "<code>lvalue = lvalue + expression</code>"
msgstr "<code>valor-L = valor-L + expressao</code>"

#. type: \b; header
#: ../E/expr.txt:96
#, no-wrap
msgid "String concatenation"
msgstr "Concatenação de strings"

#. type: Plain text
#: ../E/expr.txt:97
#, no-wrap
msgid "If at least one of the values used with the <code>+</code> operator is a <a cbot|string>string</a>, then the operation of concatenation is performed. The result of the operator is then a string, which is created by joining end-to-end the string and the other value. If the other value is not a string, then it is converted to string beforehand."
msgstr "Se pelo menos um dos valores usados com o operador <code>+</code> é uma <a cbot|string>string</a>, então uma operação de concatenação é realizada. O resultado do operador é então uma string, a qual é criada pela junção fim-a-fim da string com o outro valor. Se o outro valor não é uma string, então ela é convertida para string antecipadamente."

#. type: Source code
#: ../E/expr.txt:101
#, no-wrap
msgid ""
"\tstring s = \"a\" + \"bc\";  // returns \"abc\"\n"
"\tstring s = 1 + \"bc\";    // returns \"1bc\"\n"
"\tstring s = 2.5 + \"bc\";  // returns \"2.5bc\"\n"
"\tstring s = \"a\" + true;  // returns \"atrue\""
msgstr ""
"\tstring s = \"a\" + \"bc\";  // retorna \"abc\"\n"
"\tstring s = 1 + \"bc\";    // retorna \"1bc\"\n"
"\tstring s = 2.5 + \"bc\";  // retorna \"2.5bc\"\n"
"\tstring s = \"a\" + true;  // retorna \"atrue\""

#. type: Plain text
#: ../E/expr.txt:106
#, no-wrap
msgid "Tip: the properties of the concatenation <code>+</code> operator is useful with the <a cbot|message>message();</a> function, because it does not work with other types than string. An empty string can be used together with a value in order to create a string, which actually can be passed to the <a cbot|message>message();</a> function:"
msgstr "Dica: as propriedades do operador de concatenação <code>+</code> são úteis com a função <a cbot|message>message();</a>, porque ela não funciona com outros tipos que não sejam string. Uma string vazia pode ser utilizada junto com um valor a fim de criar uma string, a qual depois pode ser passada para a função <a cbot|message>message();</a>:"

#. type: \b; header
#: ../E/expr.txt:177
#, no-wrap
msgid "Prefix and postfix increment- and decrement operators"
msgstr "Operadores de incremento e decremento de prefixo e sufixo"

#. type: Plain text
#: ../E/expr.txt:180
#, no-wrap
msgid "For example to increment the variable <code>a</code> you can write"
msgstr "Por exemplo, para incrementar a variável <code>a</code> você pode escrever"

#. type: Source code
#: ../E/expr.txt:181
#, no-wrap
msgid "<c/>a++;<n/>"
msgstr "<c/>a++;<n/>"

#. type: Plain text
#: ../E/expr.txt:182
#, no-wrap
msgid "instead of"
msgstr "em vez de"

#. type: Source code
#: ../E/expr.txt:183
#, no-wrap
msgid "<c/>a = a + 1;<n/>"
msgstr "<c/>a = a + 1;<n/>"

#. type: Plain text
#: ../E/expr.txt:185
#, no-wrap
msgid "The result of the operation <code>a++</code> is the value of the variable <code>a</code> *before* the increment. If you use the prefix operator <code>++a</code> the result of the operation is the value of the variable <code>a</code> *after* the increment. The same holds for the <code>--</code> decrement operator."
msgstr "O resultado da operação <code>a++</code> é o valor da variável <code>a</code> *antes* do incremento. Se você usar o operador prefixo <code>++a</code>, o resultado da operação será o valor da variável <code>a</code> *após* o incremento. O mesmo se aplica ao operador de decremento <code>--</code>."

#. type: Plain text
#: ../E/expr.txt:4
#, no-wrap
msgid "Specifically speaking, an expression is an ordered series of operations which yield a result. Operations consist of operators, which are special <a cbot|function>functions</a> <code>T f(t1 x1, t2 x2, ..., tn xn)</code>, where <code>xi</code> is a value of type <code>ti</code>, and <code>T</code> is the result type. For example, <code>float +(float a, float b)</code> returns a sum of values <code>a</code> and <code>b</code>. Note: Operators are a part of the CBOT language and they cannot be defined in program. Also, the operators cannot be used as usual <a cbot|function>functions</a>, they need to be written using a special notation depending on the operator, for example <code>a+b</code>."
msgstr "Especificamente falando, uma expressão é uma série de operações ordenadas que produzem um resultado. Operações consistem de operadores, que são <a cbot|function>funções</a> especiais <code>T f(t1 x1, t2 x2, ..., tn xn)</code>, onde <code>xi</code> é um valor do tipo <code>ti</code>, e <code>T</code> é o tipo do resultado. Por exemplo, <code>float +(float a, float b)</code> retorna a soma dos valores <code>a</code> e <code>b</code>. Nota: operadores são parte da linguagem CBOT e eles não podem ser definidos no programa. Além disso, os operadores não pode ser usados como <a cbot|function>funções</a> normais, eles precisam ser escritos usando uma notação especial dependendo do operador, por exemplo, <code>a+b</code>."

#. type: Plain text
#: ../E/expr.txt:6
#, no-wrap
msgid "In nearly all operations, <a cbot>constants</a>, <a cbot|var>variables</a>, <a cbot|function>functions</a> returning non-<a cbot|void>void</a> type and also other operations can be used as values."
msgstr "Em quase todas as operações, <a cbot>constantes</a>, <a cbot|var>variáveis</a> e <a cbot|function>funções</a> retornam um tipo não <a cbot|void>nulo</a> e além disso outras operações podem ser utilizadas como valores."

#. type: Plain text
#: ../E/expr.txt:40
#, no-wrap
msgid "Note: it may be not obvious at first, but notice that <code>=</code> is an *operator* not an instruction. This mean that it can be used in the middle of an other expression! The result of <code>=</code> is the value which was assigned to the l-value - the result of the expression on the right. Example:"
msgstr "Nota: pode não ser óbvio de primeira, porém note que <code>=</code> é um *operador*, não uma instrução. Isto significa que ele pode ser usado no meio de outra expressão! O resultado de <code>=</code> é o valor que está atribuido do lado do valor-L, o resultado da expressão na direita. Exemplo:"

#. type: Source code
#: ../E/expr.txt:66
#, no-wrap
msgid ""
" int    i = 12 + 3;      // i == 15\n"
" int    i = 2 - 5;       // i == -3\n"
" \n"
" float  f = 3.01 * 10;   // f == 30.1\n"
" \n"
" int    i = 5 / 3;       // i == 1 (automatic conversion to int)\n"
" float  f = 5 / 3;       // f == 1.67\n"
" float  f = 5 / 0;       // returns an error (division by zero)\n"
" \n"
" int    i = 13 % 5;      // i == 3\n"
" int    i = -8 % 3;      // i == -2\n"
" \n"
" float  f = sin(90) * i; // f == -2.0\n"
" "
msgstr ""
" int    i = 12 + 3;      // i == 15\n"
" int    i = 2 - 5;       // i == -3\n"
" \n"
" float  f = 3.01 * 10;   // f == 30.1\n"
" \n"
" int    i = 5 / 3;       // i == 1 (conversão automática para int)\n"
" float  f = 5 / 3;       // f == 1.67\n"
" float  f = 5 / 0;       // retorna erro (divisão por zero)\n"
" \n"
" int    i = 13 % 5;      // i == 3\n"
" int    i = -8 % 3;      // i == -2\n"
" \n"
" float  f = sin(90) * i; // f == -2.0\n"
" "

#. type: Source code
#: ../E/expr.txt:108
#, no-wrap
msgid ""
" float pi = 3.14;\n"
" // message(pi); // does not work\n"
" message(\"\"+pi);"
msgstr ""
" float pi = 3.14;\n"
" // message(pi); // não funciona\n"
" message(\"\"+pi);"

#. type: Source code
#: ../E/expr.txt:189
#, no-wrap
msgid ""
" a = 2;\n"
" b = a++;\n"
" // now b contains 2 and a contains 3"
msgstr ""
" a = 2;\n"
" b = a++;\n"
" // agora b contém 2 e a contém 3"

#. type: Source code
#: ../E/expr.txt:193
#, no-wrap
msgid ""
" a = 2;\n"
" b = ++a;\n"
" // now b contains 3 and a contains 3"
msgstr ""
" a = 2;\n"
" b = ++a;\n"
" // agora b contém 3 e a contém 3"

#. type: \b; header
#: ../E/expr.txt:137
#, no-wrap
msgid "Logical operators"
msgstr "Operadores lógicos"

#. type: Plain text
#: ../E/expr.txt:138
#, no-wrap
msgid "Logical operators work with values of type <a cbot|bool>bool</a> and they always return a <a cbot|bool>bool</a>. They are mainly used in <a cbot|cond>conditions</a>."
msgstr "Operadores lógicos funcionam com valores do tipo <a cbot|bool>bool</a> e eles sempre retorna um  <a cbot|bool>bool</a>. Eles são frequentemente utilizados em  <a cbot|cond>condições</a>."

#. type: \b; header
#: ../E/expr.txt:150
#, no-wrap
msgid "Ternary operator"
msgstr "Operador ternário"

#. type: Plain text
#: ../E/expr.txt:151
#, no-wrap
msgid ""
"The ternary operator is nothing more than a syntax sugar. It is also known as \"inline if\". It might be confusing at first, because its syntax is a little more complicated than other operators. It can be described as follows:\n"
"<code>(condition) ? (result when true) : (result when false)</code>\n"
"Brackets are not needed."
msgstr ""
"O operador ternário nada mais é do que sintaxe reduzida. Também é conhecido como \"if em linha\". Pode ser confuso de início, porque sua sintaxe é um pouco mais complicada que os outros operadores. Ele pode ser descrito desta forma: \n"
"<code>(condicao) ? (resultado quando true) : (resultado quando false)</code>\n"
"Parênteses não são necessários."

#. type: Plain text
#: ../E/expr.txt:155
#, no-wrap
msgid "Firstly, the condition is valued and then the first result is returned if the condition is true, otherwise the second result is returned."
msgstr "Primeiramente, a condição é avaliada e então o primeiro resultado é retornado se a condição for verdadeira, caso contrário o segundo resultado é retornado."

#. type: \t; header
#: ../E/expr.txt:157 ../E/extends.txt:4 ../E/extends.txt:65 ../E/private.txt:4 ../E/protected.txt:4 ../E/super.txt:4
#, no-wrap
msgid "Example"
msgstr "Exemplo"

#. type: Source code
#: ../E/expr.txt:158
#, no-wrap
msgid "<c/>float c = ((3.0 > 2.0) ? 10.0 : -10.0); // c == 10.0<n/>"
msgstr "<c/>float c = ((3.0 > 2.0) ? 10.0 : -10.0); // c == 10.0<n/>"

#. type: Plain text
#: ../E/cond.txt:2
#, no-wrap
msgid "A condition is a special <a cbot|expr>expression</a> that returns a <a cbot|bool>boolean</a> value, that can only be either <code><a cbot|true>true</a></code> or <code><a cbot|false>false</a></code>. With a condition, you can choose f. ex. if the instructions in a <code><a cbot|while>while</a></code> loop must be repeated again, or if the instruction in a <code><a cbot|if>if</a></code> bloc must be executed."
msgstr "A condição é uma  <a cbot|expr>expressão</a> especial que retorna um valor <a cbot|bool>booleano</a>, que só pode ser ou <code><a cbot|true>true</a></code> ou <code><a cbot|false>false</a></code>. Com uma condição, você pode escolher, por exemplo, se as instruções em um laço <code><a cbot|while>while</a></code> devem ser repetidas de novo, ou se uma instrução em um bloco <code><a cbot|if>if</a></code> deve ser executada."

#. type: \b; header
#: ../E/expr.txt:112
#, no-wrap
msgid "Comparison operators"
msgstr "Operadores de comparação"

#. type: Plain text
#: ../E/expr.txt:113
#, no-wrap
msgid "Comparison operators work with values of type <a cbot|bool>float</a> and they always return a <a cbot|bool>bool</a>. They are mainly used in <a cbot|cond>conditions</a>."
msgstr "Operadores de comparação funcionam com valores do tipo <a cbot|bool>float</a> e eles sempre retornam um <a cbot|bool>bool</a>. Eles são frequentemente usados em <a cbot|cond>condições</a>."

#. type: Plain text
#: ../E/expr.txt:141
#, no-wrap
msgid ""
"<code>!a      </code>not <code>a</code>\n"
"<code>a && b  </code><code>a</code> and <code>b</code>\n"
"<code>a || b  </code><code>a</code> or <code>b</code>"
msgstr ""
"<code>!a      </code>não <code>a</code>\n"
"<code>a && b  </code><code>a</code> e <code>b</code>\n"
"<code>a || b  </code><code>a</code> ou <code>b</code>"

#. type: Plain text
#: ../E/expr.txt:146
#, no-wrap
msgid ""
"<code>!false        </code>returns true\n"
"<code>true && false </code>returns false \n"
"<code>true || false </code>returns true"
msgstr ""
"<code>!false        </code>retorna true\n"
"<code>true && false </code>retorna false \n"
"<code>true || false </code>retorna true"

#. type: \b; header
#: ../E/expr.txt:160
#, no-wrap
msgid "Bitwise operators"
msgstr "Operadores bit a bit"

#. type: Plain text
#: ../E/expr.txt:161
#, no-wrap
msgid "Bitwise operators are similar to the logical operator, because they are operating on bits (which can be only 0 or 1, conditions can have a value only of false or true). So in theory, they should be working with basically any type of variable, because each value in the computer must be stored as a sequence of bits."
msgstr "Operadores bit a bit são similares aos operadors lógicos, porque eles estão operando em bits (que podem ser somente 0 ou 1, condições só podem ter um valor de falso ou verdadeiro). Então em teoria, eles devem conseguir trabalhar com praticamente qualquer tipo de variável, porque cada valor no computador deve ser armazenado como uma sequência de bits."

#. type: Plain text
#: ../E/expr.txt:164
#, no-wrap
msgid ""
"<code>a & b  </code><code>a</code> AND <code>b</code>\n"
"<code>a | b  </code><code>a</code> OR <code>b</code>\n"
"<code>a ^ b  </code><code>a</code> XOR <code>b</code>\n"
"<code>a >> b  </code>shift bits of <code>a</code> to the right <code>b</code> times\n"
"<code>a << b  </code>shift bits of <code>a</code> to the left <code>b</code> times"
msgstr ""
"<code>a & b  </code><code>a</code> AND <code>b</code>\n"
"<code>a | b  </code><code>a</code> OR <code>b</code>\n"
"<code>a ^ b  </code><code>a</code> XOR <code>b</code>\n"
"<code>a >> b  </code>desloca bits de <code>a</code> para a direita <code>b</code> vezes\n"
"<code>a << b  </code>desloca bits de a <code>a</code> para a esquerda <code>b</code> vezes"

#. type: Plain text
#: ../E/expr.txt:171
#, no-wrap
msgid ""
"<code>2 & 1         </code>returns 0\n"
"<code>2 | 1         </code>returns 3\n"
"<code>2 ^ 2         </code>returns 0\n"
"<code>2 >> 1        </code>returns 1\n"
"<code>2 << 1        </code>returns 4"
msgstr ""
"<code>2 & 1         </code>retorna 0\n"
"<code>2 | 1         </code>retorna 3\n"
"<code>2 ^ 2         </code>retorna 0\n"
"<code>2 >> 1        </code>retorna 1\n"
"<code>2 << 1        </code>retorna 4"

#. type: Source code
#: ../E/array.txt:4
#, no-wrap
msgid ""
"int    [ ] a;   // an array of int\n"
"int    a [12];  // an array of int limited to 12 elements\n"
"string s[3];    // an array of 3 strings\n"
"float  xy[][];  // a 2 dimensionnal array of floats"
msgstr ""
"int    [ ] a;   // uma matriz de int\n"
"int    a [12];  // uma matriz de int limitada a 12 elementos\n"
"string s[3];    // uma matriz de 3 strings\n"
"float  xy[][];  // uma matriz bidimensional de floats"

#. type: \b; header
#: ../E/array.txt:30
#, no-wrap
msgid "Initialization syntax"
msgstr "Sintaxe de inicialização"

#. type: Plain text
#: ../E/array.txt:31
#, no-wrap
msgid "You can initialize a new array using the following syntax:"
msgstr "Você pode inicializar uma nova matriz usando a seguinte sintaxe:"

#. type: Source code
#: ../E/array.txt:33
#, no-wrap
msgid "type arrayName[] = { value0, value1, value2, ..., valueN };"
msgstr "tipo nomeMatriz[] = { valor0, valor1, valor2, ..., valorN };"

#. type: Source code
#: ../E/array.txt:37
#, no-wrap
msgid ""
"int numbers[] = { 10, 20, 30 };\n"
"MyClass objects[] = { new MyClass(1), new MyClass(2) };"
msgstr ""
"int numeros[] = { 10, 20, 30 };\n"
"MinhaClasse objetos[] = { new MinhaClasse(1), new MinhaClasse(2) };"

#. type: Plain text
#: ../E/radar.txt:2
#, no-wrap
msgid "With the instruction <c/>radar();<n/>, you can look for objects like <a object|mother>enemies</a>, bots, buildings or raw materials."
msgstr "Com a instrução <c/>radar();<n/>, você pode procurar por objetos como <a object|mother>inimigos</a>, robôs, edifícios ou matéria prima."

#. type: Plain text
#: ../E/radar.txt:81
#, no-wrap
msgid "<c/><a cbot|radarall>radarall</a>();<n/>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<c/><a cbot|radarall>radarall</a>();<n/>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/radarall.txt:1
#, no-wrap
msgid "Instruction <code>radarall</code>"
msgstr "Instrução <code>radarall</code>"

#. type: Plain text
#: ../E/radarall.txt:2
#, no-wrap
msgid "<c/>radarall();<n/> is an enhancement of the <c/><a cbot|radar>radar</a>();<n/> function -- it detects all objects matching the given criteria."
msgstr "<c/>radarall();<n/> é um aprimoramento da função <c/><a cbot|radar>radar</a>();<n/>. Ela detecta todos os objetos que correspondem ao critério dado."

#. type: \b; header
#: ../E/radarall.txt:4
#, no-wrap
msgid "Example<c/>"
msgstr "Exemplo<c/>"

#. type: Source code
#: ../E/radarall.txt:13
#, no-wrap
msgid "<c/>radarall ( cat, angle, focus, min, max, sens, filter );<n/>"
msgstr "<c/>radarall ( categoria, angulo, foco, min, max, sens, filtro );<n/>"

#. type: Plain text
#: ../E/radarall.txt:15
#, no-wrap
msgid "The function works generally the same as the <c/><a cbot|radar>radar</a>();<n/> function with the only difference being that it returns an <a cbot|array>array</a> of <a cbot|object>objects</a> instead of one object. If no object is found, <code><a cbot|null>null</a></code> is returned."
msgstr "A função funciona geralmente do mesmo jeito que a função <c/><a cbot|radar>radar</a>();<n/>, a única diferença está que ela retorna uma <a cbot|array>matriz</a> de <a cbot|object>objetos</a>  em vez de um único objeto. Se nenhum objeto for encontrado, ela retorna <code><a cbot|null>null</a></code>."

#. type: Plain text
#: ../E/radarall.txt:17
#, no-wrap
msgid "The order of objects in the returned array is sorted by distance and depends on the <code>sens</code> parameter. The first object in the array is the object which would be returned by the <c/>radar();<n/> function called with the exactly same parameters."
msgstr "A ordem dos objetos na matriz retornada é de acordo com a distância e depende do parâmetro <code>sens</code>. O primeiro objeto na matriz é o objeto que seria retornado pela função <c/>radar();<n/> com os mesmos parâmetros."

#. type: Plain text
#: ../E/radarall.txt:20
#, no-wrap
msgid "<c/><a cbot|radar>radar</a>();<n/>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr "<c/><a cbot|radar>radar</a>();<n/>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: Plain text
#: ../E/for.txt:11
#, no-wrap
msgid "This set of instructions is executed before the first loop instance."
msgstr "Este conjunto de instruções é executado antes da primeira instância do laço."

#. type: Plain text
#: ../E/for.txt:17
#, no-wrap
msgid "This set of instructions is executed at the end of every instance of the loop. "
msgstr "Este conjunto de instruções é executado ao fim de cada instância do laço."

#. type: \t; header
#: ../E/for.txt:38
#, no-wrap
msgid "Executing more instructions"
msgstr "Executando mais instruções"

#. type: Plain text
#: ../E/for.txt:39
#, no-wrap
msgid "In the <code>before</code> and <code>end</code> part of a <code>for</code> loop you can specify more than one instruction by using comma. Example:"
msgstr "Nas partes <code>inicio</code> e <code>fim</code> de um laço <code>for</code> você pode especificar mais de uma instrução usando vírgula. Exemplo:"

#. type: Source code
#: ../E/for.txt:41
#, no-wrap
msgid ""
"int i = 0;\n"
"int j;\n"
"for (i++, j = 2; i < 3 && j > 0; i++, j--)\n"
"{\n"
"    message(i);\n"
"    message(j);\n"
"}"
msgstr ""
"int i = 0;\n"
"int j;\n"
"for (i++, j = 2; i < 3 && j > 0; i++, j--)\n"
"{\n"
"    message(i);\n"
"    message(j);\n"
"}"

#. type: Plain text
#: ../E/for.txt:49
#, no-wrap
msgid "The output of the above code is <code>1 2 2 1</code>."
msgstr "A saída do código acima é <code>1 2 2 1</code>."

#. type: Source code
#: ../E/radarall.txt:5
#, no-wrap
msgid ""
"object[] items = radarall(PowerCell);\n"
"for (int i = 0; i < sizeof(items); ++i)\n"
"{\n"
"    message(items[i].id);\n"
"}"
msgstr ""
"object[] itens = radarall(PowerCell);\n"
"for (int i = 0; i < sizeof(itens); ++i)\n"
"{\n"
"    message(itens[i].id);\n"
"}"

#. type: Plain text
#: ../E/category.txt:103
#, no-wrap
msgid ""
"       <code><a object|flag>BlueFlag</a>          </code>Blue Flag\n"
"       <code><a object|flag>RedFlag</a>           </code>Red Flag\n"
"       <code><a object|flag>GreenFlag</a>         </code>Green Flag\n"
"       <code><a object|flag>YellowFlag</a>        </code>Yellow Flag\n"
"       <code><a object|flag>VioletFlag</a>        </code>Violet Flag\n"
"       <code><a object|waypoint>WayPoint</a>          </code>Checkpoint\n"
"       <code><a object|target2>Target2</a>           </code>Flying checkpoint\n"
"       <code><a object|enerspot>PowerSpot</a>        </code>Underground Energy Deposit\n"
"       <code><a object|stonspot>TitaniumSpot</a>      </code>Underground Titanium Deposit\n"
"       <code><a object|uranspot>UraniumSpot</a>       </code>Underground Uranium Deposit"
msgstr ""
"       <code><a object|flag>BlueFlag</a>          </code>Bandeira azul\n"
"       <code><a object|flag>RedFlag</a>           </code>Bandeira vermelha\n"
"       <code><a object|flag>GreenFlag</a>         </code>Bandeira verde\n"
"       <code><a object|flag>YellowFlag</a>        </code>Bandeira amarela\n"
"       <code><a object|flag>VioletFlag</a>        </code>Bandeira violeta\n"
"       <code><a object|waypoint>WayPoint</a>          </code>Ponto de verificação\n"
"       <code><a object|target2>Target2</a>           </code>Ponto de verificação voador\n"
"       <code><a object|enerspot>PowerSpot</a>        </code>Depósito de energia subterrâneo\n"
"       <code><a object|stonspot>TitaniumSpot</a>      </code>Depósito de titânio subterrâneo\n"
"       <code><a object|uranspot>UraniumSpot</a>       </code>Depósito de urânio subterrâneo"

#. type: Plain text
#: ../E/category.txt:10
#, no-wrap
msgid ""
"<button 176/>   <code><a object|huston>Houston</a>          </code>Mission Control\n"
"<button 171/>   <code><a object|base>SpaceShip</a>        </code>Spaceship\n"
"<button 160/>   <code><a object|factory>BotFactory</a>       </code>Robot Factory\n"
"<button 163/>   <code><a object|research>ResearchCenter</a>   </code>Research Center\n"
"<button 168/>   <code><a object|radar>RadarStation</a>     </code>Radar\n"
"<button 172/>   <code><a object|exchange>ExchangePost</a>     </code>Information Exchange Post\n"
"<button 169/>   <code><a object|repair>RepairCenter</a>     </code>Repair Center\n"
"<button 165/>   <code><a object|tower>DefenseTower</a>     </code>Defense Tower\n"
"<button 166/>   <code><a object|labo>AutoLab</a>          </code>Organic Matter Analyzer \n"
"<button 164/>   <code><a object|station>PowerStation</a>     </code>Power Station\n"
"<button 167/>   <code><a object|energy>PowerPlant</a>       </code>Power Cell Factory\n"
"<button 170/>   <code><a object|nuclear>NuclearPlant</a>     </code>Nuclear Plant\n"
"<button 162/>   <code><a object|convert>Converter</a>        </code>Titanium Converter\n"
"<button 161/>   <code><a object|derrick>Derrick</a>          </code>Derrick\n"
"<button 174/>   <code><a object|captor>PowerCaptor</a>      </code>Parabolic Lightning Conductor\n"
"<button 175/>   <code><a object|safe>Vault</a>            </code>Vault\n"
"       <code><a object|start>StartArea</a>        </code>Starting Pad\n"
"       <code><a object|goal>GoalArea</a>         </code>Finishing Pad\n"
"       <code><a object|target1>Target1</a>          </code>Flying target\n"
"       <code><a object|nest>AlienNest</a>        </code>Alien Nest"
msgstr ""
"<button 176/>   <code><a object|huston>Houston</a>          </code>Controle de missão\n"
"<button 171/>   <code><a object|base>SpaceShip</a>        </code>Espaçonave\n"
"<button 160/>   <code><a object|factory>BotFactory</a>       </code>Fábrica de robôs\n"
"<button 163/>   <code><a object|research>ResearchCenter</a>   </code>Centro de pesquisa\n"
"<button 168/>   <code><a object|radar>RadarStation</a>     </code>Estação de radar\n"
"<button 172/>   <code><a object|exchange>ExchangePost</a>     </code>Posto de troca de informação\n"
"<button 169/>   <code><a object|repair>RepairCenter</a>     </code>Centro de reparos\n"
"<button 165/>   <code><a object|tower>DefenseTower</a>     </code>Torre de defesa\n"
"<button 166/>   <code><a object|labo>AutoLab</a>          </code>Analisador de matéria orgânica\n"
"<button 164/>   <code><a object|station>PowerStation</a>     </code>Estação de energia\n"
"<button 167/>   <code><a object|energy>PowerPlant</a>       </code>Fábrica de células de energia\n"
"<button 170/>   <code><a object|nuclear>NuclearPlant</a>     </code>Planta nuclear\n"
"<button 162/>   <code><a object|convert>Converter</a>        </code>Convertedor de titânio\n"
"<button 161/>   <code><a object|derrick>Derrick</a>          </code>Guindaste\n"
"<button 174/>   <code><a object|captor>PowerCaptor</a>      </code>Condutor de relâmpagos parabólico\n"
"<button 175/>   <code><a object|safe>Vault</a>            </code>Cofre\n"
"       <code><a object|start>StartArea</a>        </code>Plataforma de início\n"
"       <code><a object|goal>GoalArea</a>         </code>Plataforma de finalização\n"
"       <code><a object|target1>Target1</a>          </code>Alvo voando\n"
"       <code><a object|nest>AlienNest</a>        </code>Ninho alienígena"

#. type: Plain text
#: ../E/class.txt:10
#, no-wrap
msgid "Classes can be only <a cbot|public>public</a>. This means that they can be used by all bots in a mission."
msgstr "Classes só podem ser <a cbot|public>publicas</a>. Isto significa que elas podem ser utilizadas por todos os robôs em uma missão."

#. type: \b; header
#: ../E/class.txt:12
#, no-wrap
msgid "Class Members"
msgstr "Membros da classe"

#. type: Plain text
#: ../E/class.txt:13
#, no-wrap
msgid "Class members are fields (<a cbot|var>variables</a>) and methods (<a cbot|function>functions</a>)."
msgstr "Membros da classe são atributos (<a cbot|var>variáveis</a>) e métodos (<a cbot|function>funções</a>)."

#. type: Plain text
#: ../E/class.txt:15
#, no-wrap
msgid "For example, the following class dubbed <code>MyClass</code> contains 4 fields (<code>a</code>, <code>b</code>, <code>x</code> and <code>s</code>) and one method (<code>MyFunction</code>)."
msgstr "Por exemplo, a seguinte classe chamada <code>MinhaClasse</code> contém 4 atributos  (<code>a</code>, <code>b</code>, <code>x</code> e <code>s</code>) e um método (<code>MinhaFuncao</code>)."

#. type: Source code
#: ../E/class.txt:17
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint     a, b;\n"
"\tfloat   x = 3.33;\n"
"\tstring  s = \"hello\";\n"
"\tfloat   MyFunction(float value)\n"
"\t{\n"
"\t\treturn (value * x) - 1;\n"
"\t}\n"
"}"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tint     a, b;\n"
"\tfloat   x = 3.33;\n"
"\tstring  s = \"olá\";\n"
"\tfloat   MinhaFuncao(float value)\n"
"\t{\n"
"\t\treturn (value * x) - 1;\n"
"\t}\n"
"}"

#. type: \t; header
#: ../E/class.txt:55
#, no-wrap
msgid "Member Initialization"
msgstr "Inicialização de membros"

#. type: Plain text
#: ../E/class.txt:60
#, no-wrap
msgid "Example:<c/>"
msgstr "Exemplo:<c/>"

#. type: Source code
#: ../E/class.txt:61
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint  a, b;\n"
"\tvoid MyClass()\n"
"\t{\n"
"\t\ta = 2;  b = 3;\n"
"\t}\n"
"\tvoid MyClass(int a, int b)\n"
"\t{\n"
"\t\tthis.a = a;  this.b = b;\n"
"\t}\n"
"}"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tint  a, b;\n"
"\tvoid MinhaClasse()\n"
"\t{\n"
"\t\ta = 2;  b = 3;\n"
"\t}\n"
"\tvoid MinhaClasse(int a, int b)\n"
"\t{\n"
"\t\tthis.a = a;  this.b = b;\n"
"\t}\n"
"}"

#. type: Plain text
#: ../E/class.txt:76
#, no-wrap
msgid "As the names of the parameters of the second constructor are the same as the names of the two members <code>a</code> and <code>b</code>, we must use the <code><a cbot|this>this</a></code> <a cbot|pointer>reference</a> to avoid confusion with the parameters' names."
msgstr "Como os nomes dos parâmetros do segundo construtor são iguais aos nomes dos dois membros <code>a</code> e <code>b</code>, nós devemos usar a </code> <a cbot|pointer>referência</a> <code><a cbot|this>this</a> para evitar confusão com os nomes dos parâmetros."

#. type: \b; header
#: ../E/class.txt:78
#, no-wrap
msgid "Object Creation"
msgstr "Criação de objetos"

#. type: Plain text
#: ../E/class.txt:79
#, no-wrap
msgid "You can create objects of type <code>YourClass</code> using the <code><a cbot|new>new</a></code> keyword. Example:"
msgstr "Você pode criar objetos do tipo <code>SuaClasse</code> usando a palavra-chave  <code><a cbot|new>new</a></code>. Exemplo:"

#. type: \b; header
#: ../E/class.txt:90
#, no-wrap
msgid "Object Destruction"
msgstr "Destruição de objetos"

#. type: \b; header
#: ../E/class.txt:114
#, no-wrap
msgid "Passing Objects to Functions"
msgstr "Passando objetos para funções"

#. type: Plain text
#: ../E/class.txt:115
#, no-wrap
msgid "Objects in CBOT are passed by <a cbot|pointer>reference</a>. This means that when an object is passed to a <a cbot|function>function</a>, the function receives a copy of a pointer to the instance, not a copy of the object, so any modifications on the object will be visible outside of the function."
msgstr "Objetos em CBOT são passados por <a cbot|pointer>referência</a>. Isto significa que quando um objeto é passado para uma <a cbot|function>função</a>, a função recebe uma cópia de um ponteiro para a instância, não uma cópia do objeto, então quaisquer modificações realizadas ao objeto dentro da função serão visíveis fora da função."

#. type: \b; header
#: ../E/class.txt:117
#, no-wrap
msgid "Inheritance"
msgstr "Herança"

#. type: Plain text
#: ../E/class.txt:118
#, no-wrap
msgid "A class can inherit public and protected members of another class by using the <code><a cbot|extends>extends</a></code> keyword."
msgstr "Uma classe pode herdar membros públicos e protegidos de outra classe usando a palavra-chave <code><a cbot|extends>extends</a></code>."

#. type: Plain text
#: ../E/class.txt:2
#, no-wrap
msgid "This keyword allows you to create a class definition by using the following syntax:"
msgstr "Esta palavra permite a você criar uma definição de classe usando a seguinte sintaxe:"

#. type: \t; header
#: ../E/class.txt:9
#, no-wrap
msgid "All Classes Are Public"
msgstr "Todas as classes são públicas"

#. type: \t; header
#: ../E/class.txt:52
#, no-wrap
msgid "Class Members Modifiers"
msgstr "Modificadores de membros de classe"

#. type: \t; header
#: ../E/class.txt:75
#, no-wrap
msgid "Using <code><a cbot|this>this</a></code>"
msgstr "Usando <code><a cbot|this>this</a></code>"

#. type: Source code
#: ../E/class.txt:81
#, no-wrap
msgid ""
"extern void object::Test()\n"
"{\n"
"\tMyClass object1();       // Call default constructor (without parameters)\n"
"\tMyClass object2(4, 5);   // Call constructor with two int parameters\n"
"\tMyClass object3;         // No constructor called, object3 == null\n"
"\tobject3 = new MyClass(); // We call constructor now, object3 != null\n"
"}"
msgstr ""
"extern void object::Teste()\n"
"{\n"
"\tMinhaClasse objeto1();       // Chama o construtor padrão (sem parâmetros)\n"
"\tMinhaClasse objeto2(4, 5);   // Chama o construtor com 2 parâmetros int\n"
"\tMinhaClasse objeto3;         // Nenhum construtor chamado, objeto3 == null\n"
"\tobjeto3 = new MinhaClasse(); // Chamamos o construtor agora, objeto3 != null\n"
"}"

#. type: Plain text
#: ../E/class.txt:91
#, no-wrap
msgid "You can also define a destructor. This must be a <code><a cbot|void>void</a></code> fonction without parameters, which has the same name as the class but prefixed with the <code>~</code> character. The destructor is called automatically as soon as the class instance is no more referenced by anyone. Example:"
msgstr "Você também pode definir um destrutor. Este deve uma função  <code><a cbot|void>void</a></code>sem parâmetros, que deve ter o mesmo nome da classe porém com o prefixada com o caráctere <code>~</code>. O destrutor é chamado automaticamente assim que a instância da classe não é mais referenciada por ninguém. Exemplo:"

#. type: Source code
#: ../E/class.txt:93
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tstatic private int counter = 0; // instance counter\n"
"\tvoid  MyClass( )\n"
"\t{\n"
"\t\tcounter++;  // one instance more\n"
"\t}\n"
"\tvoid ~MyClass( )\n"
"\t{\n"
"\t\tcounter--;  // one instance less\n"
"\t}\n"
"}\n"
"extern void object::Test()\n"
"{\n"
"\t                   // counter == 0\n"
"\tMyClass item1( );  // counter == 1\n"
"\tMyClass item2( );  // counter == 2\n"
"\titem1 = null;      // counter == 1\n"
"}\n"
"// counter == 0"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tstatic private int contador = 0; // contador de instância\n"
"\tvoid  MinhaClasse( )\n"
"\t{\n"
"\t\tcontador++;  // uma instância a mais\n"
"\t}\n"
"\tvoid ~MinhaClasse( )\n"
"\t{\n"
"\t\tcontador--;  // uma instância a menos\n"
"\t}\n"
"}\n"
"extern void object::Teste()\n"
"{\n"
"\t                   // contador == 0\n"
"\tMinhaClasse item1( );  // contador == 1\n"
"\tMinhaClasse item2( );  // contador == 2\n"
"\titem1 = null;      // contador == 1\n"
"}\n"
"// contador == 0"

#. type: \b; header
#: ../E/class.txt:28
#, no-wrap
msgid "Accessing Class Members"
msgstr "Acessando membros da classe"

#. type: Plain text
#: ../E/class.txt:29
#, no-wrap
msgid "Class members can be accessed outside of the class definition by using the <code>.</code> operator. Example:"
msgstr "Membros da classe podem ser acessados fora da definição da classe utilizando o operador <code>.</code>. Exemplo:"

#. type: Plain text
#: ../E/class.txt:50
#, no-wrap
msgid "Class members are <a cbot|public>public</a> by default, which means that they are accessible outside of the class definition. They can also be declared as <code><a cbot|private>private</a></code> or <code><a cbot|protected>protected</a></code>. Such members can only be accessed inside of the class definition."
msgstr "Membros de classe são <a cbot|public>public</a> por padrão, o que significa que eles são acessíveis fora da definição da classe. Eles também pode ser declarados <code><a cbot|private>private</a></code> ou <code><a cbot|protected>protected</a></code>. Estes membros só podem ser acessados dentro da definição da classe."

#. type: Plain text
#: ../E/class.txt:53
#, no-wrap
msgid "Fields and methods can also be declared as <code><a cbot|static>static</a></code>. Methods can be additionaly declared as <code><a cbot|synchro>synchronized</a></code>."
msgstr "Atributos e métodos também podem ser declarados como <code><a cbot|static>static</a></code>. Métodos também podem ser adicionalmente declarados como <code><a cbot|synchro>synchronized</a></code>."

#. type: Plain text
#: ../E/class.txt:58
#, no-wrap
msgid "Another way of initiliazing fields is by defining a constructor which is a special method having the same name as the class. This method will be called automatically at <a cbot|new>creation</a> time of a class instance. Constructors can be <a cbot|function>overloaded</a>."
msgstr "Outra forma de inicializar os atributos é definindo um construtor que é um método especial com o mesmo nome da classe. Este método será chamado automaticamente no tempo de <a cbot|new>criação</a> da instância da classe. Construtores também podem ser  <a cbot|function>sobrecarregados</a>."

#. type: Source code
#: ../E/class.txt:31
#, no-wrap
msgid ""
"public class MyClass\n"
"{\n"
"\tint myField = 0;\n"
"\tint MyFunction()\n"
"\t{\n"
"\t\treturn myField * 2;\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tMyClass myObject();\n"
"\tmyObject.myField = 10;\n"
"\tmessage(myObject.MyFunction()); // 20\n"
"\tMyClass mySecondObject();\n"
"\tmySecondObject.myField = myObject.myField - 2;\n"
"\tmessage(mySecondObject.MyFunction()); // 16\n"
"}"
msgstr ""
"public class MinhaClasse\n"
"{\n"
"\tint meuAtributo = 0;\n"
"\tint minhaFuncao()\n"
"\t{\n"
"\t\treturn meuCampo * 2;\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Teste()\n"
"{\n"
"\tMinhaClasse meuObjeto();\n"
"\tmeuObjeto.meuAtributo = 10;\n"
"\tmessage(meuObjeto.minhaFuncao()); // 20\n"
"\tMinhaClasse meuSegundoObjeto();\n"
"\tmeuSegundoObjeto.meuCampo = meuObjeto.meuCampo - 2;\n"
"\tmessage(meuSegundoObjeto.minhaFuncao()); // 16\n"
"}"

#. type: Plain text
#: ../E/class.txt:121
#, no-wrap
msgid ""
"<code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|static>static</a></code>, <code><a cbot|synchro>synchronized</a></code>, <code><a cbot|new>new</a></code>, <code><a cbot|pointer>reference</a></code>, <code><a cbot|this>this</a></code>, <code><a cbot|super>super</a></code>, <code><a cbot|extends>extends</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|static>static</a></code>, <code><a cbot|synchro>synchronized</a></code>, <code><a cbot|new>new</a></code>, <code><a cbot|pointer>referência</a></code>, <code><a cbot|this>this</a></code>, <code><a cbot|super>super</a></code>, <code><a cbot|extends>extends</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/protected.txt:1
#, no-wrap
msgid "Keyword <code>protected</code>"
msgstr "palavra-chave <code>protected</code>"

#. type: Plain text
#: ../E/protected.txt:2
#, no-wrap
msgid "This is an access modifier for <a cbot|class>class</a> members. Protected class members can be accessed in a child class, but they can't be accessed outside of classes definitions being part of the same inheritance tree (see the <code><a cbot|extends>extends</a></code> keyword)."
msgstr "Este é um modificador de acesso para membros de <a cbot|class>classe</a>. Membros de classe protegidos podem ser acessados em classes filhas, porém não podem ser acessados fora das definições de classe que fazem parte da mesma árvore de herança (veja a palavra-chave <code><a cbot|extends>extends</a></code>)."

#. type: Source code
#: ../E/protected.txt:6
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tprotected int field = 0;\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tvoid Print()\n"
"\t{\n"
"\t\tmessage(field);\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tChild child();\n"
"\tchild.Print(); // 0\n"
"\t//child.field = 1; // Error!\n"
"}"
msgstr ""
"public class Pai\n"
"{\n"
"\tprotected int atributo = 0;\n"
"}\n"
"\n"
"public class Filho extends Pai\n"
"{\n"
"\tvoid imprimir()\n"
"\t{\n"
"\t\tmessage(atributo);\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Teste()\n"
"{\n"
"\tFilho filho = new filho();\n"
"\tfilho.imprimir(); // 0\n"
"\t//child.atributo = 1; // erro!\n"
"}"

#. type: Plain text
#: ../E/private.txt:2
#, no-wrap
msgid "This is an access modifier for <a cbot|class>class</a> members. Private members are not accessible outside of the class definition."
msgstr "Este é um modificador de acesso para membros de <a cbot|class>classe</a>. Membros privados não são acessíveis fora da definição da classe."

#. type: Plain text
#: ../E/private.txt:20
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|protected>protected</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|protected>protected</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: Plain text
#: ../E/public.txt:34
#, no-wrap
msgid "<code>public</code> is also an access modifier for <a cbot|class>class</a> members, which is the default one. Public members can be accessed from outside of the class definition."
msgstr "<code>public</code> é um modificador de acesso para membros de <a cbot|class>classe</a>, ele é o modificador padrão. Membros públicos podem ser acessados fora da definição da classe."

#. type: Plain text
#: ../E/public.txt:50
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|function>functions</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|function>funções</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: Plain text
#: ../E/protected.txt:27
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|extends>extends</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|extends>extends</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/super.txt:1
#, no-wrap
msgid "Keyword <code>super</code>"
msgstr "Palavra-chave <code>super</code>"

#. type: Plain text
#: ../E/super.txt:46
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|this>this</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|this>this</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: Plain text
#: ../E/this.txt:53
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|super>super</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|super>super</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: \b; header
#: ../E/extends.txt:1
#, no-wrap
msgid "Keyword <code>extends</code>"
msgstr "Palavra-chave <code>extends</code>"

#. type: \b; header
#: ../E/extends.txt:30
#, no-wrap
msgid "Inherited Members"
msgstr "Membros herdados"

#. type: Plain text
#: ../E/extends.txt:31
#, no-wrap
msgid "Only <code><a cbot|public>public</a></code> and <code><a cbot|protected>protected</a></code> members are inherited. <code><a cbot|private>private</a></code> members are directly inaccessible even for a child, although they can be accessed indirectly through inherited methods."
msgstr "Somente membros <code><a cbot|public>public</a></code> e <code><a cbot|protected>protected</a></code> são herdados. Membros <code><a cbot|private>private</a></code> são inacessíveis até para os filhos, apesar de poder serem acessados indiretamente através de métodos herdados."

#. type: Plain text
#: ../E/extends.txt:33
#, no-wrap
msgid "Constructors and destructors are not inherited, however, they can be overriden."
msgstr "Construtores e destrutores não são herdados, entretanto, eles podem ser sobrescritos."

#. type: \b; header
#: ../E/extends.txt:35
#, no-wrap
msgid "Method Overriding"
msgstr "Sobrescrevendo métodos"

#. type: Plain text
#: ../E/extends.txt:36
#, no-wrap
msgid "Inherited methods can be overriden (redefined) in the child class definition. Example:"
msgstr "Métodos herdados podem ser sobrescritos (redefinidos) na definição de classe dos filhos. Exemplo:"

#. type: Source code
#: ../E/extends.txt:38
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"foo\");\n"
"\t}\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"bar\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tChild child();\n"
"\tchild.foo(); // Will show \"bar\"\n"
"}"
msgstr ""
"public class Pai\n"
"{\n"
"\tvoid ola()\n"
"\t{\n"
"\t\tmessage(\"Olá!\");\n"
"\t}\n"
"}\n"
"\n"
"public class Filho extends Pai\n"
"{\n"
"\tvoid ola()\n"
"\t{\n"
"\t\tmessage(\"Hello!\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Teste()\n"
"{\n"
"\tFilho filho = new Filho();\n"
"\tfilho.ola(); // Irá exibir \"Hello!\"\n"
"}"

#. type: \b; header
#: ../E/extends.txt:62
#, no-wrap
msgid "Polymorphism"
msgstr "Polimorfismo"

#. type: Plain text
#: ../E/extends.txt:63
#, no-wrap
msgid "<code><a cbot|pointer>Reference</a></code> of type Parent can point to an object of type Child. However, such a pointer can't be used to access a child member. In order to access a child member, it must be assured that the Parent reference really points to a Child object. If that's the case, it can be safely copied to a pointer of type Child, which has access to the child members."
msgstr "Uma <code><a cbot|pointer>referência</a></code> do tipo Pai pode apontar para um objeto do tipo Filho, entretanto, esta referência não pode ser usada para acessar um membro do filho. A fim de acessar um membro do filho, deve ser assegurado que o referência do Pai realmente aponta para um objeto Filho. Neste caso, ele pode ser copiado com segurança para uma referência do tipo Filho, o qual terá acesso aos membros do filho."

#. type: Source code
#: ../E/extends.txt:67
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"foo\");\n"
"\t}\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"bar\");\n"
"\t}\n"
"\tvoid bar()\n"
"\t{\n"
"\t\tmessage(\"foo bar\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tParent people[2];\n"
"\tpeople[0] = new Parent();\n"
"\tpeople[1] = new Child();\n"
"\tfor (int i = 0; i < 2; ++i)\n"
"\t{\n"
"\t\tpeople[i].foo();\n"
"\t}\n"
"\t//people[1].bar(); // Error\n"
"\tChild child = people[1];\n"
"\tchild.bar(); // OK\n"
"}"
msgstr ""
"public class Pai\n"
"{\n"
"\tvoid ola()\n"
"\t{\n"
"\t\tmessage(\"Olá!\");\n"
"\t}\n"
"}\n"
"\n"
"public class Filho extends Pai\n"
"{\n"
"\tvoid ola()\n"
"\t{\n"
"\t\tmessage(\"Hello!\");\n"
"\t}\n"
"\tvoid oi()\n"
"\t{\n"
"\t\tmessage(\"Oi!\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Teste()\n"
"{\n"
"\tPai pessoas[2];\n"
"\tpessoas[0] = new Pai();\n"
"\ttpessoas[1] = new Filho();\n"
"\tfor (int i = 0; i < 2; ++i)\n"
"\t{\n"
"\t\tpessoas[i].ola();\n"
"\t}\n"
"\t//pessoas[1].oi(); // Erro\n"
"\tFilho filho = pessoas[1];\n"
"\tfilho.oi(); // OK\n"
"}"

#. type: \b; header
#: ../E/extends.txt:102
#, no-wrap
msgid "Multiple Inheritance"
msgstr "Herança múltipla"

#. type: Plain text
#: ../E/extends.txt:103
#, no-wrap
msgid "A child cannot have multiple parents, however, a parent can have many children."
msgstr "Uma criança não pode ter múltiplos pais, porém, um pai pode ter múltiplas crianças."

#. type: Plain text
#: ../E/extends.txt:106
#, no-wrap
msgid ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|new>new</a></code>, <code><a cbot|pointer>reference</a></code>, <code><a cbot|this>this</a></code>, <code><a cbot|super>super</a></code>\n"
"<a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>."
msgstr ""
"<code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|private>private</a></code>, <code><a cbot|protected>protected</a></code>, <code><a cbot|new>new</a></code>, <code><a cbot|pointer>referência</a></code>, <code><a cbot|this>this</a></code>, <code><a cbot|super>super</a></code>\n"
"<a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>."

#. type: Plain text
#: ../E/super.txt:2
#, no-wrap
msgid "This keyword is similar to <code><a cbot|this>this</a></code>, however, it grants access to methods from the parent class (see the <code><a cbot|extends>extends</a></code> keyword), which is especially useful for method overriding."
msgstr "Esta palavra-chave é similar a <code><a cbot|this>this</a></code>, entretando, ela garante acesso aos métodos da classe Pai (veja a palavra-chave <code><a cbot|extends>extends</a></code>), o que é especialmente útil para sobrescrever métodos."

#. type: Source code
#: ../E/super.txt:6
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tprotected int field;\n"
"\t\n"
"\tvoid Parent()\n"
"\t{\n"
"\t\tfield = 0;\n"
"\t}\n"
"\t\n"
"\tvoid Print()\n"
"\t{\n"
"\t\tmessage(\"Parent's field: \" + field);\n"
"\t}\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tprivate int childsField;\n"
"\t\n"
"\tvoid Child()\n"
"\t{\n"
"\t\tsuper.Parent();\n"
"\t\tchildsField = field + 1;\n"
"\t}\n"
"\t\n"
"\tvoid Print()\n"
"\t{\n"
"\t\tsuper.Print();\n"
"\t\tmessage(\"Child's field: \" + childsField);\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tChild child();\n"
"\tchild.Print(); // Will show both 0 and 1\n"
"}"
msgstr ""
"public class Pai\n"
"{\n"
"\tprotected int atributo;\n"
"\t\n"
"\tvoid Pai()\n"
"\t{\n"
"\t\tatributo = 0;\n"
"\t}\n"
"\t\n"
"\tvoid imprimir()\n"
"\t{\n"
"\t\tmessage(\"Atributo do pai: \" + atributo);\n"
"\t}\n"
"}\n"
"\n"
"public class Filho extends Pai\n"
"{\n"
"\tprivate int filhoAtributo;\n"
"\t\n"
"\tvoid Filho()\n"
"\t{\n"
"\t\tsuper.Pai();\n"
"\t\tatributoFilho = atributo + 1;\n"
"\t}\n"
"\t\n"
"\tvoid imprimir()\n"
"\t{\n"
"\t\tsuper.imprimir();\n"
"\t\tmessage(\"Atributo do filho: \" + atributoFilho);\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Teste()\n"
"{\n"
"\tFilho filho = new Filho();\n"
"\tfilho.imprimir(); // Irá exibir ambos 0 e 1\n"
"}"

#. type: Plain text
#: ../E/extends.txt:2
#, no-wrap
msgid "This keyword is used in a <code><a cbot|class>class</a></code> definition when we want the class to inherit members from another class. The class which is extended we usually call a parent or base, the extending class we call a child."
msgstr "Esta palavra-chave é usada na definição de <code><a cbot|class>classe</a></code> quando queremos que uma classe herde membros de outra classe. A classe que é extendida nós geralmente chamamos de pai ou base, a quase que extendeu nós chamamos de filha."

#. type: Source code
#: ../E/extends.txt:6
#, no-wrap
msgid ""
"public class Parent\n"
"{\n"
"\tvoid foo()\n"
"\t{\n"
"\t\tmessage(\"foo\");\n"
"\t}\n"
"}\n"
"\n"
"public class Child extends Parent\n"
"{\n"
"\tvoid bar()\n"
"\t{\n"
"\t\tmessage(\"bar\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Test()\n"
"{\n"
"\tChild child();\n"
"\tchild.foo(); // Will show \"foo\"\n"
"\tchild.bar(); // Will show \"bar\"\n"
"}"
msgstr ""
"public class Pai\n"
"{\n"
"\tvoid ola()\n"
"\t{\n"
"\t\tmessage(\"Olá!\");\n"
"\t}\n"
"}\n"
"\n"
"public class Filho extends Pai\n"
"{\n"
"\tvoid oi()\n"
"\t{\n"
"\t\tmessage(\"Oi!\");\n"
"\t}\n"
"}\n"
"\n"
"extern void object::Teste()\n"
"{\n"
"\tFilho filho = new Filho();\n"
"\tfilho.ola(); // Irá exibir \"Ola!\"\n"
"\tfilho.oi(); // Irá exibir \"Oi!\"\n"
"}"

#. type: Plain text
#: ../E/extends.txt:60
#, no-wrap
msgid "A parent's method can be called inside an overriden method by using the <code><a cbot|super>super</a></code> keyword."
msgstr "Um método do pai pode ser chamado dentro de um método sobrescrito usando a palavra-chave  <code><a cbot|super>super</a></code>."

#. type: Plain text
#: ../E/class.txt:56
#, no-wrap
msgid "As shown in the previous example, the class members can be initialized in the class definition (<c/>int x = 3.33;<n/>)."
msgstr "Como mostrado no exemplo anterior, os membros da classe podem ser inicializados na definição da classe  (<c/>int x = 3.33;<n/>)."

#. type: Plain text
#: ../E/open.txt:13
#, no-wrap
msgid ""
"<code>\"r\"</code> mode: open for reading.\n"
"<code>\"w\"</code> mode: open for writing.\n"
"<code>\"a\"</code> mode: open for appending."
msgstr ""
"Modo <code>\"r\"</code>: abre para leitura.\n"
"Modo <code>\"w\"</code>: abre para escrita.\n"
"Modo <code>\"a\"</code>: abre para acrescentar."

#. type: Plain text
#: ../E/openfile.txt:2
#, no-wrap
msgid "<c/>openfile();<n/> opens an text file in the files/ folder. This is not a method of the <code><a cbot|file>file</a></code> class but openfile returns a <a cbot|pointer>reference</a> to a new instance of the file class. You must supply two parameters, the filename and the opening mode."
msgstr "<c/>openfile();<n/> abre um arquivo de texto no diretório files/. Este não é um método da classe <code><a cbot|file>file</a></code>, porém openfile retorna uma <a cbot|pointer>referência</a> para uma nova instância da classe file. Você deve fornecer dois parâmetros, o nome do arquivo e o modo de abertura."

#. type: Plain text
#: ../E/openfile.txt:6
#, no-wrap
msgid ""
"<code>\"r\"</code> mode: open for reading.\n"
"<code>\"w\"</code> mode: open for writing.\n"
"<code>\"w\"</code> mode: open for appending."
msgstr ""
"Modo <code>\"r\"</code>: abre para leitura.\n"
"Modo <code>\"w\"</code>: abre para escrita.\n"
"Modo <code>\"a\"</code>: abre para acrescentar."

#. type: Plain text
#: ../E/function.txt:14
#, no-wrap
msgid "Nothing but a name can be changed in the main function. The keyword <code><a cbot|extern>extern</a></code> distinguishes the main function from others."
msgstr "Nada além de um nome pode ser alterado na função principal. A palavra-chave <code><a cbot|extern>extern</a></code> distingue a função principal das outras."

#. type: \b; header
#: ../E/function.txt:117
#, no-wrap
msgid "Public Functions"
msgstr "Funções públicas"

#. type: \b; header
#: ../E/function.txt:129
#, no-wrap
msgid "Default Parameters"
msgstr "Parâmetros padrões"

#. type: Plain text
#: ../E/function.txt:130
#, no-wrap
msgid "Last function parameters can have default values that can be omitted when calling."
msgstr "Os últimos parâmetros de uma função podem ter valores padrões, permitindo a omissão dos mesmos quando a função for chamada."

#. type: Source code
#: ../E/function.txt:132
#, no-wrap
msgid ""
"float Add(float a = 0.0, float b = 0.0)\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"// Somewhere in the main program...\n"
"Add(); // Will return 0.0\n"
"Add(2.0); // Will return 2.0\n"
"Add(2.0, 3.0); // Will return 5.0\n"
"// ..."
msgstr ""
"float adicionar(float a = 0.0, float b = 0.0)\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"// Em algum lugar do programa principal...\n"
"adicionar(); // Irá retornar 0.0\n"
"adicionar(2.0); // Irá retornar 2.0\n"
"adicionar(2.0, 3.0); // Irá retornar 5.0\n"
"// ..."

#. type: \t; header
#: ../E/function.txt:144
#, no-wrap
msgid "Default Parameters and Overloading"
msgstr "Parâmetros padrões e sobrecarregamento"

#. type: Plain text
#: ../E/function.txt:145
#, no-wrap
msgid "Functions with default parameters still can be overloaded, one must only ensure that function calls are not ambiguous. For example, consider the following code:"
msgstr "Funções com parâmetros padrões ainda podem ser sobrecarregadas, só é preciso garantir que as chamadas as funções não são ambíguas. Por exemplo, considere o seguinte código:"

#. type: Source code
#: ../E/function.txt:147
#, no-wrap
msgid ""
"float Add(float a = 0.0, float b = 0.0)\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"string Add(string a = \"\", string b = \"\")\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"// Somewhere in the main program...\n"
"Add(); // Compilation error: ambiguous call\n"
"Add(\"\"); // Ok\n"
"Add(0.0); // Ok\n"
"// ..."
msgstr ""
"float adicionar(float a = 0.0, float b = 0.0)\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"string adicionar(string a = \"\", string b = \"\")\n"
"{\n"
"\treturn a + b;\n"
"}\n"
"\n"
"// Em algum lugar do programa principal...\n"
"adicionar(); // Erro de compilação: chamada ambígua\n"
"adicionar(\"\"); // Ok\n"
"adicionar(0.0); // Ok\n"
"// ..."

#. type: Plain text
#: ../E/function.txt:163
#, no-wrap
msgid "Note that in the above example overloading causes the first default parameter to be useless as caller needs to pass it anyway in order to distinguish the two functions."
msgstr "Note que no exemplo acima o sobrecarregamento torna o primeiro parâmetro padrão inútil, já que ao chamar a função ele deve ser informado para que as duas funções possam ser distinguidas."

#. type: Plain text
#: ../E/category.txt:70
#, no-wrap
msgid ""
"<button 192/>   <code><a object|botbr>WheeledBuilder</a>         </code>Wheeled Builder\n"
"<button 193/>   <code><a object|botbc>TrackedBuilder</a>         </code>Tracked Builder\n"
"<button 194/>   <code><a object|botbj>WingedBuilder</a>          </code>Winged Builder\n"
"<button 195/>   <code><a object|botbs>LeggedBuilder</a>          </code>Legged Builder"
msgstr ""