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 ?

Profil supprimé

Reprise du message précédent :
Un roi ne peut pas se faire prendre.

Si non comment il le pourrait si ne vaut pas de point.

Comment compte t'on ? :heink:

Publicité

rufo

Pas me confondre avec Lycos!

Ben si le roi peut se faire prendre : c'est le mat, ce qui arrête la partie.

Message cité 1 fois

---------------
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

Harkonnen

Modérateur
Un modo pour les bannir tous

rufo a écrit :

Ben si le roi peut se faire prendre : c'est le mat, ce qui arrête la partie.

voila, donc dans ton algo, tu vas affecter une valeur très élevée au noeud de ton arbre qui représente la position dans laquelle le roi se fait prendre

---------------
J'ai un string dans l'array (Paris Hilton)

rufo

Pas me confondre avec Lycos!

J'imagine qu'il fait distinguer la valeur affectée au roi de l'adversaire et le sien : une forte valeur si on prend le roi adverse mais au contraire une très faible valeur si le coup qu'on va jouer conduira par la suite à se faire prendre le sien... La valeur 0.0 mentionnée par Jovalise représente sans doute le valeur de son propre roi (pas la valeur du roi adverse).

Profil supprimé

Ca dépend de la logique des (+, -) après.

Profil supprimé

Heureusement que j'ai pas commencé, je serais déjà arrêté.

Si non, donc, vous auriez plus d'info ou quoi parce que là.

Harkonnen

Modérateur
Un modo pour les bannir tous

Une très bonne explication claire du minimax : http://www.flyingmachinestudios.co [...] g/minimax/

---------------
J'ai un string dans l'array (Paris Hilton)

Profil supprimé

Oui, oui, minimx, on aura compris.

Mais pour l'évaluation du jeux d'échec, et l'application des règles ca ce programme comment ?

PB-

Bah y a 70 ans un mec assez connu à fait une fonction d'évaluation elle même très connue ; tu devrais pouvoir t'en inspirer.
Quelque chose comme : evaluation(position) = (P−P′) + 3(N−N′+B−B′)+ 5(R−R′) + 9(Q−Q′) + 200(K−K′)−0.5(D−D′+S−S′+I−I′)+ 0.1(M−M′)

Avec les lettres = tes pièces les primes = pièces de l'adversaire et D les pions doublés, S les pions isolées et M la mobiilité.

C'est tout simple mais déjà tu peux battre un humain moyen avec ça.

Inutile de dire que contre un top programme ça ne suffit pas (tout comme minmax/alpha-beta ne suffient pas).

Sans indiscrétion tu es en quoi ?

Message cité 1 fois
Message édité par PB- le 27-02-2013 à 10:23:56

Profil supprimé

PB- a écrit :

Sans indiscrétion tu es en quoi ?

Je suis en acier.

Je suis pas étudiant, je cogite un jeu. je voudrait voir ce que va donner minimax sur un jeux d'échecs, avec peut-être élagage, contre lui même déjà.

Merci P-B-

Je vais voir si je peux améliorer mon heuristique avec ta fonction. Que je teste avec A* : http://80.15.188.151/others/WChess-0.2.0.tar.gz avec Ada.
Ca joue, mais ça plante au 8 ou 9eme coup. Mais ça joue. Bref, je met à minimax demain probablement.

Et pour mon arbre, comment ça s'appelle un arbre adapté à mon problème ?
Merci, si non, je me démerderai.

Message cité 1 fois

Publicité

Harkonnen

Modérateur
Un modo pour les bannir tous

Un Graphe Acyclique Dirigé (Acyclique car pas de boucle, Dirigé car dans un seul sens -du haut vers le bas-)

edit: je vois toujours pas à quoi tu joues avec A* qui n'a strictement rien à voir avec la choucroute

Message cité 1 fois
Message édité par Harkonnen le 27-02-2013 à 13:07:34

---------------
J'ai un string dans l'array (Paris Hilton)

Profil supprimé

Harkonnen a écrit :

Un Graphe Acyclique Dirigé (Acyclique car pas de boucle, Dirigé car dans un seul sens -du haut vers le bas-)

Du haut vers le bas... Bon d'accord, je vais voir ce que je peux faire.

Harkonnen a écrit :

edit: je vois toujours pas à quoi tu joues avec A* qui n'a strictement rien à voir avec la choucroute

Si je lui donne le point terminal ?
Enfni, j'y suis pas arrivé encore.

rufo

Pas me confondre avec Lycos!

Le point terminal, tu peux pas savoir puisqu'il existe des milliers de configurations dans lesquelles toi ou l'adversaire peuvent être mat (et je parle même pas des situations de pat).

Message cité 1 fois

Profil supprimé

Y a qu'à choisir...

Je suis encore sur A* =

Je sais je vais vous décourager.

A B C D E F G H

8 BV
7 BP BP WC
6 WP BT
5 WP
4
3
2
1 WT WC WV WQ WK WV
White : (BP, 1.00000E+02), (BP, 1.00000E+02), (BV, 4.00000E+02), (BC, 3.00000E+02), (BP, 1.00000E+02), (BP, 1.00000E+02), (BP, 1.00000E+02), (BQ, 9.00000E+02), (BP, 1.00000E+02), (BT, 5.00000E+02), (BC, 3.00000E+02), (BK, 4.10000E+03),
Black : (WP, 1.00000E+02), (WP, 1.00000E+02), (WP, 1.00000E+02), (WP, 1.00000E+02), (WP, 1.00000E+02), (WP, 1.00000E+02), (WT, 5.00000E+02),
Les noirs jouent pour le coup N° 46
Black Mat.

Premier parti Noirs mat en 45.5 coups. Avec la liste des points gagnés.

Mais ça joue mal, mais ça joue.

Je recommence... Non, je vais me coucher. +A Comme dirait Gilou.

Profil supprimé

J'attaque Minimax mais j'ai un problème de lecture.

Dans le code ci dessous, dans ValeurMini et ValeurMaxi on fait un pour tous les successeurs de P, mais c'est N qui est donné, alors je voulais savoir si il n'y a pas une erreur et si c'est bien pour tous les successeur de N ?
Merci

Code :

procedure Main is
 
   function ValeurMINI ( N ) is
   begin
      if Feuille( N )= Vrai Then
         return F(N);
      else
         V_Min = MAX_VAL;
         for *) Chacune Fils = Successeur(P) loop
            V_Fils = ValeurMAX(Fils);
            V_Min = Min (V_Min, V_Fils);
         end loop;
      end if;
      return V_Min;
   end;
 
 
   function ValeurMAX ( N ) is
   begin
      if Feuille( N )= Vrai Then
         return F(N)
      else
           V_Max = -MAX_VAL;
           for *) Chacune Fils = Successeur(P) loop
              V_Fils = ValeurMINI(Fils);
              V_Max= Max(V_Max,V_Fils);
           end loop;
      end if;
      return V_Max;
   end;
 
 
   function MINIMAX( P) is
      Maxime = -MAX_VAL;
   begin
      for *) Chacune Fils = Successeur(P) loop
         Val_Fils = ValeurMINI(Fils);
         if Val_Fils > Maxime Then
            Maxime = Val_Fils;
            Coup = Fils;
         end if;
      end loop;
      return Coup;
   end;
 
 
begin
   null;
end Main;

Profil supprimé

Implémentation avec Ada de Minimax façon pseudo générique pour un jeu d'échecs.

Code :

generic
   type Usr_Type is private;      
package Games is            
   
   type Heuristic_Access is 
     access function (Usr : in Usr_Type) return Float;
   
   type Plan_Type is array(Positive range <> ) of Usr_Type;
   
   type Successors_Type is
      record
     Plan       : Plan_Type(1..1024);
     Successor  : Natural := 0;
      end record;
   
   type Move_Access is 
     access function (Usr : in Usr_Type) return Successors_Type;      
   
   type Game_Type is
      record
     Usr        : Usr_Type;
     Heuristic  : Heuristic_Access;
     Successors : Move_Access;
      end record;
      
   function MINIMAX(Game : in Game_Type) return Usr_Type;
   
end Games;

Code :

package body Games is            
   
   function ValeurMINI (Game : in Game_Type) return Float;
   function ValeurMAX (Game : in Game_Type) return Float;
   
   function ValeurMINI (Game : in Game_Type) return Float is
      
      V_Min : Float := Float'Last;
   begin
      
      if Game.Heuristic(Game.Usr) > 0.0 then
     
     declare
        
        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.Usr := Successors.Plan(Succ);
          
          declare
             
             V_Fils : float := ValeurMAX(New_Game);
          begin
             
             V_Min := Float'Min (V_Min, V_Fils);
          end;
           end loop;
        end if;
     end;
      else
     
     V_Min := Game.Heuristic(Game.Usr);
      end if;
      return V_Min;
   end;
   
   
   function ValeurMAX (Game : in Game_Type) return Float is
      V_Max : Float := Float'First;
   begin    
      
      if Game.Heuristic(Game.Usr) > 0.0 then
       
     declare
        
        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.Usr := Successors.Plan(Succ);
          
          declare
             
             V_Fils : float := ValeurMINI(New_Game);
          begin
             
             V_Max := Float'Max(V_Max,V_Fils);     
          end;
           end loop;
        end if;
     end;
      else
     V_Max := Game.Heuristic(Game.Usr);
      end if;
      
      return V_Max;
   end;
   
   function MINIMAX (Game : in Game_Type) return Usr_Type is
      Maxime : Float := Float'First;      
      Successors : Successors_Type := Game.Successors(Game.Usr);
      Coup : Usr_Type;
      New_Game : Game_Type := Game;
   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);
        begin
           
           if Val_Fils > Maxime then
          
          Maxime := Val_Fils;
          Coup := Successors.Plan(Succ);
           end if;
        end;
     end loop;
      end if;
      return coup;
   end;
end Games;

Les sources complète du jeu d'échecs sans les heuristique : http://80.15.188.151/dev/MinimaxChess-0.0.1.tar.gz

Donc, il le reste les heuristiques à écrire.

Profil supprimé

Bon, j'ai mis au point une heuristique, mais elle est pas au point encore.

Si vous pouviez jeter un oeil...
Je suis perdu dans les calcul.
Pour le moment, elle retourne 0.0 au départ en suite l'avantage de l'un et au désavantage de lautre. mais le jeu est obscure quand même.
Bon, je vous donne mon heuristique puis je vais vérifier mon prog.

Code :

function Black_heuristic(Echiquier : in Echiquier_Type) return Float is
      Ucost : Float := 0.0;        
      Hcost : Float := 0.0;
      Successors : Successors_Type;
      Count : Float := (8.0*1.0+2.0*5.0+2.0*3.0+2.0*4.0+9.0+100.0);
      sum : Float := 0.0;
   begin                        
      Hcost := Count - (total(Echiquier.Black, Echiquier.Black_last));
      Hcost := hcost - (Count - (Total(Echiquier.White, Echiquier.White_last)));
      Successors  := Black_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.Black, Tmp.Black_last) - Total(Echiquier.Black, Echiquier.Black_last));
                 Sum := Sum + (Count - (Total(Tmp.White, Tmp.White_last) - Total(Echiquier.White, Echiquier.White_last)));
                 
              end;
              
           end loop;     
           Sum := (Sum/Float(Successors.Successor));
           Ucost := sum + Float(Successors.Successor)/10.0;
      end if;      
      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 - (Count - (Total(Tmp.White, Tmp.White_last) - Total(Echiquier.White, Echiquier.White_Last)));
           Sum := Sum + (Total(Tmp.Black, Tmp.Black_last) - Total(Echiquier.Black, Echiquier.Black_last));
           
              end;
              
           end loop;     
           Sum := (Sum/Float(Successors.Successor));
           Ucost := Ucost + (Sum - Float(Successors.Successor)/10.0);
      end if;      
      return Hcost + Ucost;--Ucost + (Hcost - (8.0*1.0+2.0*5.0+2.0*3.0+2.0*4.0+9.0+100.0));
   end Black_Heuristic;

Code :

function White_heuristic(Echiquier : in Echiquier_Type) return Float is
      Ucost : Float := 0.0;        
      Hcost : Float := 0.0;
      Successors : Successors_Type;
      Count : Float := (8.0*1.0+2.0*5.0+2.0*3.0+2.0*4.0+9.0+100.0);
      Sum : Float := 0.0;
   begin                  
      Hcost := Count - (Total(Echiquier.White, Echiquier.White_last));
      Hcost := Hcost - (Count - (total(Echiquier.Black, Echiquier.Black_Last)));      
      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));
                 Sum := Sum + (Count - (Total(Tmp.Black, Tmp.Black_last) - Total(Echiquier.Black, Echiquier.Black_last)));
              end;
              
           end loop;     
           Sum := (Sum/Float(Successors.Successor));
           Ucost := Sum + Float(Successors.Successor)/10.0;
      end if;      
      Sum := 0.0;
      Successors  := black_Successors(echiquier);        
      if Successors.Successor /= 0 then           
           for I in 1..Successors.Successor loop
              declare
                 Tmp : Echiquier_Type := Successors.Plan(i);
              begin
                 Sum := Sum - (Count - (Total(Tmp.Black, Tmp.Black_last) - Total(Echiquier.Black, Echiquier.Black_last)));
                 Sum := Sum + (Total(Tmp.White, Tmp.White_last) - Total(Echiquier.White, Echiquier.White_Last));
           
              end;
     
           end loop;     
           Sum := (Sum/Float(Successors.Successor));
           Ucost := Ucost + (Sum - Float(Successors.Successor)/10.0);
      end if;      
      return Hcost + Ucost;
      
      
   end White_Heuristic;

Les sources complète avec un certain équilibre du jeu. Mais donc, je suis perdu dans les heuristiques.
http://80.15.188.151/Applications/ [...] 0.0.tar.gz

Merci.

Par exemple, je me trouve dans cette situation ou un pion noir menace le roi, mais celui ci n'a pas fuit. Entre autre anomalie probable.

A B C D E F G H

8 BT BT
7 BP BP
6 BC BK BQ
5 BP BP WT
4 WP BP
3 WP WP WP WK
2 WT WV
1 BV WV WQ WC
White : (BP, 1.00000E+00), (BP, 1.00000E+00), (BC, 3.00000E+00), (BV, 4.00000E+00), (BP, 1.00000E+00),
Black : (WP, 1.00000E+00), (WP, 1.00000E+00), (WC, 3.00000E+00), (WP, 1.00000E+00), (WP, 1.00000E+00),
Les noirs jouent pour le coup N° 46
Total White : 1.00000E+01
Total Black : 7.00000E+00

White Heuristic : -2.92902E-01
Black Heuristic : 2.92908E-01

Message édité par Profil supprimé le 02-03-2013 à 18:53:08

Profil supprimé

Peut-être qu'en autant ucost à hcost en fin d'algo, c'est mieux.

J'y retourne. :whistle:

Profil supprimé

Peut-être qu'en autant hcost à ucost en fin d'algo, c'est encore plus existant . [:bounce]

Spoiler :

[:dawa]

Profil supprimé

Yep !

J'ai apporté quelque modif à mon algo, je pense rien que vous ne sachiez faire vous même.
Ca marche un poil mieu, cependant, à présent je pense que les valeur de mes pieces ne sont pas bonne.

Par exemple, un reine qui vient se mettre en danger par l'appât d'une fourchette sur une tour et un fou c'est pas normal.
Donc, peut-être y a -t- il des valeur plus juste des pièces.

Mais bon. Je suis qu'un amateur, pas une calculette.

Profil supprimé

Ca me parait logique de faire un roi à zéro points.
Par contre il doit avoir un max de facteur de mouvement.

/note

Profil supprimé

Du coup, j'ai implémenter un calcul de mobilité un poil plus précis que le précédent.
Bon, mais maintenant on cherche le mat et pas la prise du roi.

http://80.15.188.151/dev/MinimaxChess-1.2.0.zip
http://80.15.188.151/dev/MinimaxChess-1.2.0.tar.gz

Code :

-- Heuristique pour les black.
   function Black_heuristic(Echiquier : in Echiquier_Type) return Float is
      Ucost : Float := 0.0;        
      Hcost : Float := 0.0;
      Successors : Successors_Type;
      sum : Float := 0.0;
   begin                        
      Hcost := Count - (Total(Echiquier.White, Echiquier.White_last));
      Hcost := Hcost - (Count - (total(Echiquier.Black, Echiquier.Black_Last)));      
      
      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) * 2000.0;
             when WQ =>
            Sum := Sum + Float(The_Successors.Successor) * Queen_Val;
             when WC =>
            Sum := Sum + Float(The_Successors.Successor) * Chavalier_Val;
             when WV =>
            Sum := Sum + Float(The_Successors.Successor) * Valey_Val;
             when WT =>
            Sum := Sum + Float(The_Successors.Successor) * Tower_Val;
             when WP =>
            Sum := Sum + Float(The_Successors.Successor) * Pion_Val;
             when others =>
            null;
          end case;
           end;
        end if;
     end loop;
      end loop;
      Hcost := Hcost - Sum;
      Sum := 0.0;
      
      Successors  := Black_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.Black, Tmp.Black_last) - Total(Echiquier.Black, Echiquier.Black_last));
                 Sum := Sum + (Count - (Total(Tmp.White, Tmp.White_last) - Total(Echiquier.White, Echiquier.White_last)));
              end;
              
           end loop;     
           Sum := (Sum/Float(Successors.Successor));
           Ucost := Sum + Float(Successors.Successor);
      end if;      
      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 - (Count - (Total(Tmp.White, Tmp.White_last) - Total(Echiquier.White, Echiquier.White_last)));
                 Sum := Sum + (Total(Tmp.Black, Tmp.Black_last) - Total(Echiquier.Black, Echiquier.Black_Last));
           
              end;
     
           end loop;     
           Sum := (Sum/Float(Successors.Successor));
           Ucost := Ucost - (Sum + Float(Successors.Successor));
      end if;      
      return (ucost - hcost);
   end Black_Heuristic;

Pour les White c'est l'inverse.

Matez les source de chess.ads qui change un poil aussi.

Profil supprimé

rufo a écrit :

Le point terminal, tu peux pas savoir puisqu'il existe des milliers de configurations dans lesquelles toi ou l'adversaire peuvent être mat (et je parle même pas des situations de pat).

Bonjour rufo, je souhaite revenir sur ce point, car il m'intéresse particulièrement.
Si j'affronte un algo a lui même optimalement, je doit obtenir une partie.
A partir de là n'est - il pas possible de chercher le chemin optimal avec A* ?

J'ai pas trouvé avec minmax encore mais je commence à comprendre mon code, je commence à gagner qui je veux comme je veux ou bien perdre.
Comme je disais peut-être plus haut, ça dépend de la logique des + et des -

A part ça, j'en suis à donner des centaines pour les pièces, des k pour le King mais des 0.01 comme facteur de déplacement, en fait j'ai déprécier les déplacements, ça marche un poil mieux. je manipule difficilement minimax par contre, pour inverser la logique c'est à l'essai-erreur.

Là j'affronte les noirs avec un calcul d'un coup d'avance (cad l'évaluation d'un coups après) contre les blanc sans coup d'avance. Mais les blanc jouent avant.
En fait je cherche une erreur dans mon code mais bon ici, c'est interressant de voir comment ça ce passe.
Je vous laisse testet d'autre solution, je mettrai bien tôt de nouvelle sources dans le répertoire Games.
Bref, les blanc, on l'avantage du premier coup, les noir l'avantage de cacul d'un coup d'avance.

A B C D E F G H

8 BT BK BV BC
7 BP BP BV BP BP
6 BP BP
5
4
3 WP WC WP WP
2 WP WP WP BT
1 WT WK WC WT
White : (BP, 1.00000E+02), (BQ, 9.00000E+02), (BP, 1.00000E+02), (BC, 3.00000E+02),
Black : (WV, 3.25000E+02), (WP, 1.00000E+02), (WV, 3.25000E+02), (WQ, 9.00000E+02), (WP, 1.00000E+02),

Les blancs jouent pour le coup N° 11
Total White : 1.40000E+03
Total Black : 1.75000E+03

White Heuristic : -3.16000E+02
Black Heuristic : 6.38313E+02

White timer : 00:07:31
Black timer : 00:10:03

L'algo minmax est appelé pour une profondeur max de 2.
Après c'est plus long.

J'ai vue aussi que j'avais fait des tableau de successeurs de 1024 échiquiers, j'ai réduit à 128, ça gagne pas mal de temps.

Amuser vous avec mes codes, je les trouve ingénieux, maintenant reste à savoir ce qu'il valent vraiment.
C'est écrit avec Ada for ever.

Bref,

Rufo, réponses ?

Merci.

rufo

Pas me confondre avec Lycos!

Ben le minmax sur 2 de profondeur, ça va pas donner des résultats terribles Faut pas oublier qu'au échecs, t'as 2h pour jouer 40 coups donc 3 minutes de réflexion par coup. Faudra caler la profondeur sur cette donnée (ton PC met combien de temps pour calculer un minmax de profondeur 2?).

Après, tu peux combiner l'algo minmax avec une BD contenant des parties. Si Situation courante dans BD et que celui qui doit jouer le coup a aussi gagné la partie dans la BD, alors jouer le coup en BD, sinon, appliquer minmax sur la profondeur adaptée au temps...

C'est pas pour rien que les bécanes qui jouent aux échecs (correctement ) sont des gros calculateurs...Pas des PCs.

Message cité 1 fois

Profil supprimé

Bonjour rufo.

Une bd, c'est carrément exclu,

Pour jouer au niveau 1 c'est 1minute * 2 par coup.
Niveau 2 c'est attends, attends, je viens de corriger mon algo....

J'ai enfin trouvé un joueur en déséquilibre, c'est à dire que l'ago est enfin le même, et ça joue quand même, enfin niveau un, parce que niveau deux, ça n'a pas encore joué depuis que j'ai commencé à écrire ce message.

Alors voilà.

/blabla.
Je suis passé par plein d'algo différent, autant dans les heuristique que dans les condition de fonctionnement de minmax. C''est intéressant.
Mon problème principale et dans l'application des règle du jeux d'échecs, notamment dans le comportement en échec, et pour la mise en mat, mais encore faut-il trouvé un algo qui veuille bien combatre contre lui même ou qui ne fini pas en boucle en milieu de partie.
bla/

Toujours pas sortie depuis 5 minutes de plus !

Je met en ligne la version 2.0.0 dans 5 minutes.

Profil supprimé

Niveau 1 une minute donc sur Gnu/Linux et 2 minutes sur Windwos.

Je dis ça, je dis rien, je préviens.

Profil supprimé

Avec la version 2.0.0 donc, le jeux termine vite contre lui même niveau 1 car les blancs ne détectent pas l'échec.
La partie est pliée en 8 minutes et 4 coups.
Le main détecte bien la prise du roi, c'est à dire que le programme termine lorsque qu'il a mangé le roi.

Si non, il y a du mieux par rapport à la version 1.
Mais il y a encore un truc à l'envers.

Version 2 en ligne dans mon répertoire Applications/Games, MinimaxChess pour Gnu et Win. Avec sources et binaires.

Voilà, je prendrais bien un coup de pied, non un coup de main, non plus quelques corrections... pourquoi pas.

rufo

Pas me confondre avec Lycos!

Bizarre tes perfs Soit t'as une machine qui date de 10 ans, soit ton algo n'est pas optimisé pour 2 sous.

Par ailleurs, une partie gagnée en 4 coups (c'est le coup du berger, là!), je dirais que l'algo est pas au point. Tu ferais un algo avec un random que la partie durait bien plus longtemps.

Message cité 1 fois

Profil supprimé

Là j'essaie simplement une inversion de logique puisque enfin mes algo sont les même pour les blancs et les noirs, j'ai soustrait ucost à hcost en fin d'heuristique.
Ca donne 1 minute au premier coup, d'un joueur puis deux minute au deuxieme puis trois au troisième etc, pour le moment et ça continue à jouer au 5ieme coup.

Screen shot :

A B C D E F G H

8 BT BC BV BK BV BC BT
7 BP BP BQ BP BP BP
6
5 BP BP BP
4 WP
3 WC WQ
2 WP WP WP WP WP WP WP
1 WT WV WK WV WC WT
White :
Black :

Les blancs jouent pour le coup N° 5
Total White : 0.00000E+00
Total Black : 0.00000E+00

White Heuristic : 1.37166E+02
Black Heuristic : -1.37166E+02

White timer : 00:07:59
Black timer : 00:07:55

On as toujours le pile ou face de l'avantage.

Profil supprimé

rufo a écrit :

Euh oui, elle a 10 ans ma bécane pourquoi ?

Message cité 1 fois

Profil supprimé

rufo a écrit :

Faut pas oublier qu'au échecs, t'as 2h pour jouer 40 coups

Ca va être ça grosso modo, niveau 1.

Avec Hcost - Ucost. Mais je ne sais pas encore comment ça termine, j'en suis à 1:00 8 coups.

rufo

Pas me confondre avec Lycos!

Ben ce genre d'algo nécessite de grosses ressources de calcul Un vieux PC va vachement te limiter en puissance de calcul...

Profil supprimé

Pour le moment je suis dans les temps, mais c'est pas terminé.

Merci rufo. :jap: Merci PB- aussi. :jap: Merci Harko également. :jap:

Profil supprimé

Finalement, j'arrive à peine à 20 coups en deux heures. Mais ça joue. J'attends la fin.

Profil supprimé

Bon, au moins je sais comme ça, il faut faire exactement l'inverse. :bounce:

Spoiler :

:lol:

[:painkiller]

La partie de tout a l'heure... vous en pensez quoi, vous pouvez voir les dernier coup dans le sujet presse papier.

Citation :

A B C D E F G H

8 BC BV BV
7 WC BP BP BK
6 BT BC WQ
5 BP BQ BP BP BP
4 BP WP WP WV WP BT
3 WP WC WP BP
2 WP WK WP WV WP
1 WT WT
White :
Black :

Les blancs jouent pour le coup N° 24
Total White : 0.00000E+00
Total Black : 0.00000E+00

White Heuristic : -4.92578E+00
Black Heuristic : 4.92578E+00

White timer : 01:47:49
Black timer : 01:19:44

Les noirs ont joué.

A B C D E F G H

8 BC BV
7 WC BP BP BK BV
6 BT BC
5 BP BQ BP BP BP WQ
4 BP WP WP WV WP BT
3 WP WC WP BP
2 WP WK WP WV WP
1 WT WT
White :
Black :

Les blancs jouent pour le coup N° 25
Total White : 0.00000E+00
Total Black : 0.00000E+00

White Heuristic : -1.29297E+00
Black Heuristic : 1.29297E+00

White timer : 01:55:59
Black timer : 01:25:28

A B C D E F G H

8 BC BV
7 WC BP BP BK BV
6 BT BC
5 BP BQ BP BP BP WQ
4 BP WP WP WV WP BT
3 WP WC WP BP
2 WP WK WP WV WP
1 WT WT
White :
Black :

Les noirs jouent pour le coup N° 25
Total Black : 0.00000E+00
Total Black : 0.00000E+00

White Heuristic : -7.07227E+00
Black Heuristic : 7.07227E+00

White timer : 02:03:18
Black timer : 01:25:28

Nouvelle partie en inversant un truc.

Code :

if Game.heuristic(Game.Usr)>= -Game.The_end and then

dans ValeurMin
et

Code :

if Game.Heuristic(Game.Usr) < Game.The_end and then

Dans ValeurMAx

[:neo_xp] Ca marche pas. [:pingouinator]

Message édité par Profil supprimé le 06-03-2013 à 22:31:52

Profil supprimé

Bon, on recommence parce qu'il y avais tricherie.
Chercherais l'équilibre des compte plus tard.
J'ai passé 3 jour a calculer un coup avec un seul échiquier. C'est intéressant.
Mais mieux vaut en avoir deux. :lol:
Donc, niveau 1 ça joue,

A B C D E F G H

8 BC BV BQ BK BC BT

7 BP BP BP BP BP

6 BT BP BP

5

4

3 BV WP WP WP

2 WP WP WP

1 WT WC WV WQ WK WV WC WT

White : (BP, 1.00000E+02),
Black : (WP, 1.00000E+02), (WP, 1.00000E+02),

Les noirs jouent pour le coup N° 7
Total White : 1.00000E+02
Total Black : 2.00000E+02

White Heuristic : -1.14100E+04
Black Heuristic : -1.15183E+04

White timer : 00:02:17
Black timer : 00:03:51

Profil supprimé

Je l'ai je crois, faut vérif, mais je crois que j'ai bon enfin.

A B C D E F G H

8 BV BK BT

7 BP BP BP BP BP

6 BV BP

5 BP

4 WP

3 WP WP WP WC

2 BT WK WP

1 WT

White : (BQ, 9.00000E+02), (BC, 3.00000E+02), (BP, 1.00000E+02), (BC, 3.00000E+02),
Black : (WQ, 9.00000E+02), (WP, 1.00000E+02), (WP, 1.00000E+02), (WV, 3.50000E+02), (WC, 3.00000E+02), (WT, 5.00000E+02), (WV, 3.50000E+02), (WP, 1.00000E+02),
Les noirs jouent pour le coup N° 16
Total Black : 1.60000E+03
Total Black : 2.70000E+03
White Heuristic : 0.00000E+00
Black Heuristic : 0.00000E+00
White timer : 00:00:02
Black timer : 00:00:02
White Mat.

raised CHESS.MAT : chess.adb:148
root@Muse:MinimaxChess#

Ca y était pas.

Voyons celui-ci !

A B C D E F G H

8

7 BP BK BP

6 BP WV BP

5 WP BP BT

4 BV WP WP

3 WP BQ

2

1 WK

White : (BP, 1.00000E+02), (BV, 3.50000E+02), (BC, 3.00000E+02), (BP, 1.00000E+02), (BT, 5.00000E+02), (BC, 3.00000E+02), (BP, 1.00000E+02),
Black : (WP, 1.00000E+02), (WQ, 9.00000E+02), (WV, 3.50000E+02), (WT, 5.00000E+02), (WP, 1.00000E+02), (WC, 3.00000E+02), (WC, 3.00000E+02), (WT, 5.00000E+02), (WP, 1.00000E+02), (WP, 1.00000E+02),
Les noirs jouent pour le coup N° 36
Total Black : 1.75000E+03
Total Black : 3.25000E+03
White Heuristic : 3.60000E+03
Black Heuristic : 5.73000E+03
White timer : 00:00:03
Black timer : 00:00:04
White Mat.

raised CHESS.MAT : chess.adb:148
root@Muse:MinimaxChess#

Oh Oh, Oh, [:le_coyote]

Message édité par Profil supprimé le 07-03-2013 à 13:56:32

Profil supprimé

niveau zéro, c'est à dire que Minimax n'entre jamais dans ValeurMin.

[:pr3-] [:pr3-] [:pr3-] [:pr3-] [:pr3-] [:pr3-]

[:kadreg] [:intercalaire]

Profil supprimé

Code :

--
   Pion_Val      : constant Float := 100.0;
   Tower_Val     : constant Float := 500.0;
   Chavalier_Val : Constant Float := 300.0;
   Valey_Val     : constant Float := 300.0 + 20.0 * Float(Level);
   Queen_Val     : constant Float := 900.0;
   King_Val      : constant Float := 1750.0 + 50.0 * Float(Level);
   King_Move_Factor : constant Float := King_Val;

Niveau dynamique dans la version 3.0.1.

Profil supprimé

J'ai de nouvelle perfs.

22 coup en 3 ~~secondes~~ minutes niveau 1, mais cette fois j'apelle Minimax comme il faut.

J'espère que ça va jouer le mat.

Message édité par Profil supprimé le 07-03-2013 à 22:41:18

PB-

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

Message cité 1 fois

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.151 secondes