package Warborg.Joshua is                          
   
   
   procedure New_Game;
   
end Warborg.Joshua;

with Warborg.I18n;
use Warborg.I18n;
 
with Warborg.Individu.User.Player.Game.Solver;
use  Warborg.Individu.User.Player.Game;
use Warborg.Individu.User.Player;
use Warborg.Individu.User;
use Warborg.Individu;
 
with Warborg.Wargames;
use Warborg.Wargames;
with Gnat.Md5;
 
package body Warborg.Joshua is                          
         
   
   package Wargame_Solver is new Warborg.Individu.User.Player.Game.Solver(Wargame_Type, Heuristic, Uniform, Initialize, Exhausted);
   
   
   procedure New_Game is
      Current_Player : Player_Type;            
      
      Norad  : Wargame_Type;
      
      Joshua : Wargame_Solver.Self_Type;
      
   begin
      Individu_Type(Current_Player).Initialize("Joshua", "null address" );
      User_Type(Current_Player).Initialize(Gnat.Md5.Digest("" ));
      Current_Player.Initialize(Fr);   
      Player_Add(NORAD, Current_Player);
      --  Initialize(Norad);
      --  Initialize(Joshua, Norad);
      --  loop
      --     warborg.Wargames.To_Play(Wargame_Type(NORAD));
      --     Wargame_Solver.Self_Play(NORAD);      
      --  end loop;
      
      
      
   end New_Game;
      
end Warborg.Joshua;

with Warborg.Individu.User.Player.Game;
use Warborg.Individu.User.Player.Game;
use Warborg.Individu.User.Player;
package Warborg.Wargames is
   
   type Wargame_Type is new Game_Type with private;   
   procedure Initialize(Wargame : in out Wargame_Type);
   procedure Player_Add(Wargame      : in out Wargame_Type'Class;
                        Player       : in Player_Type'Class);
   procedure Player_Remove(Wargame   : in out Wargame_Type'Class;
                           Player    : in Player_Type'Class);
   
   procedure To_Play(Wargame : in out Wargame_Type);
   
   function Heuristic (Wargame : in Wargame_Type) return Float;
   -- Une fonction qui retourne la valeur du jeu pour le solver.
   
   function Uniform (Wargame : in Wargame_Type) return Float;
   -- Une fonction qui retourne la valeur du jeu pour le(s) joueur(s) opposant(s).
   
   function Initialize return Wargame_Type;
   -- Une fonction qui retourne la représentation initiale du jeu.
   
   function Exhausted(Wargame : in Wargame_Type) return Boolean;   
   -- Une fonction qui retourne Vrai si le jeu est terminé.   
   
private                  
   
   
   type Multi_Player_Type;
   type Multi_Player_Access is access Multi_Player_Type;
   type Wargame_Type is new Game_Type with
      record
         Multi_Player : Multi_Player_Access;
      end record;
   
   
end Warborg.Wargames;

generic
   type Usr_Type is new Game_Type with private;
   -- Le jeu, ça représentation.
   
   with function Heuristic (Usr : in Usr_Type) return Float;
   -- Une fonction qui retourne la valeur du jeu pour le solver.
   
   with function Uniform (Usr : in Usr_Type) return Float;
   -- Une fonction qui retourne la valeur du jeu pour le(s) joueur(s) opposant(s).
   
   with function Initialize return Usr_Type;
   -- Une fonction qui retourne la représentation initiale du jeu.
   
   with function Exhausted(Usr : in Usr_Type) return Boolean;   
   -- Une fonction qui retourne Vrai si le jeu est terminé.
   
package Warborg.Individu.User.Player.Game.Solver is
   
   type Self_Type is limited private;   
   
   procedure Initialize(self : in out Self_Type; Usr : in Usr_Type'class);
   
   procedure Self_Play(Self : in out Self_Type);
   function Usr (Self : in Self_Type) return Usr_Type;
   type Option_Type is access function (Usr : in Usr_Type) return Usr_Type;
   type Options_Type is array (Positive range <> ) of Option_Type;
   type Options_Access is access Options_Type;
   function Options(Self : in Self_Type) return Options_Type;
   procedure Set_Options(Self : in out Self_Type;
                         Options : in Options_Type);     
private
   type Self_Type is new Usr_Type with
      record                     
         Usr          : Usr_Type;
         Full_Options : Options_Access;
      end record;   
   
end Warborg.Individu.User.Player.Game.Solver;

package Warborg.Individu.User.Player.Game is
         
   type Game_Type is abstract tagged private;      
   
   procedure Initialize (Game : in out Game_Type'class);
   
   procedure To_Play(Game : in out Game_Type'Class) is abstract;
         
   function Total(Game : in Game_Type'Class) return Float;
   
   procedure Points_Add(Game : in out Game_Type'Class;
                        Points : in Float);
   
private
   
   type Game_Type is tagged
      record
         Total : Float := 0.0;   
      end record;
   
end Warborg.Individu.User.Player.Game;

function Initialize return Wargame_Type;
  -- Une fonction qui retourne la représentation initiale du jeu.

procedure Initialize(Wargame : in out Wargame_Type);
   -- Une procedure qui donne la représentation initiale du jeu.