Projeto de MAC211 -- 2010
Náufragos

Fabio Kon - Marcelo Reis

Nos capítulos anteriores....

Segunda Fase: Visualização Gráfica

Agora que a geração dos passageiros está funcionando, vamos apresentá-los em uma janela gráfica, no gerenciador de janelas de sua preferência (Gnome, KDE, Xwindows, etc.); ou seja, você deverá adaptar o código que escreveu na fase anterior para que o mesmo utilize elementos gráficos ao invés de usar caracteres em modo texto, na representação do oceano, dos passageiros, dos recifes de corais, da R.M.S. Asimov e dos botes. Além disso, você deve fazer a sua simulação ser executada em tempo real: ou seja, os botes e os passageiros devem se movimentar na tela com o passar do tempo numa velocidade "razoável". Assim, 1 segundo simulado será bem próximo de 1 segundo do tempo real (aquele tempo que o seu relógio de pulso mostra). Você ainda não precisa se preocupar com o controle dos botes nem com a interação com o usuário: esses aspectos serão desenvolvidos na próxima fase.

Passageiros e os recifes de corais

Cada passageiro será representado por um quadrado ou círculo na tela; se quiser, você pode usar formas irregulares para dar mais realismo ao formato dos objetos, mas é desejável que seu formato sempre se aproxime de um quadrado ou de um círculo. Não use um formato muito esdrúxulo pois isso dificultará a detecção de colisões.

O número de pixels que representam cada passageiro na tela poderá ser constante, embora, se você preferir, poderá variar um pouco, para distinguir adultos de crianças, gordinhos de magrinhos, etc.

Agora o número de pixels os recifes de corais deve variar de acordo com a extensão do mesmo, mas deve sempre ser próximo ao valor D, que deve ser uma constante definida no programa (ou seja, corais de tamanho "médio" são representados com D pixels, corais "grandes" com mais de D pixels, e corais "pequenos", com menos de D pixels). Inicialmente o valor de D será 10, mas poderá ser alterado em função da resolução e da velocidade do programa final. Fica a seu critério escolher valores para as constantes de forma a favorecer a "jogabilidade" do seu jogo.

Importante: observe que não modelamos os recifes na primeira fase: para o tratamento das colisões, tanto dos botes quanto dos passageiros, considerem que os recifes são uma "parede", e que a colisão contra eles (ao menos nesta fase) é totalmente elástica. Cada grupo fique à vontade para especificar como os recifes são gerenciados pelas EDs / rotinas do jogo.

R.M.S. Asimov e os botes

A R.M.S. Asimov pode ser desenhada em algum ponto aleatório da tela, ou então em algum canto, caso você ache que colocá-la no meio da tela possa afetar a jogabilidade futura. O navio precisa ser grande o bastante para claramente o distinguir dos botes, porém não tão grande a ponto de comprometer o jogo. O navio, para todos os efeitos, não se move em relação à janela de jogo.

Os botes deverão ser representados por triângulos isósceles, uma de cada cor; o tamanho dos botes deve ser maior que o tamanho do maior dos passageiros, porém não muito maior ("licença poética" para não inviabilizar o jogo). Um dos lados do triângulo é a popa do bote, portanto a proa é o vértice oposto.

A implementação do controle dos botes ficará para a próxima fase; por hora, vamos apenas simular a movimentação dos barquinhos pelo oceano. A simulação será feita da seguinte forma:

• Os dois botes são inicializados em algum canto da tela, com velocidade e direção aleatórias;
  
  
• Se um bote "se choca" com um passageiro, esse é recolhido e removido do jogo;
  
  
• Se um bote se choca contra um recife, ocorre um dos dois eventos, de acordo com uma probabilidade arbitrada por você:
  • o bote "encalha" e o mesmo deve ser reinicializado em alguma borda da tela, com velocidade e direção aleatórias;
    
  • o bote sofre uma colisão elástica e segue normalmente no jogo.
    
  
  
  
• Caso ambos os botes se colidam, há um choque elástico com a simulação física apropriada baseada nas velocidades vetoriais de cada bote. Pode-se supor que ambos possuem a mesma massa;
  
  
• Se um bote, ao se movimentar, se chocar com uma borda da tela ou contra a R.M.S. Asimov, o mesmo não é avariado e há um choque elástico com a simulação física apropriada baseada na sua velocidade vetorial;
  
  
• (opcional para esta fase) Implementar a aceleração e frenagem dos botes, testando com chamadas aleatórias dessas funcionalidades; a implementação precisa contar com simulação física;
  
  
• (opcional para esta fase) Implementar o deslocamento lateral dos botes (i.e., mover o bote a bombordo ou a estibordo, testando com chamadas aleatórias dessas funcionalidades; a implementação não precisa contar com simulação física (i.e., os botes viram em uma taxa fixa); quem quiser pode também oferecer a opção da simulação física para o movimento, como item "opcional do opcional".
  
  

Biblioteca Gráfica

Os desenhos e a animação serão feitos com base na biblioteca Allegro. Trata-se de uma biblioteca bastante abrangente, voltada para o desenvolvimento de jogos 2D em C/C++; a biblioteca não só conta com recursos gráficos, como também de som, gerenciamento de teclado, mouse e joysticks, etc. Veja abaixo a seção Allegro.

Lembretes

• Você deverá trabalhar com uma janela (seção do oceano) com uma resolução de 1024x768 pixels. Se desejar (e seu computador permitir, o que deve ser o caso para quem não tenha nada parecido com um 486 :-) você pode trabalhar com uma resolução maior, desde que mantenha como alternativa trabalhar também em 1024x768.
  
  
• As figuras dos botes devem ser atualizadas, no mínimo, 10 vezes por segundo; já as figuras dos passageiros, que são mais lentas que as naves, devem ser atualizadas no mínimo 1 vez por segundo. As figuras da R.M.S. Asimov e dos corais, é claro, são fixas.
  
  
• Para garantir uma boa velocidade nas funções de desenho, procure não desenhar pixel por pixel, mas sim retângulos, polígonos ou círculos diretamente, usando as funções da biblioteca, que são descritas na seção abaixo.
  
  
• Coloque as funções de desenho em um arquivo à parte. Procure também ter um arquivo separado dedicado à animação.

Biblioteca Allegro

Esta seção apresenta um pequeno resumo das funções da Allegro. Para mais detalhes, veja a página oficial da biblioteca, no SourceForge, especialmente os tutoriais que ensinam como utilizar as funções gráficas.

Seguem abaixo algumas instruções para se dar o pontapé inicial na utilização desta biblioteca.

Inicialização e finalização.

Para inicializar a biblioteca, use a função:

• int allegro_init();
  Ela devolve zero se a biblioteca for inicializada com sucesso. Ela deve ser chamada antes de qualquer outra coisa, apenas uma vez.

• void set_color_depth(int depth);
  Esta função define o número de cores; depth pode receber os valores 8, 15, 16, 24 e 32. ela deve ser chamada após a inicialização da biblioteca Allegro e antes de set_gfx_mode.

• int set_gfx_mode (int CARD, int W, int H, int V_W, int V_H);
  Esta função incializa o modo gráfico, utilizando a placa de vídeo CARD (inicialmente teste com GFX_AUTODETECT), com largura W e altura H. V_W e V_H são utilizados caso você queira trabalhar com uma tela virtual; no nosso caso, pode-se deixar ambos os parâmetros como 0. Após a chamada da função, a janela é criada e apresentada; ela deve ser chamada após a inicialização da biblioteca Allegro e da definição do número de cores.

Para encerrar e liberar os recursos alocados, use:

• void allegro_exit();
  Termina o processamento, libera memória e demais recursos.

Bitmaps

A Allegro trabalha com objetos do tipo BITMAP. Bitmaps são matrizes de pixels, onde cada pixel representa uma cor. A tela é um tipo especial de BITMAP, chamado screen. Para alocar um objeto do tipo BITMAP:

• BITMAP *meu_bitmap = (* BITMAP) create_bitmap(int width, int height);
  create_bitmap devolve NULL caso não tenha sido possível alocar o objeto.

Para desalocar um objeto do tipo BITMAP:

• void destroy_bitmap(BITMAP *meu_bitmap);
  O comando destroy_bitmap desaloca a memória utilizada pelo objeto.

Desenhando

Dado um objeto do tipo BITMAP, você pode criar figuras nele; seguem abaixo algumas das várias funções de desenho:

• void putpixel(BITMAP *meu_bitmap, int x, int y, int cor);
  Desenha um pixel de cor cor em meu_bitmap, nas coordenadas (x,y).

• void line(BITMAP *meu_bitmap, int x1, int y1, int x2, int y2, int cor);
  Desenha uma linha de cor cor em meu_bitmap, de (x1,y1) até (x2,y2).

• void circle(BITMAP *meu_bitmap, int x, int y, int raio, int cor);
  Desenha uma circunferência de cor cor em meu_bitmap, com centro em (x,y) e raio raio.

• void blit(BITMAP *fonte, BITMAP *dest, int fonte_x, int fonte_y, int dest_x, int dest_y, int larg, int alt);
  Copia um quadrado de largura larg e altura alt, nas coordenadas (fonte_x, fonte_y) do bitmap fonte para as coordenadas (dest_x, dest_y) do bitmap dest.

A biblioteca Allegro oferece muitas outras funções além das aqui descritas, incluindo mais funções de desenho, manipulação de paleta de cores, de fontes, etc. Existem diversos tutoriais (inclusive em português) e exemplos pela Internet que as explicam em detalhes.

Download da biblioteca

Tempo Real

Para controle do tempo real você poderá utilizar a seguinte função POSIX:

#include <time.h> 
int nanosleep(const struct timespec *requested, struct timespec *remaining);

Nesta fase do projeto, você pode iniciar o desenvolvimento gerando uma "foto" ou quadro por segundo, chamando a função nanosleep para dormir 1 bilhão de nanosegundos entre um quadro e outro. Depois que o seu programa estiver funcionando bem, você deve reconfigurá-lo para gerar 10 quadros por segundo para dar impressão de movimento (dormindo 100 milhões nanosegundos entre um quadro e outro). Lembre-se que 10 quadros por segundo é o número mínimo de vezes necessário que você deve redesenhar os botes (os passageiros, que se movem mais lentamente, podem ser atualizados pelo menos 1 vez por segundo). Se o programa estiver funcionando muito bem, você pode ainda tentar 30 quadros por segundo, que é uma taxa comumente utilizada em vídeos e jogos.

Otimização do Joguinho:

Para medir o tempo gasto no processamento de cada quadro, você pode usar, por exemplo:

   #include <sys/time.h>
   int gettimeofday(struct timeval *tv, struct timezone *tz);

Data de entrega

A segunda fase deverá ser entregue até o dia 9 de junho (quarta-feira). Dúvidas podem ser discutidas no fórum da disciplina no Moodle, para o aproveitamento de todos.