VenusPapaMoscas
SeInimigo 4
esquerda
VaPara 1
infecte
VaPara 1

A Vênus Papa-Moscas fica parada em um lugar e gira. Ela infecta quanquer coisa que esteja na sua frente.

Na sua implementação, você deve usar as seguintes constantes para controlar a operação do seu programa:
/* 
 * Constants 
 * --------- 
 * Nlinhas		Número de linhas no mundo Darwin 
 * NColunas         	Número de colunas 
 * MaxEspecies       	Número máximo de diferentes espécies 
 * MaxCriaturas     	Número máximo de criaturas individuais 
 * MaxPrograma         Tamanho máximo do programa da criatura(em linhas) 
 * ContagemInicial      Número inicial de criaturas por espécie. 
 
 */ 
#define  Nlinhas           15 
#define  NColunas        15 
#define  MaxEspecies      10 
#define  MaxCriaturas   100 
#define  MaxPrograma     250 
#define  ContagemInicial    10

/* 
 * Arquivo: geometria.h 
 * ---------------- 
 * Esta interface fornece alguns tipos extremamente simples 
 * e operações que são úteis para a manipulação dos pontos 
 * numa grade x-y 
 */ 
#ifndef _geometria_h 
#define _geometria_h 
 
/* 
 * Tipo: pontoT 
 * ------------ 
 * O tipo pontoT é usado para encapsular um par de coordenadas 
 * em um único valor. 
 */ 
typedef struct { 
    int x, y; 
} pontoT; 
/* 
 * Tipo: direcaoT 
 * ---------------- 
 * Este tipo é um exemplo de uma “enumeração” em C. Os 
 * valores do tipo enumeração são simplesmente constantes listadas entre 
 * chaves após a palavra reservada enum. Desta forma, uma variável 
 * do tipo direcaoT pode assumir um dos 4 valores Norte, Leste, 
 * Sul e Oeste. 
 */ 
typedef enum { Norte, Leste, Sul, Oeste} direcaoT; 
/* 
 * Função: CriaPonto
 * Uso: pt = CriaPonto(x, y); 
 * ------------------------------ 
 * Esta função combina as coordenadas x e y em uma estrutura
 *  pontoT e retornar este valor. 
 */ 
pontoT CriaPonto(int x, int y); 
/* 
 * Função: PontoAdjacente 
 * Uso: novopt = PontoAdjacente(pt, dir); 
 * -------------------------------------- 
 * Esta função retorna o pontoT que resulta do movimento de um 
 * quadrado na direção indicada de pt. 
 */ 
pontoT PontoAdjacente(pontoT pt, direcaoT dir); 
/* 
 * Funções: VirarParaEsquerda, VirarParaDireita 
 * Uso: novadir = VirarParaEsquerda(dir); 
 *        novadir = VirarParaDireita(dir); 
 * ------------------------------- 
 * Estas funções retornam as direções que resultam do ato de virar
 * para esquerda ou para direita a partir de uma direção incial. 
 */ 
direcaoT VirarParaEsquerda(direcaoT dir); 
direcaoT VirarParaDireita(direcaoT dir); 
#endif

/* 
 * File: mundo.h 
 * ------------- 
 * Esta interface define uma abstração que pode ser usada 
 * para armazenar objetos em um mundo cartesiano x/y. Esta abstração 
 * é completamente independente do display gráfico e o cliente 
 * é responsável por qualquer atualização da tela que seja necessária. 
 */ 
#ifndef _mundo_h 
#define _mundo_h 
#include "geometria.h" 
/* 
 * Tipo: mundoTAD 
 * -------------- 
 * Este tipo abstrato armazena os dados de um mundo que é definido 
 * como uma grade bidimensional capaz de armazenar 
 * objetos arbitrários representados como ponteiros, cujo tipo é 
 * compreendido apenas pelo cliente. 
 */ 
typedef struct worldCDT *mundoTAD; 
/* 
 * Função: NovoMundo
 * Uso: mundo = NovoMundo(comprimento, altura); 
 * --------------------------------------- 
 * Esta função cria um novo mundo que consiste de comprimento 
 * colunas e altura linhas, cada uma das quais numeradas a partir de zero. 
 * Um mundo recém criado não possui nenhum objeto. 
 */ 
mundoTAD NovoMundo(int comprimento, int altura); 
/* 
 * Função: LiberaMundo 
 * Uso: LiberaMundo (mundo); 
 * ------------------------ 
 * Esta função libera todo armazenamento associado com um mundo. 
 */ 
void LiberaMundo ( mundoTAD mundo); 
/* 
 * Funções: ComprimentoMundo, AlturaMundo
 * Uso: comprimento = ComprimentoMundo(mundo); 
 *        altura = AlturaMundo(mundo); 
 * ----------------------------------- 
 * Esdtas funções retornam o comprimento e a altura de um mundo, 
 * respectivamente. 
 */ 
int ComprimentoMundo( mundoTAD mundo); 
int AlturaMundo( mundoTAD mundo); 
/* 
 * Função: Dentro 
 * Uso: if (Dentro(mundo, pt)) . . . 
 * ------------------------------------ 
 * Esta função retorna  1 se o ponto especificado 
 * está dentro dos limites do mundo . 
 */ 
int Dentro( mundoTAD mundo, pontoT pt); 
/* 
 * Função: FixaConteudo 
 * Uso: FixaConteudo(mundo, pt, obj); 
 * ----------------------------------- 
 * Esta função coloca o objeto no mundo 
 * na posição indicada por pt. 
 */ 
void FixaConteudo( mundoTAD mundo, pontoT pt, void *obj); 
/* 
 * Função: ObtemConteudo 
 * Uso: obj = ObtemConteudo (mundo, pt); 
 * ------------------------------------ 
 * Esta função retorna o objeto atualmente no mundo 
 * na posição pt. 
 */ 
void *ObtemConteudo( mundoTAD mundo, pontoT pt); 
 
#endif

/* 
 * File: especies.h 
 * --------------- 
 * Esta interface define a abstração especies. 
 */ 
#ifndef _especies_h 
#define _especies_h 
 
/* 
 * Type: especiesTAD 
 * ---------------- 
 * Este é o tipo abstrato de dados para as espécies. 
 */ 
typedef struct especiesCDT *especiesTAD; 
/* 
 * Tipo: opcodeT 
 * ------------- 
 * O tipo opcodeT é uma enumeração dos comandos válidos .
 */ 
typedef enum { 
    frente, esquerda, direita, infecta, 
    SeVazio, SeBorda, SeIgual, SeInimigo, SeAleatorio, 
    VaPara 
} opcodeT; 
 
 
/* 
 * Tipo: instrucaoT 
 * ------------------ 
 * O tipo instrucaoT é usado para representar uma instrução 
 * e consiste de um par de um código de operação e um inteiro. 
 */ 
typedef struct { 
    opcodeT op; 
    int endereco; 
} instrucaoT; 
 
/* 
 * Função: LerEspecies 
 * Uso: especies = LerEspecies(nomearquivo); 
 * --------------------------------------- 
 * Esta função lê para uma nova espécie a partir de um arquivo específico. 
 * Para encontrar o arquivo, a função procura em um subdiretório denominado 
 * "Criaturas". Se não existe um arquivo com o nome indicado 
 * naquele subdiretório, a função retorna NULL. 
 */ 
especiesTAD LerEspecies(string nomearquivo); 
/* 
 * Função: NomeEspecies 
 * Uso: nome = NomeEspecies(especies); 
 * ----------------------------------- 
 * Esta função retorna o nome de uma espécie existente. 
 */ 
char * NomeEspecies(especiesTAD especies); 
/* 
 * Função: TamanhoPrograma 
 * Uso: nPassos = TamanhoPrograma(especies); 
 * ------------------------------------- 
 * Esta função retorna o número de instruções no programa 
 * para aquela espécie. 
 */ 
int TamanhoPrograma(especiesTAD especies); 
/* 
 * Função: PassoPrograma 
 * Uso: comando = PassoPrograma(especies, k); 
 * ------------------------------------------- 
 * Esta função retorna a  k-ésima instrução no programa para 
 * aquela espécie, sendo os passos numerados no início a partir de 1. 
 * Atente que selecionar uma instrução fora da faixa do programa 
 * gera um erro. 
 */ 
instrucaoT PassoPrograma(especiesTAD especies, int k); 
 
#endif

/* 
 * Arquivo: criatura.h 
 * ---------------- 
 * Esta interface define a abstração de criatura. 
 */ 
#ifndef _criatura_h 
#define _criatura_h 
#include "geometria.h" 
#include "especies.h" 
#include "mundo.h" 
/* 
 * Tipo: criaturaTAD 
 * ----------------- 
 * Este tipo é o tipo abstrato de dados para criatura. 
 */ 
typedef struct criaturaCDT *criaturaTAD; 
/* 
 * Função: NovaCriatura 
 * Uso: criatura = NovaCriatura(especies, mundo, pt, dir); 
 * ------------------------------------------------------- 
 * Esta função cria uma nova criatura da espécie indicada 
 * que vive no mundo específico. A criatura é incialmente 
 * posicionada na posição pt olhando para a direção dir. 
 */ 
criaturaTAD NovaCriatura(especiesTAD especies, mundoTAD mundo, 
                         pontoT pt, direcaoT dir); 
/* 
 * Função: ObtemEspecies 
 * Uso: especies = ObtemEspecies(criatura); 
 * -------------------------------------- 
 * esta função retorna as espécies à qual esta criatura 
 * pertence. 
 */ 
especiesTAD ObtemEspecies(criaturaTAD criatura); 
/* 
 * Função: ExecutaUmaVez 
 * Uso: ExecutaUmaVez(criatura); 
 * ----------------------------- 
 * Esta função executa um vez para esta criatura. 
 */ 
void ExecutaUmaVez(criaturaTAD criatura); 
 
#endif

/* 
 * Arquivo: mapamundi.h 
 * ---------------- 
 * Esta interface suporta a apresentação do mundo darwin. 
 */ 
#ifndef _mapamundi_h 
#define _mapamundi_h 

#include "geometria.h" 
/* 
 * Função: IniciaMapaMundi 
 * Uso: IniciaMapaMundi(colunas, linhas); 
 * ----------------------------------- 
 * Esta função abre e mostra uma janela na tela. A chamada a esta função 
 * deve ser feita antes de qualquer outra chamada 
 * e antes de qualquer saída para os canais de E/S padrão. Os parâmetros 
 * colunas e linhas especificam o tamanho do mundo, embora 
 * alguns quadrados possam ficar fora da tela visível se o 
 * mundo for muito grande. 
 */ 
void IniciaMapaMundi(int colunas, int linhas); 
/* 
 * Função: MostraQuadrado 
 * Uso: MostraQuadrado(qd, letrachave, dir); 
 * --------------------------------------- 
 * Esta função muda o desenho da tela para o quadrado indicado 
 * (cuja posição é expressa por um ponto) de tal modo
 * que ele contenha uma criatura indicada pelo caractere letrachave ,
 * olhando para a direção especificada por dir. Se a letrachave é um 
 * espaço, o quadrado é mostrado como vazio e a direção 
 * é ignorada. 
 */ 
void MostraQuadrado(pontoT qd, char letrachave, direcaoT dir); 

#endif

O arquivo .ttf deve ser posto no mesmo diretório do seu programa executável, para permitir a renderização correta das letras das criaturas.