PROGRAM JuegoDeLasBombas (input , output);

{  Realizado por:  David SALAME PALENCIA                         }
{  Fecha:  17-01-2.000                                           }
{  Centro Politecnico Superior, Ingenieria Industrial            }
{  Asignatura: Programacion (Pascal)                             }

{  Este programa es un juego parecido al buscaminas, en el       }
{  tienes que moverte por el tablero desde la entrada hasta la   }
{  salida sin pisar ninguna bomba.                               }

USES CRT;

TYPE
    tpCasilla = (entrada , salida , pared , bomba , limpia , pisada);
    tpMatriz = Array [1..12,1..12] of tpCasilla;

VAR
   a , b : Integer;
   c : Char;
   matrix : tpMatriz;
   contador : Integer;

{----------}

{ Este procedimiento crea la matriz de juego, y primero asigna a todas    }
{ las casillas el valor limpia. Despues asigna los valores entrada y      }
{ salida. Luego pone un muro que rodea a toda la matriz y por ultimo      }
{ asigna los valores de bomba a 18 casillas elegidas al azar, teniendo    }
{ en cuenta que no puede haber bombas ni en la entrada ni en la salida,   }
{ ni 2 bombas en la misma casilla, ni tampoco bombas en las paredes.      }

Procedure CreaMatrizDeJuego (var matrix : tpMatriz);
Var
   i , j , cont : Integer;
Begin
     i := 2;
     j := 2;
     cont := 1;
     For i := 2 To 11 Do
         Begin
              For j := 2 To 11 Do
                  Begin
                       matrix[i,j] := limpia;
                  End;
              j := 2;
         End;
     matrix[2,2] := entrada;
     matrix[11,11] := salida;
     For i := 1 To 12 Do
         Begin
              matrix[i,1] := pared;
              matrix[i,12] := pared;
         End;
     For j := 1 To 12 Do
         Begin
              matrix[1,j] := pared;
              matrix[12,j] := pared;
         End;
     Randomize;
     While (cont <= 18) Do
           Begin
                i := 2 + Random(10);
                j := 2 + Random(10);
                While (matrix[i,j] = entrada) Or (matrix[i,j] = salida)
                      Or (matrix[i,j] = bomba) Do
                        Begin
                             i := 2 + Random(10);
                             j := 2 + Random(10);
                        End;
                matrix[i,j] := bomba;
                cont := cont + 1;
           End;
End; { del procedure CreaMatrizDeJuego }

{----------}

{ Este procedimiento dibuja el estado actual de la matriz de juego tras    }
{ cada movimiento, poniendo un simbolo diferente a cada posible valor de   }
{ cada casilla, excepto para las casillas con valores limpia y bomba, que  }
{ tienen el mismo valor, para que el usuario no sepa donde se encuentran   }
{ las bombas                                                               }

Procedure DibujaMatriz (var matrix : tpMatriz);
Var
   x , y : Integer;
Begin
     x := 1;
     y := 1;
     While (x <= 12) Do
           Begin
                While (y <= 12) Do
                      Begin
                           Case matrix[x,y] Of

                                entrada : Write(' E ');
                                salida  : Write(' S ');
                                pared   : Write(' = ');
                                bomba   : Write(' ú ');
                                limpia  : Write(' ú ');
                                pisada  : Write('   ');
                           End;
                           y := y + 1;
                      End;
                WriteLn;
                y := 1;
                x := x + 1;
           End;
End; { del procedure DibujaMatriz }

{----------}

{ Este procedimiento se encarga de llevar a cabo el movimiento }
{ hacia abajo.                                                 }

Procedure Movimiento (var matrix : tpMatriz; var a , b : Integer;
          c : Char);
Begin
     Case c Of
          '2' : a := a + 1;
          '4' : b := b - 1;
          '6' : b := b + 1;
          '8' : a := a - 1;
     End;

     Case (matrix[a,b]) Of

          entrada : WriteLn('Has vuelto a la entrada.');
          salida  : WriteLn('Has encontrado a salida.');
          pared   : Begin
                         WriteLn('Hay un muro y no eres un fantasma.');
                         WriteLn('Vuelves a estar donde antes.');
                         Case c Of
                              '2' : a := a - 1;
                              '4' : b := b + 1;
                              '6' : b := b - 1;
                              '8' : a := a + 1;
                         End;
                    End;
          bomba   : WriteLn('Lo siento. Has muerto. Has pisado una bomba.');
          limpia  : Begin
                         WriteLn('Puedes pisar sin miedo.');
                         matrix[a,b] := pisada;
                    End;
          pisada  : WriteLn('Ya habias pasado por aqui.');
     End;
End; { del procedure Movimiento }

{----------}

{ Este procedimiento sirve para contar el numero de bombas que hay   }
{ alrededor de la casilla en la que el jugador se encuentra.         }

Procedure Alrededores(matrix : tpMatriz; a , b : Integer);
Var
   cuenta : Integer;
   n , e , s , o : Integer;
Begin
     cuenta := 0;
     n := a - 1;
     e := b + 1;
     s := a + 1;
     o := b - 1;
     If (matrix[n,b] = bomba) Then cuenta := cuenta + 1;
     If (matrix[a,e] = bomba) Then cuenta := cuenta + 1;
     If (matrix[s,b] = bomba) Then cuenta := cuenta + 1;
     If (matrix[a,o] = bomba) Then cuenta := cuenta + 1;

     If (cuenta >= 1) Then WriteLn('Hay ',cuenta,' bombas a tu alrededor.')
                      Else WriteLn('No hay bombas a tu alrededor.');
End;

{----------}

{ Este procedimiento se encarga de explicar al usuario como }
{ funciona el juego.                                        }

Procedure Introduccion;
Begin
     ClrScr;
     WriteLn('BIENVENIDO AL JUEGO DE LAS BOMBAS.');
     WriteLn;
     WriteLn('La entrada se encuentra en la casilla con una E.');
     WriteLn('La salida se encuentra en la casilla con una S.');
     WriteLn('Tu mision es alcanzar la salida sin pisar ninguna');
     WriteLn('bomba por el camino.');
     WriteLn;
     WriteLn('Los movimientos se realizan con los numeros del');
     WriteLn('teclado numerico, para lo cual tiene que estar bloqueado.');
     WriteLn;   WriteLn;
     WriteLn('Los movimientos posibles son:');
     WriteLn;
     WriteLn('4: para mover a la izquierda;');
     WriteLn('8: para mover hacia arriba;');
     WriteLn('6: para mover a la derecha;');
     WriteLn('2: para mover hacia abajo;');
     WriteLn;   WriteLn;
     WriteLn;   WriteLn;
     WriteLn('Para comenzar presiona enter.');
     ReadLn;
End;

{----------}

{ Este procedimiento dibuja, una vez que la partida ha terminado, el }
{ tablero, con las bombas que ten¡a, y la senda que hab¡a seguido el }
{ jugador por el tablero.                                            }

Procedure DibujaFinal (var matrix : tpMatriz);
Var
   x , y : Integer;
Begin
     x := 1;
     y := 1;
     While (x <= 12) Do
           Begin
                While (y <= 12) Do
                      Begin
                           Case matrix[x,y] Of

                                entrada : Write(' E ');
                                salida  : Write(' S ');
                                pared   : Write(' = ');
                                bomba   : Write(' * ');
                                limpia  : Write('   ');
                                pisada  : Write(' ú ');
                           End;
                           y := y + 1;
                      End;
                WriteLn;
                y := 1;
                x := x + 1;
           End;
End; { del procedure DibujaFinal }

{----------}

BEGIN { del programa principal }

      Introduccion;
      ClrScr;
      a := 2;
      b := 2;
      contador := 1;
      CreaMatrizDeJuego(matrix);
      DibujaMatriz(matrix);
      REPEAT
            Alrededores(matrix,a,b);
            Write('Tu movimiento.');
            ReadLn(c);
            CASE c OF
                 '2' , '4' , '6' , '8' : Movimiento(matrix , a , b , c);
{otherwise : en cps}   else  WriteLn('Movimiento no permitido.');
            END;
            WriteLn('(presiona enter)');
            ReadLn;
            ClrScr;
            DibujaMatriz(matrix);
      UNTIL (matrix[a,b] = salida) OR (matrix[a,b] = bomba);
      IF (matrix[a,b] = salida) THEN
            BEGIN
                 WriteLn('Enhorabuena, has salvado tu vida.');
                 WriteLn('Espero que otra vez no tengas tanta suerte.');
            END
         ELSE
            BEGIN
                 WriteLn('Vaya, has pisado una minita y ahora');
                 WriteLn('te vamos a tener que recoger con una cucharilla.');
                 WriteLn('Que le decimos a tu familia cuando te llevemos');
                 WriteLn('en una caja de zapatos?.');
            END;
      ReadLn;
      WriteLn;   WriteLn;
      WriteLn('Asi estaba el campo minado:');
      WriteLn;   WriteLn;
      DibujaFinal(matrix);
      WriteLn;   WriteLn;

      WriteLn('Vuelve a jugar cuando quieras.');
      WriteLn('(presiona enter)');
      ReadLn;
END. { del programa principal }