--AUTOR: Jose Luis VILLARIG GARCIA (V2975813) 472542@cepsz.unizar.es
--PROYECTO: Practicas de Intr. Programación 99/00. Práctica3-Ej.2.1.3
--FICHERO: ahorcado.adb
--FECHA: Noviembre-Diciembre 1999
--Modidicado por:
--Fecha modificacion:
--Descripcion: Se trata del juego del ahorcado (aunque sin el monigote) y
--mejorado frente al propuesto en las practicas.

--El numero de intentos es constante (10) y en cada intento, el usuario
--propone una letra y el programa dice cuantas veces esta (si ya se ha
--adivinado lo comunica) y el numero de intentos que quedan, asi como la
--posicion de las letras. Por ejemplo si se han adivinado 'a' y 'e' de la
--palabra escala, pone "Llevas adivinado: e--a-a".
--La palabra oculta es de tamaño fijo y se coge al azar (numero aleatorio
--entre 1 y 25) de un fichero de texto que tiene 25 palabras, "ahorcado.txt",
--las cuales estan a razon de una por linea sin figurar nada mas y siendo
--todas de 6 letras.
--Al haber variedad, resulta interesante incluso cuando es uno mismo el que
--ha metido las palabras en el fichero.

--El que las palabras sean de tamaño acotado (y por lo tanto, palabras
--de cualquier longitud es el principal cambio introducido en ahorcado2.adb
--Problemas sin resolver:
--1) Una forma relativamente sencilla (si es que existe, cosa que dudo) de
--pintar el monigote. Conozco la existencia de screen pero para cada intento
--habria que mover el cursor a una posicion distinta y poner un caracter
--distinto, dando por resultado una legibilidad y modificabilidad
--practicamente nulas.
--2 No es que sea muy importante, pero quedaria mejor si no hiciese falta
--darle al return (ademas, es una cuestion interesante para poder hacer
--algun juego en Ada; imagina un matamarcianos con infinitas pausas).
with text_io, Ada.integer_text_io, Ada.Numerics.Discrete_Random;
use text_io, Ada.integer_text_io;
procedure ahorcado is
-- declaracion de constantes y variables
  INTENTOS : constant integer := 10;
  fichAhorcado: File_Type;
  palabra : string (1..6);
  letrasAdivinadas : string (1..6);
  i, j, k, letrasRestantes : integer;
  c : character;
-- numeros aleatorios
  SUBTYPE tpRangoAleatorio IS Positive RANGE 1..25;
  PACKAGE Aleatorios IS NEW Ada.Numerics.Discrete_Random(tpRangoAleatorio);
  use Aleatorios;
  g: Generator;
  numero: integer;

   ---------------------------------------------------------
   -- PROPOSITO: Procedimiento para inicializar letrasAdivinadas con guiones
   -- Pre: cad: string
   -- Post: cad llena de guiones
   ---------------------------------------------------------
   procedure ponerGuiones (cad: in out string) is
    -- declaracion de variables
    i : integer;

   begin
      i := 1;

      while i <= cad'LAST loop
         cad(i) := '-';
         i := i+1;
      end loop;

   end ponerGuiones;
   ---------------------------------------------------------
   -- PROPOSITO: Funcion para comprobar si la letra ya ha sido adivinada
   -- Pre: c in caracter
   -- Post: yaAdivinada=TRUE si esta en letrasAdivinadas; sino, FALSE.
   ---------------------------------------------------------

   function yaAdivinada (c: character) return boolean is
   -- declaracion de variables
    i : integer;
    yaAdivinada : boolean;
   begin
      i := 1;
      yaadivinada := FALSE;
      while i <= palabra'LENGTH loop
         if letrasAdivinadas(i) = c then
            yaAdivinada := TRUE;
         end if;
         i := i + 1;
      end loop;
      return yaAdivinada;
   end yaAdivinada;

   ---------------------------------------------------------
   -- PROPOSITO: Funcion para calcular el numero de veces que esta c
   -- Pre: c in caracter
   -- Post: numVeces=numero de veces que esta c.
   ---------------------------------------------------------

   function numVeces (c : character) return integer is
   -- declaracion de variables
    i, numVeces : integer;

   begin
      i := 1;
      numVeces := 0;

      while i <= palabra'LENGTH loop

         if palabra(i) = c then
            numVeces := numVeces + 1;
            letrasAdivinadas(i):=c;
         end if;

         i := i+1;
      end loop;

      return NumVeces;

   end NumVeces;

   ---------------------------------------------------------
   -- PROPOSITO: Procedimiento para comunicar el resultado de la letra
   -- introducida por el usuario. Esta quitado del principal, por su largura
   -- y por ser autoexplicativo. Debido a su especifidad, no tiene parametros
   -- propios y maneja los del programa principal.
   ---------------------------------------------------------
   procedure comunicarResultado is
   begin
      put ("La letra ");
      put (c);
      put (" esta ");
      put (numVeces(c),0);
      put (" veces y te quedan ");
      put (INTENTOS-i+1,0);
      put (" intentos y ");
      letrasRestantes := letrasRestantes - numVeces (c);
      put (letrasRestantes,0);
      put_line (" letras por adivinar.");
      put ("Llevas adivinado: ");
      put (letrasAdivinadas);
      new_line;
   end comunicarResultado;

begin
   open (fichAhorcado, In_File, "Ahorcado.txt");
   Reset(g);
   numero := Random(g);
   k := 1;
   while k < numero loop
      skip_line (fichAhorcado);
      k := k+1;
   end loop;
   get (fichAhorcado, palabra);
   close (fichAhorcado);
   i := 1;
   j := 1;
   letrasRestantes := palabra'LENGTH;
   ponerGuiones(letrasAdivinadas);

   while i <= intentos and letrasAdivinadas/=palabra loop
      put ("Introduce una letra: ");
      get (c);

      if yaAdivinada(c) then --sin esto seria muy facil ganar (con encontrar
         --una letra que estuviese e introducirla varias veces, se ganaria.
         put_line ("Ya has adivinado esa letra."); 

      else
         if numveces(c) = 0 then
            i := i + 1;
         end if;
         comunicarResultado;
      end if;

   end loop;

   if i = intentos+1 then
      put ("Perdiste");
   else
      put ("Ganaste.");
   end if;
end ahorcado;