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 é:

def identificador(bot):
    bloco

Exemplo da definição da função vire_a_direita:

def vire_a_direita(bot):
    vire_a_esquerda(bot)
    vire_a_esquerda(bot)
    vire_a_esquerda(bot)

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 é:

for i in range(0, número_de_vezes):
    bloco

Por exemplo, queremos fazer um progobot avançar 6 casas. Neste caso
conhecemos o número de vezes, e portanto usamos o comando
for:

for i in range(0, 6):
    avance(bot)

O comando while é utilizado para fazer uma repetição até
que uma condição mude. A forma geral do comando while é:

while condição:
    bloco

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:

while frente_esta_livre(bot):
    avance(bot)

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 é:

if condição:
    bloco
elif condição:
    bloco
...
elif condição:
    bloco
else:
    bloco

O exemplo a seguir faz o progobot sair por uma porta que pode estar
a sua frente, a direita ou a esquerda:

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)

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.

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)

Os comentários estão encerrados.