Algo

[Algo] Vous ne préférez pas une bonne partie d'échecs ?

Recherche :

Mot : Pseudo : Filtrer
Page : 1 2 3 Page Suivante Page Précédente Bas de page
Auteur	Sujet : [Algo] Vous ne préférez pas une bonne partie d'échecs ?

PB-

Reprise du message précédent :
Tu veux dire qu'il te faut 3 minutes pour faire un minmax niveau 1 ??

Message cité 1 fois

Publicité

Profil supprimé

PB- a écrit :

Tu veux dire qu'il te faut 3 minutes pour faire un minmax niveau 1 ??

Je voulais dire que j'ai modifié minmax de manière à ce qu'il appelle alternativement les successeurs du joueur et de l'adversaire et que ça joue plus vite.
Cela dit, ça m'a pris 5 minute pour le faire.
Par contre pour les valeur des cavalier ou des fou c'est peut-être à réajuster.

Profil supprimé

Je sais pas encore si c'est mieux, le truc, c'est que je tombe parfois soit sur des truc interminable ou des bug... Oui je programme par essai-erreur.

A B C D E F G H

8 BT BC BV BQ BK BV BC BT

7 BP BP BP BP BP BP BP

6 BP

5

4 WP WP

3

2 WP WP WP WP WP WP

1 WT WC WV WQ WK WV WC WT

White :
Black :
Les noirs jouent pour le coup N° 2
Total Black : 0.00000E+00
Total Black : 0.00000E+00
White Heuristic : 5.70000E+03
Black Heuristic : 5.70000E+03
White timer : 00:01:24
Black timer : 00:00:40

Profil supprimé

8 BT BC BV BQ BK BV BC BT

7 BP BP BP BP BP BP

6 BP

5 BP

4 WP WP

3

2 WP WP WQ WP WP WP WP

1 WT WC WV WK WV WC WT

White :
Black :
Les noirs jouent pour le coup N° 3
Total Black : 0.00000E+00
Total Black : 0.00000E+00
White Heuristic : 5.70000E+03
Black Heuristic : 5.70000E+03
White timer : 00:02:37
Black timer : 00:01:25

C'est le coup des noir du même coup

Message édité par Profil supprimé le 08-03-2013 à 16:28:33

Profil supprimé

J'ai mis les stats des partie automatique de 1er niveau dans le premier post.

Merci encore au participant du sujet.

Profil supprimé

rufo a écrit :

Fais pas du récursif C'est lent et ça pompe trop de mémoire...

Alpha béta c'est carrément récursif.

Message cité 1 fois

PB-

Je pense que c'est pas l'unique raison de la lenteur de ton code.

Message édité par PB- le 12-03-2013 à 10:36:57

rufo

Pas me confondre avec Lycos!

Je sais mais pour rappel, tout algo récursif peut être transformé en itératif (et inversement). Je te conseille vivement une implémentation itérative du alpha-béta pour de meilleures perfs et éviter des plantages dus à la saturation mémoire...

---------------
Astres, outil de help-desk GPL : http://sourceforge.net/projects/astres, ICARE, gestion de conf : http://sourceforge.net/projects/icare, Outil Planeta Calandreta : https://framalibre.org/content/planeta-calandreta

breizhbugs

Plop les gens!
Didon jova, tu as essayé (ou dans l'idée) d'en faire un bot pour mesurer ton IA contre des programmes d'échec automatisés?
(pour éviter de tester en jouant toi même chaque partie par exemple?)
(ou alors organiser la base de ton programme pour faire en sorte que ton IA puisse jouer contre elle même et ses différentes versions?)
(Bon j'avoue que j'ai pas regardé le programme en lui-même (beurk le Ada :pouah: ), c'est peut être déjà le cas?)

Message édité par breizhbugs le 12-03-2013 à 12:38:57

---------------
Seul Google le sait...

rufo

Pas me confondre avec Lycos!

ben c'est ce qu'il fait, son IA joue contre elle-même, c'est pas lui qui joue Il peut pas à la fois coder l'algo et jouer les parties pour le tester

Message cité 1 fois

Publicité

Profil supprimé

rufo a écrit :

ben c'est ce qu'il fait, son IA joue contre elle-même, c'est pas lui qui joue Il peut pas à la fois coder l'algo et jouer les parties pour le tester

Effectivement. :jap:

Belle analyse.

Finalement je suis revenue sur mes premières heuristique, j'obtien des mat en 50 coup contre lui même au niveau 0.
Allé j'y retourne.

Message édité par Profil supprimé le 12-03-2013 à 19:18:18

Profil supprimé

Salutations les meilleurs.

Je voudrais au moins essayer d'implémenter alpa-beta.
J'ai trouvé un pseudocode que j'arrive à lire, mais que je pige pas encore.
C'est quoi alpha, c'est quoi beta, et quoi n.
Et comment dérécurssiver cette algo, bon si je comprend ce qu'on fait mais non.

Valeur-noeud(n, alpha, beta)
si n est terminal alors retourner eval(n)
sinon
soient f1, ... , fj les fils de n
si n est max
alors
pour i de 1 à j et tant que alpha < beta faire
alpha <- max(alpha,Valeur-noeud(fi, alpha, beta))
retourner alpha
sinon
pour i de 1 à j et tant que alpha < beta faire
beta <- min(alpha,Valeur-noeud(fi, alpha, beta))
retourner beta
fsi
fsi

Source http://www.emn.fr/z-info/pdavid/En [...] -beta.html

Voici déjà mon code Ada Minimax qui déjà donc, n'est sensiblement pas normal.

Code :

with Text_Io;
use Text_Io;
package body Games is            
   
   
      
   function ValeurMINI (Game : in Game_Type; 
            Depth : in Natural;
            Advers : in Game_Type) return Float;
   function ValeurMAX (Game : in Game_Type; 
               Depth : in Natural;
               Advers : in Game_Type) return Float;
   
   function ValeurMINI (Game : in Game_Type; 
            Depth : in Natural;
            Advers : in Game_Type) return Float is      
      V_Min : Float := Float'Last;
   begin
      
      if not (game.Heuristic(Game.Usr, Game.pred) > Game.Val_Max) and then
    game.Depth >= Depth then
     
     declare
        
        Successors : Successors_Type := advers.Successors(game.Usr);
        New_Game : Game_Type := advers;
     begin
        
        if Successors.Successor /= 0 then
           for Succ in 1..Successors.Successor loop        
          New_Game.Pred := Game.Usr;
          New_Game.Usr := Successors.Plan(Succ);
          
          declare             
             V_Fils : float := ValeurMAX(New_Game, Depth, game);
          begin
             
             V_Min := Float'Min (V_Min, V_Fils);
          end;
           end loop;
        end if;
     end;
      else
     
     V_Min := Game.Heuristic(Game.Usr, Game.pred);
      end if;
      --Put_Line("MaleurMINI : " & Float'Image(V_Min));
      return V_Min;
   end;
   
   
   function ValeurMAX (Game : in Game_Type;
               Depth : in Natural;
               Advers : in Game_Type) return Float is
      V_Max : Float := Float'First;
   begin    
      if not (game.heuristic(Game.Usr, game.pred) > Game.Val_max) and then    
    advers.Depth >= Depth then
     
     declare
        
        Successors : Successors_Type := advers.Successors(Game.Usr);
        New_Game : Game_Type := Advers;        
     begin                  
                
 
        if Successors.Successor /= 0 then
           
           for Succ in 1..Successors.Successor loop        
          New_Game.Pred := Game.Usr;
          New_Game.Usr := Successors.Plan(Succ);
          --Print(New_Game.Usr);
          declare
 
             V_Fils : float := ValeurMINI(New_Game, Depth+1, game);
          begin
             
             V_Max := Float'Max(V_Max,V_Fils);     
          end;
           end loop;
        end if;
     end;
      else
     V_Max := Game.Heuristic(Game.Usr, Game.pred);
      end if;
      --Put_Line("ValeurMAXI : " & Float'Image(V_Max));
      return V_Max;
   end;
   
   function MINIMAX (player : in Game_Type; Advers : in Game_Type) return Usr_Type is
      
      Maxime : Float := Float'first;      
      Successors : Successors_Type := Player.Successors(Player.Usr);
      Coup : Usr_Type;
      New_Game : Game_Type := Player;
   begin      
      
      if Successors.Successor /= 0 then
     
     for Succ in 1..Successors.Successor loop        
        
        New_Game.Usr := Successors.Plan(Succ);
        
        declare
           
           Val_Fils : Float := ValeurMINI(New_Game, 0, Advers);
        begin
           
           if Val_Fils > Maxime then
          Put_Line("MINIMAX : " & Float'Image(Val_fils));
          Maxime := Val_Fils;
          Coup := Successors.Plan(Succ);
           end if;
        end;
     end loop;
      end if;
      return coup;
   end;
   
   
end Games;

Profil supprimé

Bonjour, pour la postérité et pour ceux que ça intéresserait, voici mon code final avec élagage alpha-beta.non récursif.

Code :

with Text_Io;
use Text_Io;
package body Games is            
      
   function ValeurMINI (Game : in Game_Type; 
            Depth : in Natural;
            Advers : in Game_Type;
            Alpha : in Float;
            Beta  : in float) return Float;
   function ValeurMAX (Game : in Game_Type; 
               Depth : in Natural;
               Advers : in Game_Type;
            Alpha : in Float;
            Beta  : in float) return Float;
   
   function ValeurMINI (Game : in Game_Type; 
            Depth : in Natural;
            Advers : in Game_Type;
            Alpha : in Float;
            Beta  : in float) return Float is      
      V_Min : Float := Beta;
      Hcost : Float := game.Heuristic(Game.Usr, Game.pred);
   begin
      
      if not (hcost > 0.0) and 
        Game.Depth > Depth then
     
     declare
        V_Fils : Float := Float'Last;
        Successors : Successors_Type := advers.Successors(game.Usr);
        New_Game : Game_Type := Game;
     begin
        
        if Successors.Successor /= 0 then
           for Succ in 1..Successors.Successor loop        
          New_Game.Pred := Game.Usr;
          New_Game.Usr := Successors.Plan(Succ);
          V_Fils := Float'Min (V_Fils, ValeurMAX(New_Game, Depth, Advers, Alpha, V_Min));
          if Alpha >= V_Fils Then
             return V_Fils;
          else
             V_Min := Float'Min (V_Min, V_Fils);
          end if;           
           end loop;
        end if;
     end;
      else     
     V_Min := Hcost;
      end if;
      
      return V_Min;
   end;
   
 
 
   function ValeurMAX (Game : in Game_Type;
               Depth : in Natural;
               Advers : in Game_Type;
            Alpha : in Float;
            Beta  : in float) return Float is
      V_Max : Float := Alpha;
      Hcost : Float := advers.Heuristic(Game.Usr, Game.pred);
   begin    
      if not (hcost > 0.0) and
    
    game.Depth > Depth then
     
     declare
        V_Fils : float := Float'First;
        Successors : Successors_Type := game.Successors(Game.Usr);
        New_Game : Game_Type := game;        
     begin                  
        
        
        if Successors.Successor /= 0 then
           
           for Succ in 1..Successors.Successor loop        
          New_Game.Pred := Game.Usr;
          New_Game.Usr := Successors.Plan(Succ);
          
          V_Fils := Float'Max(V_Fils, ValeurMINI(New_Game, Depth+1, Advers, V_Max, beta));
 
          if V_Fils >= Beta then
             return V_Fils;
          else
             V_Max := Float'Max(V_Max,V_Fils);     
          end if;           
           end loop;
        end if;
     end;
      else
     V_Max := Hcost;
      end if;
      
      return V_Max;
   end;
   
   function MINIMAX (player : in Game_Type; Advers : in Game_Type) return Usr_Type is
      
      Maxime : Float := Float'First;
      
      Successors : Successors_Type := Player.Successors(Player.Usr);
      Coup : Usr_Type;
      New_Game : Game_Type := Player;
   begin      
      
      if Successors.Successor /= 0 then
     
     for Succ in 1..Successors.Successor loop        
        
        New_Game.Usr := Successors.Plan(Succ);
        
        declare
           
           Val_Fils : Float := ValeurMINI(New_Game, 0, Advers, Float'First, Float'last);
        begin
           
           if Val_Fils > Maxime then
          Put_Line("MINIMAX : " & Float'Image(Val_fils));
          Maxime := Val_Fils;
          Coup := Successors.Plan(Succ);
           end if;
        end;
     end loop;
      end if;
      return coup;
   end;
   
   
end Games;

Merci au participants du sujet qui ont su me conseiller.

Message édité par Profil supprimé le 22-03-2013 à 16:13:48

Profil supprimé

En fait, je ne sais même pas si ce code est valide vue qu'il est très lent et que je n'ai pu faire des tests que niveau zéro et niveau 1.
Je teste couramment niveau 2 mais sans conviction vu que déjà le code niveau 1 donne la même partie que le niveau zéro.
Il me semble avoir corriger tous les bug de mon prog, mais ça doit être loin d'être optimal.
Encore une fois je doute de la consistance de mon implémentation.
Je n'ai pas vraiment su comment formuler (est feuille).
Quant à mon interprétation de l'apha-béta, j'ai une doute, vu la lenteur relative persistante.

Profil supprimé

En fait c'est inférieur à zéro dans ValeurMini et supérieur à zéro dans Valeur Maxi ou dans l'inverse.
Et j'ai fait une gourde j'ai testé avec < alpha et > à béta et ça marche pas en fait.
Donc, ça doit bien être < et > à 0.0. Mais qui sait, j'ai peut-être loupé une truc.
Voilà, je voulais dire aussi que j'ai pas lu grand chose, deux pseudo code, et les valeur des piece. et ici. et un peut cherché la, mais j'y connais toujours rien.
Donc, même si on comprends pas un truc, de la manière dont on nous explique en cherchant on peut parvenir à un bon travail.
Mais le plus important c'est l'heuristique, si t'a une heuristique déséquilibré, ou mal proportionné, c'est fichu.

Voici la mienne finalement, enfin, pour le moment.

Code :

function Black_heuristic(Echiquier : in Echiquier_Type; Pred : in Echiquier_Type) return Float is
      Ucost : Float := 0.0;        
      Hcost : Float := 0.0;
      Successors : Successors_Type;
      sum : Float := 0.0;
    begin                        
       
       Hcost := (Total(Echiquier.Black, Echiquier.Black_last) -  (Total(pred.Black, pred.Black_last)));
       
       for Line in Line_Type loop
      for Colum in Colum_Type loop
         if Echiquier.Board(Line, Colum).piece in BK..BP then
        declare 
           The_Successors : Successors_Type;
                 begin
                Echiquier_Succ(Echiquier.Board(Line, Colum).Piece)(Echiquier, Line, Colum, The_Successors);
                case Echiquier.board(Line, Colum).Piece is
                   when Empty =>
                  null;
                   when BK =>
                  Sum := Sum + Float(The_Successors.Successor) * King_Val/50.0;
                   when BQ =>
                  Sum := Sum + Float(The_Successors.Successor) * Queen_Val/50.0;
                   when BC =>
                  Sum := Sum + Float(The_Successors.Successor) * Chavalier_Val/50.0;
                   when BV =>
                  Sum := Sum + Float(The_Successors.Successor) * Valey_Val/50.0;
                   when BT =>
                  Sum := Sum + Float(The_Successors.Successor) * Tower_Val/50.0;
                   when BP =>
                  Sum := Sum + Float(The_Successors.Successor) * Pion_Val/50.0;
                   when others =>
                  null;
                end case;
                 end;
              end if;
           end loop;
      end loop;
      Hcost := Hcost + Sum;
          
      
      
      Sum := 0.0;
      
            
      for Line in Line_Type loop
           for Colum in Colum_Type loop
              if Echiquier.Board(Line, Colum).piece in WK..WP then
                 declare 
                The_Successors : Successors_Type;
                 begin
                Echiquier_Succ(Echiquier.Board(Line, Colum).Piece)(Echiquier, Line, Colum, The_Successors);
                case Echiquier.board(Line, Colum).Piece is
                   when Empty =>
                  null;
                   when WK =>
                  Sum := Sum + Float(The_Successors.Successor) * King_Val/50.0;
                   when WQ =>
                  Sum := Sum + Float(The_Successors.Successor) * Queen_Val/50.0;
                   when WC =>
                  Sum := Sum + Float(The_Successors.Successor) * Chavalier_Val/50.0;
                   when WV =>
                  Sum := Sum + Float(The_Successors.Successor) * Valey_Val/50.0;
                   when WT =>
                  Sum := Sum + Float(The_Successors.Successor) * Tower_Val/50.0;
                   when WP =>
                  Sum := Sum + Float(The_Successors.Successor) * Pion_Val/50.0;
                   when others =>
                  null;
                end case;
                 end;
              end if;
           end loop;
      end loop;
      
      hcost := hcost - Sum;
        
      
      
      
      
 
      
      
      Sum := 0.0;
      Successors  := White_Successors(echiquier);        
      if Successors.Successor /= 0 then           
     for I in 1..Successors.Successor loop
        declare
           Tmp : Echiquier_Type := Successors.Plan(i);
        begin
           Sum := Sum + (Total(Tmp.White, Tmp.White_last) - Total(Echiquier.White, Echiquier.White_Last));                
        end;
        
     end loop;                
     Ucost := Sum / Float(Successors.Successor);     
      end if;
      
      return (Hcost - ucost);
    end Black_Heuristic;

Evidamment c'est l'inverse pour les blancs.

Faut tester avec plein de valeur de pieces aussi c'est intéressant.

~~La je joue niveau 5 en quelque seconde.~~ ça devais pas être ça. oops. [:clooney8]
Voici l'ouverture du coup 9 des blancs.

A B C D E F G H

8 BT BV BQ BK BV BT

7 BP BP BP BP

6 BP BC BP BP

5 BP WP

4 WP WP BC

3 WV WC WC WP

2 WP WP WP WP

1 WT WQ WK WV WT

White :
Black :
Total White : 0.00000E+00
Total Black : 0.00000E+00
White Heuristic : -8.53448E+00
Black Heuristic : -4.55769E+01
White timer : 00:01:07
Black timer : 00:00:56

Les noirs jouent pour le coup N 9
MINIMAX : -5.15769E+01
MINIMAX : -4.15769E+01
MINIMAX : -3.29231E+01
MINIMAX : -2.60000E+01
MINIMAX : -2.59286E+01

En fait je suis en train d'écrire j'ai pas vérifier si ça respecte bien les règles d'échecs, mais ça njoue vite et plutôt bien donc, puisque la situation d'éuquilibre deumeure au 40eme coup, avec un bug à 3 pions à 4. je vais teste niveau 10 ou 15 maintenant.

Voilà, je me repassionne pour les échecs du coups.

Message édité par Profil supprimé le 23-03-2013 à 01:28:53

Profil supprimé

Ca marche pas, et ça commence à m'enerver, alors, je viens demander votre aide.

Profil supprimé

Bonjour,

L'algo, c'est encore une question, NegaMax, c'est la même chose que minmax ?

Profil supprimé

Bon, j'ai mis un mois à saisir qu'il fallait que j'appel min en premier, je ne désespère pas de trouver sur combien de niveau l'appeller.

Message cité 1 fois

Profil supprimé

rufo a écrit :

Fais pas du récursif C'est lent et ça pompe trop de mémoire...

J'ai essayé, j'ai échoué, le récursif est plus rapide.

Profil supprimé

J'ai re-essayé, j'ai réussi normalement. [:dawa_neowen]
Version X parce que les version en les compte plus, c'est même la X-0.2.
Ca fait 30 jour pile que j'ai commencé le truc. J'ai mis 8 heure à coder les successeurs et 15 jour à les débuger.
En suite j'ai mis 1( jours pour débuguer réimplémenter les algo MinMax et NégaMax, au moins 10 fois, alors, que mon erreur que j'ai introduite au cour du mois était du au calcul en moyen des pertes sur un coup.
J'ai optmimiser la structure du programme en passant un pointeur sur un game_type au lieu de copier un ame_type.
Et j'ai implémenter un algo random, mais qui doit pas fonctionner puisque c'est du randum.
Merci encore.

Profil supprimé

Raté. lol

Message cité 1 fois

Profil supprimé

Rien n'est moins certain en fait.

Mais mon jeux marche toujours pas.

Profil supprimé

Pour la mise en appliation les gars, faura revoir votre politique. Non ? :sweat:

Profil supprimé

Bon en l'occurrence je commence par appeler Min
Je fais bien depth - 1 dans chacun des deux sauf que je donne un pair comme depth max.
Et je renvoie la négation de la valeur d'un coup dans min.
Je pense que le plus important est d'exécuter Min et Max au moins une fois.
j'ai trouvé un code qui à l'air de fonctionner, mais je suis pas convaincu de quoi que ce soit.
Du coup, je vous refile l'adresse des sources de DoChess écrit avec Ada
Merci encore pour votre aide.

Au prochain bug. :hello:

Profil supprimé

Je laisee tomber, ça joue encore échecs. J'abandonne. De la mouise ce minmax.

Message édité par Profil supprimé le 09-04-2013 à 13:41:10

Profil supprimé

Bonjour, je viens donner des nouvelle, malheureusement je ne peux encore vous donner les sources de manque d'hébergement.
Normalement j'ai corriger les 5 algo de multichess-4.0.0 et ça joue aléatoirement avec les 5 algo niveau 0 et 1.
Je suis encore en cour de test.
Mais vous aurez corrigé par vous même je suis certain.
Merci encore, peut-être que finalement, minimax c'est pas si mal pour jouer au échecs.

Profil supprimé

Avec les caractères Unicode s'il vous plaît !
Mais bien sur M. le client.

Previsious algo is : NegaMax.

A B C D E F G H
---------------------------------------------------------------
| | | | | | | | |
8 | ♜ | ♞ | | | | | | |
| | | | | | | | |
---------------------------------------------------------------
| | | | | | | | |
7 | ♟ | ♝ | | | ♚ | | | ♗ |
| | | | | | | | |
---------------------------------------------------------------
| | | | | | | | |
6 | | ♟ | | | | | | |
| | | | | | | | |
---------------------------------------------------------------
| | | | | | | | |
5 | | ♕ | ♟ | ♟ | ♞ | | | |
| | | | | | | | |
---------------------------------------------------------------
| | | | | | | | |
4 | | | | | | ♛ | | |
| | | | | | | | |
---------------------------------------------------------------
| | | | | | | | |
3 | ♙ | | ♙ | | | | | ♙ |
| | | | | | | | |
---------------------------------------------------------------
| | | | | | | | |
2 | ♖ | | | | ♔ | | ♙ | |
| | | | | | | | |
---------------------------------------------------------------
| | | | | | | | |
1 | ♗ | ♘ | | | | | ♘ | ♖ |
| | | | | | | | |
---------------------------------------------------------------
White : ♟♟♜♟♟♝
Black : ♙♙♙♙
White timer : 00:00:13
Black timer : 00:00:14

Les noirs jouent pour le coup N 72
NegaMax :

Le projet MultiChess est maintenant rattaché au projet Warborg. Vous pouvez retrouver Warborg-Chess_Solver sur sourceforge.net projet Warborg.

Message édité par Profil supprimé le 05-09-2013 à 03:52:26

par l'anneau de l'ia

word master

Bonjour,

Je reviens parce que mon Negamax ne foctionnne toujours pas.
Le problème est visible par un coups d'échec, Negamax peu retourner une valeur théoriquement éronnée.
Je suppose que mon heuristique est correcte, alors j'incrémine Négamax en fait.
Si vous avez le temps de vérifir mon code, merci pour vos retours.

Voici mon code actuel: (écrit avec Ada)

Code :

-- Negamax avec élagage.
   function NegaMax (player : in Game_Access; Advers: in Game_Access; Depth : in Natural; A, B : in Float; Side : in Boolean := True) return float is
     Alpha : Float := A;
     Beta  : Float := B;
      begin
     if ((not Player.Terminator(player.Usr)) and (not advers.Terminator(player.Usr))) and then
       Depth > 0 then
        declare
           V_Fils  : Float := 0.0;
           Best    : Float := Float'First;
           New_player : Game_Access;
           New_advers : Game_Access;
           Successors : Successors_Type;
        begin
           
           New_advers := new Game_Type ' (Player.all);
           New_player := new Game_Type ' (Advers.all);
           
           Successors := advers.Successors(New_player.Usr);
           for Succ in 1..Successors.Last loop                  
          New_Player.Usr := Successors.Plan(Succ);          
          V_Fils := -NegaMax(New_Player, New_Advers, Depth-1, -Beta, -Alpha, not side);
          Best := Float'Max(V_Fils, Best);
          Alpha := Float'Max(V_fils, alpha);
          if Alpha >= Beta then
             exit;
          end if;
           end loop;
           return Best;
        end;
     else
        return player.Heuristic(player.usr, advers.usr);
     end if;
      end negaMax;

Voici mon appel.

Code :

-- Appel de Negamax pour les deux joueur.
-- On doit pour les deux Jouers avec une profondeur paire.
   function jovajovi(player : in Game_Access; Advers : in Game_Access; Side : in boolean) return Usr_Type is
     Maxime : Float := Float'First;
     
     Successors : Successors_Type := player.Successors(player.Usr);
     Coup : Usr_Type;      
      begin          
     Text_Io.Put_Line("NegaMax : " );
     if Successors.Last /= 0 then     
        for Succ in 1..Successors.Last loop        
           
           player.usr := Successors.Plan(Succ);
           
           declare           
          Val_Fils : Float := negamax(Player, Advers, Player.Depth, Float'First, Float'Last, side);
           begin
          
          if Val_Fils > Maxime then
             --Put_Line(Float'Image(Val_fils));
             Maxime := Val_Fils;
             Coup := Successors.Plan(Succ);
             player.System.Movement := Movement_Type(Succ);
          end if;
           end;
        end loop;
     end if;
     return coup;
      end Jovajovi;

Je vais relire, ça me fera du bien.

par l'anneau de l'ia

word master

Arf, ça fait 5 minutes que ça tourne pas d'erreur.

Désolé pour le dérangement, j'avais mis le roi potentiellement à une valeur inférieur aux autres pièces.

Merci en tout cas. :whistle:

Publicité

Page : 1 2 3

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

Algo

[Algo] Vous ne préférez pas une bonne partie d'échecs ?

Sujets relatifs
avis site web (bonne section?)	Remplacer une partie de texte par une autre dans un fichier texte
Développer la partie PHP d'abord ?	Script Javascript - Fond d'une partie du site
[ORACLE OCI] Select sur un clob ne retourne qu'une partie du contenu	je suis bloqué dans une partie de mon prg
[BATCH] Lire une certaine partie d'un fichier texte	code ça marche mais se n'est pas une bonne execution
besoin d'explication du fonctionnement de cette partie de programme!	[MySQL] update une partie d'un champ ?
Plus de sujets relatifs à : [Algo] Vous ne préférez pas une bonne partie d'échecs ?

Page générée en 0.174 secondes