Manual do Progobots
Introdução
Progobots é uma ferramenta educacional utilizada para introdução a arte da programação. Existem duas entidades principais no Progobots: o mundo e os robôs progobots que vivem no mundo.
Um mundo dos progobots é composto por ruas e avenidas numeradas. As ruas são horizontais e numeradas da esquerda para direita, começando com 1. As avenidas são verticais e numeradas de baixo para cima, começando com 1. Um cruzamento entre uma rua e uma avenida pode ser identificado com dois números, o primeiro indicando a avenida e o segundo indicando a rua. Por exemplo, no canto inferior esquerdo está o cruzamento 1 1.
Um progobot é um tipo de robô capaz de executar algumas ações no mundo em que vive. Um progobot pode estar em qualquer cruzamento e ficar virado para uma das direções: norte, sul, leste, oeste. Um progobot pode ser programado para realizar tarefas no mundo. A programação dos progobots é realizada utilizando a linguagem python.
Identificadores
Antes de começar a programar os progobots é necessário conhecer o conceito de identificador.
Um identificador é um nome que identifica algo (uma função, um progobot,
uma biblioteca, etc). Um identificador pode ser composto de qualquer sequência
de letras e números, deste que comece com uma letra. Uma letra para o
python são os caracteres a..z, A..Z e traço baixo (_). Não é possível
utilizar letras acentuadas e nem o cê cedilha.
Existem algumas palavras no python que tem um significado pré-definido, estas
palavras são chamadas de palavras reservadas. As palavras reservadas não
podem ser utilizadas como identificadores. Algumas palavras reservadas do
python: from, import, def, for, while, if, elif, else, return, and, or,
not.
Instruções primitivas
Uma instrução primitiva é uma instrução indivisível já conhecida pelo ambiente de execução. Um progobot tem 4 instruções primitivas:
avance(bot): Faz bot avançar uma quadra na direção que está virado. Falha se existir um parede a frente de bot.vire_a_esquerda(bot): Faz bot virar 90 graus a esquerda.pegue_bipador(bot): Faz bot pegar um bipador. Falha se bot não estiver perto de pelo menos um bipador.deixe_bipador(bot): Faz bot deixar um bipador. Falha se bot não tiver pelo menos um bipador na bolsa.
Sensores
Além de executar as instruções primitivas um progobot vem equipado com alguns sensores. Um sensor é um equipamento capaz de perceber a presença ou ausênsia de uma determinada característica no mundo. Um progobot pode realizar ações de acordo com as repostas do sensores. Por exemplo, um progobot tem um sensor que pode detectar se existe ou não uma parede a sua frente e tomar uma decisão de acordo com a resposta.
A reposta de um sensor pode ser sim ou não. Na computação utilizamos o
termo verdadeiro para sim e o termo falso para não. Na linguagem
python utilizamos True para verdadeiro e False para falso.
Tabela das condições verificáveis por um progobot
Condição (Pergunta verdade)
Descrição
Negação
frente_esta_livre(bot)
Verdadeiro se não existe parede a frente de bot. Falso caso contrário.
frente_esta_bloqueada(bot)
direita_esta_livre(bot)
Verdadeiro se não existe parede a direita de bot. Falso caso contrário.
direita_esta_bloqueada(bot)
esquerda_esta_livre(bot)
Verdadeiro se não existe parede a esquerda de bot. Falso caso contrário.
esquerda_esta_bloqueada(bot)
esta_virado_para_o_norte(bot)
Verdadeiro se bot esta virado para o norte. Falso caso contrário.
nao_esta_virado_para_o_norte(bot)
esta_virado_para_o_oeste(bot)
Verdadeiro se bot esta virado para o oeste. Falso caso contrário.
nao_esta_virado_para_o_oeste(bot)
esta_virado_para_o_sul(bot)
Verdadeiro se bot esta virado para o sul. Falso caso contrário.
nao_esta_virado_para_o_sul(bot)
esta_virado_para_o_leste(bot)
Verdadeiro se bot esta virado para o leste. Falso caso contrário.
nao_esta_virado_para_o_leste(bot)
esta_perto_de_um_bipador(bot)
Verdadeiro se bot esta perto de pelo menos um bipador (ou seja, tem pelo menos um bipador no mesmo cruzamento). Falso caso contrário.
nao_esta_perto_de_um_bipador(bot)
tem_bipador_na_bolsa(bot)
Verdadeiro se bot tem pelo menos um bipador na bolsa. Falso caso contrário.
nao_tem_bipador_na_bolsa(bot)
Operadores lógicos
Um operador lógico é utilizado para construir novas condições utilizando condições existentes.
Os principais operadores lógicos são o and, or e o not. Os operadores
and e or são operadores binários, enquanto o operador not é unário.
A reposta da operação lógica and só é True se os dois operandos forem
True:
Tabela verdade do operador and
A
B
A and B
False
False
False
False
True
False
True
False
False
True
True
True
A reposta da operação lógica or é True se algum dos operandos for
True:
Tabela verdade do operador or
A
B
A or B
False
False
False
False
True
True
True
False
True
True
True
True
A reposta da operação lógica not é o inverso do operando. Se o operado
for True a reposta é False, se o operando for False a resposta é
True:
Tabela verdade do operador not
A
not A
False
True
True
False
Bloco de comandos
Um bloco de comandos é uma sequência de uma ou mais instruções indentadas com o mesmo número de espaços. Uma instrução pode ser uma instrução primitiva, uma repetição, uma execução condicional, ou uma função definida pelo usuário.
Novas funções
A palavra reservada def é usada para definir novas funções. A forma geral
para definição de novas funções é:
[sourcecode language="python"] def identificador(bot): bloco [/sourcecode]
Exemplo da definição da função vire_a_direita:
[sourcecode language="python"] def vire_a_direita(bot): vire_a_esquerda(bot) vire_a_esquerda(bot) vire_a_esquerda(bot) [/sourcecode]
Repetição
Em geral, existem dois tipos de repetição. A primeira é quando o número de vezes é conhecido. A segundo é quando se deseja repetir o processo até que uma condição mude.
O comando for é utilizado para repetição com número fixo de vezes. A forma
geral do comando for é:
[sourcecode language="python"] for i in range(0, número_de_vezes): bloco [/sourcecode]
Por exemplo, queremos fazer um progobot avançar 6 casas. Neste caso conhecemos
o número de vezes, e portanto usamos o comando for:
[sourcecode language="python"] for i in range(0, 6): avance(bot) [/sourcecode]
O comando while é utilizado para fazer uma repetição até que uma condição
mude. A forma geral do comando while é: [sourcecode language="python"] while
condição: bloco [/sourcecode]
Se quisermos fazer um progobot avançar até a parede, o comando for não é
adequado, visto que não sabemos quantos vezes devemos repetir o comando
avance. Neste caso devemos usar o comando while:
[sourcecode language="python"] while frente_esta_livre(bot): avance(bot) [/sourcecode]
Execução condicional
Muitas vezes é necessário executar comandos diferentes dependendo de uma ou mais condições. Por exemplo, um progobot tem que sair de uma sala, sendo que a porta de saída pode estar a sua frente, a direita ou a esquerda. Neste caso, as ações que o progobot tem que realizar dependem do lugar da saída. Dissemos que o progobot tem que realizar uma execução condicional.
O comando if é utilizado para expressar execuções condicionais. A forma geral
do comando if é:
[sourcecode language="python"] if condição: bloco elif condição: bloco ... elif condição: bloco else: bloco [/sourcecode]
O exemplo a seguir faz o progobot sair por uma porta que pode estar a sua frente, a direita ou a esquerda:
[sourcecode language="python"] if frente_esta_livre(bot): avance(bot) elif direita_esta_livre(bot): vire_a_direita(bot) avance(bot) else: vire_a_esquerda(bot) avance(bot) [/sourcecode]
Exemplo completo
O programa a seguir faz um progobot que está no cruzamento 1 1, virado para o leste, dar uma volta ao mundo e voltar a posição inicial.
[sourcecode language="python"] from progobots import * def avance_ate_a_parede(bot): while frente_esta_livre(bot): avance(bot) def de_uma_volta_no_mundo(bot): for i in range(0, 4): avance_ate_a_parede(bot) vire_a_esquerda(bot) bot = Progobot() de_uma_volta_no_mundo(bot) [/sourcecode]
