Home Instruções Avançadas
Instruções Avançadas

Instruções Avançadas

Além dos comandos básicos do robô, você pode utilizar algumas instruções que permitem a você programar um comportamento mais sofisticado para seu robô. Veja quais são as instruções e exemplos de como utilizá-las.

Laços

repetir(n){...instruções...}
Repete a instrução entre chaves exatamente "n" vezes.
Exemplo:
# desenhar um quadrado de 2x2
repetir(4)
{
andarFrente(2)
virarDireita()
}
repetir(){...instruções...}
Repete continuamente as instruções entre chaves.
Exemplo:
# permanece andando para frente
# (até que eventualmente encontre uma parede)
repetir()
{
andarFrente(1)
}
repetirEnquanto(condição){...instruções...}

Repete as instruções entre chaves enquanto a condição é verdadeira. A condição deve ser do tipo ver (como por exemplo, vazioFrente())

Exemplo:
# mantém andando para frente,
# parando quando encontrar um obstáculo
repetirEnquanto(temObstáculoFrente())
{
andarFrente(1)
}
sair
Permite a você sair do laço (por exemplo, repeat()) interrompendo a execução das instruções entre chaves. O robô irá executar as instruções após o fechamento das chaves do laço.
Exemplo:
# mantém andando em frente até encontrar um obstáculo
repetir()
{
se(temObstáculoFrente())
{
sair
}
senão
{
andarFrente(1)
}
}
voltar
Permite a você sair de dentro de um procedimento, interrompendo a execução das instruções dentro dele. O robô irá executar as instruções após a chamada do procedimento.
Exemplo:

procedimento p1()
{
andarFrente(1)
se(vazioFrente()) {
voltar
}
andarSul(2)
}

p1()
andarFrente(4)
virarDireita()

 

Condições

se(condição)
{...instruções...}

Executará as instruções entre chaves somente se a condição for verdadeira. Senão o robô pula as instruções entre chaves. A condição deve ser uma instrução do tipo ver (por exemplo: vazioFrente()).

Exemplo:
# se estiver pintado de branco na esquerda, pintar de preto
se(brancoEsquerda())
{
virarEsquerda()
andarFrente(1)
pintarPreto()
pararPintar()
andarTrás(1)
virarDireita()
}

se(condição)
{...instruções...}

senão
{...instruções...}

Executará as instruções entre o primeiro par de chaves, somente se a condição for verdadeira e, neste caso, não executará as instruções do bloco senão (instruções do segundo par de chaves). Quando a condição não for verdadeira, o robô somente executa as instruções compreendidas no segundo par de chaves. Depois de executado um dos blocos de instruções, o robô continuará executando as instruções ao final das chaves. A condição deve ser uma instrução do tipo ver (por exemplo: vazioFrente()).

Exemplo:
# se estiver branco na esquerda, pinte de preto
# senão ande um pouco mais para frente
se(brancoEsquerda())
{
virarEsquerda()
andarFrente(1)
pintarPreto()
pararPintar()
andarTrás(1)
virarDireita()
}
senão
{
andarFrente(3)
}

 

Expressões Lógicas

 

 

As condições contidas nos comandos "se" e "repetirEnquanto" são denominadas expressões lógicas. Estas expressões sempre resultam em valores verdadeiro ou falso, sendo utilizado para definir que parte do código deve ser executado.
Exemplo:
se(brancoEsquerda())
{
virarEsquerda()
andarFrente(1)
}

A condição pode também ser refinada para indicar com mais precisão o momento que determinadas instruções devem ser executadas usando (uma combinação) os seguintes operadores:

Operador

Notação
Alternativa

Número de
Argumentos

Explicação
não~ 1

Nega o valor do argumento:

Tabela verdade:
~verdadeiro = falso
~falso = verdadeiro


Exemplo: ~vazioFrente()

e&
2Somente verdade quando ambos os argumentos são verdadeiros:

Tabela verdade:
verdadeiro & verdadeiro = verdadeiro
verdadeiro & falso = falso
falso & verdadeiro = falso
falso & falso = falso


Exemplo: vazioFrente() & brancoDireita()
ou|
2Verdade quando pelo menos um argumento é verdadeiro:

Tabela verdade:
verdadeiro | verdadeiro = verdadeiro
verdadeiro | falso = verdadeiro
falso | verdadeiro = verdadeiro
falso | falso = falso


Exemplo: vazioFrente() | brancoDireita()

 

Os valores verdadeiro e falso podem também ser diretamente aplicados como se fosse uma instrução de percepção (ver).

A ordem dos operadores é muito importante (como multiplicação e soma de números). O operador ~ é o mair forte, seguido por &, seguido por |. Parênteses podem ser usados para influenciar a ordem.

 

Exemplo:
repetirEnquanto(não vazioFrente() e (brancoEsquerda() ou brancoDireita()) )
{
andarFrente(1)
}
se(sortear() e não brancoDireita())
{
virarDireita()
andarTrás(1)
}
se(verdadeiro & falso)
{
# essa instrução nunca será executada
andarFrente(1)
}

 

Procedimentos

procedimento nome(par1, par2, ..., parN) { ... }

Define um novo procedimento com o nome que você desejar. O procedimento pode ter zero ou mais parâmetros, os quais você pode dar nomes mais usuais. Aqui eles são chamados de par1, par2, ..., parN. Estas são as variáveis que você pode utilizar nas instruções entre parênteses. O código do procedimento não será realizado automaticamente, você tem que escrever uma "chamada de procedimento" cada vez que você quiser realizar as instruções contidas dentro dele (veja a próxima instrução).
Sugestão: criar um novo procedimento quando você usa uma sequência de instruções mais de uma vez.

 

Exemplo: 
# define como desenhar um retângulo
procedimento retangulo(largura, altura)
{
pintarBranco()
repetir(2)
{
andarFrente(altura)
virarDireita()
andarFrente(largura)
virarDireita()
}
pararPintar()
}
nome(arg1, arg2, argN)

É a chamada ao procedimento que corresponde ao nome e ao mesmo número de parâmetros. Os argumentos, aqui chamados de arg1, arg2, ..., argN, são valores particulares que serão usados na definição do procedimento.

 

Exemplo: 
# estas instruções serão executadas
andarFrente(1)
retangulo(3, 2) # uma chamada ao procedimento retangulo
andarFrente(3)
retangulo(1, 4) # uma outra chamada, agora com novos parâmetros

# define como desenhar um retângulo
procedimento retangulo(largura, altura)
{
pintarBranco()
repetir(2)
{
andarFrente(altura)
virarDireita()
andarFrente(largura)
virarDireita()
}
pararPintar()
}
Fim
 
fim

Fará com que todo o programa pare quando essa instrução for executada.

 

Exemplo: 
# para a execução após 5 passos, ou antes se encontrar um objeto a direita
repetir(5)
{
andarFrente(1)
se(temObjetoFrente())
{
fim # para a execução do programa
}
}
# fim normal do programa