Projeto de MAC-211 -- 2009
Protetores do Espaço Sideral 2: A Missão

Fabio Kon - Marcelo Reis

Introdução

O objetivo deste projeto é o desenvolvimento de um programa composto de várias partes (módulos), ao longo do semestre. O projeto será desenvolvido em ambiente PC/Linux por grupos de 1 a 3 alunos. Os módulos serão construídos ao longo de 3 fases, com uma fase adicional para a ``amarração'' e construção do programa final.

Na avaliação, serão consideradas a documentação, organização e elegância do código, além do seu funcionamento de forma correta. Os módulos devem ser tão independentes quanto possível e a comunicação entre eles só deverá ser feita através de interfaces bem definidas. Deve-se evitar promiscuidades como, por exemplo, o compartilhamento de variáveis globais entre funções em módulos diferentes. Aliás, variáveis globais deveriam ser proibidas por lei :-)

Simulação de Corpos Celestes

Nos capítulos anteriores...

A vida no planeta Terra está ameaçada por uma chuva de asteróides que cairá no século XXIX. Uma estação espacial é incumbida de destruir asteróides com risco de colisão com a Terra. Graças aos esforços dos alunos de MAC211 de 2002, a estação foi bem sucedida no início de sua árdua missão de proteger o nosso planeta de tal ameaça.

Situação atual

Todavia, a estação espacial demanda como combustível um raro cristal, denominado dilítio. Tal minério é encontrado somente em remotas regiões do Sistema Solar, que infelizmente são infestadas de asteróides. Duas pequenas espaçonaves, pilotadas por Kirk e por Spock, partem da estação espacial rumo ao cinturão de asteróides, com a missão de coletarem a maior quantidade possível de dilítio.

A Missão

O projeto, portanto, consiste em construir um jogo, para dois jogadores, onde cada um controla uma das duas espaçonaves (uma de cada cor) e ambos têm a tarefa de recolher a maior quantidade possível de cristais. Os jogadores devem se desviar dos perigosos asteróides ou então destruí-los: para isso cada espaçonave está equipada com um poderoso phaser e com um campo esférico desintegrador, de antimatéria.

Cada jogador controla a sua nave pressionando determinadas teclas, sendo que as teclas de cada jogador ficam nas extremidades opostas do teclado. São elas:

• Quatro teclas para a movimentação da nave:
  • uma tecla para propulsão e outra para freio (com simulação física);
  • duas teclas para girar no sentido horário e anti-horário (sem simulação física, i.e., gira numa taxa fixa para cada aperto de tecla).
• Uma tecla para disparar o phaser.
• Uma tecla para acionar o campo de força.

As principais partes do programa são as seguintes:

• Simulação do espaço sideral
• Apresentação gráfica
• Tratamento da entrada do usuário
• Simulação do movimento das espaçonaves, dos cristais e dos asteróides
• Jogo propriamente dito, incluindo a contagem dos pontos

Estas partes serão desenvolvidas nas etapas descritas nas próximas seções.

O programa dependerá de diversas constantes (por exemplo, os limites máximo e mínimo para a velocidade e a massa dos asteróides e dos cristais). Estas constantes deverão ser definidas como tal no programa, de modo a ser fácil o ajuste para se obter um jogo mais realista. Isto pode ser feito em C com o pré-processador. Veja a diretiva #define.

Primeira Fase: Simulação do Espaço

O que o usuário verá na tela é uma seção do espaço, com os asteróides e os cristais "passeando" pela mesma.

Nesta primeira fase, o espaço sideral será representado através de uma saída baseada apenas em texto, com uma "resolução" de 120x30 "pixels" (na verdade, 120x30 caracteres). Ou seja, você irá imprimir a saída usando funções como, por exemplo, printf. Eis aqui um exemplo de saída:

..........................*..................................#..........................................................
........!......................................................................*.......................................@
......................................@.................................................................................
.....@..................................................................@.................#.............................
...............................................................................................................@........
.........................#..................@....................&......................................................
#.......................................................................................................................
.......................................................*................................................................
........................................................................................!................#..........@...
......................................................&.......................@..................................*......
..........................*..................................#..........................................................
........!......................................................................*........................................
......................................@.................................................................................
.....@..................................................................@.................#.............................
.....................................................................................................#..................
................&...........................@.................................!.........................................
........................................................................................................................
...............................................................................&........................................
........................................................................................!.............#.......@.........
......................................................*.........................................*.....................*.
..........................*..................................#..........................................................
........!......................................................................*........................................
......................................@.................................................................................
.....@..................................................................@.................#.............................
.....................................................................................................................#..
.........................*..................@.................................&.........................................
........................................................................................................................
.......................................................*..................................................#.............
........................................................................................!...............#.......@.......
......................................................*.......................@...............................*.........

Nesta fase, o seu programa deverá gerar várias fotos instantâneas do espaço a intervalos de tempo fixos (por exemplo, uma foto por segundo). Note que não é necessário fazer isso em tempo real, ou seja, o seu programa pode jogar para a saída de uma vez, 100 fotos representando 100 segundos da simulação.

O programa deve ser capaz de gerar asteróides e cristais, que surgem de alguma borda da tela com massa, velocidade e direção iniciais aleatórias. No início do jogo, é gerado um número fixo de asteróides e de cristais (digamos 60). A partir desse ponto, quando um objeto "sai" da tela (ou seja, quando passa por alguma borda), esse é descartado e um novo objeto do mesmo tipo surge em alguma borda, também com massa, velocidade e direção aleatórias. Além disso, de tempos em tempos novos asteróides e cristais são adicionados, até que seja atingindo um limite máximo de objetos na tela.

Asteróides e cristais de maior massa devem ser representados na tela com um número maior de "pixels" (nesta fase inicial, como tudo será representado como texto, você pode usar caracteres diferentes para representar objetos com massas diferentes). As características dos asteróides e dos cristais devem ser geradas levando-se em consideração:

• massa: um valor entre 1 e 10Kg;
  
  
• velocidade: dentro de uma faixa de valores a ser definida por você de forma que não inviabilize o jogo, ou seja, não pode ser um valor muito baixo (que torna o jogo muito fácil) tampouco muito elevado (que dificulta a simulação e torna o jogo muito difícil). Resumindo, cada asteróide ou cristal gerado tem uma posição inicial (x0,y0) e um vetor de velocidade (vx,vy). Sua posição (x,y) é atualizada uma vez por segundo, utilizando seu respectivo vetor de velocidade.
  
  
• colisão: quando dois asteróides e/ou cristais se colidem, seus respectivos vetores de velocidades devem ser atualizados, de acordo com as leis da mecânica clássica.

Nesta primeira fase, para simplificar, não será necessário desenhar as espaçonaves. Outra simplificação é o número de asteróides e de cristais: para esta fase, devem existir na tela até 100 deles simultaneamente.

Algumas recomendações muito importantes:

• Procure separar seu código de acordo com a funcionalidade. Por exemplo, as rotinas que recalculam a posição, a velocidade e a direção dos objetos devem ser as mesmas tanto para os cristais e os asteróides quanto para as naves. O procedimento que redesenha a tela deve chamar essas rotinas diversas vezes, e não precisa se basear em nenhum detalhe das rotinas que realizam os cálculos a não ser a forma da chamada (cabeçalho).

• Quebre seu programa em vários arquivos, cada um com um conjunto de funções relacionado. Por exemplo, um arquivo para as funções relativas ao desenho na tela usando texto, um arquivo para as funções relativas à simulação do espaço sideral, um arquivo para a inicialização e a função main() e assim por diante.

Geração dos Asteróides e dos Cristais

Os asteróides e cristais serão gerados aleatoriamente com base em uma semente que poderá ser fornecida pelo usuário na linha de comando ou obtida a partir do tempo do sistema. Para gerar números aleatórios, você pode usar a função int rand() e, neste caso, para inicializar o gerador de números pseudo-aleatórios você deve usar a função srand(unsigned int seed). O protótipo de ambas é definido em stdlib.h.

A freqüência média de geração dos asteróides e dos cristais e a velocidade média com a qual eles são gerados deverão ser passados como argumentos ao programa; se o usuário não fornecer esses argumentos, valores default serão utilizados.

Testes Automatizados

É sempre muito importante realizar testes para verificar se o seu programa está implementado corretamente. Nesta primeira fase, além de escrever o programa que gera a simulação, você deverá também escrever um programa que realiza uma série de testes para verfificar se a sua implementação está correta. Faça um pequeno programa que chame seu simulador sob diversas condições e avalie os resultados.

Alguns pontos que devem ser testados:

1. Robustez: o programa sobrevive em condições especiais, como número de asteróides e de cristais muito grande ou muito pequeno ou velocidade muito próxima de zero? O que acontece se dois asteróides/cristais se chocam um com o outro?
   
   
2. Correção: o programa detecta corretamente o choque entre dois asteróides/cristais? Monte essa situação veja se o seu código detecta as colisões corretamente.
   
   
3. Variações: uma função deverá executar uma simulação por t segundos e medir a velocidade máxima, mínima e média dos asteróides e dos cristais e apresentar um relatório para análise, informando o valor das constantes utilizadas, o valor de t e os resultados medidos. Se quiser caprichar, pode calcular também o desvio padrão.

As funções de teste devem estar em um arquivo separado. Você pode entregar duas versões da função main: uma que simplesmente mostra na tela a simulação de 30 segundos e outra que realiza testes de robustez, correção e imprime um relatório das variações (como descrito acima).

Data de entrega