# 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:109 ../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:70
#, 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:79
#, 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:89
#, 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:110
#, 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>1</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>1</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:77
#, no-wrap
msgid "Enemies:"
msgstr "Inimigos:"

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

#. type: \t; header
#: ../E/category.txt:96
#, 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:98
#, 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."