colobot-data 0.1.7 - en to pt_BR translation catalogue (993 entries)

note: type: \b; header
en: Instruction <code>abstime</code>
pt_BR: Instrução <code>abstime</code>

note: type: Plain text
en: Syntax:
pt_BR: Sintaxe:

note: type: Plain text
en: Return the time in seconds elapsed since the beginning of the mission.
pt_BR: Retorna o tempo que passou em segundos desde o início da missão.

note: type: \t; header
en: Return: <code><a cbot|float>float</a></code>
pt_BR: Retorna: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Time in seconds.
pt_BR: Tempo em segundos.

note: type: \t; header
en: See also
pt_BR: Veja também

note: type: Plain text
en: <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>aim</code>
pt_BR: Instrução <code>aim</code>

note: type: Plain text
en: Syntax :
pt_BR: Sintaxe:

note: type: Bullet: 'o'
en: <a object|botfr>Shooter</a>
pt_BR: <a object|botfr>Atirador</a>

note: type: Bullet: 'o'
en: <a object|botor>Orga shooter</a>
pt_BR: <a object|botor>Atirador orgânico</a>

note: type: Bullet: 'o'
en: <a object|botphaz>Phazer shooter</a>
pt_BR: <a object|botphaz>Atirador phazer</a>

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \t; header
en: angle: <code><a cbot|float>float</a></code>
pt_BR: ângulo: <code><a cbot|float>float</a></code>

note: type: Plain text
en: 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.
pt_BR: Â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.

note: type: \t; header
en: Return value: <code><a cbot|int>int</a></code>
pt_BR: Valor de retorno: <code><a cbot|int>int</a></code>

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

note: type: \b; header
en: Arrays
pt_BR: Matrizes

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Source code
en: int a[5];  // a is now a null reference
pt_BR: int a[5];  // a é agora uma referência nula

note: type: Plain text
en: As soon as you put values into the array, the elements are created and the reference is initialized:
pt_BR: Assim que você coloca valores na matriz, os elementos são criados e a referência é inicializada.

note: type: Source code
en: a[2] = 213;  // a points to
                 // 3 elements [0], [1] et [2]
pt_BR: a[2] = 213;  // a aponta para
                 // 3 elementos [0], [1] e [2]

note: type: Plain text
en: 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.
pt_BR: 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.
    A instrução <code><a cbot|sizeof>sizeof</a></code> permite a você obter a quantidade de elementos contidos na matriz.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Source code
en: {
    	int a[5];
    	a[7] = 123;  // no error at compile time
    	             // but error at run time
    }
pt_BR: {
    	int a[5];
    	a[7] = 123;  // nenhum erro ao compilar
    	             // porém com erros ao executar
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Blocks
pt_BR: Blocos

note: type: Plain text
en: 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:
pt_BR: Você pode usar chaves <code>{ }</code> para agrupar um número de intruções em ordem para criar um bloco com elas, por exemplo:

note: type: Source code
en: 	{
    		float  t;
    		t = a;
    		a = b;
    		b = t;  // switches round a and b
    	}
pt_BR: 	{
    		float  t;
    		t = a;
    		a = b;
    		b = t;  // troca a e b
    	}

note: type: Plain text
en: Every instruction in the block is followed by a <a cbot|term>semicolon</a>, but the block itself is not. 
    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:
pt_BR: Cada instrução no bloco é seguida por um <a cbot|term>ponto e vírgula</a>, mas o bloco em sí não.
    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:

note: type: Plain text
en: 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. 
    If you want to perform instructions 1 and 2 only if the condition is true, you have to bracket them together in a block:
pt_BR: 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.
    Se você quer executar as instruções 1 e 2 somente se a condição for verdadeira,  você deve colocá-las em um bloco:

note: type: Plain text
en: 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. 
    You can fit blocks into other blocks, on as many levels as you need. Here is an example of imbrication on two levels :
pt_BR: 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. 
    Você pode colocar blocos em outros blocos, em quantos níveis você necessitar. Aqui está um exemplo da sobreposição de 2 níveis:

note: type: Plain text
en: 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 :
pt_BR: É 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:

note: type: Plain text
en: <a cbot>Instructions</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <a cbot>Instruções</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Type <code>bool</code>
pt_BR: Tipo <code>bool</code>

note: type: Plain text
en: 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.
pt_BR: Uma variável deste tipo pode receber valores booleanos, isto significa que só pode ter dois valores: true ou false (verdadeiro ou falso).

note: type: \b; header
en: Instruction <code>break</code>
pt_BR: Instrução <code>break</code>

note: type: Source code
en: <c/>while ( condition )
    {
    	break;
    }
pt_BR: <c/>while ( condição )
    {
    	break;
    }

note: type: Plain text
en: 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.
pt_BR: 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>.

note: type: Plain text
en: Here is an example:
pt_BR: Aqui está um exemplo:

note: type: Source code
en: <c/>int i = 0;
    while ( true )
    {
    	<n/>Instructions ...<c/>
    	i = i+1;
    	if ( i >= 10 )
    	{
    		break;
    	}
    	<n/>more instructions ...<c/>
    }
pt_BR: <c/>int i = 0;
    while ( true )
    {
    	<n/>instruções …<c/>
    	i = i+1;
    	if ( i >= 10 )
    	{
    		break;
    	}
    	<n/>mais instruções…<c/>
    }

note: type: \b; header
en: Value <code>Categories</code>
pt_BR: <code>Categorias</code> de valor

note: type: Plain text
en: Categories represent the names of objects in the CBOT language. Everything in COLOBOT is an object: robots, buildings, raw materials, etc., even yourself.
pt_BR: 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.

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

note: type: Plain text
en: <button 158/>   <code><a object|bottr>PracticeBot</a>            </code>Practice Bot
    <button 173/>   <code><a object|bottarg>TargetBot</a>              </code>Target Bot
pt_BR: <button 158/>   <code><a object|bottr>PracticeBot</a>            </code>Robô de prática
    <button 173/>   <code><a object|bottarg>TargetBot</a>              </code>Robô alvo

note: type: Plain text
en: <button 137/>   <code><a object|botgr>WheeledGrabber</a>         </code>Wheeled Grabber
    <button 138/>   <code><a object|botgc>TrackedGrabber</a>         </code>Tracked Grabber
    <button 139/>   <code><a object|botgj>WingedGrabber</a>          </code>Winged Grabber
    <button 150/>   <code><a object|botgs>LeggedGrabber</a>          </code>Legged Grabber
pt_BR: <button 137/>   <code><a object|botgr>WheeledGrabber</a>         </code>Agarrador com rodas
    <button 138/>   <code><a object|botgc>TrackedGrabber</a>         </code>Agarrador com esteiras
    <button 139/>   <code><a object|botgj>WingedGrabber</a>          </code>Agarrador alado
    <button 150/>   <code><a object|botgs>LeggedGrabber</a>          </code>Agarrador com pernas

note: type: Plain text
en: <button 140/>   <code><a object|botsr>WheeledSniffer</a>         </code>Wheeled Sniffer
    <button 141/>   <code><a object|botsc>TrackedSniffer</a>         </code>Tracked Sniffer
    <button 142/>   <code><a object|botsj>WingedSniffer</a>          </code>Winged Sniffer
    <button 152/>   <code><a object|botss>LeggedSniffer</a>          </code>Legged Sniffer
pt_BR: <button 140/>   <code><a object|botsr>WheeledSniffer</a>         </code>Farejador com rodas
    <button 141/>   <code><a object|botsc>TrackedSniffer</a>         </code>Farejador com esteiras
    <button 142/>   <code><a object|botsj>WingedSniffer</a>          </code>Farejador alado
    <button 152/>   <code><a object|botss>LeggedSniffer</a>          </code>Farejador com pernas

note: type: Plain text
en: <button 143/>   <code><a object|botfr>WheeledShooter</a>         </code>Wheeled Shooter
    <button 144/>   <code><a object|botfc>TrackedShooter</a>         </code>Tracked Shooter
    <button 145/>   <code><a object|botfj>WingedShooter</a>          </code>Winged Shooter
    <button 151/>   <code><a object|botfs>LeggedShooter</a>          </code>Legged Shooter
pt_BR: <button 143/>   <code><a object|botfr>WheeledShooter</a>         </code>Atirador com rodas
    <button 144/>   <code><a object|botfc>TrackedShooter</a>         </code>Atirador com esteiras
    <button 145/>   <code><a object|botfj>WingedShooter</a>          </code>Atirador alado
    <button 151/>   <code><a object|botfs>LeggedShooter</a>          </code>Atirador com pernas

note: type: Plain text
en: <button 153/>   <code><a object|botor>WheeledOrgaShooter</a>     </code>Wheeled Orga Shooter
    <button 154/>   <code><a object|botoc>TrackedOrgaShooter</a>     </code>Tracked Orga Shooter
    <button 155/>   <code><a object|botoj>WingedOrgaShooter</a>      </code>Winged Orga Shooter
    <button 156/>   <code><a object|botos>LeggedOrgaShooter</a>      </code>Legged Orga Shooter
pt_BR: <button 153/>   <code><a object|botor>WheeledOrgaShooter</a>     </code>Atirador orgânico com rodas
    <button 154/>   <code><a object|botoc>TrackedOrgaShooter</a>     </code>Atirador orgânico com esteiras
    <button 155/>   <code><a object|botoj>WingedOrgaShooter</a>      </code>Atirador orgânico alado
    <button 156/>   <code><a object|botos>LeggedOrgaShooter</a>      </code>Atirador orgânico com pernas

note: type: Plain text
en: <button 149/>   <code><a object|botsub>Subber</a>                 </code>Subber
    <button 148/>   <code><a object|botrecy>Recycler</a>               </code>Recycler
    <button 157/>   <code><a object|botshld>Shielder</a>               </code>Shielder
    <button 146/>   <code><a object|bottump>Thumper</a>                </code>Thumper
    <button 147/>   <code><a object|botphaz>PhazerShooter</a>          </code>Phazer Shooter
pt_BR: <button 149/>   <code><a object|botsub>Subber</a>                 </code>Mergulhador
    <button 148/>   <code><a object|botrecy>Recycler</a>               </code>Reciclador
    <button 157/>   <code><a object|botshld>Shielder</a>               </code>Protetor
    <button 146/>   <code><a object|bottump>Thumper</a>                </code>Batedor
    <button 147/>   <code><a object|botphaz>PhazerShooter</a>          </code>Atirador phazer

note: type: Plain text
en:        <code><a object|mother>AlienQueen</a>         </code>Alien Queen
           <code><a object|egg>AlienEgg</a>           </code>Alien Egg
           <code><a object|ant>AlienAnt</a>           </code>Ant
           <code><a object|spider>AlienSpider</a>        </code>Spider
           <code><a object|wasp>AlienWasp</a>          </code>Wasp
           <code><a object|worm>AlienWorm</a>          </code>Worm
pt_BR:        <code><a object|mother>AlienQueen</a>         </code>Reinha alienígena
           <code><a object|egg>AlienEgg</a>           </code>Ovo alienígena
           <code><a object|ant>AlienAnt</a>           </code>Formiga
           <code><a object|spider>AlienSpider</a>        </code>Aranha
           <code><a object|wasp>AlienWasp</a>          </code>Vespa
           <code><a object|worm>AlienWorm</a>          </code>Verme

note: type: Plain text
en: <a cbot>CBOT Language</a> and <a cbot|type>Variables</a>.
pt_BR: <a cbot>Linguagem CBOT</a> e <a cbot|type>variáveis</a>.

note: type: \b; header
en: Instruction <code>class</code>
pt_BR: Instrução <code>class</code>

note: type: Source code
en: public class ClassName
    {
    	declarations;
    }
pt_BR: public class NomeDaClasse 
    {
    	declarações;
    }

note: type: \b; header
en: Instruction <code>close</code>
pt_BR: Instrução <code>close</code>

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Plain text
en: <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>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Conditions
pt_BR: Condições

note: type: Plain text
en: <code>a == b  </code><code>a</code> equals <code>b</code>
    <code>a != b  </code><code>a</code> is different from <code>b</code>
    <code>a <  b  </code><code>a</code> smaller than <code>b</code>
    <code>a <= b  </code><code>a</code> smaller than or equal to <code>b</code>
    <code>a >  b  </code><code>a</code> greater than <code>b</code>
    <code>a >= b  </code><code>a</code> greater than or equal to <code>b</code>
pt_BR: <code>a == b  </code><code>a</code> é igual a <code>b</code>
    <code>a != b  </code><code>a</code> é diferente de <code>b</code>
    <code>a <  b  </code><code>a</code> é menor que <code>b</code>
    <code>a <= b  </code><code>a</code> é menor ou igual a <code>b</code>
    <code>a >  b  </code><code>a</code> é maior que <code>b</code>
    <code>a >= b  </code><code>a</code> é maior ou igual a <code>b</code>

note: type: Plain text
en: <code>12 == 12  </code>returns true
    <code>45 != 47  </code>returns true 
    <code>99 == 98  </code>returns false
    <code>12 <  -1  </code>returns false
    <code>12 >= 10  </code>returns true 
    <code>12 >= 12  </code>returns true
pt_BR: <code>12 == 12  </code>retorna true
    <code>45 != 47  </code>retorna true 
    <code>99 == 98  </code>retorna false
    <code>12 <  -1  </code>retorna false
    <code>12 >= 10  </code>retorna true 
    <code>12 >= 12  </code>retorna true

note: type: Plain text
en: Be careful not to confuse the equality comparison <code>==</code> with the assignment of a <a cbot|var>variable</a> <code>=</code>.
pt_BR: 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>.

note: type: Plain text
en: <code>a == b</code> is an expression that compares <code>a</code> with <code>b</code>.
    <code>a = b</code> is an expression that copies the value of <code>b</code> into <code>a</code>.
pt_BR: <code>a == b</code> é uma expressão que compara <code>a</code> com <code>b</code>.
    <code>a = b</code> é uma expressão que copia o valor de <code>b</code> em <code>a</code>.

note: type: \b; header
en: Instruction <code>continue</code>
pt_BR: Instrução <code>continue</code>

note: type: Source code
en: <c/>while ( condition )
    {
    	continue;
    }
pt_BR: <c/>while ( condição )
    {
    	continue;
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: <c/>int i = 0;
    while ( i < 5 )
    {
    	i = i+1;
    	if ( i == 3 )
    	{
    		continue;
    	}
    	<n/>Instructions ...<c/>
    }
pt_BR: <c/>int i = 0;
    while ( i < 5 )
    {
    	i = i+1;
    	if ( i == 3 )
    	{
    		continue;
    	}
    	<n/>instruções...<c/>
    }

note: type: Plain text
en: The instructions will only be executed for the values of <code>i</code> 1, 2, 4 and 5.
pt_BR: As instruções só serão executadas quando o valor de <code>i</code> for 1, 2, 4 ou 5.

note: type: \b; header
en: Instruction <code>deletefile</code>
pt_BR: Instrução <code>deletefile</code>

note: type: Plain text
en: The deletefile instruction deletes an existing file in the files/ folder.
pt_BR: A instrução deletefile remove um arquivo existente na pasta files/.

note: type: Plain text
en: 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.
pt_BR: 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/.

note: type: Source code
en: <c/>deletefile ( filename );<n/>
pt_BR: <c/>deletefile ( nome_do_arquivo );<n/>

note: type: \b; header
en: Instruction <code>deleteinfo</code>
pt_BR: Instrução <code>deleteinfo</code>

note: type: Source code
en: <c/>deleteinfo ( name, power );<n/>
pt_BR: <c/>deleteinfo ( nome, energia );<n/>

note: type: Plain text
en: Delete an existing information in the closest <a object|exchange>information exchange post</a>.
pt_BR: Deleta uma informação existente no <a object|exchange>posto de troca de informação</a> mais próximo.

note: type: \t; header
en: name: <code>string</code>
pt_BR: nome: <code>string</code>

note: type: Plain text
en: Name of the information to be deleted. This name is a string: it must be written in quotation marks "".
pt_BR: Nome da informação a ser deletada. Este nome é uma string: deve ser escrito entre aspas "...".

note: type: \t; header
en: power: <code>float</code>
pt_BR: energia: <code>float</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: <code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> and <code><a cbot|testinfo>testinfo</a></code>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> e <code><a cbot|testinfo>testinfo</a></code>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>direction</code>
pt_BR: Instrução <code>direction</code>

note: type: Plain text
en: Calculates the rotation that a robot must perform in order to point towards a given position.
pt_BR: Calcula a rotação que um robô deve fazer a fim de apontar para uma  posição informada.

note: type: Plain text
en: Position towards which the robot must point.
pt_BR: Posição que o robô deve apontar.

note: type: \t; header
en: Return value: <code><a cbot|float>float</a></code>
pt_BR: Valor de retorno: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Angle of the rotation that must be performed. -90 means f. ex. a rotation of 90 degrees to the right.
pt_BR: Ângulo da rotação que deve ser realizada. -90 significa que deve rotacionar 90 graus a direita.

note: type: \b; header
en: Instruction <code>distance</code>
pt_BR: Instrução <code>distance</code>

note: type: Plain text
en: With the instruction <code>distance( , )</code> you can calculate the distance between two positions.
pt_BR: Com a instrução <code>distance( , )</code> você pode calcular a distância entre duas posições.

note: type: \b; header
en: Basic use
pt_BR: Uso básico

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Here is a program that moves forward, covering exactly the distance between the bot and the closest ant:
pt_BR: Aqui está um programa que avança, cobrindo exatamente a distância entre o robô e a formiga mais próxima.

note: type: Plain text
en: This is of course pure suicide. Better to stop 40 meters before, in order to be at shooting range:
pt_BR: Isto é claro, puro suicidio. Melhor parar 40 metros antes de forma a estar no alcance de tiro:

note: type: \b; header, \t; header
en: For specialists
pt_BR: Para especialistas

note: type: Plain text, \t; header
en: Syntax:
pt_BR: Sintaxe:

note: type: Plain text
en: Calculates the distance between two positions.
pt_BR: Calcula a distância entre duas posições.

note: type: Plain text
en: Coordinates of the two positions.
pt_BR: Coordenadas das duas posições.

note: type: Plain text
en: Distance between the two positions.
pt_BR: A distância entre as duas posições.

note: type: \b; header
en: Instruction <code>distance2d</code>
pt_BR: Instrução <code>distance2d</code>

note: type: Plain text
en: Calculates the distance between two positions (ignores the z coordinate).
pt_BR: Calcula a distância entre duas posições (ignora a coordenada z)

note: type: \b; header
en: Instruction <code>do - while</code>
pt_BR: Instrução <code>do - while</code>

note: type: Source code
en: <code>do
    {
    	</code>Instructions ...<c/>
    }
    while ( condition );
pt_BR: <code>do
    {
    	</code>instruções...<c/>
    }
    while ( condição );

note: type: Plain text
en: 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.
    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.
pt_BR: 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.
    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.

note: type: \t; header
en: <code>condition</code>
pt_BR: <code>condição</code>

note: type: Plain text
en: The instructions in the block are performed over and over again, as long as the <a cbot|cond>condition</a> is true.
pt_BR: As instruções no bloco são executadas de novo e de novo, enquanto a  <a cbot|cond>condição</a> é verdadeira.

note: type: Plain text
en: Here is an example :
pt_BR: Veja aqui um exemplo:

note: type: \t; header
en: Attention
pt_BR: Atenção

note: type: Plain text
en: Always put a <a cbot|term>semicolon</a> at the end of the line <code>while ( )</code>.
pt_BR: Sempre coloque um <a cbot|term>ponto e vírgula</a> no fim da linha <code>while ( )</code>.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \b; header
en: Instruction <code>drop</code>
pt_BR: Instrução <code>drop</code>

note: type: Plain text
en: 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.
pt_BR: 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ô.

note: type: Plain text
en: 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:
pt_BR: 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.

note: type: Source code
en: <c/>drop ( oper );<n/>
pt_BR: <c/>drop ( local );<n/>

note: type: Plain text
en: This instruction appeals to the operating arm of a <a object|botgr>grabber bot</a>, in order to drop what it is holding.
pt_BR: 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.

note: type: \t; header
en: oper: <code><a cbot|int>int</a></code> (default value<code>InFront</code>)
pt_BR: local: <code><a cbot|int>int</a></code> (valor padrão: <code>InFront</code>)

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

note: type: Plain text
en: 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/>.
    <code>== 0 </code>object was dropped
    <code>!= 0 </code>error, no object was dropped
pt_BR: 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/>.
    <code>== 0 </code>objeto foi largado com sucesso
    <code>!= 0 </code>erro, nenhum objeto foi largado

note: type: \b; header
en: Instruction <code>eof</code>
pt_BR: Instrução <code>eof</code>

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Plain text
en: Example:
pt_BR: Exemplo:

note: type: Plain text
en: <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>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>errmode</code>
pt_BR: Instrução <code>errmode</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: <c/>errmode ( mode );<n/>
pt_BR: <c/>errmode ( modo );<n/>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \t; header
en: mode: <code><a cbot|float>float</a></code> (<code>1</code> per default)
pt_BR: modo: <code><a cbot|float>float</a></code> (valor padrão: <code>1</code>)

note: type: Plain text
en: Error treatment mode.
    <code>0</code> -> continues program execution and returns a non zero value
    <code>1</code> -> stops the program (default behavior)
pt_BR: Modo de tratamento de erros.
    <code>0</code> -> continua a execução do programa e retorna um valor diferente de zero
    <code>1</code> -> para o programa (comportamento padrão)

note: type: Plain text
en: Example 1:
pt_BR: Exemplo 1:

note: type: Plain text
en: Example 2:
pt_BR: Exemplo 2:

note: type: Source code
en: <c/>errmode(0);
    int err;
    err = goto(pos);
    if ( err != 0 )
    {
    	<n/>goto did not perform correctly ...<code>
    	</code>take some appropriate action ...<c/>
    }
pt_BR: <c/>errmode(0);
    int erro;
    erro = goto(pos);
    if ( erro != 0 )
    {
    	<n/>goto não executou corretamente...<code>
    	</code>tome uma ação apropriada...<c/>
    }

note: type: \b; header
en: Expressions
pt_BR: Expressões

note: type: Plain text
en: is equivalent to
pt_BR: é equivalente a

note: type: Plain text
en: <code>+=</code>  addition
    <code>-=</code>  subtraction
    <code>*=</code>  multiplication
    <code>/=</code>  division
    <code>%=</code>  remainder of the division (only for the type <code><a cbot|int>int</a></code>)
pt_BR: <code>+=</code>  adição
    <code>-=</code>  subtração
    <code>*=</code>  multiplicação
    <code>/=</code>  divisão
    <code>%=</code>  resto da divisão (somente para o tipo <code><a cbot|int>int</a></code>)

note: type: Plain text
en: The operators <code>++</code> and <code>--</code> allow you to increment (++) or to decrement (--) a variable in very compact and efficient manner.
pt_BR: Os operadores <code>++</code> e <code>--</code> permitem a você incrementar (++)ou decrementar (--) uma variável de uma maneira bem compacta e eficiente.

note: type: \b; header
en: Instruction <code>extern</code>
pt_BR: Instrução <code>extern</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: extern void object::MowDown( )
    {
    	while ( true )
    	{
    		fire(1);
    		turn(10);
    	}
    }
pt_BR: extern void object::Massacre( )
    {
    	while ( true )
    	{
    		fire(1);
    		turn(10);
    	}
    }

note: type: Plain text
en: If the program contains other functions, only the main function must be preceded by <code>extern</code>.
pt_BR: Se o programa conter outras funções, somente a função principal deve ser precedidade por <code>extern</code>.

note: type: Source code
en: extern void object::Square( )
    {
    	for ( int i=0 ; i<4 ; i++ )
    	{
    		Line(10);
    	}
    }
    
    void object::Line(float dist)
    {
    	move(dist);
    	turn(90);
    }
pt_BR: extern void object::Quadrado( )
    {
    	for ( int i=0 ; i<4 ; i++ )
    	{
    		Linha(10);
    	}
    }
    
    void object::Linha(float distancia)
    {
    	move(distancia);
    	turn(90);
    }

note: type: \b; header
en: Type <code>false</code>
pt_BR: Tipo <code>false</code>

note: type: Plain text
en: 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.
pt_BR:  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.

note: type: \b; header
en: Type <code>file</code>
pt_BR: Tipo <code>file</code>

note: type: Plain text
en: This type is used for accessing files in the files/ folder.
pt_BR: Este tipo é usado para acessar arquivos na pasta files/.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: 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.
pt_BR: 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/.

note: type: Plain text
en: <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>:
pt_BR: <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>:

note: type: Source code
en: 	handle.open("test.txt", "w");
    	handle.close();
pt_BR: 	handle.open("arquivo.txt", "w");
    	handle.close();

note: type: Plain text
en: <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>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>fire</code>
pt_BR: Instrução <code>fire</code>

note: type: Plain text
en: The instruction <c/>fire();<n/> fires the bot's onboard cannon.
pt_BR: A instrução <c/>fire();<n/> atira o canhão a bordo do robô.

note: type: Plain text
en: Generally this instruction is used to shoot one-second bursts:
pt_BR: Geralmente a instrução é utilizada para atirar rajadas de um segundo.

note: type: Source code
en: <c/>fire ( time );<n/>
pt_BR: <c/>fire ( tempo );<n/>

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: In order to move the gun upward or downward, use the instruction <code><a cbot|aim>aim</a></code>.
pt_BR: A fim de mover a arma para cima ou para baixo, use a instrução <code><a cbot|aim>aim</a></code>.

note: type: \t; header
en: time: <code><a cbot|float>float</a></code>
pt_BR: tempo: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Duration of the burst. Generally, the value given is 1. Shorter bursts can also be performed in order to spare time and energy.
pt_BR: Duração da rajada. Normalmente, o valor dado é 1. Rajadas curtas também podem ser realizadas a fim de economizar tempo e energia.

note: type: Plain text
en: Zero if OK, or a value different from zero if an error occurred.
    <code>== 0 </code>the cannon has been fired
    <code>!= 0 </code>error, the cannon could not be fired
pt_BR: Zero se OK, ou um valor diferente de zero se um erro ocorreu.
    <code>== 0 </code>o canhão atirou
    <code>!= 0 </code>erro, o canhão não pôde atirar

note: type: \b; header
en: Instruction <code>flatground</code>
pt_BR: Instrução <code>flatground</code>

note: type: Source code
en: <c/>flatground ( center, rmax );<n/>
pt_BR: <c/>flatground ( centro, raioMaximo );<n/>

note: type: Plain text
en: Calculates the maximal radius of a flat zone on which a building ca be built.
pt_BR: Calcula o raio máximo de um zona plana na qual um edifício pode ser construído.

note: type: \t; header
en: center: <code><a cbot|point>point</a></code>
pt_BR: centro: <code><a cbot|point>point</a></code>

note: type: Plain text
en: Center of the circlular zone.
pt_BR: Centro da zona circular.

note: type: \t; header
en: rmax: <code><a cbot|float>float</a></code>
pt_BR: raioMaximo: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Maximal radius.
pt_BR: Raio máximo.

note: type: Plain text
en: Radius of the flat zone (always between 0 and rmax).
pt_BR: Raio da zona plana (sempre entre 0 e raioMaximo)

note: type: \b; header
en: Type <code>float</code>
pt_BR: Tipo <code>float</code>

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: If you need only whole numbers (f. ex. 12 or -5000), you should rather use the type <code><a cbot|int>int</a></code>.
pt_BR: 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>.

note: type: Plain text
en: Do not insert space or colon characters into a number. To separate the whole part from the fractional part, use a dot.
pt_BR: Não insira espaços ou vírgulas em um número. Para separar a parte inteira da parte fracionada, use um ponto.

note: type: Source code
en:    Write       and not
       12.56       12 . 56
      -54.34       -54,34
    12895.69    12,895.69
pt_BR:   Correto     Errado
       12.56       12 . 56
      -54.34       -54,34
    12895.69    12,895.69

note: type: Plain text
en: Floating point numbers are represented in Colobot with 32 bits.
    The highest value that can be represented is 3.4E+38.
    The smallest value that can be represented is 3.4E-38.
pt_BR: Números de ponto flutuantes são representados em Colobot com 32 bits.
    O maior valor que pode ser representado é 3.4E+38.
    O menor valor que pode ser representado é 3.4E-38.

note: type: \b; header
en: Instruction <code>for</code>
pt_BR: Instrução <code>for</code>

note: type: Source code
en: <c/>for ( before ; condition ; end )
    {
    	<n/>Instructions ...<c/>
    }
pt_BR: <c/>for ( antes ; condição ; fim )
    {
    	<n/>Instruções...<c/>
    }

note: type: Plain text
en: This instruction allows you to execute a certain number of times the instructions contained in the <a cbot|bloc>block</a>.
pt_BR: Esta instrução permite a você executar um certo número de vezes as instruções dentro de um <a cbot|bloc>bloco</a>.

note: type: \t; header
en: <code>before</code>
pt_BR: <code>antes</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \t; header
en: <code>end</code>
pt_BR: <code>fim</code>

note: type: Plain text
en: The following example is strictly equivalent to a <code>for</code>-loop, but it uses the instruction <code><a cbot|while>while</a></code>:
pt_BR: 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>:

note: type: Source code
en: <c/>before;
    while ( condition )
    {
    	<n/>Instructions ...<c/>
    	end;
    }
pt_BR: <c/>antes;
    while ( condição )
    {
    	<n/>Instruções...<c/>
    	fim;
    }

note: type: Plain text
en: Do not put a <a cbot|term>semicolon</a> at the end of the line <code>for ( )</code>.
pt_BR: Não coloque um <a cbot|term>ponto e vírgula</a> no fim da linha <code>for ( )</code>.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \b; header
en: Functions
pt_BR: Funções

note: type: Plain text
en: You can also declare a function <a cbot|public>public</a> so it can be used by other bots.
pt_BR: Você também pode declarar uma função <a cbot|public>public</a>, desta forma ela poderá ser usada por outros robôs.

note: type: \b; header
en: Instruction <code>goto</code>
pt_BR: Instrução <code>goto</code>

note: type: Plain text
en: The instruction <c/>goto();<n/> instructs the bot to reach a given position.
pt_BR: A instrução <c/>goto();<n/> instrui o robô a alcançar uma determinada posição.

note: type: Plain text
en: 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:
pt_BR: 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.

note: type: Source code
en: 	item = <a cbot|radar>radar</a>(Titanium);
    	goto(item.position);
    	<a cbot|grab>grab</a>();
pt_BR: 	object item;
    	item = <a cbot|radar>radar</a>(Titanium);
    	goto(item.position);
    	<a cbot|grab>grab</a>();

note: type: Source code
en: <c/>goto ( position, altitude, goal, crash );<n/>
pt_BR: <c/>goto ( posição, altitude, alvo, colisão );<n/>

note: type: Plain text
en: Tells the robot to go to the given position, avoiding all the obstacles if this is possible.
pt_BR: Diz ao robô para ir a uma posição dada, evitando todos os obstáculos se possível.

note: type: Plain text
en: Coordinates of the goal position.
pt_BR: Coordenadas da posição alvo.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \t; header
en: goal: <code><a cbot|int>int</a></code> (default value <code>0</code>)
pt_BR: alvo: <code><a cbot|int>int</a></code> (valor padrão: <code>0</code>)

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

note: type: Plain text
en: 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>.
    <code>== 0 </code>Goal position reached
    <code>!= 0 </code>Goal position impossible to reach
pt_BR: 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.
    <code>== 0 </code>Posição alvo atingida
    <code>!= 0 </code>Posição alvo impossível de atingir

note: type: \b; header
en: Instruction <code>grab</code>
pt_BR: Instrução <code>grab</code>

note: type: Plain text
en: 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.
pt_BR: 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ô.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Source code
en: <c/>grab ( oper );<n/>
pt_BR: <c/>grab ( local );<n/>

note: type: Plain text
en: This instruction appeals to the operating arm of a <a object|botgr>grabber bot</a>, in order to grab the closest object.
pt_BR: 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.

note: type: Plain text
en: 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.
    <code>InFront   </code>  Grabs in front (default value).
    <code>Behind    </code>  Grabs behind.
    <code>EnergyCell</code>  Grabs the bot's own power cell.
pt_BR: Local indica onde o robô deve procurar um objeto para pegar. Se nenhuma indicação é dada, o objeto a frente do robô será pego.
    <code>InFront   </code>  Pega na frente (valor padrão).
    <code>Behind    </code>  Pega atrás.
    <code>EnergyCell</code>  Pega a célula de energia do robô.

note: type: Plain text
en: 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/>.
    <code>== 0 </code>an object was grabbed
    <code>!= 0 </code>error, no object was grabbed
pt_BR: 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.
    <code>== 0 </code>um objeto foi pego
    <code>!= 0 </code>erro, nenhum objeto foi pego

note: type: \b; header
en: Instructions <code>if</code> and <code>else</code>
pt_BR: Instruções <code>if</code> e <code>else</code>

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: Here is a concrete example: The bot will shoot only if the target is closer than 40 meters:
pt_BR: Aqui está um exemplo concreto: o robô irá atirar somente quando o alvo estiver  mais perto que 40 metros:

note: type: Source code
en: 	item = <a cbot|radar>radar</a>(AlienAnt);
    	if (<a cbot|dist>distance</a>(position, item.position) < 40)
    	{
    		fire(1);
    	}
pt_BR: 	alvo = <a cbot|radar>radar</a>(AlienAnt);
    	if (<a cbot|dist>distance</a>(position, alvo.position) < 40)
    	{
    		fire(1);
    	}

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Source code
en: 	item = <a cbot|radar>radar</a>(PowerStation);
    	if (item != null)
    	{
    		<a cbot|goto>goto</a>(item.position);
    		<a cbot|wait>wait</a>(5);
    	}
pt_BR: 	estacao = <a cbot|radar>radar</a>(PowerStation);
    	if (estacao!= null)
    	{
    		<a cbot|goto>goto</a>(estacao.position);
    		<a cbot|wait>wait</a>(5);
    	}

note: type: Source code
en: <code>if ( condition )
    {
    	</code>Instructions A ...<code>
    }
    else
    {
    	</code>Instructions B ...<c/>
    }
pt_BR: <code>if ( condição )
    {
    	</code>Instruções A ...<code>
    }
    else
    {
    	</code>Instruções B ...<c/>
    }

note: type: Plain text
en: 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. 
    Part <code>else { }</code> is not compulsory.
pt_BR: 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. 
    A parte <code>else { }</code> não é obrigatória.

note: type: Plain text
en: Do not put a <a cbot|term>semicolon</a> at the end of the line <code>if ( )</code>.
pt_BR: Não coloque <a cbot|term>ponto e vírgula</a> no fim da linha  <code>if ( )</code>.

note: type: \b; header
en: Type <code>int</code>
pt_BR: Tipo <code>int</code>

note: type: Plain text
en: Use this type for variables that contain only whole numbers, negative or positive. For example:
pt_BR: Use este tipo para variáveis que contenham somente números inteiros, negativos  ou positivos. Por exemplo:

note: type: Plain text
en: To represent real numbers like 12.05 or -0.005, use the type <code><a cbot|float>float</a></code>.
pt_BR: Para representar números reais como 12.05 ou -0.005, use o tipo <code><a cbot|float>float</a></code>.

note: type: Plain text
en: Do not put space or colon signs inside a number.
pt_BR: Não coloque espaços ou vírgulas dentro de um número.

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

note: type: \b; header
en: Instruction <code>jet</code>
pt_BR: Instrução <code>jet</code>

note: type: Source code
en: <c/>jet ( power );<n/>
pt_BR: <c/>jet ( energia );<n/>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \t; header
en: power: <code><a cbot|float>float</a></code>
pt_BR: energia: <code><a cbot|float>float</a></code>

note: type: Plain text
en: 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/>.
pt_BR: 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/>.

note: type: \t; header
en: Return value: <code><a cbot|void>void</a></code>
pt_BR: Valor de retorno: <code><a cbot|void>void</a></code>

note: type: Plain text
en: None.
pt_BR: Nenhum.

note: type: \b; header
en: Instruction <code>message</code>
pt_BR: Instrução <code>message</code>

note: type: Source code
en: <c/>message ( text, type );<n/>
pt_BR: <c/>message ( texto, tipo );<n/>

note: type: Plain text
en: Prints a message on top of the screen. After a few seconds, the message disappears automatically.
pt_BR: Imprime uma mensagem no topo da tela. Depois de alguns segundos, a mensagem desaparece automaticamente.

note: type: \t; header
en: text: <code><a cbot|string>string</a></code>
pt_BR: texto: <code><a cbot|string>string</a></code>

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

note: type: \t; header
en: type: <code><a cbot|int>int</a></code> (default value <code>DisplayMessage</code>)
pt_BR: tipo: <code><a cbot|int>int</a></code> (valor padrão: <code>DisplayMessage</code>)

note: type: Plain text
en: Type of the message, that determines the background color.
pt_BR: Tipo da mensagem, determina a cor de fundo.

note: type: Bullet: 'o'
en: <code>DisplayMessage</code>  Standard message on yellow background.
pt_BR: <code>DisplayMessage</code>  Mensagem padrão com um fundo amarelo.

note: type: Bullet: 'o'
en: <code>DisplayInfo   </code>  Information on green background.
pt_BR: <code>DisplayInfo   </code>  Informação com fundo verde.

note: type: Bullet: 'o'
en: <code>DisplayWarning</code>  Warning on blue background.
pt_BR: <code>DisplayWarning</code>  Aviso com fundo azul.

note: type: Bullet: 'o'
en: <code>DisplayError  </code>  Error on red background.
pt_BR: <code>DisplayError  </code>  Erro com fundo vermelho.

note: type: \b; header
en: Instruction <code>motor</code>
pt_BR: Instrução <code>motor</code>

note: type: Plain text
en: The instruction <c/>motor( , );<n/> sets the speed for the left-hand and the right-hand motor of the bot.
pt_BR: A instrução <c/>motor( , );<n/> define a velocidade dos motores esquerdo e direito do robô.

note: type: Plain text
en: 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:
pt_BR: 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ô:

note: type: Source code
en: 	<a cbot|turn>turn</a>(45);         // turns 45 degrees left
    	motor(0.5, -0.5); // slow rotation to the right
    	<a cbot|fire>fire</a>(2);          // fire
    	motor(0,0);       // stops the rotation
pt_BR: 	<a cbot|turn>turn</a>(45);         // gira 45 graus a esquerda
    	motor(0.5, -0.5); // desacelera a rotação a direita
    	<a cbot|fire>fire</a>(2);          // atira
    	motor(0,0);       // para a rotação

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: <c/>motor ( left, right );<n/>
pt_BR: <c/>motor ( esquerdo, direito );<n/>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \t; header
en: left: <code><a cbot|float>float</a></code>
pt_BR: esquerdo: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Speed instruction for the left motor; the value must range between -1 and 1.
pt_BR: Instrução de velocidade para o motor esquerdo; o valor deve ser entre -1 e 1.

note: type: \t; header
en: right: <code><a cbot|float>float</a></code>
pt_BR: direito: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Speed instruction for the right motor; the value must range between -1 and 1.
pt_BR: Instrução de velocidade para o motor direito; o valor deve ser entre -1 e 1.

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

note: type: Plain text
en: Note :
    <c/>motor(2, 2);<n/> will not move forward any faster than <code>motor(1, 1)</code> 
    <c/>motor(-2, -2);<n/> will not move backward any faster than <code>motor(-1, -1)</code>
pt_BR: Nota:
    <c/>motor(2, 2);<n/> não moverá para frente mais rápido que <code>motor(1, 1)</code> 
    <c/>motor(-2, -2);<n/> não moverá para trás mais rápido que <code>motor(-1, -1)</code>

note: type: \b; header
en: Instruction <code>move</code>
pt_BR: Instrução <code>move</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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/>.
pt_BR: 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/>.

note: type: Source code
en: <c/>move ( length );<n/>
pt_BR: <c/>move ( distância );<n/>

note: type: Plain text
en: Moves forward or backward of a given distance, always keeping the current orientation of the bot.
pt_BR: Move para frente ou para trás dada um distância, sempre mantendo a orientação atual do robô.

note: type: \t; header
en: length: <code><a cbot|float>float</a></code>
pt_BR: distância: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Length of the move, in meters. A negative value makes the bot move backward.
pt_BR: Distância do movimento, em metros. Um valor negativo significa que o robô se moverá para trás.

note: type: Plain text
en: 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>.
    <code>== 0 </code>Move executed
    <code>!= 0 </code>error, the instruction was not performed correctly
pt_BR: 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.
    <code>== 0 </code>movimento executado
    <code>!= 0 </code>erro, a instrução não foi executada corretamente

note: type: \b; header
en: Type <code>nan</code>
pt_BR: Tipo <code>nan</code>

note: type: Plain text
en: 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". 
    For example, if the instruction <code><a cbot|receive>receive</a></code> can not get the requested information, it returns <code>nan</code> :
pt_BR: 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". 
    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>:

note: type: Source code
en: 	value = receive("Length");
    	if ( value == nan )  // not found ?
    	{
    		
    	}
pt_BR: 	resposta = receive("Length");
    	if ( resposta == nan )  // não encontrado?
    	{
    	}

note: type: \t; header
en: Dictionnary
pt_BR: Dicionário inglês-português

note: type: Plain text
en: <code>nan</code> = Not A Number
pt_BR: <code>nan</code> = Not A Number (Não é um Número)

note: type: \b; header
en: Instruction <code>new</code> (for specialists)
pt_BR: Instrução <code>new</code> (para especialistas)

note: type: Plain text
en: The <code>new</code> operator creates a <a cbot|class>class</a> instance:
    <c/><s/>	MyClass item;    // now item is a null reference
pt_BR: O operador <code>new</code> cria uma instância de uma <a cbot|class>classe</a>:
    <c/><s/>	MinhaClasse item;    // agora item é uma referência nula

note: type: Source code
en: 	item = new MyClass(); // now item is a reference
    	                      // to a new class instance
pt_BR: 	item = new MinhaClasse(); // agora item é uma referência
    	                      // para uma nova instância de classe

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: Instead of:
    <c/><s/>	MyClass item = new MyClass();
    <n/>you can write:
    <c/><s/>	MyClass item();
pt_BR: Em vez de escrever:
    <c/><s/>	MinhaClasse item = new MinhaClasse();
    <n/>você pode escrever:
    <c/><s/>	MinhaClasse item();

note: type: Plain text
en: If your class has a constructor with parameters you can write:
    <c/><s/>	MyClass item = new MyClass(2, 3);
    <n/>or:
    <c/><s/>	MyClass item(2, 3);
pt_BR: Se sua classe tem um construtor com parâmetros você pode escrever:
    <c/><s/>	MinhaClasse item = new MinhaClasse(2, 3);
    <n/>ou:
    <c/><s/>	MinhaClasse item(2, 3);

note: type: Plain text
en: <code><a cbot|class>class</a></code>, <code><a cbot|pointer>reference</a></code>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|class>class</a></code>, <code><a cbot|pointer>reference</a></code>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Type <code>null</code>
pt_BR: Tipo <code>null</code>

note: type: Plain text
en: This special value indicates that the variable containing it does not reference an instance.
pt_BR: Este valor especial indica que a variável que o contém não faz referência a uma instância.

note: type: Plain text
en: <a cbot|pointer>References</a>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <a cbot|pointer>Referências</a>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Type <code>object</code>
pt_BR: Tipo <code>object</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: Â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.

note: type: Plain text
en: 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.
pt_BR: Â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.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: 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. 
    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>.
pt_BR: 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. 
    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>.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: The age of the object in seconds since it's creation.
pt_BR: A idade de um objeto em segundos desde a sua criação.

note: type: Plain text
en: 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.
    If you want to know the energy level of a robot, you must not check <code>energyLevel</code>, but <code>energyCell.energyLevel</code>.
    If the bot has bot no power cell, <code>energyCell</code> returns <code>null</code>.
pt_BR: 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.
    Se você quer saber o nível de energia de um robô, você deve checar o <code>energyLevel</code>, escrevendo <code>energyCell.energyLevel</code>.
    Se o robô não tiver uma célula de energia, <code>energyCell</code> retorna <code>null</code>.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \t; header, \b; header
en: Examples
pt_BR: Exemplos

note: type: Plain text
en: The type <code>object</code> returns the special value <code><a cbot|null>null</a></code> when the object does not exist. For example:
pt_BR: O tipo <code>object</code> retorna o valor especial <code><a cbot|null>null</a></code>quando o objeto não existe. Por exemplo:

note: type: Source code
en: 	object a;
    	a = radar(BotGrabberRoller);
    	if ( a == null )  // object does not exist ?
    	{
    	}
    	if ( a.position.z > 50 )  // is it on a mountain ?
    	{
    	}
pt_BR: 	object a;
    	a = radar(BotGrabberRoller);
    	if ( a == null )  // objeto não existe?
    	{
    	}
    	if ( a.position.z > 50 )  // está em uma montanha?
    	{
    	}

note: type: \b; header
en: Instruction <code>open</code>
pt_BR: Instrução <code>open</code>

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Source code
en: 	handle.open("test.txt", "w");
pt_BR: 	handle.open("arquivo.txt", "w");

note: type: Plain text
en: To open a file, proceed as follows:
pt_BR: Para abrir um arquivo, proceda da seguinte forma:

note: type: Source code
en: 	file handle();
    	handle.open("filename", "w");
    	handle.writeln("abc");
    	handle.close();
pt_BR: 	file handle();
    	handle.open("nomeArquivo", "w");
    	handle.writeln("abc");
    	handle.close();

note: type: Plain text
en: 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.
pt_BR: 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/.

note: type: Plain text
en: <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>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>openfile</code>
pt_BR: Instrução <code>openfile</code>

note: type: Source code
en: file handle = openfile("filename", "r");
pt_BR: file handle = openfile("nomeArquivo", "r");

note: type: \b; header
en: Type <code>point</code>
pt_BR: Tipo <code>point</code>

note: type: Plain text
en: 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.
    <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. 
    The <code>z</code> value corresponds to the altitude above sea level.
pt_BR: 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>.
    <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.
    O valor de <code>z</code> corresponde a altitude acima do nível do mar.

note: type: Plain text
en: If you want to declare a variable of type point, you can write:
pt_BR: Se você deseja declarar uma variável do tipo point, você pode escrever:

note: type: Plain text
en: You can also set the variable taking one value after another:
pt_BR: Você também pode definir a variável informando um valor por vez:

note: type: Plain text
en: With these examples, the following <a cbot|cond>condition</a> is true:
pt_BR: Com estes exemplos, a seguinte <a cbot|cond>condição</a>  é verdadeira:

note: type: Plain text
en: <n/> 
    The following declaration :
pt_BR: <n/> 
    A seguinte declaração:

note: type: Plain text
en: Is equivalent to :
pt_BR: É equivalente a:

note: type: \b; header
en: References (for specialists)
pt_BR: Referências (para especialistas)

note: type: Plain text
en: 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.
pt_BR: 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>.

note: type: Plain text
en: Example:
    <c/><s/>{
pt_BR: Exemplos:
    <c/><s/>{

note: type: Source code
en: 	MyClass item1(); // create a new instance
    	                 // referenced by item1
    	MyClass item2;   // create a null reference
    	item2 = item1;   // copy the reference,
    	                 // item2 and item1 now reference
    	                 // the same instance
    	item1.a = 12;    // modifies the instance
    	                 // referenced by item1 (and item2)
    	message(item2.a);// displays 12
    }
pt_BR: 	MinhaClasse item1(); // cria uma nova instância
    	                 // referenciada por item1
    	MinhaClasse item2;   // cria uma referência nula
    	item2 = item1;   // copia a referência,
    	                 // item2 e item1 agora referenciam
    	                 // a mesma instância
    	item1.a = 12;    // modifica a instância
    	                 // referênciada por item1 (e item2)
    	message(item2.a);// exibe 12
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: <c/><s/>void Test( MyClass item )
pt_BR: <c/><s/>void Teste( MinhaClasse item )

note: type: Source code
en: {
    	item.a = 12;          // modify the original instance
    	item = new MyClass(); // new local instance
    	item.a = 33;          // modifie the local instance
    }
pt_BR: {
    	item.a = 12;          // modifica a instância original
    	item = new MinhaClasse(); // nova instância local
    	item.a = 33;          // modifica a instância local
    }

note: type: Plain text
en: Calling the fucntion <code>Test()</code>:
    <c/><s/>{
pt_BR: Chamando a função <code>Teste()</code>:
    <c/><s/>{

note: type: Source code
en: 	MyClass toto();
    	Test(toto);
    	message(toto.a);  // displays 12
    }
pt_BR: 	MinhaClasse toto();
    	Teste(toto);
    	message(toto.a);  // displays 12
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: A function can return an instance:
    <c/><s/>MyClass Test2( )
pt_BR: Uma função pode retornar uma instância:
    <c/><s/>MinhaClasse Teste2( )

note: type: Source code
en: {
    	MyClass item = new MyClass();
    	item.a = 33;
    	return item;
    }
pt_BR: {
    	MinhaClasse item = new MinhaClasse();
    	item.a = 33;
    	return item;
    }

note: type: Plain text
en: Call the function like this:
    <c/><s/>{
pt_BR: Chame a função deste jeito:
    <c/><s/>{

note: type: Source code
en: 	MyClass toto;
    	toto = Test2(); // toto will contain a reference to
    	                // the instance created by Test2()
    	message(toto.a); // displays 33
    }
pt_BR: 	MinhaClasse toto;
    	toto = Teste2(); // toto irá conter uma referência
    	                // a instância criada por Teste2()
    	message(toto.a); // exibe 33
    }

note: type: Plain text
en: <code><a cbot|class>class</a></code>, <code><a cbot|new>new</a></code>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|class>class</a></code>, <code><a cbot|new>new</a></code>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>private</code> (for specialists)
pt_BR: Instrução <code>private</code> (para especialistas)

note: type: Source code
en: public class MyClass
    {
    	int    b;                // public by default
    	public int a;            // also public 
    	private point position;  // private
    }
    void Test()
    {
    	MyClass item;
    	item.a = item.b = 12;      // ok
    	message( item.position );  // this is an error
    }
pt_BR: public class MinhaClasse
    {
    	int    b;                // público por padrão
    	public int a;            // também público 
    	private point posicao;  // privado
    }
    void Teste()
    {
    	MinhaClasse item;
    	item.a = item.b = 12;      // ok
    	message( item.posicao );  // isso é um erro
    }

note: type: \b; header
en: Instruction <code>public</code> (for specialists)
pt_BR: Instrução <code>public</code> (para especialistas)

note: type: Plain text
en: This instruction has two distinct purposes:
pt_BR: Esta instrução tem dois propósitos distintos:

note: type: Bullet: '1)'
en: Make a function available to other bots.
pt_BR: Tornar uma função disponível para outros robôs.

note: type: Bullet: '2)'
en: Make a class member accessible from outside the class definition.
pt_BR: Tornar um membro de uma classe acessível fora da definição da classe.

note: type: \b; header
en: Instruction <code>public</code> for functions
pt_BR: Instrução <code>public</code> para funções

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: For example in the first bot we would have:
pt_BR: Por exemplo, no primeiro robô nós teriamos:

note: type: Source code
en: public void object::Segment(float dist, float angle)
    {
    	move(dist);
    	turn(angle);
    }
pt_BR: public void object::Segmento(float distancia, float angulo)
    {
    	move(distancia);
    	turn(angulo);
    }

note: type: Plain text
en: And in another bot we would have:
pt_BR: E em outro robô teriamos:

note: type: Source code
en: extern void object::Square( )
    {
    	for ( int i=0 ; i<4 ; i++ )
    	{
    		Segment(10, 90);
    		fire(1);
    	}
    }
pt_BR: extern void object::Quadrado( )
    {
    	for ( int i=0 ; i<4 ; i++ )
    	{
    		Segmento(10, 90);
    		fire(1);
    	}
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Instruction <code>public</code> for classes
pt_BR: Instrução <code>public</code> para classes

note: type: Source code
en: public class MyClass
    {
    	int    b;                // public by default
    	public int a;            // also public 
    	private point position;  // privat
    }
    void Test()
    {
    	MyClass item;
    	item.a = item.b = 12;      // ok
    	message( item.position );  // this is an error
    }
pt_BR: public class MinhaClasse
    {
    	int    b;                // público por padrão
    	public int a;            // também público 
    	private point posicao;  // privado
    }
    void Teste()
    {
    	MinhaClasse item;
    	item.a = item.b = 12;      // ok
    	message( item.posicao );  // isto é um erro
    }

note: type: \b; header
en: Instruction <code>radar</code>
pt_BR: Instrução <code>radar</code>

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Source code
en: // At the beginning of the program:
    object  item; // variable declaration
    
    // Look for the closest ant
    item = radar(AlienAnt);
pt_BR: // No começo do programa:
    object  item; // declaração da variável
    
    // Procurando pela formiga (AlienAnt) mais próxima
    item = radar(AlienAnt);

note: type: Plain text
en: Detects an object according to several parameters.
pt_BR: Detecta um objeto de acordo com vários parâmetros.

note: type: Plain text
en: Seen from above, the purple zone corresponds to the zone where objects will be detected.
pt_BR: Visto de cima, a zona roxa representa a zona onde os objetos serão detectados.

note: type: \t; header
en: category: <code><a cbot|int>int</a></code>
pt_BR: categoria: <code><a cbot|int>int</a></code>

note: type: Plain text
en: Direction that the radar is facing, in degrees. 
    <code>  0</code> -> radar is facing straight ahead
    <code>-90</code> -> radar is facing a quarter turn right
    <code> 90</code> -> radar is facing a quarter turn left
pt_BR: Direção que o radar está apontando, em graus. 
    <code>  0</code> -> o radar virado para a frente
    <code>-90</code> -> o radar está virado um quarto a direita
    <code> 90</code> -> o radar está virado um quarto a esquerda

note: type: Plain text
en: Opening angle of the radar, in degrees.
pt_BR: Abertura do ângulo do radar, em graus

note: type: Plain text
en: Minimum detection distance, in meters. Objects that are closer than the minimum distance will not be detected.
pt_BR: 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.

note: type: Plain text
en: Maximum detection distance, in meters. Objects that are farther away than the maximum distance will not be detected.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \t; header
en: Return value: <code><a cbot|object>object</a></code>
pt_BR: Valor de retorno: <code><a cbot|object>object</a></code>

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \t; header
en: Remark
pt_BR: Observação

note: type: Plain text
en: You do not have to give all the parameters. Here are two examples of instructions that are equivalent:
pt_BR: Você não precisa necessariamente informar todos os parâmetros. Aqui estão dois exemplos de instruções equivalentes:

note: type: Source code
en: 	radar(Titanium, 0, 360, 0, 1000);
    	radar(Titanium);  // equivalent
pt_BR: 	radar(Titanium, 0, 360, 0, 1000);
    	radar(Titanium);  // equivalente

note: type: Source code
en: 	radar(Titanium, 0, 90, 0, 1000);
    	radar(Titanium, 0, 90);  // equivalent
pt_BR: 	radar(Titanium, 0, 90, 0, 1000);
    	radar(Titanium, 0, 90);  // equivalente

note: type: Plain text
en: When one or more parameters are not specified, the default values indicated above are used instead; only the first parameter is compulsory.
    Generally, only the first parameter is specified: f. ex. <code>radar (AlienAnt)</code> detects the closest ant, wherever it may be.
pt_BR: 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.
    Geralmente, somente o primeiro parâmetro é utilizado, por exemplo: <code>radar (AlienAnt)</code> detecta a formiga mais próxima, onde quer que esteja.

note: type: \b; header
en: Instruction <code>readln</code>
pt_BR: Instrução <code>readln</code>

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Plain text
en: 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).
pt_BR: 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).

note: type: Plain text
en: <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>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>receive</code>
pt_BR: Instrução <code>receive</code>

note: type: Source code
en: <c/>receive ( name, power );<n/>
pt_BR: <c/>receive ( nome, energia );<n/>

note: type: Plain text
en: Retrieves an information from the closest <a object|exchange>information exchange post</a>.
pt_BR: Recebe uma informação do <a object|exchange>posto de troca de informação</a> mais próximo.

note: type: Plain text
en: Name of the information required from the exchange post. This name is a string: it must be written in quotation marks "".
pt_BR: Nome da informação requerida do posto de troca. Este nome é uma string: deve ser escrito entre aspas " ".

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: <code><a cbot|send>send</a></code>, <code><a cbot|testinfo>testinfo</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|send>send</a></code>, <code><a cbot|testinfo>testinfo</a></code> e <code><a cbot|delinfo>deleteinfo</a></code>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>recycle</code>
pt_BR: Instrução <code>recycle</code>

note: type: Plain text
en: Recycles the derelict bot in front of the <a object|botrecy>recycler</a> into a <a object|titan>titanium cube</a>.
pt_BR: Recicla o robô abandonado na frente do <a object|botrecy>reciclador</a> em um <a object|titan>cubo de titânio</a>.

note: type: Plain text
en: Zero if OK, or a value different from zero if an error occurred.
    <code>== 0 </code>the derelict bot has been recycled
    <code>!= 0 </code>error, no derelict bot could be recycled
pt_BR: Zero se OK, ou um valor diferente de zero que um erro ocorreu.
    <code>== 0 </code>o robô abandonado foi reciclado
    <code>!= 0 </code>erro, nenhum robô abandonado pôde ser reciclado

note: type: \b; header
en: Instruction <code>retobject</code>
pt_BR: Instrução <code>retobject</code>

note: type: Source code
en: <c/>retobject ( number );<n/>
pt_BR: <c/>retobject ( ranque );<n/>

note: type: Plain text
en: Returns the object corresponding to the given number.
pt_BR: Retorna o objeto correspondente ao número informado.

note: type: \t; header
en: number: <code><a cbot|int>int</a></code>
pt_BR: ranque: <code><a cbot|int>int</a></code>

note: type: Plain text
en: Number of the object, between 0 and n. "n" represents the total number of objects in the scene.
pt_BR: Número do objeto, entre 0 e n, "n" representa o número total de objetos em cena.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Instruction <code>return</code>
pt_BR: Instrução <code>return</code>

note: type: Plain text
en: Returns from a function. Syntax:
pt_BR: Retorno de uma <a cbot|function>função</a>. Sintaxe:

note: type: Source code
en: void function ( )
    {
    	return;
    }
pt_BR: <c/>void funcao ( )
    {
    	return;
    }

note: type: Plain text
en: 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:
pt_BR:  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:

note: type: Source code
en: float Mean (float a, float b)
    {
    	return (a+b)/2;
    }
pt_BR: float Media (float a, float b)
    {
    	return (a+b)/2;
    }

note: type: Source code
en: string Sign (float a)
    {
    	if ( a > 0 )  return "positive";
    	if ( a < 0 )  return "negative";
    	return "null";
    }
pt_BR: string Sinal (float a)
    {
    	if ( a > 0 )  return "positivo";
    	if ( a < 0 )  return "negativo";
    	return "null";
    }

note: type: \b; header
en: Instruction <code>search</code>
pt_BR: Instrução <code>search</code>

note: type: Source code
en: <c/>search ( category, position );<n/>
pt_BR: <c/>search ( categoria, posicao );<n/>

note: type: \t; header
en: position: <code><a cbot|point>point</a></code>
pt_BR: posicao: <code><a cbot|point>point</a></code>

note: type: Plain text
en: <code>search</code> returns the object of the given category that is closest to the position indicated here.
pt_BR: <code>search</code> retorna o objeto da categoria dada que está mais próximo da posição indicada.

note: type: Plain text
en: 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.
pt_BR: Características do objeto que foi encontrado. O valor <code><a cbot|null>null</a></code>  significa que nenhum objeto desta categoria foi encontrado.

note: type: \b; header
en: Instruction <code>send</code>
pt_BR: Instrução <code>send</code>

note: type: Source code
en: <c/>send ( name, value, power );<n/>
pt_BR: <c/>send ( nome, valor, energia );<n/>

note: type: Plain text
en: Sends an information to the closest <a object|exchange>information exchange post</a>.
pt_BR: Envia uma informação para o <a object|exchange>posto de troca de informação</a> mais próximo.

note: type: Plain text
en: Name of the information to be sent to the exchange post. This name is a string: it must be written in quotation marks "".
    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.
pt_BR: Nome da informação a ser enviada ao posto de troca. Este nome é uma string: deve ser escrita entre aspas " ".
    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.

note: type: \t; header
en: value: <code>float</code>
pt_BR: valor: <code>float</code>

note: type: Plain text
en: Value of the information to be sent.
pt_BR: Valor da informação a ser enviada.

note: type: Plain text
en: Power of the transmitter, which corresponds to the maximal distance to where information can be the sent. Default value is 10 metres.
pt_BR: 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.

note: type: Plain text
en: <code><a cbot|receive>receive</a></code>, <code><a cbot|testinfo>testinfo</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|receive>receive</a></code>, <code><a cbot|testinfo>testinfo</a></code> e <code><a cbot|delinfo>deleteinfo</a></code>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>shield</code>
pt_BR: Instrução <code>shield</code>

note: type: Source code
en: <c/>shield ( oper, radius );<n/>
pt_BR: <c/>shield ( operacao, raio );<n/>

note: type: Plain text
en: Activates or deactivates the shield of the <a object|botshld>shielder</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.
pt_BR: 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.

note: type: \t; header
en: oper: <code><a cbot|float>float</a></code>
pt_BR: operacao: <code><a cbot|float>float</a></code>

note: type: Plain text
en: <code>1</code> activates the shield.
    <code>0</code> deactivates the shield
    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.
pt_BR: <code>1</code> ativa o escudo.
    <code>0</code> desativa o escudo
    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.

note: type: \t; header
en: radius: <code><a cbot|float>float</a></code>
pt_BR: raio: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Radius of the shield, ranging between 10 and 25 meters.
pt_BR: Raio do escudo, variando entre 10 e 25 metros.

note: type: \b; header
en: Instruction <code>sizeof</code>
pt_BR: Instrução <code>sizeof</code>

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

note: type: Source code
en: {
    	int a[12];
    	a[5] = 345;
    	message( sizeof(a) );  // will display 6
    }
pt_BR: {
    	int a[12];
    	a[5] = 345;
    	message( sizeof(a) );  // irá exibir 6
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: With multidimensionnal arrays you can get the size of a sub array:
pt_BR: Com matrizes multidimensionais você pode pegar o tamanho de uma sub-matriz:

note: type: Source code
en: float xy[][];  // 2 dimensionnal array
    xy[5][10] = 67;
    message( sizeof(xy)    );  // will display 6
    message( sizeof(xy[5]) );  // will display 11
pt_BR: float xy[][];  // matriz de 2 dimensões
    xy[5][10] = 67;
    message( sizeof(xy)    );  // irá exibir 6
    message( sizeof(xy[5]) );  // irá exibir 11

note: type: \b; header
en: Instruction <code>sniff</code>
pt_BR: Instrução <code>sniff</code>

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: <code>TitaniumSpot</code>  ->  <a object|stonspot>Red cross</a>
    <code>UraniumSpot </code>  ->  <a object|uranspot>Yellow circle</a>
    <code>PowerSpot   </code>  ->  <a object|enerspot>Green cross</a>
pt_BR: <code>TitaniumSpot</code>  ->  <a object|stonspot>Cruz vermelha</a>
    <code>UraniumSpot </code>  ->  <a object|uranspot>Circulo amarelo</a>
    <code>PowerSpot   </code>  ->  <a object|enerspot>Cruz verde</a>

note: type: Plain text
en: Zero if everything is OK, or a value different from zero if an error occurred. 
    <code>== 0 </code>sounding performed
    <code>!= 0 </code>sounding impossible
pt_BR: Zero se tudo está OK, ou um valor diferente de zero se um erro ocorreu.
    <code>== 0 </code>sondagem realizada
    <code>!= 0 </code>sondagem impossível

note: type: \b; header
en: Instruction <code>space</code>
pt_BR: Instrução <code>space</code>

note: type: Source code
en: <c/>space ( center, rmin, rmax, dist );<n/>
pt_BR: <c/>space ( centro, rminimo, rmaximo, distancia );<n/>

note: type: Plain text
en: Determines the position of the nearest free space around a given position.
pt_BR: Determina a posição do espaço livre mais próximo de uma posição dada.

note: type: \t; header
en: center: <code><a cbot|point>point</a></code> (default: bot position)
pt_BR: centro: <code><a cbot|point>point</a></code> (padrão: posição do robô)

note: type: Plain text
en: Desired position of the free space.
pt_BR: Ponto desejado do espaço livre.

note: type: \t; header
en: rmin: <code><a cbot|float>float</a></code> (default value: <code>8</code>)
pt_BR: rminimo: <code><a cbot|float>float</a></code> (valor padrão: <code>10</code>)

note: type: Plain text
en: Minimum distance from the desired position.
pt_BR: Distância mínima da posição desejada.

note: type: \t; header
en: rmax: <code><a cbot|float>float</a></code> (default value: <code>50</code>)
pt_BR: rmaxima: <code><a cbot|float>float</a></code> (valor padrão: <code>50</code>)

note: type: Plain text
en: Maximum distance from the desired position.
pt_BR: Distância máxima da posição desejada.

note: type: \t; header
en: dist: <code><a cbot|float>float</a></code> (default value: <code>4</code>)
pt_BR: distancia: <code><a cbot|float>float</a></code> (valor padrão: <code>4</code>)

note: type: Plain text
en: Required distance between two free spaces.
pt_BR: Distância requerida entre dois espaços livres.

note: type: \t; header
en: Return: <code><a cbot|point>point</a></code>
pt_BR: Valor de retorno: <code><a cbot|point>point</a></code>

note: type: Plain text
en: Position of the free space.
pt_BR: Posição do espaço livre.

note: type: \b; header
en: Instruction <code>static</code> (for specialists)
pt_BR: Instrução <code>static</code> (para especialistas)

note: type: Plain text
en: <a cbot|class>Class</a> members declared with <code>static</code> are shared between all instances of the class.
pt_BR: Membros de uma <a cbot|class>classe</a> declarados com <code>static</code> são compartilhados entre todas as instâncias da classe.

note: type: Source code
en: public class MyClass
    {
    	static int nb = 1;
    	static string [ ] list = null;
    }
    void Test ()
    {
    	MyClasse item1();
    	MyClasse item2();
    	item1.nb = 3;
    	item1.list[item1.nb] = "Hello";
    	message( item2.list[item2.nb] ); // display "Hello"
    }
pt_BR: public class MinhaClasse
    {
    	static int numero = 1;
    	static string [ ] lista = null;
    }
    void Teste ()
    {
    	MinhaClasse item1();
    	MinhaClasse item2();
    	item1.numero = 3;
    	item1.lista[item1.numero] = "Olá";
    	message( item2.lista[item2.numero] ); // exibe "Olá"
    }

note: type: Plain text
en: <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).
pt_BR: 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).

note: type: Plain text
en: <code><a cbot|class>class</a></code>, <code><a cbot|synchro>synchronized</a></code>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|class>class</a></code>, <code><a cbot|synchro>synchronized</a></code>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>strfind</code>
pt_BR: Instrução <code>strfind</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: <c/>strfind ( string, sub );<n/>
pt_BR: <c/>strfind ( string, texto );<n/>

note: type: Plain text
en: String we are searching in.
pt_BR: String onde o texto será buscado.

note: type: \t; header
en: sub: <code><a cbot|string>string</a></code>
pt_BR: texto: <code><a cbot|string>string</a></code>

note: type: Plain text
en: Substring we are searching for.
pt_BR: Texto que estamos procurando.

note: type: Plain text
en: Examples:
pt_BR: Exemplos:

note: type: Source code
en: <c/>	int pos = strfind("abcdef", "ab"); // pos will be 0
    	int pos = strfind("abcdef", "de"); // pos will be 3
    	int pos = strfind("abcdef", "xy"); // pos will be <a cbot|nan>nan</a>
pt_BR: <c/>	int posicao = strfind("abcdef", "ab"); // posicao será 0
    	int posicao = strfind("abcdef", "de"); // posicao será 3
    	int posicao = strfind("abcdef", "xy"); // posicao será <a cbot|nan>nan</a>

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Type <code>string</code>
pt_BR: Tipo <code>string</code>

note: type: Plain text
en: Use a variable of this type for storing characters or strings.
pt_BR: Use uma variável deste tipo para armazenar carácteres ou cadeias de carácteres.

note: type: Plain text
en: For example:
pt_BR: Por exemplo:

note: type: Source code
en: <c/>	"Hello!"
    	"This is a string"
    	"x"
    	""  // empty string
pt_BR: <c/>	"Olá!"
    	"Isto é uma string"
    	"x"
    	""  // string vazia

note: type: Plain text
en: You can append two strings with the <code>+</code> operator :
pt_BR: Você pode concatenar duas strings com o operador <code>+</code>:

note: type: Source code
en: <c/>	"Good morning," + " " + "Sir"
pt_BR: <c/>	"Bom dia," + " " + "Senhor"

note: type: Plain text
en: Returns the string:
pt_BR: Retorna a string:

note: type: Source code
en: <c/>	"Good morning, Sir"
pt_BR: <c/>	"Bom dia, Senhor"

note: type: Plain text
en: If you want to put a quotation mark (") or a backslash (\) in a string you must write:
pt_BR: Se você quiser colocar uma aspa (") ou uma barra invertida (\) em uma string você deve escrever:

note: type: Source code
en: <c/>"This is \"very\" important"
pt_BR: <c/>"Isto é \"muito\" importante"

note: type: Plain text
en: <n/>which will result in the string <c/> This is "very" important.
pt_BR: <n/>o qual resultará na string <c/> Iso é "muito" importante.

note: type: Source code
en: <c/>"%user%\\ant.txt"
pt_BR: <c/>"%user%\\formiga.txt"

note: type: Plain text
en: <n/>will result in <c/>%user%\ant.txt
pt_BR: <n/>resultará em <c/>%user%\formiga.txt

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

note: type: \b; header
en: Instruction <code>strleft</code>
pt_BR: Instrução <code>strleft</code>

note: type: Plain text
en: Extracts the first (that is, leftmost) characters from a string.
pt_BR: Extrai os primeiros (isto é, mais a esquerda) carácteres de uma string.

note: type: Source code
en: <c/>strleft ( string, len );<n/>
pt_BR: <c/>strleft ( string, tamanho );<n/>

note: type: \t; header
en: len: <code><a cbot|int>int</a></code>
pt_BR: tamanho: <code><a cbot|int>int</a></code>

note: type: Plain text
en: Number of characters to be extracted.
pt_BR: Número de carácteres a serem extraídos.

note: type: Source code
en: <c/>	string s = strleft("abcdef", 2);  // s is "ab"
    	string s = strleft("abc", 10);  // s is "abc"
pt_BR: <c/>	string s = strleft("abcdef", 2);  // s é "ab"
    	string s = strleft("abc", 10);  // s é "abc"

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>strlen</code>
pt_BR: Instrução <code>strlen</code>

note: type: Plain text
en: Get the length of a string.
pt_BR: Pega o tamanho de uma string.

note: type: Source code
en: <c/>	int len = strlen("abc");  // len is 3
    	int len = strlen("");  // len is 0
    	if ( strlen(s) == 0 )  // is string empty ?
pt_BR: <c/>	int tamanho = strlen("abc");  // tamanho recebe 3
    	int tamanho = strlen("");  // tamanho recebe 0
    	if ( strlen(s) == 0 )  // esta string está vazia?

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>strlower</code>
pt_BR: Instrução <code>strlower</code>

note: type: Plain text
en: Convert all characters in a string to lowercase.
pt_BR: Converte todos os carácteres de uma string para minúsculas.

note: type: Source code
en: <c/>	string s = strlower("Abc");  // s is "abc"
pt_BR: <c/>	string s = strlower("Abc");  // s recebe "abc"

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>strmid</code>
pt_BR: Instrução <code>strmid</code>

note: type: Plain text
en: Extracts a substring of a given length starting at a given position from a string.
pt_BR: Extrai um pedaço (com tamanho definido) de uma string a partir da posição dada.

note: type: Source code
en: <c/>strmid ( string, pos, len );<n/>
pt_BR: <c/>strmid ( string, posicao, tamanho );<n/>

note: type: \t; header
en: pos: <code><a cbot|int>int</a></code>
pt_BR: posicao: <code><a cbot|int>int</a></code>

note: type: Plain text
en: The index of the first character that is to be included in the extracted substring.
pt_BR: Índice do primeiro carácter que deve ser incluído no texto a extrair.

note: type: Source code
en: <c/>	string s = strmid("abcdef", 1, 2);  // s is "bc"
    	string s = strmid("abcdef", 4, 5);  // s is "ef"
    	string s = strmid("abcdef", 9, 2);  // s is ""
pt_BR: <c/>	string s = strmid("abcdef", 1, 2);  // s recebe "bc"
    	string s = strmid("abcdef", 4, 5);  // s recebe "ef"
    	string s = strmid("abcdef", 9, 2);  // s recebe ""

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>strright</code>
pt_BR: Instrução <code>strright</code>

note: type: Plain text
en: Extracts the last (that is, rightmost) characters from a string.
pt_BR: Extrai os últimos (isto é, mais a direita) carácteres de uma string.

note: type: Source code
en: <c/>strright ( string, len );<n/>
pt_BR: <c/>strright ( string, tamanho );<n/>

note: type: Source code
en: <c/>	string s = strright("abcdef", 2);  // s is "ef"
    	string s = strright("abc", 10);  // s is "abc"
pt_BR: <c/>	string s = strright("abcdef", 2);  // s recebe "ef"
    	string s = strright("abc", 10);  // s recebe "abc"

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>strupper</code>
pt_BR: Instrução <code>strupper</code>

note: type: Plain text
en: Convert all characters in a string to uppercase.
pt_BR: Converte todos os carácteres de uma string para maiúsculas.

note: type: Source code
en: <c/>	string s = strupper("Abc");  // s is "ABC"
pt_BR: <c/>	string s = strupper("Abc");  // s recebe "ABC"

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>strval</code>
pt_BR: Instrução <code>strval</code>

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Source code
en: <c/>	string s = "45"+"12";  // s contains "4512"
    	float  n =  45 + 12;   // n contains 67
pt_BR: <c/>	string s = "45"+"12";  // s contém "4512"
    	float  n =  45 + 12;   // n contém 67

note: type: Source code
en: <c/>	float n = strval("1.23");     // n is 1.23
    	float n = strval("12abc45");  // n is 12
    	float n = strval("abc");      // n is 0
    	float n = strval("100")+2;    // n is 102
pt_BR: <c/>	float n = strval("1.23");     // n recebe 1.23
    	float n = strval("12abc45");  // n recebe 12
    	float n = strval("abc");      // n recebe 0
    	float n = strval("100")+2;    // n recebe 102

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>synchronized</code> (for specialists)
pt_BR: Instrução <code>synchronized</code> (para especialistas)

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: The following example illustrates the problem:
pt_BR: O seguinte exemplo ilustra o problema:

note: type: Source code
en: class blocking
    {
    	static int nb = 33;
    	synchronized int inc( )
    	{
    		int val = nb;
    		wait ( 2 );  // wait 2 sec.
    		nb = nb + 1;
    		return val;
    	}
    }
pt_BR: class bloqueio
    {
    	static int numero = 33;
    	synchronized int incrementar( )
    	{
    		int valor = numero;
    		wait ( 2 );  // espere 2 segundos.
    		numero = numero + 1;
    		return valor;
    	}
    }

note: type: Plain text
en: What happens if two bots execute the <code>inc</code> method at the same time?
    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>.
pt_BR: O que aconteceria se dois robôs executassemo método <code>incrementar</code> ao mesmo tempo?
    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>.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: <code><a cbot|class>class</a></code>, <code><a cbot|static>static</a></code>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|class>class</a></code>, <code><a cbot|static>static</a></code>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Semicolon
pt_BR: Ponto e vírgula

note: type: Plain text
en: Always use a semicolon <c/>;<n/> after a simple expression. For example:
pt_BR: Sempre use ponto e vírgula <c/>;<n/> após uma expressão simples. Por exemplo:

note: type: Source code
en: 	int counter = 0;
pt_BR: 	int contador = 0;

note: type: Plain text
en: However, after a <a cbot|bloc>bloc</a>, never put a semicolon:
pt_BR: Entretando, após um <a cbot|bloc>bloco</a>, nunca ponha um ponto e vírgula:

note: type: Source code
en: 	{
    		float dist;
    		dist = distance(p1, p2);
    	} <n/>// no semicolon here!<c/>
pt_BR: 	{
    		float distancia;
    		distancia = distance(p1, p2);
    	} <n/>// nenhum ponto e vírgula aqui!<c/>

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Source code
en: 	if ( a < b ) <n/>// no semicolon here!<c/>
    	{
    		b = 100-a;
    	}
pt_BR: 	if ( a < b ) <n/>// nenhum ponto e vírgula aqui!<c/>
    	{
    		b = 100-a;
    	}

note: type: Plain text
en: 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:
pt_BR: 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.

note: type: Plain text
en: Is equivalent to:
pt_BR: É equivalente a:

note: type: \b; header
en: Instruction <code>testinfo</code>
pt_BR: Instrução <code>testinfo</code>

note: type: Source code
en: <c/>testinfo ( name, power );<n/>
pt_BR: <c/>testinfo ( nome, energia );<n/>

note: type: Plain text
en: Tests if an information exists in the closest <a object|exchange>information exchange post</a>.
pt_BR: Testa se uma informação existe no <a object|exchange>posto de troca de informação</a> mais perto.

note: type: Plain text
en: Name of the information to be tested in the exchange post. This name is a string: it must be written in quotation marks "".
pt_BR: Nome da informação a ser testada no posto de troca. Este nome é uma string: deve vir entre aspas " ".

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \t; header
en: Return: <code><a cbot|bool>bool</a></code>
pt_BR: Valor de retorno: <code><a cbot|bool>bool</a></code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: <code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> and <code><a cbot|delinfo>deleteinfo</a></code>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|receive>receive</a></code>, <code><a cbot|send>send</a></code> et <code><a cbot|delinfo>deleteinfo</a></code>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>this</code>
pt_BR: Instrução <code>this</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: public class MyClass
    {
    	int    m_int;
    	string m_str;
    	void MyFunction()
    	{
    		OtherFunction(this);
    		m_int = 2;
    	}
    }
    
    void OtherFunction(MyClass obj)
    {
    	message(obj.m_str);
    }
    
    extern void object::Test()
    {
    	MyClass item();
    	item.m_str = "Hello";
    	item.MyFunction();  // display "Hello"
    }
pt_BR: public class MinhaClasse
    {
    	int    m_int;
    	string m_str;
    	void MinhaFuncao()
    	{
    		OutraFuncao(this);
    		m_int = 2;
    	}
    }
    
    void OutraFuncao(MinhaClasse obj)
    {
    	message(obj.m_str);
    }
    
    extern void object::Teste()
    {
    	MinhaClasse item();
    	item.m_str = "Olá";
    	item.MinhaFuncao();  // exibe "Olá"
    }

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Source code
en: 	m_int = 2;
    	this.m_int = 2;  // identical
pt_BR: 	m_int = 2;
    	this.m_int = 2;  // identico

note: type: Plain text
en: In a method of the <code><a cbot|object>object</a></code> class, you can also use <code>this.</code> before a fieldname.
pt_BR: 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.

note: type: Source code
en: extern void object::Display()
    {
    	message(orientation);
    	message(this.orientation); // same thing but
    	                           // more explicit
    }
pt_BR: extern void object::Exibir()
    {
    	message(orientation);
    	message(this.orientation); // mesma coisa
    	                           // porém mais explicito
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: public class MyClass
    {
    	int  value;
    	void Put( int value )
    	{
    		this.value = value;
    	}
    }
pt_BR: public class MinhaClasse
    {
    	int  valor;
    	void Colocar( int valor )
    	{
    		this.valor = valor;
    	}
    }

note: type: \b; header
en: Instruction <code>thump</code>
pt_BR: Instrução <code>thump</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Zero if everything is OK, a value different from zero if an error occurred. 
    <code>== 0 </code>Thumping performed
    <code>!= 0 </code>Operation impossible
pt_BR: Zero se tudo está OK, um valor diferente de zero se um erro ocorreu.
    <code>== 0 </code>Batida realizada
    <code>!= 0 </code>Operação impossível

note: type: \b; header
en: Instruction <code>topo</code>
pt_BR: Instrução <code>topo</code>

note: type: Source code
en: <c/>topo ( position );<n/>
pt_BR: <c/>topo ( posicao );<n/>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Coordinates of the position whose altitude you want to know.
pt_BR: Coordenadas da posição da qual a altitude você quer conhecer.

note: type: Plain text
en: Altitude of the ground at the given position.
pt_BR: Altitude do chão na posição dada.

note: type: \b; header
en: Type <code>true</code>
pt_BR: Tipo <code>true</code>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Instruction <code>turn</code>
pt_BR: Instrução <code>turn</code>

note: type: Plain text
en: Use the instruction <c/>turn();<n/> to instruct the bot to perform a rotation on itself of a certain number of degrees.
pt_BR: 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.

note: type: Plain text
en: 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/>:
pt_BR: 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/>:

note: type: Plain text
en: <c/>turn(90);<n/>  quarter turn to the left
    <c/>turn(-90);<n/> quarter turn to the right (negative angle)
    <c/>turn(180);<n/> half turn
pt_BR: <c/>turn(90);<n/>  gira um quarto para a esquerda
    <c/>turn(-90);<n/> gira um quarto para a direita (ângulo negativo)
    <c/>turn(180);<n/> gira metade

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Plain text
en: After these lines, just fire the cannon, and there is one hostile element less.
pt_BR: Depois dessa linhas, apenas atire com o canhão, e haverá um elemento hostil a menos.

note: type: Source code
en: <c/>turn ( angle );<n/>
pt_BR: <c/>turn ( angulo );<n/>

note: type: Plain text
en: Turns the bot with a given angle, right or left, without moving either forward or backward.
pt_BR: Gira o robô com o ângulo dado, direita ou esquerda, sem mover para frente ou para trás.

note: type: Plain text
en: Angle of the required rotation, in degrees. A positive value turns left, a negative value turns right. <code>turn(180)</code> turns round completely.
pt_BR: Â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.

note: type: Plain text
en: Zero if everything is OK, or a value different from zero if an error occurred. 
    <code>== 0 </code>rotation performed
    <code>!= 0 </code>rotation impossible
pt_BR: Zero se está tudo OK, um valor diferente de zero se um erro ocorreu.
    <code>== 0 </code>rotação realizada
    <code>!= 0 </code>rotação impossível

note: type: \b; header
en: Variable types
pt_BR: Tipos de variáveis

note: type: Plain text
en: When you define a <a cbot|var>variable</a>, you must give two elements:
pt_BR: Quando você define uma <a cbot|var>variável</a>, você deve informar dois elementos:

note: type: Bullet: '1)'
en: a name
pt_BR: um nome

note: type: Bullet: '2)'
en: a type
pt_BR: um tipo

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: For a whole number (12, -500, etc.).
pt_BR: Para um número inteiro (12, -500, etc).

note: type: Plain text
en: For a real number (12, 3.14, 0.2, -99.98, etc.).
pt_BR: Para números reais (12, 3.14, 0.2, -99.98, etc.).

note: type: Plain text
en: For a boolean variable, that can only take the values <code>true</code> or <code>false</code>.
pt_BR: Uma variável booleana só pode conter os valores <code>true</code> ou <code>false</code> (verdadeiro ou falso).

note: type: Plain text
en: For texts ("Hello!", "No object found", etc.)
pt_BR: Para textos ("Olá!", "Nenhum objeto encontrado", etc.)

note: type: Plain text
en: For the coordinates of a point in space; a variable of this type consists of three parts named x, y and z.
pt_BR: Para as coordenadas de um ponto no espaço; uma variável deste tipo consiste de três partes nomeadas x, y e z.

note: type: Plain text
en: A variable of this type contains the information about an object (bot, building, enemy, etc.).
pt_BR: Uma variável deste tipo contém informação sobre um objeto (robô, edifício, inimigo, etc).

note: type: Plain text
en: This type is an "empty type", that you use when you do not want to specify a type.
pt_BR: Este tipo é um "tipo vazio", que você usa quando não quer especificar um tipo.

note: type: \b; header
en: Variables
pt_BR: Variáveis

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: For the declaration of the variable, write the following line: 
    <c/><s/>	int  countTit;<n/>
pt_BR: Para a declaração da variável escreva a seguinte linha: 
    <c/><s/>	int  contadorTit;<n/>

note: type: Plain text
en: To put <code>0</code> into the variable, write:
    <c/><s/>	countTit = 0;<n/>
pt_BR: Para colocar <code>0</code> na variável, escreva:
    <c/><s/>	contadorTit = 0;<n/>

note: type: Plain text
en: At every titanium ore grabbed, write:
    <c/><s/>	countTit = countTit + 1<n/>
pt_BR: Toda vez que um minério de titânio for pego, escreva:
    <c/><s/>	contadorTit = contadorTit + 1<n/>

note: type: Plain text
en: 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.
    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.
    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>.
pt_BR: 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.
    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.
    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>.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: In fact, a variable is made up of three parts:
pt_BR: Em fato, uma variável é composta por três partes:

note: type: Bullet: '1)'
en: the name,
pt_BR: o nome,

note: type: Bullet: '2)'
en: the type of the information stored inside,
pt_BR: o tipo da informação armazenada,

note: type: Bullet: '3)'
en: the content, i.e. the information itself.
pt_BR: o conteúdo, ou seja, a informação em sí

note: type: \t; header
en: the name
pt_BR: o nome

note: type: Plain text
en: You need the name to be able to distinguish the different variables from each other.
pt_BR: Você precisa do nome para conseguir distinguir as diferentes variáveis entre sí.

note: type: \t; header
en: the type
pt_BR: o tipo

note: type: Plain text
en: 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. 
    Here is a list of the most common variable types:
pt_BR: 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. 
    Aqui está uma lista dos tipos mais comuns de variáveis:

note: type: Bullet: 'o'
en: <code><a cbot|int>int</a></code> for a whole number (12, -500, etc.)
pt_BR: <code><a cbot|int>int</a></code> para um número inteiro (12, -500, etc.)

note: type: Bullet: 'o'
en: <code><a cbot|float>float</a></code> for a real number (3.14, 0.2, -99.98, etc.)
pt_BR: <code><a cbot|float>float</a></code> para um número real (3.14, 0.2, -99.98, etc.)

note: type: Bullet: 'o'
en: <code><a cbot|string>string</a></code> for a character string ("Hello!", "No object found", etc.)
pt_BR: <code><a cbot|string>string</a></code> para uma cadeia de carácteres ("Olá!", "Nenhum objeto encontrado", etc.)

note: type: Bullet: 'o'
en: <code><a cbot|point>point</a></code> for a x,y,z-coordinate in space
pt_BR: <code><a cbot|point>point</a></code> para coordenadas x, y e z no espaço

note: type: Bullet: 'o'
en: <code><a cbot|object>object</a></code> for information about an object (bot, building, etc.)
pt_BR: <code><a cbot|object>object</a></code> para informação sobre um objeto (robô, edifício, etc.)

note: type: \t; header
en: The content
pt_BR: O conteúdo

note: type: Plain text
en: The content of a variable is an information of the kind specified in the type. It can change during the execution of the program.
pt_BR: O conteúdo de uma variável é uma informação da natureza especificada no tipo. Ela pode mudar durante a execução do programa.

note: type: Plain text
en: Once you declared a variable, it still does not contain any value. Before you can use it, you must put a value inside: 
    <c/><s/>	int  i, j;
pt_BR: 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: 
    <c/><s/>	int  i, j;

note: type: Source code
en: 	j = 25;  // j takes the value 25
    	j = i;   // can not write this, because i has got no content yet.
pt_BR: 	j = 25;  // j pega o valor 25
    	j = i;   // não pode escrever isso, porque i ainda não tem conteúdo

note: type: Plain text
en: You can also declare a variable and put a value inside in the same line, writing: 
    <c/><s/>	int  countTit = 0;
pt_BR: Você também pode declarar uma variável e colocar um valor dentro na mesma linha, escrevendo: 
    <c/><s/>	int  contadorTit = 0;

note: type: Plain text
en: 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: 
    <c/><s/>	int  i, j;
pt_BR: 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: 
    <c/><s/>	int  i, j;

note: type: Source code
en: 	i = 5+2;  // i takes the value 7
    	j = i+6;  // j takes the value of i plus 6, this is 13
    	i = j;    // i takes the value of j, this is 13
pt_BR: 	i = 5+2;  // i pega o valor 7
    	j = i+6;  // j pega o valor de i + 6, que é 13
    	i = j;    // i pega o valor de j, que é 13

note: type: Plain text
en: At the end of this example, both variables <code>i</code> and <code>j</code> contain the value <code>13</code>.
pt_BR: No fim deste exemplo, ambas as variáveis <code>i</code> e <code>j</code> contém o valor <code>13</code>.

note: type: Plain text
en: The following assignment is not correct, because on the left side of the equals sign <code>=</code>, there can be only a variable name:
    <c/><s/>	i+2 = j;  // impossible
pt_BR: 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:
    <c/><s/>	i+2 = j;  // impossível

note: type: Plain text
en: 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> :
    <c/><s/>	int temp;
pt_BR: 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> :
    <c/><s/>	int temporario;

note: type: Source code
en: 	temp = a;  // temp takes the value of a
    	a = b;     // the content of b is copied into a
    	b = temp;  // the content of temp is copied into b
pt_BR: 	temporario = a;  // temporario recebe o valor de a
    	a = b;     // o conteúdo de b é copiado para a
    	b = temp;  // o conteúdo de temporario é copiado para b

note: type: \b; header
en: Type <code>void</code>
pt_BR: Tipo <code>void</code>

note: type: Plain text
en: Use this type when you want to declare a function that returns nothing.
pt_BR: Use este tipo quando você quiser declarar uma função que não retorna nada.

note: type: Plain text
en: Example:
    <c/><s/>void MyFunction(int a)
pt_BR: Exemplo:
    <c/><s/>void MinhaFuncao(int a)

note: type: \b; header
en: Instruction <code>wait</code>
pt_BR: Instrução <code>wait</code>

note: type: Plain text
en: The instruction <c/>wait();<n/> instructs the bot to wait for some seconds, according to the value written in brackets.
pt_BR: A instrução <c/>wait();<n/> instrui o robô a esperar alguns segundos de acordo com o valor escrito entre os parênteses.

note: type: Plain text
en: 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/>.
pt_BR: 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/>.

note: type: Plain text
en: 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/>.
pt_BR: 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/>.

note: type: Source code
en: <c/>wait ( time );<n/>
pt_BR: <c/>wait ( tempo );<n/>

note: type: Plain text
en: Waits for a moment.
pt_BR: Espera por um momento.

note: type: Plain text
en: Specifies the time that the bot must wait.
pt_BR: Especifica o tempo que o robô deve esperar.

note: type: \b; header
en: Instruction <code>while</code>
pt_BR: Instrução <code>while</code>

note: type: Plain text
en: The instruction <code>while () {}</code> is used to repeat a set of instructions several times.
pt_BR: A instrução <code>while () {}</code> é usada para repetir um conjunto de instruções varias vezes.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Bullet: 'o'
en: look for a spider,
pt_BR: procurar por uma aranha,

note: type: Bullet: 'o'
en: turn towards it,
pt_BR: virar para ela,

note: type: Bullet: 'o'
en: shoot.
pt_BR: atirar.

note: type: Source code
en: 	while (true)
    	{
    		item = <a cbot|radar>radar</a>(AlienSpider);
    		<a cbot|turn>turn</a>(direction(item.position));
    		<a cbot|fire>fire</a>(1);
    	}
pt_BR: 	while (true)
    	{
    		alvo = <a cbot|radar>radar</a>(AlienSpider);
    		<a cbot|turn>turn</a>(direction(alvo.position));
    		<a cbot|fire>fire</a>(1);
    	}

note: type: Plain text
en: Just execute this program once, and it will kill all spiders around it.
pt_BR: Apenas execute este programa uma vez, e ele irá matar todas as aranhas ao redor dele.

note: type: Source code
en: <code>while ( condition )
    {
    	</code>Instructions ...<c/>
    }
pt_BR: <code>while ( condição )
    {
    	</code>Instruções...<c/>
    }

note: type: Plain text
en: This instruction allows you to perform the instructions inside the <a cbot|bloc>block</a> several times.
pt_BR: Esta instrução permite a você executar as instruções dentro do <a cbot|bloc>bloco</a> varias vezes.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: <c/>int i = 0;
    while ( i < 10 )
    {
    	<n/>Instructions ...<c/>
    	i = i+1;
    }
pt_BR: <c/>int i = 0;
    while ( i < 10 )
    {
    	<n/>Instruções...<c/>
    	i = i+1;
    }

note: type: Plain text
en: Do not put a <a cbot|term>semicolon</a> at the end of the line <code>while ( )</code>.
pt_BR: Não coloque um <a cbot|term>ponto e vírgula</a> no fim da linha <code>while ( )</code>.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \b; header
en: Instruction <code>writeln</code>
pt_BR: Instrução <code>writeln</code>

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Plain text
en: 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).
pt_BR: 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).

note: type: Source code
en: 	writeln("Line of text");
pt_BR: 	writeln("Linha de texto");

note: type: Plain text
en: <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>.
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>.
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>acos</code>
pt_BR: Instrução <code>acos</code>

note: type: Source code
en: <c/>acos ( value );<n/>
pt_BR: <c/>acos( valor );</n>

note: type: \t; header
en: value: <code><a cbot|float>float</a></code>
pt_BR: valor: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Number between -1 and 1 (including both).
pt_BR: Número entre -1 e 1 (incluindo ambos)

note: type: Plain text
en: Arcus cosine (in degrees) of the value.
pt_BR: Arco cosseno (em graus) do valor.

note: type: Plain text
en: <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>.
pt_BR: <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|expr>expressões</a>.

note: type: Plain text
en: This instruction sets the vertical and the horizontal angle of the cannon. The following robots are equipped with a cannon:
pt_BR: Esta instrução define o ângulo vertical e horizontal de um canhão. Os seguintes robôs são equipados com um canhão:

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \t; header
en: x: <code><a cbot|float>float</a></code> (default value: <code>0</code>)
pt_BR: x: <code><a cbot|float>float</a></code> (valor padrão: <code>0</code>)

note: type: Plain text
en: 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.
pt_BR: Â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.

note: type: \b; header
en: Instruction <code>asin</code>
pt_BR: Instrução <code>asin</code>

note: type: Source code
en: <c/>asin ( value );<n/>
pt_BR: <c/>asin ( valor );<n/>

note: type: Plain text
en: Arcus sine (in degrees) of the value.
pt_BR: Arco seno (em graus) do valor.

note: type: \b; header
en: Instruction <code>atan</code>
pt_BR: Instrução <code>atan</code>

note: type: Source code
en: <c/>atan ( value );<n/>
pt_BR: <c/>atan ( valor );<n/>

note: type: Plain text
en: Number.
pt_BR: Número.

note: type: Plain text
en: Arcus tangent (in degrees) of the value.
pt_BR: Arco tangente (em graus) do valor.

note: type: \b; header
en: Instruction <code>atan2</code>
pt_BR: Instrução <code>atan2</code>

note: type: Plain text
en: 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.
pt_BR: 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,

note: type: Plain text
en: Arcus tangent (in degrees) of <code>y/x</code>.
pt_BR: Arco tangente (em graus) de <code>y/x</code>.

note: type: \b; header
en: Instruction <code>build</code>
pt_BR: Instrução <code>build</code>

note: type: Source code
en:  <a cbot|object>object</a> item = <a cbot|radar>radar</a>(<a object|titan>Titanium</a>);
     <a cbot|goto>goto</a>(item.position);
     build(<a object|factory>BotFactory</a>);
pt_BR:  <a cbot|object>objeto</a> item = <a cbot|radar>radar</a>(<a object|titan>Titanium</a>);
     <a cbot|goto>goto</a>(item.position);
     build(<a object|factory>BotFactory</a>);

note: type: Source code
en: <c/>build ( cat );<n/>
pt_BR: <c/>build ( categoria );<n/>

note: type: \t; header
en: cat: <code><a cbot|int>int</a></code>
pt_BR: categoria: <code><a cbot|int>int</a></code>

note: type: Plain text
en: <a cbot|category>Category</a> of a building.
pt_BR: <a cbot|category>Categoria</a> de um edifício.

note: type: Plain text
en: 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>.
    <code>== 0 </code>Successfully built
    <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)
pt_BR: 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.
    <code>== 0 </code>Construído com sucesso
    <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)

note: type: \b; header
en: Instruction <code>buildingenabled</code>
pt_BR: Instrução <code>buildingenabled</code>

note: type: Plain text
en: 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.
pt_BR: É similar a instrução <c/><a cbot|canbuild>canbuild();</a><n/>. Entretanto, ela não checa se uma pesquisa necessária foi realizada.

note: type: Source code
en: <c/>buildingenabled ( cat );<n/>
pt_BR: <c/>buildingenabled ( categoria );<n/>

note: type: \t; header
en: Return value: <code><a cbot|bool>bool</a></code>
pt_BR: Valor de retorno: <code><a cbot|bool>bool</a></code>

note: type: Plain text
en: Any building which can take some action (e.g. <a cbot|convert>Converter</a>).
pt_BR: Qualquer edifício que pode tomar alguma ação (por exemplo: <a cbot|convert>Conversor</a>).

note: type: Plain text
en: <code><format const>true</format></code> if the object is doing something (e.g. converting)
    <code><format const>false</format></code> if the object is not doing anything
pt_BR: <code><format const>true</format></code> se o objeto está fazendo algo (por exemplo: convertendo)
    <code><format const>false</format></code> se o objeto não está fazendo nada

note: type: \b; header
en: Instruction <code>canbuild</code>
pt_BR: Instrução <code>canbuild</code>

note: type: Plain text
en: It helps to prevent errors in programs using the <c/><a cbot|build>build();</a><n/> instruction. Here is an example:
pt_BR: Ela ajuda a prevenir erros em programas que usam a instrução <c/><a cbot|build>build();</a><n/>. Aqui está um exemplo:

note: type: Source code
en: <c/>canbuild ( cat );<n/>
pt_BR: <c/>canbuild ( categoria );<n/>

note: type: Plain text
en: <code>true</code> if the building can be built, <code>false</code> otherwise.
pt_BR: <code>true</code> se o edifício pode ser construído, <code>false</code> caso contrário.

note: type: \b; header
en: Instruction <code>canresearch</code>
pt_BR: Instrução <code>canresearch</code>

note: type: Source code
en: <c/>canresearch ( research );<n/>
pt_BR: <c/>canresearch ( pesquisa );<n/>

note: type: \t; header
en: research: <code><a cbot|int>int</a></code>
pt_BR: pesquisa: <code><a cbot|int>int</a></code>

note: type: Plain text
en: <a cbot|researches>Research name</a>.
pt_BR: <a cbot|researches>Nome da pesquisa</a>.

note: type: Plain text
en: <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)
    <format const>false</format> if the research cannot be done
pt_BR: <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>)
    <format const>false</format> se a pesquisa não pode ser realizada

note: type: Plain text
en: Below are the different categories available:
pt_BR: Abaixo estão as diferentes categorias disponíveis:

note: type: \t; header
en: Buildings:
pt_BR: Edifícios:

note: type: \t; header
en: Portable Objects:
pt_BR: Objetos portáteis:

note: type: \t; header
en: Robots:
pt_BR: Robôs:

note: type: \t; header
en: Enemies:
pt_BR: Inimigos:

note: type: \t; header
en: Miscellaneous:
pt_BR: Variados:

note: type: \t; header
en: Flags and Other Indicators:
pt_BR: Bandeiras e outros indicadores:

note: type: \b; header
en: Instruction <code>ceil</code>
pt_BR: Instrução <code>ceil</code>

note: type: Source code
en: <c/>ceil ( value );<n/>
pt_BR: <c/>ceil ( valor );<n/>

note: type: Plain text
en: Rounds up a number.
pt_BR: Arredonda um número para cima.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: <a cbot|round>round</a>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|expr>expressions</a>.
pt_BR: <a cbot|round>round</a>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|expr>expressões</a>.

note: type: \b; header
en: Value <code>Colors</code>
pt_BR: Valor <code>Cores</code>

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Below are the different colors available:
pt_BR: Abaixo estão as diferentes cores disponíveis:

note: type: Plain text
en: <code><format const>White</format></code>
    <code><format const>Black</format></code>
    <code><format const>Gray</format></code>
    <code><format const>LightGray</format></code>
    <code><format const>Red</format></code>
    <code><format const>Pink</format></code>
    <code><format const>Purple</format></code>
    <code><format const>Orange</format></code>
    <code><format const>Yellow</format></code>
    <code><format const>Beige</format></code>
    <code><format const>Brown</format></code>
    <code><format const>Skin</format></code>
    <code><format const>Green</format></code>
    <code><format const>LightGreen</format></code>
    <code><format const>Blue</format></code>
    <code><format const>LightBlue</format></code>
pt_BR: <code><format const>White</format></code> // Branco
    <code><format const>Black</format></code> // Preto
    <code><format const>Gray</format></code> // Cinza
    <code><format const>LightGray</format></code> // Cinza claro
    <code><format const>Red</format></code> // Vermelho
    <code><format const>Pink</format></code> // Rosa
    <code><format const>Purple</format></code> // Roxo
    <code><format const>Orange</format></code> // Laranja
    <code><format const>Yellow</format></code> // Amarelo
    <code><format const>Beige</format></code> // Bege
    <code><format const>Brown</format></code> // Marrom
    <code><format const>Skin</format></code> // Pele
    <code><format const>Green</format></code> // Verde
    <code><format const>LightGreen</format></code> // Verde claro
    <code><format const>Blue</format></code> // Azul
    <code><format const>LightBlue</format></code> // Azul claro

note: type: Plain text
en: You can also draw colored symbols:
pt_BR: Você também pode desenhar simbolos coloridos:

note: type: Plain text
en: <code><format const>BlackArrow</format></code>
    <code><format const>RedArrow</format></code>
pt_BR: <code><format const>BlackArrow</format></code> // Flecha negra
    <code><format const>RedArrow</format></code> // Flecha vermelha

note: type: \b; header
en: Instruction <code>cos</code>
pt_BR: Instrução <code>cos</code>

note: type: Source code
en: <c/>cos ( angle );<n/>
pt_BR: <c/>cos ( angulo );<n/>

note: type: Plain text
en: Angle in degrees.
pt_BR: Ângulo em graus.

note: type: Plain text
en: Cosine of the angle.
pt_BR: Coseno do ângulo.

note: type: \b; header
en: Instruction <code>destroy</code>
pt_BR: Instrução <code>destroy</code>

note: type: Plain text
en: Destroys an object.
pt_BR: Destroi um objeto.

note: type: Plain text
en: 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>.
    <code>== 0 </code>The operation of destroying of an object was started
    <code>!= 0 </code>The instruction could not be done (e.g. nothing to destroy)
pt_BR: 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.
    <code>== 0 </code>A operação de destruição de um objeto foi iniciada
    <code>!= 0 </code>A instrução não pode ser realizada (ex.: nada a destruir)

note: type: \b; header
en: Instruction <code>detect</code>
pt_BR: Instrução <code>detect</code>

note: type: Plain text
en: 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/>.
pt_BR: 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/>.

note: type: Source code
en: <c/>detect ( cat );<n/>
pt_BR: <c/>detect ( categoria );<n/>

note: type: Plain text
en: 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:
pt_BR: Detecta o objeto mais próximo da <a cbot|category>categoria</a> especificada na frente do robô. É similar a seguinte instrução:

note: type: Source code
en: <c/>radar(cat, 0, 45, 0, 20);<n/>
pt_BR: <c/>radar(categoria, 0, 45, 0, 20);<n/>

note: type: Bullet: 'o'
en: <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>.
pt_BR: <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>.

note: type: Bullet: 'o'
en: <a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers:<c/>
pt_BR: <a cbot|array>Matriz</a> de categorias dos objetos que devem ser detectados. Por exemplo, quando você estiver procurando por agarradores:<c/>

note: type: Source code
en: int bots[4];
    bots[0] = WheeledGrabber;
    bots[1] = TrackedGrabber;
    bots[2] = WingedGrabber;
    bots[3] = LeggedGrabber;
    object nearestGrabber = radar(bots);
pt_BR: int robos[4];
    robos[0] = WheeledGrabber;
    robos[1] = TrackedGrabber;
    robos[2] = WingedGrabber;
    robos[3] = LeggedGrabber;
    object agarradoresProximos = radar(robos);

note: type: Bullet: 'o'
en: Keyword <format const>Any</format> if you are looking for any object (including even plants and so on).
pt_BR: Palavra-chave <format const>Any</format> se você estiver procurando por qualquer objeto (incluindo até plantas e assim por diante).

note: type: Plain text
en: <format const>true</format> if the object was found
    <format const>false</format> if the object was not found
pt_BR: <format const>true</format> se o objeto foi encontrado
    <format const>false</format> se o objeto não foi encontrado

note: type: \b; header
en: Instruction <code>factory</code>
pt_BR: Instrução <code>factory</code>

note: type: Plain text
en: <a cbot|category>Category</a> of the robot to construct.
pt_BR: <a cbot|category>Categoria</a> do robô para construir.

note: type: \t; header
en: program: <code><a cbot|string>string</a></code> (default value: <code>""</code>)
pt_BR: programa: <code><a cbot|string>string</a></code> (valor padrão: <code>""</code>)

note: type: Plain text
en: 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>.
    <code>== 0 </code>The construction successfully started
    <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)
pt_BR: 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.
    <code>== 0 </code>A construção foi iniciada com sucesso
    <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)

note: type: \b; header
en: Instruction <code>flatspace</code>
pt_BR: Instrução <code>flatspace</code>

note: type: Source code
en: <c/>flatspace ( center, flatmin, rmin, rmax, dist );<n/>
pt_BR: <c/>flatspace ( centro, flatmin, rmin, rmax, distancia );<n/>

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: Minimum radius of flat ground around the desired position.
pt_BR: Raio mínimo de solo plano ao redor da posição desejada.

note: type: \b; header
en: Instruction <code>floor</code>
pt_BR: Instrução <code>floor</code>

note: type: Source code
en: <c/>floor ( value );<n/>
pt_BR: <c/>floor ( valor );<n/>

note: type: Plain text
en: Rounds down a number.
pt_BR: Arredonda um número para baixo.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: Example: count from 1 to 4
    <c/><s/><c/>for ( i = 1 ; i <= 4 ; i++ )
pt_BR: Exemplo: contar de 1 até 4
    <c/><s/><c/>for ( i = 1 ; i <= 4 ; i++ )

note: type: Plain text
en: Function, simply put, is an instruction created by you.
pt_BR: Função, em termos simples, é uma instrução criada por você.

note: type: \b; header
en: Main function
pt_BR: Função principal

note: type: Plain text
en: You probably already know how to create a function. Every program in CBOT must have a main function, which looks like this:
pt_BR: Você provavelmente já sabe como criar uma função. Todo programa em CBOT deve ter uma função principal, que parece como isto:

note: type: Source code
en: extern void object::ProgramName()
    {
    	
    	// instructions
    	
    }
pt_BR: extern void object::NomePrograma()
    {
    	
    	// instruções
    	
    }

note: type: Plain text
en: With functions you can divide your program into several parts. Each of them will execute a specific task. For example, see the following program:
pt_BR: Com funções você pode dividir seu programa em diversas partes. Cada uma delas executará uma tarefa especifica. Por exemplo, veja o programa abaixo:

note: type: Source code
en: extern void object::Remote()
    {
    	send("order", 1, 100);
    	wait(5);
    	send("order", 3, 100);
    	wait(5);
    	send("order", 2, 100);
    	wait(5);
    	send("order", 4, 100);
    	wait(5);
    }
pt_BR: extern void object::Remoto()
    {
    	send("ordem", 1, 100);
    	wait(5);
    	send("ordem", 3, 100);
    	wait(5);
    	send("ordem", 2, 100);
    	wait(5);
    	send("ordem", 4, 100);
    	wait(5);
    }

note: type: Plain text
en: <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:
pt_BR: <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:

note: type: Source code
en: void SendToPost(float op)
    {
    	send("order", op, 100);
    	wait(5);
    }
    
    extern void object::Remote()
    {
    	SendToPost(1);
    	SendToPost(3);
    	SendToPost(2);
    	SendToPost(4);
    }
pt_BR: void EnviarParaPosto(float op)
    {
    	send("ordem", op, 100);
    	wait(5);
    }
    
    extern void object::Remoto()
    {
    	EnviarParaPosto(1);
    	EnviarParaPosto(3);
    	EnviarParaPosto(2);
    	EnviarParaPosto(4);
    }

note: type: Plain text
en: Now the program is much easier to read. It is a good practice to split the program into several functions with self-describing names.
pt_BR: 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.

note: type: \b; header
en: Syntax
pt_BR: Sintaxe

note: type: Source code
en: result_type FunctionName(optional_parameters)
    {
    	body
    }
pt_BR: tipo_resultado NomeFuncao(parametros_opcionais)
    {
    	Corpo
    }

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \t; header
en: Parameters
pt_BR: Parâmetros

note: type: Plain text
en: A function can have parameters:
pt_BR: Uma função pode ter parâmetros:

note: type: Source code
en: void Example(int a, float x, string s)
    {
    	message(a);
    	message(x);
    	message(s);
    }
pt_BR: void Exemplo(int a, float x, string s)
    {
    	message(a);
    	message(x);
    	message(s);
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \t; header
en: Result
pt_BR: Resultado

note: type: Plain text
en: 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>:
pt_BR: 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>:

note: type: Source code
en: float Average(float a, float b)
    {
    	return (a+b)/2;
    }
    
    extern void object::Test( )
    {
    	float value;
    	value = Average(2, 6);
    	message(value);  // will display 4
    }
pt_BR: float Media(float a, float b)
    {
    	return (a+b)/2;
    }
    
    extern void object::Teste( )
    {
    	float valor;
    	valor = Media(2, 6);
    	message(valor);  // irá exibir 4
    }

note: type: Plain text
en: Some other examples:
pt_BR: Alguns outros exemplos:

note: type: Source code
en: float Pi()
    {
    	return 3.1415;
    }
    
    string Sign(float a)
    {
    	if (a > 0)  return "positive";
    	if (a < 0)  return "negative";
    	return "null";
    }
pt_BR: float Pi()
    {
    	return 3.1415;
    }
    
    string Sinal(float a)
    {
    	if (a > 0)  return "positivo";
    	if (a < 0)  return "negativo";
    	return "null";
    }

note: type: \b; header
en: Overloading
pt_BR: Sobrecarregar

note: type: Plain text
en: You can declare several functions with the same name but different parameters:
pt_BR: Você pode declarar várias funções com o mesmo nome, porém com parâmetros diferentes:

note: type: Source code
en: float Pythagoras(float a, float b)
    {
    	return sqrt((a*a)+(b*b));
    }
    
    float Pythagoras(float a, float b, float c)
    {
    	return sqrt((a*a)+(b*b)+(c*c));
    }
pt_BR: float Pitagoras(float a, float b)
    {
    	return sqrt((a*a)+(b*b));
    }
    
    float Pitagoras(float a, float b, float c)
    {
    	return sqrt((a*a)+(b*b)+(c*c));
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: void object::Example()
    {
    	message(this.category);
    }
pt_BR: void object::Exemplo()
    {
    	message(this.category);
    }

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: <code><a cbot|int>int</a>    object.category     </code><a cbot|category>Category</a> of the object
    <code><a cbot|point>point</a>  object.position     </code>Position of the object (x,y,z)
    <code><a cbot|float>float</a>  object.orientation  </code>Orientation of the object (0..360)
    <code><a cbot|float>float</a>  object.pitch        </code>Forward/backward angle of the object
    <code><a cbot|float>float</a>  object.roll         </code>Right/left angle of the object 
    <code><a cbot|float>float</a>  object.energyLevel  </code>Energy level (0..1)
    <code><a cbot|float>float</a>  object.shieldLevel  </code>Shield level (0..1)
    <code><a cbot|float>float</a>  object.temperature  </code>Jet temperature (0..1)
    <code><a cbot|float>float</a>  object.altitude     </code>Altitude above ground
    <code><a cbot|float>float</a>  object.lifeTime     </code>Lifetime of the object
    <code>object object.energyCell   </code>Power cell on the bot
    <code>object object.load         </code>Object carried by the bot
    <code><a cbot|int>int</a>    object.team         </code>The object's team (see <a battles>code battles</a>)
    <code><a cbot|point>point</a>  object.velocity     </code>Velocity of the object
pt_BR: <code><a cbot|int>int</a>    object.category     </code><a cbot|category>Categoria</a> do objeto
    <code><a cbot|point>point</a>  object.position     </code>Posição do objeto (x,y,z)
    <code><a cbot|float>float</a>  object.orientation  </code>Orientação do objeto (0..360)
    <code><a cbot|float>float</a>  object.pitch        </code>Ângulo de avanço / retrocesso do objeto
    <code><a cbot|float>float</a>  object.roll         </code>Ângulo direito / esquerdo do objeto 
    <code><a cbot|float>float</a>  object.energyLevel  </code>Nível de energia (0..1)
    <code><a cbot|float>float</a>  object.shieldLevel  </code>Nível do escudo (0..1)
    <code><a cbot|float>float</a>  object.temperature  </code>Temperatura do jato (0..1)
    <code><a cbot|float>float</a>  object.altitude     </code>Altitude acima do chão
    <code><a cbot|float>float</a>  object.lifeTime     </code>Tempo de vida do objeto
    <code>object object.energyCell   </code>Célula de energia do robô
    <code>object object.load         </code>Objeto carregado pelo robô
    <code><a cbot|int>int</a>    object.team         </code>A equipe do objeto (veja <a battles>códigos de batalhas</a>)
    <code><a cbot|point>point</a>  object.velocity     </code>Velocidade do objeto

note: type: Plain text
en: 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.
pt_BR: 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".

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: Current velocity of the object. Should be treated as a three-dimensional vector.
pt_BR: Velocidade atual do objeto. Deve ser tratada como um vetor de três dimensões.

note: type: \b; header
en: Instruction <code>pencolor</code>
pt_BR: Instrução <code>pencolor</code>

note: type: Source code
en: <c/>pencolor ( color );<n/>
pt_BR: <c/>pencolor ( cor );<n/>

note: type: Plain text
en: The instruction <c/>pencolor();<n/> instructs the bot to change the color of the pencil.
pt_BR: A instrução <c/>pencolor();<n/> instruí o robô a mudar a cor do pincel.

note: type: \t; header
en: color: <code><a cbot|int>int</a></code> (default value: <code>Black</code>)
pt_BR: cor: <code><a cbot|int>int</a></code> (valor padrão: <code>Black</code>)

note: type: Plain text
en: <a cbot|colors>Color name</a>.
pt_BR: <a cbot|colors>Nome da cor</a>.

note: type: Plain text
en: 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/>.
    <code>== 0 </code>The color was changed
    <code>!= 0 </code>The instruction did not work
pt_BR: 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.
    <code>== 0 </code>A cor foi alterada
    <code>!= 0 </code>A instrução não funcionou

note: type: \b; header
en: Instruction <code>pendown</code>
pt_BR: Instrução <code>pendown</code>

note: type: Source code
en: <c/>pendown ( color, width );<n/>
pt_BR: <c/>pendown ( cor, largura );<n/>

note: type: Plain text
en: The instruction <c/>pendown();<n/> instructs the bot to have the pen down, so it starts drawing.
pt_BR: A instrução <c/>pendown();<n/> instruí o robô a baixar a caneta, iniciando assim a escrita.

note: type: \t; header
en: width: <code><a cbot|float>float</a></code> (default value: <code>0.5</code>)
pt_BR: largura: <code><a cbot|float>float</a></code> (valor padrão: <code>0.5</code>)

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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/>.
    <code>== 0 </code>The pen is now down
    <code>!= 0 </code>The instruction did not work
pt_BR: 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.
    <code>== 0 </code>A caneta está baixada agora
    <code>!= 0 </code>A instrução não funcionou

note: type: \b; header
en: Instruction <code>penup</code>
pt_BR: Instrução <code>penup</code>

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: 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/>.
    <code>== 0 </code>The pen is now up
    <code>!= 0 </code>The instruction did not work
pt_BR: 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.
    <code>== 0 </code>A caneta está levantada agora
    <code>!= 0 </code>A instrução não funcionou

note: type: \b; header
en: Instruction <code>penwidth</code>
pt_BR: Instrução <code>penwidth</code>

note: type: Source code
en: <c/>penwidth ( color );<n/>
pt_BR: <c/>penwidth ( largura );<n/>

note: type: Plain text
en: The instruction <c/>penwidth();<n/> instructs the bot to change the width of the pencil.
pt_BR: A instrução <c/>penwidth();<n/> instruí o robô a mudar a largura da caneta.

note: type: \t; header
en: width: <code><a cbot|float>float</a></code>
pt_BR: largura: <code><a cbot|float>float</a></code>

note: type: Plain text
en: 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/>.
    <code>== 0 </code>The width was changed
    <code>!= 0 </code>The instruction did not work
pt_BR: 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.
    <code>== 0 </code>A largura foi alterada
    <code>!= 0 </code>A instrução não funcionou

note: type: \b; header
en: Instruction <code>pow</code>
pt_BR: Instrução <code>pow</code>

note: type: Plain text
en: Exponent.
pt_BR: Expoente

note: type: Plain text
en: x to the y (x raised to the yth power).
pt_BR: x para y (x elevado a potência y)

note: type: Bullet: 'o'
en: <a cbot|array>Array</a> of categories of the objects that should be detected. For example, when you are looking only for grabbers:
pt_BR: <a cbot|array>Matriz</a> de categorias dos objetos que devem ser detectados. Por exemplo, quando você estiver procurando por agarradores:

note: type: Plain text
en: <c/><s/>int bots[4];
pt_BR: <c/><s/>int robos[4];

note: type: Source code
en: bots[0] = WheeledGrabber;
    bots[1] = TrackedGrabber;
    bots[2] = WingedGrabber;
    bots[3] = LeggedGrabber;
    object nearestGrabber = radar(bots);<n/>
pt_BR: robos[0] = WheeledGrabber;
    robos[1] = TrackedGrabber;
    robos[2] = WingedGrabber;
    robos[3] = LeggedGrabber;
    object agarradorMaisProximo = radar(robos);<n/>

note: type: Bullet: 'o'
en: 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.
pt_BR: 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.

note: type: \t; header
en: angle: <code><a cbot|float>float</a></code> (default value: <code>0</code>)
pt_BR: angle: <code><a cbot|float>float</a></code> (valor padrão: <code>0</code>)

note: type: \t; header
en: focus: <code><a cbot|float>float</a></code> (default value: <code>360</code>)
pt_BR: focus: <code><a cbot|float>float</a></code> (valor padrão: <code>360</code>)

note: type: \t; header
en: min: <code><a cbot|float>float</a></code> (default value: <code>0</code>)
pt_BR: min: <code><a cbot|float>float</a></code> (valor padrão: <code>0</code>)

note: type: \t; header
en: max: <code><a cbot|float>float</a></code> (default value: <code>1000</code>)
pt_BR: max: <code><a cbot|float>float</a></code> (valor padrão: <code>1000</code>)

note: type: \t; header
en: sens: <code><a cbot|float>float</a></code> (default value: <code>1</code>)
pt_BR: sens: <code><a cbot|float>float</a></code> (valor padrão: <code>1</code>)

note: type: \t; header
en: filter: <code><a cbot|int>int</a></code> (default value: <code><format const>FilterNone</format></code>)
pt_BR: filter: <code><a cbot|int>int</a></code> (valor padrão: <code><format const>FilterNone</format></code>)

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: <code><format const>FilterNone</format>        </code>Detects everything (default)
    <code><format const>FilterOnlyLanding</format> </code>Detects only objects being on the ground
    <code><format const>FilterOnlyFlying</format>  </code>Detects only objects not being on the ground
    <code><format const>FilterFriendly</format>    </code>Detects only allies (objects in the same team)
    <code><format const>FilterEnemy</format>       </code>Detects only enemies (objects in an other team except neutral)
    <code><format const>FilterNeutral</format>     </code>Detects only neutral objects (e.g. resources)
pt_BR: <code><format const>FilterNone</format>        </code>Detecta tudo (default)
    <code><format const>FilterOnlyLanding</format> </code>Detecta somente  objetos no chão
    <code><format const>FilterOnlyFlying</format>  </code>Detecta somente objetos que não estão no chão
    <code><format const>FilterFriendly</format>    </code>Detecta somente aliados (objetos que estão na mesma equipe)
    <code><format const>FilterEnemy</format>       </code>Detecta somente inimigos (objetos em outra equipe, exceto neutros)
    <code><format const>FilterNeutral</format>     </code>Detecta somente objetos neutros (isto é, recursos)

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Instruction <code>rand</code>
pt_BR: Instrução <code>rand</code>

note: type: Plain text
en: Pseudorandom number between 0 and 1 (including 0, but excluding 1).
pt_BR: Número aleatório entre 0 e 1 (incluindo 0, porém excluindo 1).

note: type: \b; header
en: Instruction <code>research</code>
pt_BR: Instrução <code>research</code>

note: type: \t; header
en: type: <code><a cbot|int>int</a></code>
pt_BR: tipo: <code><a cbot|int>int</a></code>

note: type: Plain text
en: 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>.
    <code>== 0 </code>The research successfully started
    <code>!= 0 </code>The research could not be started (e.g. the research is disabled in the level, no power cell)
pt_BR: 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.
    <code>== 0 </code>A pesquisa foi iniciada com sucesso
    <code>!= 0 </code>A pesquisa não pode ser iniciada (isto é, a pesquisa está desativada neste nível, sem célula de energia)

note: type: \b; header
en: Instruction <code>researched</code>
pt_BR: Instrução <code>researched</code>

note: type: Source code
en: <c/>researched ( research );<n/>
pt_BR: <c/>researched ( pesquisa );<n/>

note: type: \b; header
en: Value <code>Research names</code>
pt_BR: Valor de <code>nomes de pesquisa</code>

note: type: Plain text
en: 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>).
pt_BR: 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>).

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Below are the different research names available.
pt_BR: Abaixo estão os diferentes nomes de pesquisa disponíveis.

note: type: \t; header
en: Done by <a object|research>ResearchCenter</a>:
pt_BR: Realizado por <a object|research>ResearchCenter</a>:

note: type: \t; header
en: Done by <a object|labo>AutoLab</a>:
pt_BR: Realizado por <a object|labo>AutoLab</a>:

note: type: \t; header
en: Impossible to research:
pt_BR: Impossível de pesquisar:

note: type: \b; header
en: Instruction <code>round</code>
pt_BR: Instrução <code>round</code>

note: type: Source code
en: <c/>round ( value );<n/>
pt_BR: <c/>round ( valor );<n/>

note: type: Plain text
en: Rounds a number.
pt_BR: Arredonda um número.

note: type: Plain text
en: 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>.
pt_BR: <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>.

note: type: Plain text
en: <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>.
pt_BR: <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>.

note: type: Plain text
en: 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.
pt_BR: 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ô.

note: type: Bullet: 'o'
en: <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>.
pt_BR: <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>.

note: type: Bullet: 'o'
en: <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:
pt_BR: <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:

note: type: Source code
en: bots[0] = WheeledGrabber;
    bots[1] = TrackedGrabber;
    bots[2] = WingedGrabber;
    bots[3] = LeggedGrabber;
    point p(50, 24, 0);
    object grabberNearestThePoint = search(bots, p);<n/>
pt_BR: robos[0] = WheeledGrabber;
    robos[1] = TrackedGrabber;
    robos[2] = WingedGrabber;
    robos[3] = LeggedGrabber;
    point ponto(50, 24, 0);
    object agarradoresProximosAoPonto = search(robos, ponto);<n/>

note: type: \t; header
en: position: <code><a cbot|point>point</a></code> (default value: <code><a cbot|this>this</a>.<a cbot|object>position</a></code>)
pt_BR: position: <code><a cbot|point>point</a></code> (valor padrão: <code><a cbot|this>this</a>.<a cbot|object>position</a></code>)

note: type: \b; header
en: Instruction <code>sin</code>
pt_BR: Instrução <code>sin</code>

note: type: Source code
en: <c/>sin ( angle );<n/>
pt_BR: <c/>sin ( angulo );<n/>

note: type: Plain text
en: Sine of the angle.
pt_BR: Seno do ângulo.

note: type: \b; header
en: Instruction <code>sqrt</code>
pt_BR: Instrução <code>sqrt</code>

note: type: Source code
en: <c/>sqrt ( value );<n/>
pt_BR: <c/>sqrt ( valor );<n/>

note: type: Plain text
en: Non-negative number.
pt_BR: Número não negativo.

note: type: Plain text
en: Square root of the value.
pt_BR: Raiz quadrada do valor.

note: type: \b; header
en: Instructions <code>switch</code>, <code>case</code> and <code>default</code>
pt_BR: Instruções <code>switch</code>, <code>case</code> e <code>default</code>

note: type: Plain text
en: With the instruction <code>switch() {}</code> you can execute a proper set of instructions (a case) basing on some value.
pt_BR: Com a instrução <code>switch() {}</code> você pode executar um conjunto adequado de instruções (um caso) baseado em algum valor.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Source code
en: public void WaitForTaskCompleted(object building)
    {
    	int cat = building.category;
    	<a cbot|if>if</a> (cat == Converter) wait(15);
    	else if (cat == BotFactory) wait(15);
    	else if (cat == PowerPlant) wait(12);
    	else message("Undefined wait time", DisplayError);
    }
pt_BR: public void EsperarFimTarefa(object edificio)
    {
    	int cat = edificio.category;
    	<a cbot|if>if</a> (cat == Converter) wait(15);
    	else if (cat == BotFactory) wait(15);
    	else if (cat == PowerPlant) wait(12);
    	else message("Tempo de espera indefinido", DisplayError);
    }

note: type: Plain text
en: This function can be also written using the <code>switch() {}</code> instruction:
pt_BR: Esta função também pode ser escrita usando a instrução <code>switch() {}</code>:

note: type: Source code
en: public void WaitForTaskCompleted(object building)
    {
    	switch (building.category)
    	{
    		case Converter: wait(15); break;
    		case BotFactory: wait(15); break;
    		case PowerPlant: wait(12); break;
    		default: message("Undefined wait time", DisplayError);
    	}
    }
pt_BR: public void EsperarFimTarefa(object edificio)
    {
    	switch (edificio.category)
    	{
    		case Converter: wait(15); break;
    		case BotFactory: wait(15); break;
    		case PowerPlant: wait(12); break;
    		default: message("Tempo de espera indefinido", DisplayError);
    	}
    }

note: type: Plain text
en: Which way to write this kind of choice structures, is a matter of taste.
pt_BR: De qual maneira escrever estes tipos de estruturas de escolhas, é uma questão de gosto.

note: type: Plain text
en: You can also make cases like this:
pt_BR: Você também pode fazer casos assim:

note: type: Source code
en: switch (building.category)
    {
    	case Converter:
    	case BotFactory:
    		wait(15); break;
    	case PowerPlant: wait(12); break;
    	default: message("Undefined wait time", DisplayError);
    }
pt_BR: switch (edificio.category)
    {
    	case Converter:
    	case BotFactory:
    		wait(15); break;
    	case PowerPlant: wait(12); break;
    	default: message("Tempo de espera indefinido", DisplayError);
    }

note: type: Plain text
en: <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.
pt_BR: 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>.

note: type: Source code
en: <c/>switch ( value )
    {
    	case value1: instructions1
    	case value2: instructions2
    	...
    	case valueN: instructionsN
    	default: instructionsDefault
    }
pt_BR: <c/>switch ( valor )
    {
    	case valor1: instruções1
    	case valor2: instruções2
    	...
    	case valorN: instruçõesN
    	default: instruçõesPadrão
    }

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: If the <code>value</code> is equal to <code>value1</code>, <code>instructions1</code> to <code>N</code> (including <code>instructionsDefault</code>) are executed.
    If the <code>value</code> is equal to <code>value2</code>, <code>instructions2</code> to <code>N</code> (including <code>instructionsDefault</code>) are executed.
    And so on.
    If the <code>value</code> is equal to <code>valueN</code>, <code>instructionsN</code> and <code>instructionsDefault</code> are executed.
    If the <code>value</code> is not equal to any value in the given cases, <code>instructionsDefault</code> are executed.
pt_BR: 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.
    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.
    E assim por diante.
    Se o <code>valor</code> é igual a <code>valorN</code>, <code>instruçõesN</code> e <code>instruçõesPadrão</code> são executadas.
    Se o <code>valor</code> não é igual a nenhum valor dos casos dados, <code>instruçõesPadrão</code> são executadas.

note: type: Plain text
en: You can exit from the the <code>switch() {}</code> instruction using <code><a cbot|break>break</a></code>.
pt_BR: Você pode sair da instrução <code>switch() {}</code> usando <code><a cbot|break>break</a></code>.

note: type: Plain text
en: Do not put a <a cbot|term>semicolon</a> at the end of the <code>switch ( ) { }</code> instruction.
pt_BR: Não coloque um <a cbot|term>ponto e vírgula</a> no fim da instrução <code>switch ( ) { }</code>.

note: type: \b; header
en: Instruction <code>takeoff</code>
pt_BR: Instrução <code>takeoff</code>

note: type: Plain text
en: 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>.
    <code>== 0 </code>Spaceship takes off
    <code>!= 0 </code>Spaceship could not take off (e.g. mission is not finished yet)
pt_BR: 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.
    <code>== 0 </code>A nave decolou
    <code>!= 0 </code>A nave não pode decolar (por exemplo, a missão ainda não foi finalizada)

note: type: \b; header
en: Instruction <code>tan</code>
pt_BR: Instrução <code>tan</code>

note: type: Source code
en: <c/>tan ( angle );<n/>
pt_BR: <c/>tan ( angulo );<n/>

note: type: Plain text
en: Angle in degrees (except multiples of 90).
pt_BR: Ângulo em graus (exceto múltiplos de 90).

note: type: Plain text
en: Tangent of the angle.
pt_BR: Tangente do ângulo.

note: type: \b; header
en: Instruction <code>trunc</code>
pt_BR: Instrução <code>trunc</code>

note: type: Source code
en: <c/>trunc ( value );<n/>
pt_BR: <c/>trunc ( valor );<n/>

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Truncated <code>value</code>. For example, <code>trunc(-2.5)</code> is <code>-2.00</code>.
pt_BR: <code>Valor</code> truncado . Por exemplo, <code>trunc(-2.5)</code> é <code>-2.00</code>.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: \b; header
en: Instruction <code>produce</code>
pt_BR: Instrução <code>produce</code>

note: type: Source code
en: <c/>produce ( position, orientation, category, program, power );<n/>
pt_BR: <c/>produce ( posicao, orientacao, categoria, programa, energia );<n/>

note: type: Source code
en: <c/>produce ( category, power );<n/>
pt_BR: <c/>produce ( categoria, energia );<n/>

note: type: Plain text
en: Immediately creates an <a cbot|category>object</a>.
pt_BR: Imediatamente cria um <a cbot|category>objeto</a>.

note: type: \t; header
en: orientation: <code><a cbot|float>float</a></code>
pt_BR: orientacao: <code><a cbot|float>float</a></code>

note: type: Plain text
en: Orientation (angle) of the object.
pt_BR: Orientação (ângulo) do objeto.

note: type: Plain text
en: <a cbot|category>Category</a> of the object.
pt_BR: <a cbot|category>Categoria</a> do objeto.

note: type: \t; header
en: program: <code><a cbot|string>string</a></code>
pt_BR: programa: <code><a cbot|string>string</a></code>

note: type: Plain text
en: Energy level.
pt_BR: Nível de energia.

note: type: \t; header
en: Return: <code><a cbot|void>void</a></code>
pt_BR: Retorna: <code><a cbot|void>void</a></code>

note: type: Plain text
en: Nothing.
pt_BR: Nada.

note: type: \b; header
en: Example usage
pt_BR: Exemplo de uso

note: type: Plain text
en: It is used by <a object|mother>AlienQueen</a> to produce <a object|egg>AlienEggs</a>.
pt_BR: É utilizado pela <a object|mother>AlienQueen</a> para produzir <a object|egg>AlienEggs</a>.

note: type: Plain text
en: Where object will be created. The second syntax creates the object at the current bot's position.
pt_BR: Onde o objeto será criado. A segunda sintaxe cria o objeto na posição atual do robô.

note: type: Plain text
en: Program for the object. Will have effect only for programmable objects like robots or aliens.
pt_BR: Programa para o objeto. Só terá efeitos em objetos programáveis como robôs ou alienígenas.

note: type: Plain text
en: 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.
pt_BR: 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:

note: type: \b; header
en: Binary operations
pt_BR: Operações binárias

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \t; header
en: Order of operations
pt_BR: Ordem das operações

note: type: Plain text
en: Let <code>a op1 b op2 c</code> be a legal expression, then the following rules apply:
pt_BR: Deixe <code>a op1 b op2 c</code> ser uma expressão legal, então as seguintes regras se aplicam:

note: type: Bullet: 'o'
en: 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.
pt_BR: 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.

note: type: Bullet: 'o'
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Here is a complicated example, which uses arithemtic operations described below, showing how expressions are calculated:
    <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:
      a * b + c - d / x % (y * z) - e =
    = r1 + c - d / x % (y * z) - e    = , r1 = a * b
    = r2 - d / x % (y * z) - e        = , r2 = r1 + c
    = r2 - r3 % (y * z) - e           = , r3 = d / x
    = r2 - r3 % r4 - e                = , r4 = y * z
    = r2 - r5 - e                     = , r5 = r3 % r4
    = r6 - e                          = , r6 = r2 - r5
    = r7                                , r7 = r6 - e
    r7 is the final result of this expression.
pt_BR: Aqui está um exemplo complicado, o qual usa operações aritméticas descritas abaixo, mostrando como as expressões são calculadas:
    <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:
      a * b + c - d / x % (y * z) - e =
    = r1 + c - d / x % (y * z) - e    = , r1 = a * b
    = r2 - d / x % (y * z) - e        = , r2 = r1 + c
    = r2 - r3 % (y * z) - e           = , r3 = d / x
    = r2 - r3 % r4 - e                = , r4 = y * z
    = r2 - r5 - e                     = , r5 = r3 % r4
    = r6 - e                          = , r6 = r2 - r5
    = r7                                , r7 = r6 - e
    r7 é o resultado final desta expressão.

note: type: \b; header
en: Assignment operator
pt_BR: Operador de atribuição

note: type: Plain text
en: <code>=</code> is the assignment operator. It is used to store the result of an expression in a variable.
pt_BR: <code>=</code> é o operador de atribuição. Ele é usado para armazenar o resultado de uma expressão em uma variável.

note: type: Plain text
en: 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>).
pt_BR: 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>).

note: type: Plain text
en: This example is actually really confusing, but this property is actually useful, because it lets doing something like this:
pt_BR: Este exemplo é realmente confuso, porém este uso é atualmente útil, porque ele está fazendo algo como isso:

note: type: \b; header
en: Basic arithmetic operations
pt_BR: Operações aritméticas básicas

note: type: Plain text
en: Binary operators below are working with fundamental number types (<code><a cbot|int>int</a></code>, <code><a cbot|float>float</a></code>).
pt_BR: 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>).

note: type: \t; header
en: List
pt_BR: Lista

note: type: Plain text
en: <code>+</code>  addition
    <code>-</code>  subtraction
    <code>*</code>  multiplication
    <code>/</code>  division
    <code>%</code>  remainder of the division (only for the type <code><a cbot|int>int</a></code>)
pt_BR: <code>+</code>  adição
    <code>-</code>  subtração
    <code>*</code>  multiplicação
    <code>/</code>  divisão
    <code>%</code>  resto da divisão (somente para o tipo <code><a cbot|int>int</a></code>)

note: type: \t; header
en: Notes
pt_BR: Notas

note: type: Bullet: 'o'
en: The <code>*</code>, <code>/</code>, <code>%</code> are all stronger than <code>+</code> and <code>-</code>.
pt_BR: Os operadores <code>*</code>, <code>/</code>, <code>%</code> são mais fortes que <code>+</code> e <code>-</code>.

note: type: Bullet: 'o'
en: 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.
pt_BR: 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>.

note: type: \t; header
en: Real life examples
pt_BR: Exemplos da vida real

note: type: \t; header
en: Compound assignment operators
pt_BR: Operadores de atribuição compostos

note: type: Plain text
en: Besides the <code>=</code> operator for variable assignment there are several compound-assignment operators.
pt_BR: Além do operador <code>=</code> para atribuição a variáveis, existem muitos outros operadores de atribuição compostos.

note: type: Plain text
en: 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
pt_BR: 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

note: type: Source code
en: <code>lvalue += expression</code>
pt_BR: <code>valor-L += expressao</code>

note: type: Source code
en: <code>lvalue = lvalue + expression</code>
pt_BR: <code>valor-L = valor-L + expressao</code>

note: type: \b; header
en: String concatenation
pt_BR: Concatenação de strings

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: 	string s = "a" + "bc";  // returns "abc"
    	string s = 1 + "bc";    // returns "1bc"
    	string s = 2.5 + "bc";  // returns "2.5bc"
    	string s = "a" + true;  // returns "atrue"
pt_BR: 	string s = "a" + "bc";  // retorna "abc"
    	string s = 1 + "bc";    // retorna "1bc"
    	string s = 2.5 + "bc";  // retorna "2.5bc"
    	string s = "a" + true;  // retorna "atrue"

note: type: Plain text
en: 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:
pt_BR: 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>:

note: type: \b; header
en: Prefix and postfix increment- and decrement operators
pt_BR: Operadores de incremento e decremento de prefixo e sufixo

note: type: Plain text
en: For example to increment the variable <code>a</code> you can write
pt_BR: Por exemplo, para incrementar a variável <code>a</code> você pode escrever

note: type: Plain text
en: instead of
pt_BR: em vez de

note: type: Plain text
en: 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.
pt_BR: 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>.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Source code
en:  int    i = 12 + 3;      // i == 15
     int    i = 2 - 5;       // i == -3
     
     float  f = 3.01 * 10;   // f == 30.1
     
     int    i = 5 / 3;       // i == 1 (automatic conversion to int)
     float  f = 5 / 3;       // f == 1.67
     float  f = 5 / 0;       // returns an error (division by zero)
     
     int    i = 13 % 5;      // i == 3
     int    i = -8 % 3;      // i == -2
     
     float  f = sin(90) * i; // f == -2.0
pt_BR:  int    i = 12 + 3;      // i == 15
     int    i = 2 - 5;       // i == -3
     
     float  f = 3.01 * 10;   // f == 30.1
     
     int    i = 5 / 3;       // i == 1 (conversão automática para int)
     float  f = 5 / 3;       // f == 1.67
     float  f = 5 / 0;       // retorna erro (divisão por zero)
     
     int    i = 13 % 5;      // i == 3
     int    i = -8 % 3;      // i == -2
     
     float  f = sin(90) * i; // f == -2.0

note: type: Source code
en:  float pi = 3.14;
     // message(pi); // does not work
     message(""+pi);
pt_BR:  float pi = 3.14;
     // message(pi); // não funciona
     message(""+pi);

note: type: Source code
en:  a = 2;
     b = a++;
     // now b contains 2 and a contains 3
pt_BR:  a = 2;
     b = a++;
     // agora b contém 2 e a contém 3

note: type: Source code
en:  a = 2;
     b = ++a;
     // now b contains 3 and a contains 3
pt_BR:  a = 2;
     b = ++a;
     // agora b contém 3 e a contém 3

note: type: \b; header
en: Logical operators
pt_BR: Operadores lógicos

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: \b; header
en: Ternary operator
pt_BR: Operador ternário

note: type: Plain text
en: 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:
    <code>(condition) ? (result when true) : (result when false)</code>
    Brackets are not needed.
pt_BR: 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: 
    <code>(condicao) ? (resultado quando true) : (resultado quando false)</code>
    Parênteses não são necessários.

note: type: Plain text
en: Firstly, the condition is valued and then the first result is returned if the condition is true, otherwise the second result is returned.
pt_BR: 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.

note: type: \t; header
en: Example
pt_BR: Exemplo

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Comparison operators
pt_BR: Operadores de comparação

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: <code>!a      </code>not <code>a</code>
    <code>a && b  </code><code>a</code> and <code>b</code>
    <code>a || b  </code><code>a</code> or <code>b</code>
pt_BR: <code>!a      </code>não <code>a</code>
    <code>a && b  </code><code>a</code> e <code>b</code>
    <code>a || b  </code><code>a</code> ou <code>b</code>

note: type: Plain text
en: <code>!false        </code>returns true
    <code>true && false </code>returns false 
    <code>true || false </code>returns true
pt_BR: <code>!false        </code>retorna true
    <code>true && false </code>retorna false 
    <code>true || false </code>retorna true

note: type: \b; header
en: Bitwise operators
pt_BR: Operadores bit a bit

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: <code>a & b  </code><code>a</code> AND <code>b</code>
    <code>a | b  </code><code>a</code> OR <code>b</code>
    <code>a ^ b  </code><code>a</code> XOR <code>b</code>
    <code>a >> b  </code>shift bits of <code>a</code> to the right <code>b</code> times
    <code>a << b  </code>shift bits of <code>a</code> to the left <code>b</code> times
pt_BR: <code>a & b  </code><code>a</code> AND <code>b</code>
    <code>a | b  </code><code>a</code> OR <code>b</code>
    <code>a ^ b  </code><code>a</code> XOR <code>b</code>
    <code>a >> b  </code>desloca bits de <code>a</code> para a direita <code>b</code> vezes
    <code>a << b  </code>desloca bits de a <code>a</code> para a esquerda <code>b</code> vezes

note: type: Plain text
en: <code>2 & 1         </code>returns 0
    <code>2 | 1         </code>returns 3
    <code>2 ^ 2         </code>returns 0
    <code>2 >> 1        </code>returns 1
    <code>2 << 1        </code>returns 4
pt_BR: <code>2 & 1         </code>retorna 0
    <code>2 | 1         </code>retorna 3
    <code>2 ^ 2         </code>retorna 0
    <code>2 >> 1        </code>retorna 1
    <code>2 << 1        </code>retorna 4

note: type: Source code
en: int    [ ] a;   // an array of int
    int    a [12];  // an array of int limited to 12 elements
    string s[3];    // an array of 3 strings
    float  xy[][];  // a 2 dimensionnal array of floats
pt_BR: int    [ ] a;   // uma matriz de int
    int    a [12];  // uma matriz de int limitada a 12 elementos
    string s[3];    // uma matriz de 3 strings
    float  xy[][];  // uma matriz bidimensional de floats

note: type: \b; header
en: Initialization syntax
pt_BR: Sintaxe de inicialização

note: type: Plain text
en: You can initialize a new array using the following syntax:
pt_BR: Você pode inicializar uma nova matriz usando a seguinte sintaxe:

note: type: Source code
en: type arrayName[] = { value0, value1, value2, ..., valueN };
pt_BR: tipo nomeMatriz[] = { valor0, valor1, valor2, ..., valorN };

note: type: Source code
en: int numbers[] = { 10, 20, 30 };
    MyClass objects[] = { new MyClass(1), new MyClass(2) };
pt_BR: int numeros[] = { 10, 20, 30 };
    MinhaClasse objetos[] = { new MinhaClasse(1), new MinhaClasse(2) };

note: type: Plain text
en: With the instruction <c/>radar();<n/>, you can look for objects like <a object|mother>enemies</a>, bots, buildings or raw materials.
pt_BR: 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.

note: type: Plain text
en: <c/><a cbot|radarall>radarall</a>();<n/>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <c/><a cbot|radarall>radarall</a>();<n/>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Instruction <code>radarall</code>
pt_BR: Instrução <code>radarall</code>

note: type: Plain text
en: <c/>radarall();<n/> is an enhancement of the <c/><a cbot|radar>radar</a>();<n/> function -- it detects all objects matching the given criteria.
pt_BR: <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.

note: type: \b; header
en: Example<c/>
pt_BR: Exemplo<c/>

note: type: Source code
en: <c/>radarall ( cat, angle, focus, min, max, sens, filter );<n/>
pt_BR: <c/>radarall ( categoria, angulo, foco, min, max, sens, filtro );<n/>

note: type: Plain text
en: 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.
pt_BR: 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>.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: <c/><a cbot|radar>radar</a>();<n/>, <a cbot>programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <c/><a cbot|radar>radar</a>();<n/>, <a cbot>programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: Plain text
en: This set of instructions is executed before the first loop instance.
pt_BR: Este conjunto de instruções é executado antes da primeira instância do laço.

note: type: Plain text
en: This set of instructions is executed at the end of every instance of the loop.
pt_BR: Este conjunto de instruções é executado ao fim de cada instância do laço.

note: type: \t; header
en: Executing more instructions
pt_BR: Executando mais instruções

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: The output of the above code is <code>1 2 2 1</code>.
pt_BR: A saída do código acima é <code>1 2 2 1</code>.

note: type: Source code
en: object[] items = radarall(PowerCell);
    for (int i = 0; i < sizeof(items); ++i)
    {
        message(items[i].id);
    }
pt_BR: object[] itens = radarall(PowerCell);
    for (int i = 0; i < sizeof(itens); ++i)
    {
        message(itens[i].id);
    }

note: type: Plain text
en:        <code><a object|flag>BlueFlag</a>          </code>Blue Flag
           <code><a object|flag>RedFlag</a>           </code>Red Flag
           <code><a object|flag>GreenFlag</a>         </code>Green Flag
           <code><a object|flag>YellowFlag</a>        </code>Yellow Flag
           <code><a object|flag>VioletFlag</a>        </code>Violet Flag
           <code><a object|waypoint>WayPoint</a>          </code>Checkpoint
           <code><a object|target2>Target2</a>           </code>Flying checkpoint
           <code><a object|enerspot>PowerSpot</a>        </code>Underground Energy Deposit
           <code><a object|stonspot>TitaniumSpot</a>      </code>Underground Titanium Deposit
           <code><a object|uranspot>UraniumSpot</a>       </code>Underground Uranium Deposit
pt_BR:        <code><a object|flag>BlueFlag</a>          </code>Bandeira azul
           <code><a object|flag>RedFlag</a>           </code>Bandeira vermelha
           <code><a object|flag>GreenFlag</a>         </code>Bandeira verde
           <code><a object|flag>YellowFlag</a>        </code>Bandeira amarela
           <code><a object|flag>VioletFlag</a>        </code>Bandeira violeta
           <code><a object|waypoint>WayPoint</a>          </code>Ponto de verificação
           <code><a object|target2>Target2</a>           </code>Ponto de verificação voador
           <code><a object|enerspot>PowerSpot</a>        </code>Depósito de energia subterrâneo
           <code><a object|stonspot>TitaniumSpot</a>      </code>Depósito de titânio subterrâneo
           <code><a object|uranspot>UraniumSpot</a>       </code>Depósito de urânio subterrâneo

note: type: Plain text
en: <button 176/>   <code><a object|huston>Houston</a>          </code>Mission Control
    <button 171/>   <code><a object|base>SpaceShip</a>        </code>Spaceship
    <button 160/>   <code><a object|factory>BotFactory</a>       </code>Robot Factory
    <button 163/>   <code><a object|research>ResearchCenter</a>   </code>Research Center
    <button 168/>   <code><a object|radar>RadarStation</a>     </code>Radar
    <button 172/>   <code><a object|exchange>ExchangePost</a>     </code>Information Exchange Post
    <button 169/>   <code><a object|repair>RepairCenter</a>     </code>Repair Center
    <button 165/>   <code><a object|tower>DefenseTower</a>     </code>Defense Tower
    <button 166/>   <code><a object|labo>AutoLab</a>          </code>Organic Matter Analyzer 
    <button 164/>   <code><a object|station>PowerStation</a>     </code>Power Station
    <button 167/>   <code><a object|energy>PowerPlant</a>       </code>Power Cell Factory
    <button 170/>   <code><a object|nuclear>NuclearPlant</a>     </code>Nuclear Plant
    <button 162/>   <code><a object|convert>Converter</a>        </code>Titanium Converter
    <button 161/>   <code><a object|derrick>Derrick</a>          </code>Derrick
    <button 174/>   <code><a object|captor>PowerCaptor</a>      </code>Parabolic Lightning Conductor
    <button 175/>   <code><a object|safe>Vault</a>            </code>Vault
           <code><a object|start>StartArea</a>        </code>Starting Pad
           <code><a object|goal>GoalArea</a>         </code>Finishing Pad
           <code><a object|target1>Target1</a>          </code>Flying target
           <code><a object|nest>AlienNest</a>        </code>Alien Nest
pt_BR: <button 176/>   <code><a object|huston>Houston</a>          </code>Controle de missão
    <button 171/>   <code><a object|base>SpaceShip</a>        </code>Espaçonave
    <button 160/>   <code><a object|factory>BotFactory</a>       </code>Fábrica de robôs
    <button 163/>   <code><a object|research>ResearchCenter</a>   </code>Centro de pesquisa
    <button 168/>   <code><a object|radar>RadarStation</a>     </code>Estação de radar
    <button 172/>   <code><a object|exchange>ExchangePost</a>     </code>Posto de troca de informação
    <button 169/>   <code><a object|repair>RepairCenter</a>     </code>Centro de reparos
    <button 165/>   <code><a object|tower>DefenseTower</a>     </code>Torre de defesa
    <button 166/>   <code><a object|labo>AutoLab</a>          </code>Analisador de matéria orgânica
    <button 164/>   <code><a object|station>PowerStation</a>     </code>Estação de energia
    <button 167/>   <code><a object|energy>PowerPlant</a>       </code>Fábrica de células de energia
    <button 170/>   <code><a object|nuclear>NuclearPlant</a>     </code>Planta nuclear
    <button 162/>   <code><a object|convert>Converter</a>        </code>Convertedor de titânio
    <button 161/>   <code><a object|derrick>Derrick</a>          </code>Guindaste
    <button 174/>   <code><a object|captor>PowerCaptor</a>      </code>Condutor de relâmpagos parabólico
    <button 175/>   <code><a object|safe>Vault</a>            </code>Cofre
           <code><a object|start>StartArea</a>        </code>Plataforma de início
           <code><a object|goal>GoalArea</a>         </code>Plataforma de finalização
           <code><a object|target1>Target1</a>          </code>Alvo voando
           <code><a object|nest>AlienNest</a>        </code>Ninho alienígena

note: type: Plain text
en: Classes can be only <a cbot|public>public</a>. This means that they can be used by all bots in a mission.
pt_BR: 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.

note: type: \b; header
en: Class Members
pt_BR: Membros da classe

note: type: Plain text
en: Class members are fields (<a cbot|var>variables</a>) and methods (<a cbot|function>functions</a>).
pt_BR: Membros da classe são atributos (<a cbot|var>variáveis</a>) e métodos (<a cbot|function>funções</a>).

note: type: Plain text
en: 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>).
pt_BR: 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>).

note: type: Source code
en: public class MyClass
    {
    	int     a, b;
    	float   x = 3.33;
    	string  s = "hello";
    	float   MyFunction(float value)
    	{
    		return (value * x) - 1;
    	}
    }
pt_BR: public class MinhaClasse
    {
    	int     a, b;
    	float   x = 3.33;
    	string  s = "olá";
    	float   MinhaFuncao(float value)
    	{
    		return (value * x) - 1;
    	}
    }

note: type: \t; header
en: Member Initialization
pt_BR: Inicialização de membros

note: type: Plain text
en: Example:<c/>
pt_BR: Exemplo:<c/>

note: type: Source code
en: public class MyClass
    {
    	int  a, b;
    	void MyClass()
    	{
    		a = 2;  b = 3;
    	}
    	void MyClass(int a, int b)
    	{
    		this.a = a;  this.b = b;
    	}
    }
pt_BR: public class MinhaClasse
    {
    	int  a, b;
    	void MinhaClasse()
    	{
    		a = 2;  b = 3;
    	}
    	void MinhaClasse(int a, int b)
    	{
    		this.a = a;  this.b = b;
    	}
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Object Creation
pt_BR: Criação de objetos

note: type: Plain text
en: You can create objects of type <code>YourClass</code> using the <code><a cbot|new>new</a></code> keyword. Example:
pt_BR: Você pode criar objetos do tipo <code>SuaClasse</code> usando a palavra-chave  <code><a cbot|new>new</a></code>. Exemplo:

note: type: \b; header
en: Object Destruction
pt_BR: Destruição de objetos

note: type: \b; header
en: Passing Objects to Functions
pt_BR: Passando objetos para funções

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Inheritance
pt_BR: Herança

note: type: Plain text
en: A class can inherit public and protected members of another class by using the <code><a cbot|extends>extends</a></code> keyword.
pt_BR: Uma classe pode herdar membros públicos e protegidos de outra classe usando a palavra-chave <code><a cbot|extends>extends</a></code>.

note: type: Plain text
en: This keyword allows you to create a class definition by using the following syntax:
pt_BR: Esta palavra permite a você criar uma definição de classe usando a seguinte sintaxe:

note: type: \t; header
en: All Classes Are Public
pt_BR: Todas as classes são públicas

note: type: \t; header
en: Class Members Modifiers
pt_BR: Modificadores de membros de classe

note: type: \t; header
en: Using <code><a cbot|this>this</a></code>
pt_BR: Usando <code><a cbot|this>this</a></code>

note: type: Source code
en: extern void object::Test()
    {
    	MyClass object1();       // Call default constructor (without parameters)
    	MyClass object2(4, 5);   // Call constructor with two int parameters
    	MyClass object3;         // No constructor called, object3 == null
    	object3 = new MyClass(); // We call constructor now, object3 != null
    }
pt_BR: extern void object::Teste()
    {
    	MinhaClasse objeto1();       // Chama o construtor padrão (sem parâmetros)
    	MinhaClasse objeto2(4, 5);   // Chama o construtor com 2 parâmetros int
    	MinhaClasse objeto3;         // Nenhum construtor chamado, objeto3 == null
    	objeto3 = new MinhaClasse(); // Chamamos o construtor agora, objeto3 != null
    }

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Source code
en: public class MyClass
    {
    	static private int counter = 0; // instance counter
    	void  MyClass( )
    	{
    		counter++;  // one instance more
    	}
    	void ~MyClass( )
    	{
    		counter--;  // one instance less
    	}
    }
    extern void object::Test()
    {
    	                   // counter == 0
    	MyClass item1( );  // counter == 1
    	MyClass item2( );  // counter == 2
    	item1 = null;      // counter == 1
    }
    // counter == 0
pt_BR: public class MinhaClasse
    {
    	static private int contador = 0; // contador de instância
    	void  MinhaClasse( )
    	{
    		contador++;  // uma instância a mais
    	}
    	void ~MinhaClasse( )
    	{
    		contador--;  // uma instância a menos
    	}
    }
    extern void object::Teste()
    {
    	                   // contador == 0
    	MinhaClasse item1( );  // contador == 1
    	MinhaClasse item2( );  // contador == 2
    	item1 = null;      // contador == 1
    }
    // contador == 0

note: type: \b; header
en: Accessing Class Members
pt_BR: Acessando membros da classe

note: type: Plain text
en: Class members can be accessed outside of the class definition by using the <code>.</code> operator. Example:
pt_BR: Membros da classe podem ser acessados fora da definição da classe utilizando o operador <code>.</code>. Exemplo:

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Plain text
en: 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>.
pt_BR: 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>.

note: type: Source code
en: public class MyClass
    {
    	int myField = 0;
    	int MyFunction()
    	{
    		return myField * 2;
    	}
    }
    
    extern void object::Test()
    {
    	MyClass myObject();
    	myObject.myField = 10;
    	message(myObject.MyFunction()); // 20
    	MyClass mySecondObject();
    	mySecondObject.myField = myObject.myField - 2;
    	message(mySecondObject.MyFunction()); // 16
    }
pt_BR: public class MinhaClasse
    {
    	int meuAtributo = 0;
    	int minhaFuncao()
    	{
    		return meuCampo * 2;
    	}
    }
    
    extern void object::Teste()
    {
    	MinhaClasse meuObjeto();
    	meuObjeto.meuAtributo = 10;
    	message(meuObjeto.minhaFuncao()); // 20
    	MinhaClasse meuSegundoObjeto();
    	meuSegundoObjeto.meuCampo = meuObjeto.meuCampo - 2;
    	message(meuSegundoObjeto.minhaFuncao()); // 16
    }

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Keyword <code>protected</code>
pt_BR: palavra-chave <code>protected</code>

note: type: Plain text
en: 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).
pt_BR: 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>).

note: type: Source code
en: public class Parent
    {
    	protected int field = 0;
    }
    
    public class Child extends Parent
    {
    	void Print()
    	{
    		message(field);
    	}
    }
    
    extern void object::Test()
    {
    	Child child();
    	child.Print(); // 0
    	//child.field = 1; // Error!
    }
pt_BR: public class Pai
    {
    	protected int atributo = 0;
    }
    
    public class Filho extends Pai
    {
    	void imprimir()
    	{
    		message(atributo);
    	}
    }
    
    extern void object::Teste()
    {
    	Filho filho = new filho();
    	filho.imprimir(); // 0
    	//child.atributo = 1; // erro!
    }

note: type: Plain text
en: This is an access modifier for <a cbot|class>class</a> members. Private members are not accessible outside of the class definition.
pt_BR: 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.

note: type: Plain text
en: <code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|protected>protected</a></code>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|class>class</a></code>, <code><a cbot|public>public</a></code>, <code><a cbot|protected>protected</a></code>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: Plain text
en: <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.
pt_BR: <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.

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Keyword <code>super</code>
pt_BR: Palavra-chave <code>super</code>

note: type: Plain text
en: <code><a cbot|class>class</a></code>, <code><a cbot|this>this</a></code>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|class>class</a></code>, <code><a cbot|this>this</a></code>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: Plain text
en: <code><a cbot|class>class</a></code>, <code><a cbot|super>super</a></code>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <code><a cbot|class>class</a></code>, <code><a cbot|super>super</a></code>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: \b; header
en: Keyword <code>extends</code>
pt_BR: Palavra-chave <code>extends</code>

note: type: \b; header
en: Inherited Members
pt_BR: Membros herdados

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Constructors and destructors are not inherited, however, they can be overriden.
pt_BR: Construtores e destrutores não são herdados, entretanto, eles podem ser sobrescritos.

note: type: \b; header
en: Method Overriding
pt_BR: Sobrescrevendo métodos

note: type: Plain text
en: Inherited methods can be overriden (redefined) in the child class definition. Example:
pt_BR: Métodos herdados podem ser sobrescritos (redefinidos) na definição de classe dos filhos. Exemplo:

note: type: Source code
en: public class Parent
    {
    	void foo()
    	{
    		message("foo");
    	}
    }
    
    public class Child extends Parent
    {
    	void foo()
    	{
    		message("bar");
    	}
    }
    
    extern void object::Test()
    {
    	Child child();
    	child.foo(); // Will show "bar"
    }
pt_BR: public class Pai
    {
    	void ola()
    	{
    		message("Olá!");
    	}
    }
    
    public class Filho extends Pai
    {
    	void ola()
    	{
    		message("Hello!");
    	}
    }
    
    extern void object::Teste()
    {
    	Filho filho = new Filho();
    	filho.ola(); // Irá exibir "Hello!"
    }

note: type: \b; header
en: Polymorphism
pt_BR: Polimorfismo

note: type: Plain text
en: <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.
pt_BR: 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.

note: type: Source code
en: public class Parent
    {
    	void foo()
    	{
    		message("foo");
    	}
    }
    
    public class Child extends Parent
    {
    	void foo()
    	{
    		message("bar");
    	}
    	void bar()
    	{
    		message("foo bar");
    	}
    }
    
    extern void object::Test()
    {
    	Parent people[2];
    	people[0] = new Parent();
    	people[1] = new Child();
    	for (int i = 0; i < 2; ++i)
    	{
    		people[i].foo();
    	}
    	//people[1].bar(); // Error
    	Child child = people[1];
    	child.bar(); // OK
    }
pt_BR: public class Pai
    {
    	void ola()
    	{
    		message("Olá!");
    	}
    }
    
    public class Filho extends Pai
    {
    	void ola()
    	{
    		message("Hello!");
    	}
    	void oi()
    	{
    		message("Oi!");
    	}
    }
    
    extern void object::Teste()
    {
    	Pai pessoas[2];
    	pessoas[0] = new Pai();
    	tpessoas[1] = new Filho();
    	for (int i = 0; i < 2; ++i)
    	{
    		pessoas[i].ola();
    	}
    	//pessoas[1].oi(); // Erro
    	Filho filho = pessoas[1];
    	filho.oi(); // OK
    }

note: type: \b; header
en: Multiple Inheritance
pt_BR: Herança múltipla

note: type: Plain text
en: A child cannot have multiple parents, however, a parent can have many children.
pt_BR: Uma criança não pode ter múltiplos pais, porém, um pai pode ter múltiplas crianças.

note: type: Plain text
en: <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>
    <a cbot>Programming</a>, <a cbot|type>types</a> and <a cbot|category>categories</a>.
pt_BR: <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>
    <a cbot>Programação</a>, <a cbot|type>tipos</a> e <a cbot|category>categorias</a>.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: public class Parent
    {
    	protected int field;
    	
    	void Parent()
    	{
    		field = 0;
    	}
    	
    	void Print()
    	{
    		message("Parent's field: " + field);
    	}
    }
    
    public class Child extends Parent
    {
    	private int childsField;
    	
    	void Child()
    	{
    		super.Parent();
    		childsField = field + 1;
    	}
    	
    	void Print()
    	{
    		super.Print();
    		message("Child's field: " + childsField);
    	}
    }
    
    extern void object::Test()
    {
    	Child child();
    	child.Print(); // Will show both 0 and 1
    }
pt_BR: public class Pai
    {
    	protected int atributo;
    	
    	void Pai()
    	{
    		atributo = 0;
    	}
    	
    	void imprimir()
    	{
    		message("Atributo do pai: " + atributo);
    	}
    }
    
    public class Filho extends Pai
    {
    	private int filhoAtributo;
    	
    	void Filho()
    	{
    		super.Pai();
    		atributoFilho = atributo + 1;
    	}
    	
    	void imprimir()
    	{
    		super.imprimir();
    		message("Atributo do filho: " + atributoFilho);
    	}
    }
    
    extern void object::Teste()
    {
    	Filho filho = new Filho();
    	filho.imprimir(); // Irá exibir ambos 0 e 1
    }

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Source code
en: public class Parent
    {
    	void foo()
    	{
    		message("foo");
    	}
    }
    
    public class Child extends Parent
    {
    	void bar()
    	{
    		message("bar");
    	}
    }
    
    extern void object::Test()
    {
    	Child child();
    	child.foo(); // Will show "foo"
    	child.bar(); // Will show "bar"
    }
pt_BR: public class Pai
    {
    	void ola()
    	{
    		message("Olá!");
    	}
    }
    
    public class Filho extends Pai
    {
    	void oi()
    	{
    		message("Oi!");
    	}
    }
    
    extern void object::Teste()
    {
    	Filho filho = new Filho();
    	filho.ola(); // Irá exibir "Ola!"
    	filho.oi(); // Irá exibir "Oi!"
    }

note: type: Plain text
en: A parent's method can be called inside an overriden method by using the <code><a cbot|super>super</a></code> keyword.
pt_BR: 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>.

note: type: Plain text
en: As shown in the previous example, the class members can be initialized in the class definition (<c/>int x = 3.33;<n/>).
pt_BR: Como mostrado no exemplo anterior, os membros da classe podem ser inicializados na definição da classe  (<c/>int x = 3.33;<n/>).

note: type: Plain text
en: <code>"r"</code> mode: open for reading.
    <code>"w"</code> mode: open for writing.
    <code>"a"</code> mode: open for appending.
pt_BR: Modo <code>"r"</code>: abre para leitura.
    Modo <code>"w"</code>: abre para escrita.
    Modo <code>"a"</code>: abre para acrescentar.

note: type: Plain text
en: <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.
pt_BR: <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.

note: type: Plain text
en: <code>"r"</code> mode: open for reading.
    <code>"w"</code> mode: open for writing.
    <code>"w"</code> mode: open for appending.
pt_BR: Modo <code>"r"</code>: abre para leitura.
    Modo <code>"w"</code>: abre para escrita.
    Modo <code>"a"</code>: abre para acrescentar.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: \b; header
en: Public Functions
pt_BR: Funções públicas

note: type: \b; header
en: Default Parameters
pt_BR: Parâmetros padrões

note: type: Plain text
en: Last function parameters can have default values that can be omitted when calling.
pt_BR: 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.

note: type: Source code
en: float Add(float a = 0.0, float b = 0.0)
    {
    	return a + b;
    }
    
    // Somewhere in the main program...
    Add(); // Will return 0.0
    Add(2.0); // Will return 2.0
    Add(2.0, 3.0); // Will return 5.0
    // ...
pt_BR: float adicionar(float a = 0.0, float b = 0.0)
    {
    	return a + b;
    }
    
    // Em algum lugar do programa principal...
    adicionar(); // Irá retornar 0.0
    adicionar(2.0); // Irá retornar 2.0
    adicionar(2.0, 3.0); // Irá retornar 5.0
    // ...

note: type: \t; header
en: Default Parameters and Overloading
pt_BR: Parâmetros padrões e sobrecarregamento

note: type: Plain text
en: Functions with default parameters still can be overloaded, one must only ensure that function calls are not ambiguous. For example, consider the following code:
pt_BR: 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:

note: type: Source code
en: float Add(float a = 0.0, float b = 0.0)
    {
    	return a + b;
    }
    
    string Add(string a = "", string b = "")
    {
    	return a + b;
    }
    
    // Somewhere in the main program...
    Add(); // Compilation error: ambiguous call
    Add(""); // Ok
    Add(0.0); // Ok
    // ...
pt_BR: float adicionar(float a = 0.0, float b = 0.0)
    {
    	return a + b;
    }
    
    string adicionar(string a = "", string b = "")
    {
    	return a + b;
    }
    
    // Em algum lugar do programa principal...
    adicionar(); // Erro de compilação: chamada ambígua
    adicionar(""); // Ok
    adicionar(0.0); // Ok
    // ...

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Note: the <a cbot|isbusy>isbusy</a> instruction might be much better to use in this scenario.
pt_BR: Nota: a instrução <a cbot|isbusy>isbusy</a> pode ser muito boa para usar neste cenário.
