Projeto de MAC-211 -- 2010

"Náufragos"

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.

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 :-)

Obviamente, não preciso dizer que plágio será absolutamente não tolerado e todos os envolvidos serão rigorosamente punidos.

A História

Estamos nos primeiros anos do século XX. O imponente transatlântico RMS Positronic deixa a Europa rumo ao Novo Mundo. Tudo corria bem em sua viagem, até que o navio esbarrou em um iceberg (sim, clichê básico de tragédias marítimas). Todavia, para a felicidade dos passageiros, o navio seguia rigorosamente os protocolos de segurança e havia coletes salva-vidas para todos. Outra sorte é que era verão na época do naufrágio, dessa forma tampouco as vítimas tiveram problemas com hipotermia.

Felizmente para os passageiros, quis o destino que próximo ao naufrágio passasse o modesto navio cargueiro Asimov. O cargueiro, que contava com dois botes, prontamente colocou-os para o resgate dos passageiros em alto-mar.

A Missão

O projeto, portanto, consiste em construir um jogo, para dois jogadores, onde cada um controla um dos dois botes (um de cada cor) e ambos têm a tarefa de resgatar a maior quantidade possível de passageiros. Os jogadores devem se desviar dos perigosos recifes de corais, do contrário o bote irá encalhar e/ou naufragar.

Cada jogador controla o seu bote 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 do bote:
  • uma tecla para remar para frente e outra para trás (com simulação física);
  • duas teclas para girar a bombordo e a estibordo (sem simulação física, i.e., gira numa taxa fixa para cada aperto de tecla).

As principais partes do programa são as seguintes:

• Simulação do oceano
• Apresentação gráfica
• Tratamento da entrada do usuário
• Simulação do movimento dos botes e dos passageiros
• 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 dos passageiros). 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 Oceano

O que o usuário verá na tela é uma seção do oceano, com os passageiros à deriva "passeando" erraticamente pela mesma.

Nesta primeira fase, o oceano 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 oceano em 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 passageiros, que surgem de alguma borda da tela, com um padrão de deslocamento aleatório. No início do jogo, é gerado um número fixo de passageiros (digamos 60). A partir desse ponto, quando um passageiro "sai" da tela (ou seja, quando passa por alguma borda), esse é descartado e um novo passageiro surge em alguma borda, também com um padrão de deslocamento aleatório. Além disso, de tempos em tempos novos passageiros são adicionados, até que seja atingindo um limite máximo de passageiros na tela.

Nesta fase inicial, como tudo será representado como texto, você pode usar caracteres ASCII para representar os passageiros. O padrão de deslocamento de um passageiro será determinado por uma Cadeia de Markov. Utilizaremos a Cadeia de Markov para alterar a direção de deslocamento de um passageiro, com isso simulando o seu deslocamento errático pelo oceano. Seja PC o conjunto de pontos cardeais e colaterais, ou seja, PC = {N, S, L, O, NE, SE, NO, SO}. Se a direção de deslocamento de um passageiro no instante de tempo t for, digamos, X[t] = NE, então a direção de deslocamento de um passageiro no instante de tempo t+1 é dada por:

X[t+1] = NE, com 65%;
X[t+1] = um elemento de PC - {NE}, com 5% de chances para cada um.

Dado um passageiro @ da simulação, as possíveis direções de deslocamento são:

NO N NE
O @ L
SO S SE

Outros cuidados importantes durante a simulação são:

• 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 passageiro 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. O vetor de velocidade, por sua vez, também deve ser atualizado uma vez por segundo, conforme a realização da Cadeia de Markov no instante de tempo atual.
  
  
• colisão: quando dois passageiros 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 os botes e os recifes de corais. Mas se quiser, pode ser uma boa você desenhar os recifes para ir adiantando o trabalho da próxima fase. Note que, nesse caso, será necessário simular o que acontece quando um náufrago colide com um recife (você decide o que acontece). Outra simplificação é o número de passageiros: 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 passageiros quanto para os botes. 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 oceano, um arquivo para a inicialização e a função main() e assim por diante.

Geração dos passageiros

Os passageiros 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 frequência média de geração dos passageiros 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 passageiros muito grande ou muito pequeno ou velocidade muito próxima de zero? O que acontece se dois passageiros se chocam um com o outro?
   
   
2. Correção: o programa detecta corretamente o choque entre dois passageiros? 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 passageiros 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

Melhorias no modelo Físico