colobot-data 0.1.7 - en to pt_PT translation catalogue (44 entries)

note: type: Title-text
en: Remote control #4
pt_PT: Controle remoto #4

note: type: Resume-text
en: Remote control a bot without using an information exchange post by defining a class for the orders.
pt_PT: Controle remotamente um robô sem usar uma posto de troca de informações definindo uma classe para os pedidos.

note: type: ScriptName-text
en: Remote4
pt_PT: Remoto4

note: type: \b; header
en: Exercise
pt_PT: Exercício

note: type: Plain text
en: Remote control a slave robot without using an <a object|exchange>information exchange post</a>. The robot should pass over the 6 blue crosses. You must use a <code><a cbot|static>static</a></code> variable to pass the orders to the slave bot.
pt_PT: Controle remotamente um robô escravo sem usar um <a object|exchange>posto de troca de informações</a>. O robô deve passar pelas 6 cruzes azuis. Você deve usar uma variável <code><a cbot|static>estática</a></code> para passar as ordens para o robô escravo.

note: type: Plain text
en: The two main actors of this exercise are:
pt_PT: Os dois principais atores deste exercício são:

note: type: Bullet: '1)'
en: The <a object|botgr>wheeled grabber</a> without an energy pack and therefore immobile. This is the master you should program so it will transmit orders to the slave.
pt_PT: O <a object|botgr>agarrador com rodas</a> sem uma célula de energia e, portanto, imóvel. Este é o mestre que você deve programar para transmitir ordens ao escravo.

note: type: Bullet: '2)'
en: The slave <a object|bottr>practice bot</a> which is already programmed and just waits for orders from the master.
pt_PT: O <a object|bottr>robô de prática</a> escravo que já está programado e apenas aguarda ordens do mestre.

note: type: \b; header
en: The slave
pt_PT: O escravo

note: type: Plain text
en: First of all we must understand how the program of the slave works. The <a cbot|class>class</a> <code>order</code> contains two members: <code>m_type</code> is the order to execute (move or turn) and <code>m_param</code> is the distance to move or the rotation angle:
pt_PT: Primeiro de tudo, devemos entender como funciona o programa do escravo. A classe <a cbot|class>classe</a> <code>ordem</code> contém dois membros: <code>m_tipo</code> é a ordem para executar (mover ou girar) e <code>m_param</code > é a distância para se mover ou o ângulo de rotação:

note: type: Plain text
en: <c/><s/><a cbot|public>public</a> <a cbot|class>class</a> order
pt_PT: <c/><s/><a cbot|public>public</a> <a cbot|class>class</a> ordem

note: type: Source code
en: {
    	<a cbot|int>int</a>    m_type = <a cbot|nan>nan</a>;
    	<a cbot|float>float</a>  m_param;
    }
pt_PT: {
    	<a cbot|int>int</a>    m_tipo = <a cbot|nan>nan</a>;
    	<a cbot|float>float</a>  m_param;
    }

note: type: Plain text
en: A second <a cbot|class>class</a> <code>exchange</code> contains the mechanism for exchanging the orders. We declare a <code><a cbot|static>static</a></code> class member <code>m_order</code> which will contain the order to be executed. The word <code>static</code> insures that the member <code>m_order</code> is shared between all instances of the <a cbot|class>class</a> exchange.
pt_PT: Uma segunda <a cbot|class>classe</a> <code>troca</ code> contém o mecanismo para trocar as ordens. Nós declaramos um membro de classe <code><a cbot|static>estático</a></code> <code>m_ordem</code> que conterá a ordem a ser executada. A palavra <code>static</code> assegura que o membro <code>m_ordem</code> seja compartilhado entre todas as instâncias da classe <a cbot|class>troca</a>.

note: type: Plain text
en: <c/><s/><a cbot|public>public</a> <a cbot|class>class</a> exchange
pt_PT: <c/><s/><a cbot|public>public</a> <a cbot|class>class</a> troca

note: type: Source code
en: {
    	<a cbot|static>static</a> <a cbot|private>private</a> order m_order = new order;
pt_PT: {
    	<a cbot|static>static</a> <a cbot|private>private</a> ordem m_ordem = new ordem;

note: type: Plain text
en: <n/>The <code>put</code> method will be used by the master robot for transmitting an order. As long as <code>m_order</code> is different from <code><a cbot|nan>nan</a></code>, the slave has not finished the order and the <code>put</code> method will return <code>false</code> and will do nothing:
pt_PT: <n /> O método <code>colocar</code> será usado pelo robô mestre para transmitir um pedido. Enquanto <code>m_ordem</code> é diferente de <code><a cbot|nan>nan</a></code>, o escravo não finalizou o pedido e o método <code>colocar</ code> retornará <code> false </code> e não fará nada:

note: type: Plain text
en: <c/><s/>	<a cbot|synchro>synchronized</a> <a cbot|bool>bool</a> put(order a)
pt_PT: <c/><s/>	<a cbot|synchro>synchronized</a> <a cbot|bool>bool</a> colocar(ordem a)

note: type: Source code
en: 	{
    		if ( m_order.m_type == nan )
    		{
    			m_order = a;
    			return true;
    		}
    		else
    		{
    			return false;
    		}
    	}
pt_PT: 	{
    		if ( m_ordem.m_tipo == nan )
    		{
    			m_ordem = a;
    			return true;
    		}
    		else
    		{
    			return false;
    		}
    	}

note: type: Plain text
en: Another method <code>get</code> will be used by the slave to retrieve the orders. This method returns the order to be executed:
pt_PT: Outro método <code>pegar</code> será usado pelo escravo para recuperar as ordens. Este método retorna o pedido a ser executado:

note: type: Plain text
en: <c/><s/>	<a cbot|synchro>synchronized</a> order get()
pt_PT: <c/><s/>	<a cbot|synchro>synchronized</a> order pegar()

note: type: Source code
en: 	{
    		return m_order;
    	}
pt_PT: 	{
    		return m_ordem;
    	}

note: type: Plain text
en: A third method <code>delete</code> will be used by the slave to indicate that the order has been executed:
pt_PT: Um terceiro método <code>excluir</code> será usado pelo escravo para indicar que o pedido foi executado:

note: type: Plain text
en: <c/><s/>	<a cbot|synchro>synchronized</a> void delete()
pt_PT: <c/><s/>	<a cbot|synchro>synchronized</a> void excluir()

note: type: Source code
en: 	{
    		m_order.m_type = nan;
    	}
    }
pt_PT: 	{
    		m_ordem.m_tipo = nan;
    	}
    }

note: type: Plain text
en: The main program of the slave contains an instance of the class <code>exchange</code> called <code>list</code>. We put () after the word <code>list</code> in order to create an instance of the class <code>exchange</code>.
pt_PT: O programa principal do escravo contém uma instância da classe <code>troca</code> chamada <code>lista</code>. Nós colocamos () depois da palavra <code>lista</code> para criar uma instância da classe <code>troca</code>.

note: type: Plain text
en: <c/><s/><a cbot|extern>extern</a> void object::Slave3( )
pt_PT: <c/><s/><a cbot|extern>extern</a> void object::Escravo3( )

note: type: Source code
en: {
    	exchange list();
    	order    todo;
pt_PT: {
    	troca lista();
    	ordem    para_fazer;

note: type: Plain text
en: The outer <code>while</code> loop lasts for ever. The inner <code>while</code> loop waits for an order by using the <code>get</code> method of the <code>exchange</code> class. As soon as <code>get</code> returns a value different from <code>nan</code>, the while loop stops.
pt_PT: O laço externo <code>while</code> dura para sempre. O laço interno <code>while</code> espera por uma ordem usando o método <code>pegar</code> da classe <code>troca</code>. Assim que <code>pegar</code> retorna um valor diferente de <code>nan</code>, o laço while para.

note: type: Source code
en: 	{
    		<a cbot|while>while</a> ( true )
    		{
    			todo = list.get();
    			if ( todo.m_type != nan )  break;
    			wait(1);
    		}
pt_PT: 	{
    		<a cbot|while>while</a> ( true )
    		{
    			para_fazer = lista.pegar();
    			if ( para_fazer.m_tipo != nan )  break;
    			wait(1);
    		}

note: type: Plain text
en: Now we have received the order in the <code>todo</code> variable. All we have to do is execute it:
pt_PT: Agora recebemos a ordem na variável <code>para_fazer</code>. Tudo o que temos a fazer é executá-la:

note: type: Plain text
en: <c/><s/>		if ( todo.m_type == 1 )
pt_PT: <c/><s/>		if ( para_fazer.m_tipo == 1 )

note: type: Source code
en: 		{
    			move(todo.m_param);
    		}
    		else if ( todo.m_type == 2 )
    		{
    			turn(todo.m_param);
    		}
    		else
    		{
    			message("Unknown order");
    		}
pt_PT: 		{
    			move(para_fazer.m_param);
    		}
    		else if ( para_fazer.m_tipo == 2 )
    		{
    			turn(para_fazer.m_param);
    		}
    		else
    		{
    			message("Ordem desconhecida");
    		}

note: type: Plain text
en: As soon as the execution of the order is finished, we must call the <code>delete</code> method so the master knows that another order can be sent:
pt_PT: Assim que a execução do pedido estiver concluída, devemos chamar o método <code>excluir</code> para que o mestre saiba que outro pedido pode ser enviado:

note: type: Plain text
en: <c/><s/>		list.delete();
pt_PT: <c/><s/>		lista.excluir();

note: type: \b; header
en: The master
pt_PT: O mestre

note: type: Plain text
en: In the master we write an function called <code>SendOrder</code> which will send an order to the slave:
pt_PT: No mestre nós escrevemos uma função chamada <code>EnviarOrdem</code> que irá enviar um pedido para o escravo:

note: type: Plain text
en: <c/><s/>void object::SendOrder(float order, float param)
pt_PT: <c/><s/>void object::EnviarOrdem(float ordem, float param)

note: type: Source code
en: {
    	exchange list();
    	order    todo();
    	
    	todo.m_type = order;
    	todo.m_param = param;
    	
    	while ( list.put(todo) == false )
    	{
    		wait(1);
    	}
    }
pt_PT: {
    	troca lista();
    	ordem    para_fazer();
    	
    	para_fazer.m_tipo = ordem;
    	para_fazer.m_param = param;
    	
    	while ( lista.colocar(para_fazer) == false )
    	{
    		wait(1);
    	}
    }

note: type: Plain text
en: The <code>while</code> loop waits until a pending order has been terminated, that is the slaved has exited from the <code>get</code> method and the <code>delete</code> method has been called.
    Now the main program of the master is very simple:
pt_PT: O laço <code>while</code> aguarda até que uma ordem pendente seja finalizada, ou seja, o escravo tenha saído do método <code>pegar</ code> e o método <code>excluir</code> tenha sido chamado . 
    Agora o programa principal do mestre é muito simples:

note: type: Plain text
en: <c/><s/>extern void object::Remote4( )
pt_PT: <c/><s/>extern void object::Remoto4( )

note: type: Source code
en: {
    	SendOrder(1, 20);  // move(20);
    	SendOrder(2, 90);  // turn(90);
    	SendOrder(1, 20);  // move(20);
    	SendOrder(2, 90);  // turn(90);
    	SendOrder(1, 10);  // move(10);
    	SendOrder(2, 90);  // turn(90);
    	SendOrder(1, 10);  // move(10);
    	SendOrder(2,-90);  // turn(-90);
    	SendOrder(1, 10);  // move(10);
    }
pt_PT: {
    	EnviarOrdem(1, 20);  // move(20);
    	EnviarOrdem(2, 90);  // turn(90);
    	EnviarOrdem(1, 20);  // move(20);
    	EnviarOrdem(2, 90);  // turn(90);
    	EnviarOrdem(1, 10);  // move(10);
    	EnviarOrdem(2, 90);  // turn(90);
    	EnviarOrdem(1, 10);  // move(10);
    	EnviarOrdem(2,-90);  // turn(-90);
    	EnviarOrdem(1, 10);  // move(10);
    }

note: type: Plain text
en: <format key><key help/></format> show these instruction at any time.
pt_PT: <format key><key help/></format> mostra essas instruções a qualquer momento.

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

note: type: Plain text
en: <a command>Controls</a> and <a cbot>programming</a>.
pt_PT: <a command>Controles e <a cbot>Linguagem CBOT</a>
