Pontifícia Universidade Católica do Rio Grande do Sul
Faculdade de Informática — Laboratório de Programação II

Trabalho 2 - 2016/2

Data de Entrega: 23/11/2016

Simulação de Comportamento de Robôs

1 Enunciado

O objetivo do trabalho é programar robôs com comportamentos variados. Os robôs tentam achar a saída de um labirinto como o da figura abaixo:
figure maze.png

1.1 Robôs

Quando instanciado, um robô recebe no seu construtor a posição inicial, o ponteiro para um labirinto e a quantidade máxima de passos admitida para tentar sair do labirinto.
Todos os robôs devem ser derivados de uma superclasse abstrata chamada Robo, a qual define alguns métodos que devem ser reimplementados: 
class Robo
{
	public:

	Robo(const Point& posIni, Labirinto* lab, int maxSteps);
	virtual void draw() = 0;
	void move(const Point& pos) { this->pos = pos; }
	virtual void generateSteps() = 0;
	vector<Point> getSteps() { return steps; }

	protected:

	Point posIni;
	Labirinto* lab;
	int maxSteps;
	vector<Point> steps;
};
A idéia é criar robôs que tentem sair do labirinto. Para tanto, devem ser implementadas pelo menos duas subclasses de Robo, cada uma com características diferentes:
Para cada tipo de robô, você deve alterar o código do método draw correspondente, para modificar a figura utilizada no desenho do robô.
A classe RoboB9 implementa um robô cujo movimento é aleatório: use ela para ter dicas de como implementar as funcionalidades das demais.

1.2 Labirinto

Assim como os robôs, um labirinto é definido pela classe abstrata Labirinto: 
class Labirinto
{
	public:

	virtual bool isEmpty(const Point& ponto) = 0;
	virtual int getWidth() = 0;
	virtual int getHeight() = 0;
	virtual int getRobot() = 0;
	virtual Point getIniPos() = 0;
	virtual void loadMaze(string arquivo) = 0;
};
Portanto, você deve criar uma classe que implemente os métodos em Labirinto. Isso é necessário para que o labirinto possa ser desenhado corretamente pela interface gráfica (ver abaixo).
O labirinto em si é carregado a partir de um arquivo texto com o seguinte formato: 
dim 9 9 // dimensões do labirinto: linhas x colunas
pos 1 1 // coordenadas iniciais do robo (x,y)
robo 1  // tipo do robo: C3-PO (1), R2-D2 (2) ou WALL-E (3)
*********
*     * *
* ***** *
* * *   *
* * *** *
*   *   *
*** * * *
*     * *
******* *
Observe que após as informações numéricas vem o desenho do labirinto, feito com * e espaços em branco.
A classe LabirintoTeste implementa um labirinto de teste, que tem apenas paredes nas laterais e uma saída na parte de baixo.

1.3 Interface Gráfica

Para tornar o trabalho mais interessante, está sendo disponibilizada uma classe denominada GL, que implementa uma visualização gráfica do labirinto através de OpenGL. A classe GL deve ser empregada da seguinte forma:
O programa principal inicia com a chamada ao método GL::init, que tem a função de inicializar a biblioteca gráfica e criar a janela da aplicação.
Depois, uma vez realizada a criação dos objetos robô e labirinto, deve ser chamado o método GL::setLabirintoRobo, passando-se como parâmetros o labirinto (ponteiro para um objeto que estenda a classe abstrata Labirinto) e o robô (ponteiro para um objeto que estenda a classe Robo): 
GL::setLabirintoRobo(lab, robo);
A seguir, deve ser chamado o método loop, que não retorna: 
GL::loop();
A partir desse ponto, toda a interação se dá através da classe GL: você NÃO deve chamar os métodos da classe GL de outros pontos do programa.
A interface gráfica chama automaticamente os métodos generateSteps, draw e getSteps do robô desejado, de forma que a interação se dá através dos seguintes comandos:
Note também que não se deve criar uma instância de GL para utilizá-la: os métodos são todos static, o que é uma exigência da biblioteca gráfica.
Em resumo, suas tarefas são:
Veja abaixo o resultado do programa de exemplo, que usa uma classe LabirintoTeste.
figure tela.jpg
O zip robos-base.zip contém todos os arquivos mencionados anteriormente, bem como alguns exemplos de labirinto. Há um projeto para Linux, e outro para Windows, que inclui as bibliotecas necessárias. Se você estiver utilizando uma máquina pessoal, instale os pacotes freeglut3-dev e libjpeg8-dev (no Ubuntu).

2 Critérios de Avaliação

Leia com atenção os critérios de avaliação:

2.1 Funcionamento

2.2 Código

2.3 Entrega