Programa 4:

Programa de laboratório: caça ao tesouro

Descrição sucita: 
********* ******

Desenvolva um programa no qual dois bonequinhos (no mesmo molde das "crianças" 
do exercício anterior) são guiados pelo usuário com o fim de pegar um tesouro 
que se encontra em uma posição aleatória da tela.

Descrição detalhada:
********* *********

O programa funcionará como um jogo no qual dois bonequinhos aparecem em 
posições aleatórias da tela e devem ser guiados por dois jogadores com o fim
de alcançar um tesouro que também aparece em uma posição aleatória. O jogo 
funcionará em turnos. Em cada turno, um jogador terá direito a fazer três 
movimentos, utilizando para isso as setas cursoras (direcionais). Cada 
toque em uma dessas teclas corresponde a um movimento na direção 
correspondente. Aquele que chegar primeiro à posição na qual o tesouro 
se encontra vence o jogo.

Além dos bonequinhos e do tesouro, o programa deverá também mostrar dez 
obstáculos. Cada um desses obstáculos corresponde a um quadrado 3 x 3 e 
representa um terreno através do qual os bonequinhos não podem atravessar. 
Por exemplo:

    *** o
    ***/|\
    ***/ \
    
No cenário acima, o bonequinho não pode seguir para a esquerda, pois esbarra 
no obstáculo. Note que tanto o bonequinho quanto o obstáculo ocupam 3 x 3 
posições. Fica a critério do aluno decidir se os bonequinhos se movimentarão 
uma ou três posições a cada toque em uma seta cursora. Para simplificar a 
implementação, assuma que colisões ocorrem apenas no "tronco" do bonequinho, 
ou seja, você não precisa levar os braços, a cabeça e as pernas em 
consideração, na hora de verificar colisões (em outras palavras: apenas uma 
posição da tela precisa ser armazenada para um bonequinho inteiro, mesmo
levando em consideração que ele ocupa mais que isso). 

Dicas:
*****

- Para detectar as possíveis colisões entre cada bonequinho e os obstáculos,
  use uma função parametrizada que recebe como parâmetro a posição para a qual
  se deseja mexer o bonequinho. Desse modo, torna-se fácil definir se este pode
  ou não se mexer para um determinado lugar.
  
  Por exemplo, suponha que guardamos a posição do centro de cada obstáculo em 
  um par de números inteiros, correspondentes às suas coordenadas X e Y. Para o 
  obstáculo
  
  1, teríamos então duas variáveis: 
  
      var obs1X, obs1Y : integer;
      
  Suponha ainda que armazenamos a posição atual do bonequinho 1 em duas 
  variáveis: 
  
  2. 
      var pos1X, pos1Y : integer;    
      
  O procedimento responsável por detectar colisões teria e! ntão a seguinte 
  "cara":
  
      procedure detecta_colisao(X:integer, Y:integer);
      begin
          if (X = obs1X + 1) or (X = obs1X - 1) or (X = obs1X)
             (X = obs1Y + 1) or (Y = obs1Y - 1) or (Y = obs1Y) then
             colisao := true
          else 
             colisao := false;
      end; 
     
      No exemplo de código acima, "colisao" é uma variável do programa que
      define se o movimento de um dos bonequinhos resulta ou não em colisão
      com um obstáculo. Claro,! no programa final seria necessário verificar
      colisão com cada um dos obstáculos existentes (dez, no total) a cada
      movimento de cada bonequinho. 
      
      Uma maneira mais elegante de implementar o procedimento acima seria
      usando um procedimento local. Esse procedimento serviria simplesmente
      para verificar se uma dada posição colide com um dado obstáculo. 
      Se implementado deste modo, o procedimento detecta_colisao passa ser
      uma lista de dez chamadas a este procedimento interno. Essa é uma 
      solução mais elegante porque evita a repetição do código responsável
      por verificar a colisão com cada obstáculo.