PROGRAM JuegoDelAhorcado (input , output);


{  Realizado por:  David SALAME PALENCIA                           }
{  Fecha:  19-12-1.999                                             }
{  Centro Politecnico Superior, Ingenieria Industrial              }
{  Asignatura: Programacion (Pascal)                               }

{  Este programa es un juego del Ahorcado. En principio esta       }
{  preparado para palabras de 4 letras, pero cambiando el valor    }
{  de la constante MAXLONG, deberia funcionar para palabras de     }
{  otras longitudes, pues todos los vectores, estrings y procesos  }
{  iterativos estan definidos desde 1 hasta MAXLONG.               }


USES CRT;

CONST
     MAXLONG = 4;
     OPOR = (2 * MAXLONG) + Round(MAXLONG / 2);


VAR
   i : Integer;
   palAux , palabra : String [MAXLONG];
   aciertos : Integer;
   tiradas : Integer;
   esta , es : Array [1..MAXLONG] of Boolean;
   vale : Boolean;
   cond : Boolean;
   victorias , derrotas , games : Integer;
   auxquerer , querer : Char;
   seguir : Boolean;


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


PROCEDURE Datos;                 {  Este procedimiento lee las letras de  }
                                 {  la palabra que la persona introduce   }
VAR                              {  y se encarga de ocultarla para que    }
   ii : Integer;                 {  el jugador no la vea.                 }

BEGIN {del procedure Datos}

     FOR ii := 1 TO 5 DO         {  El FOR sirve para dejar unas lineas   }
         BEGIN {del FOR}         {  en blanco, por la presentacion.       }
              WriteLn;
         END; {del FOR}

     Write('Palabra clave: ');   {  Se piden y leen las letras que        }
     Read(palAux);               {  formaran la palabra clave del juego.  }
     palabra := palAux;


     ReadLn;

     FOR ii := 1 TO 100 DO       {  Se oculta la palabra clave para que   }
         BEGIN {del FOR}         {  el jugador no la vea.                 }
              WriteLn;
         END; {del FOR}

END; {del procedure Datos}


{**************************************}


PROCEDURE NormalizacionDeDatos;

BEGIN {del procedure NormalizacionDeDatos}

     FOR i := 1 TO MAXLONG DO
         BEGIN
              IF (Ord(palabra[i]) >= Ord('A')) AND (Ord(palabra[i]) <= Ord('Z'))
                 THEN palabra[i] := palabra[i]
                 ELSE palabra[i] := Chr(Ord(palabra[i]) + Ord('A') - Ord('a'));
         END;

  {  Aqui se pasan todas las letras a mayusculas en caso de que alguna    }
  {  sea minuscula, para que luego, a la hora de comprobar si las letras  }
  {  introducidas estan o no en la palabra, el proceso sea mas rapido.    }

END; {del procedure NormalizacionDeDatos}


{**************************************}


PROCEDURE Partidas;

BEGIN

     IF (aciertos = MAXLONG) THEN victorias := victorias + 1
                             ELSE derrotas := derrotas + 1;

     games := games + 1;

   {  Aqui se cuentan el numero de partidas jugadas, las ganadas y  }
   {  las perdidas.                                                 }


     WriteLn;       WriteLn;
     WriteLn;       WriteLn;

     Write('¨Quieres jugar otra vez? (s/n): ');
     ReadLn(auxquerer);

     IF (auxquerer >= 'A') AND (auxquerer <= 'Z')
        THEN querer := auxquerer
        ELSE querer := Chr(Ord(auxquerer) + Ord('A') - Ord('a'));

     WHILE (querer <> 'S') AND (querer <> 'N') DO
           BEGIN {del WHILE}

                WriteLn;     WriteLn;

                WriteLn('RESPUESTA NO VALIDA');

                Write('¨Quieres jugar otra vez? (s/n): ');
                ReadLn(auxquerer);

                IF (auxquerer >= 'A') AND (auxquerer <= 'Z')
                   THEN querer := auxquerer
                   ELSE querer := Chr(Ord(auxquerer) + Ord('A') - Ord('a'));

           END; {del WHILE}

     IF (querer = 'S') THEN seguir := TRUE
                       ELSE seguir := FALSE;

END; {del procedure Partidas}


{**************************************}


PROCEDURE Comprobacion;

VAR
   estan : Integer;

BEGIN {del procedure Comprobacion}

   {  Me aseguro de que los caracteres introducidos son letras, y si   }
   {  alguno no lo es, se vuelven a pedir otra vez, y asi hasta que    }
   {  todos sean letras.                                               }

     estan := 0;

     FOR i := 1 TO MAXLONG DO
         BEGIN
              IF (Ord(palabra[i]) >= Ord('A')) AND (Ord(palabra[i]) <= Ord('Z'))
                 THEN es[i] := TRUE
                 ELSE es[i] := FALSE;
         END;

     FOR i := 1 TO MAXLONG DO
         BEGIN
              IF (es[i] = TRUE) THEN estan := estan + 1;
         END;

     IF (estan = MAXLONG) THEN vale := TRUE
                          ELSE vale := FALSE;


END; {del procedure Comprobacion}


{**************************************}


PROCEDURE Estado;

BEGIN {del procedure Estado}

      Write('=> ');

      FOR i := 1 TO MAXLONG DO
          BEGIN
               IF (esta[i] = TRUE) THEN Write(palabra[i],' ')
                                   ELSE Write('_ ');
          END;

      WriteLn;

END; {del procedure Estado}


{**************************************}


PROCEDURE Jugando;

VAR
   car : Char;
   aux : Char;

BEGIN {del procedure Jugando}

     Write('Letra: ');
     ReadLn(aux);

     IF (Ord(aux) >= Ord('A')) AND (Ord(aux) <= Ord('Z'))
           THEN car := aux
           ELSE car := Chr(Ord(aux) + Ord('A') - Ord('a'));


     FOR i := 1 TO MAXLONG DO
         BEGIN
              IF (car = palabra[i]) THEN
                 BEGIN
                      IF (esta[i] = FALSE) THEN
                           BEGIN
                                esta[i] := TRUE;
                                WriteLn('La letra ',car,' esta.');
                                WriteLn;
                                aciertos := aciertos + 1;
                           END
                        ELSE IF (esta[i] = TRUE) THEN
                            BEGIN
                                 WriteLn('La letra ',car,' ya estaba.');
                                 WriteLn('Has perdido una tirada.');
                                 WriteLn;
                            END;
                 END;
         END;


        Estado; {llamada al procedure Estado}
        WriteLn;

        tiradas := tiradas + 1;

        WriteLn;

END; {del procedure Jugando}


{**************************************}


PROCEDURE Fin;

BEGIN {del procedure Fin}

     WriteLn;   WriteLn;
     WriteLn;   WriteLn;

     WriteLn('Has jugado  ',games,' partidas.');
     WriteLn('Has ganado  ',victorias,' partidas.');
     WriteLn('Has perdido ',derrotas,' partidas.');

     WriteLn;   WriteLn;
     WriteLn;   WriteLn;

     WriteLn('ADIOS');

     WriteLn;   WriteLn;
     WriteLn;   WriteLn;

END; {del procedure Fin}


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


BEGIN {del programa principal}


      victorias := 0;        {  los valores de estas variables los dejo  }
      derrotas := 0;         {  fuera del REPEAT  porque llevan un       }
      games := 0;            {  control de las partidas jugadas y demas  }
      seguir := FALSE;       {  datos, cosa que no ocurre con las demas  }


  REPEAT

      i := 1;
      tiradas := 0;
      aciertos := 0;
      cond := FALSE;

      FOR i := 1 TO MAXLONG DO
          BEGIN
               esta[i] := FALSE;
          END;


      FOR i := 1 TO 50 DO
          BEGIN {del FOR}
               WriteLn;
          END; {del FOR}


      WriteLn('Bienvenido al JUEGO DEL AHORCADO.');
      WriteLn('Tienes que adivinar una palabra de ',MAXLONG,' letras que');
      WriteLn('otra persona deber  escribir sin que tu lo veas y');
      WriteLn('pulsar ENTER.');
      WriteLn('Tienes ',OPOR,' intentos. Buena suerte.');

      Datos; {llamada al procedure Datos}

      NormalizacionDeDatos; {llamada al procedure NormalizacionDeDatos}

      Comprobacion; {llamada al procedimiento Comprobacion}


      WHILE (vale = FALSE) DO
           BEGIN {del WHILE}

                WriteLn('La palabra que has introducido (',palAux,') no vale.');
                WriteLn('No puede haber numeros, simbolos ni espacios, solo letras.');
                WriteLn('Por favor, vuelve a introducir la palabra.');

                Datos;
                NormalizacionDeDatos;
                Comprobacion;

           END; {del WHILE}



      REPEAT

            Jugando; {llamada al procedure Jugando}

            IF (tiradas = OPOR) OR (aciertos = MAXLONG) THEN cond := TRUE;


      UNTIL (cond = TRUE); {condicion de finalizacion del REPEAT}



      IF (aciertos = MAXLONG) THEN
           BEGIN
                WriteLn;
                WriteLn('Has GANADO.');
                WriteLn('Has usado ',tiradas,' tiradas.');
           END
        ELSE BEGIN
                  WriteLn;
                  WriteLn('Has PERDIDO.');
                  WriteLn;
                  WriteLn('Has usado ',tiradas,' tiradas.');
                  WriteLn('Has tenido ',aciertos,' aciertos.');
             END;

      WriteLn;
      WriteLn('La palabra era: ',palabra);

      WriteLn;    WriteLn;
      WriteLn;    WriteLn;

      Partidas; {llamada al procedure Partidas}


  UNTIL seguir = FALSE;

      Fin; {llamada al procedure Fin}

      ReadLn;


END. {del programa principal}