Bonjour,
Alors, j’y ai passé un jour de plus … Avec de la persévérence et du travail on sait jamais.
J’ai trouvé que les valeurs des pièces doivent être scrupuleusement adaptées au mode calculatoire qu’exige le jeu d’échecs.
Ainsi, j’ai redéfini les valeurs de mes pièces ainsi :
– Light values
W_Pawn_Val : Float := 0.000000001;
W_Tower_Val : Float := 0.000000004;
W_Chavalier_Val : Float := 0.00000000245;
W_Valey_Val : Float := 0.00000000255;
W_Queen_Val : Float := 0.000000008;
W_King_Val : Float := 0.000000034;
– Dark values
B_Pawn_Val : Float := 0.000000001;
B_Tower_Val : Float := 0.000000004;
B_Chavalier_Val : Float := 0.00000000255;
B_Valey_Val : Float := 0.0000000245;
B_Queen_Val : Float := 0.000000008;
B_King_Val : Float := 0.000000034;
Et mon heuristique est devenu celle - ci (l’exemple est donné pour les noirs) :
function Black_heuristic(Ground : in Chess_Type) return Float is
Hcost : Float := 0.0;
Ucost : Float := 0.0;
Usr : Chess_Type := Chess_Type(Ground);
Successors : Successors_Type;
sum : Float := 0.0;
begin
Hcost := B_Count - (B_Count - (white_Total(Usr.white, Usr.white_last) + ((Black_Total(Usr.Black, Usr.Black_last)))));
Ucost := white_Total(Usr.white, Usr.white_last);
for Line in Line_Type loop
for Colum in Column_Type loop
if usr.Board(Line, (Colum)).Piece in WK..WP then
declare
begin
case Usr.Board(Line, (Colum)).Piece is
when Empty =>
null;
when WK =>
Sum := Sum + W_King_Val/10.0;
when WQ =>
Sum := Sum + W_Queen_Val/10.0;
when WC =>
Sum := Sum + W_Chavalier_Val/10.0;
when WV =>
Sum := Sum + W_Valey_Val/10.0;
when WT =>
Sum := Sum + W_Tower_Val/10.0;
when WP =>
Sum := Sum + W_Pawn_Val/10.0;
when others =>
null;
end case;
end;
end if;
end loop;
end loop;
Sum := 0.0;
Successors := white_Successors(Usr);
if Successors.Successor /= 0 then
for I in 1..Successors.Successor loop
declare
Tmp : Chess_Type := Chess_Type(Successors.Plan(i));
begin
if (white_Total(Tmp.white, Tmp.white_last) - white_Total(Usr.white, Usr.white_Last)) >= B_King_Val then
return -((B_King_Val * 10000.0 * Float(Ground.Round)));
else
sum := sum + (white_Total(Tmp.white, Tmp.white_last) - white_Total(Usr.white, Usr.white_Last));
end if;
end;
declare
Tmp : Chess_Type := Chess_Type(Successors.Plan(i));
Black_Succs : Successors_Type := Black_Successors(Tmp);
Sum : Float := 0.0;
Gains : Float := 0.0;
begin
for J in 1..Black_succs.Successor loop
declare
Black_Round : Chess_Type := Chess_Type(Black_succs.Plan(j));
begin
gains := gains + ((Black_Total(Black_round.Black, Black_round.Black_last) - Black_Total(Usr.Black, Usr.Black_Last)) - white_Total(Tmp.white, Tmp.white_last));
for Line in Line_Type loop
for Colum in Column_Type loop
if Black_round.Board(Line, (Colum)).Piece in BK..BP then
declare
begin
case Black_round.Board(Line, (Colum)).Piece is
when Empty =>
null;
when BK =>
Sum := Sum + B_King_Val/10.0;
when BQ =>
Sum := Sum + B_Queen_Val/10.0;
when BC =>
Sum := Sum + B_Chavalier_Val/10.0;
when BV =>
Sum := Sum + B_Valey_Val/10.0;
when BT =>
Sum := Sum + B_Tower_Val/10.0;
when BP =>
Sum := Sum + B_Pawn_Val/10.0;
when others =>
null;
end case;
end;
end if;
end loop;
end;
end loop;
Hcost := Hcost + Sum / Float(Black_succs.Successor);
Hcost := Hcost + Gains / (Float(Black_succs.Successor) * 2.0);
end;
end loop;
Ucost := Ucost + Sum;
end if;
Sum := 0.0;
for Line in Line_Type loop
for Colum in Column_Type loop
if usr.Board(Line, (Colum)).Piece in BK..BP then
declare
begin
case Usr.Board(Line, (Colum)).Piece is
when Empty =>
null;
when BK =>
Sum := Sum + B_King_Val/100.0;
when BQ =>
Sum := Sum + B_Queen_Val/40.0;
when BC =>
Sum := Sum + B_Chavalier_Val/240.0;
when BV =>
Sum := Sum + B_Valey_Val/50.0;
when BT =>
Sum := Sum + B_Tower_Val/300.0;
when BP =>
Sum := Sum + B_Pawn_Val/10.0;
when others =>
null;
end case;
end;
end if;
end loop;
end loop;
return (Hcost + Sum) - ucost;
end Black_Heuristic;
Niveau zéro, l’heuristique fait touner le jeu en boucle ; Alors que niveau 1 avec 2 de profoncdeur, C’est Light Echec and Light Mat dans les premières minutes.
J’ai interverti les valeurs des fous et des chavaliers entre les blancs et les noirs pour avoir un contraste.
La valeur des rois est scrupuleursement identique et est strictement égale à la somme des autres pièces.
Faire attention de distinguer les valeurs de la variable Sum dont la porté est différente pour ucost et hcost alors que ucost accumule le handicap pour l’état à évaluer et hcost l’avantage du même état.
Résultat obtenu : (chess-zero_player_depth_2)
Aussi, je prie de m’excuser, j’ai confondu dans un message précédent, les secondes et les dixiemes de seconde, ici il s’agit de 21 secondes contre 19.