malbarbo.pro.br

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:

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 respostas 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 resposta 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 resposta 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 resposta 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 resposta da operação lógica not é o inverso do operando. Se o operado for True a resposta é 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)