Discussion :

[Jipété]

Si tu avais le temps et l'envie de contribuer à ce projet, tu serais le bienvenu.

Merci de ta proposition, mais je n'ai déjà pas le temps de mener à bien mes projets...

En ce qui concerne le vert et le rouge, les couleurs sont dans le fichier colors.txt. J'avais fait ça justement pour pouvoir faire des réglages sans recompiler l'application à chaque fois. Si tu trouves des couleurs qui te paraissent plus appropriées, j'adopterai volontiers ta proposition.

Et pour ne rien te cacher, je n'ai pas téléchargé ton projet, je me suis juste contenté de regarder l'image et d'écrire ce que j'ai ressenti.

Je n'ai plus le temps de jouer aux échecs (ou à autre chose, d'ailleurs)...

[Roland Chastain]

@Jipété

En tout cas merci pour tes observations. J'en ai tenu compte et j'ai choisi des couleurs un peu plus foncées.

[Roland Chastain]

Si je comprends bien, tu as un contour antialiasé et tu veux le remplir.

Alors oui tu peux le faire dans LazPaint :
- crée un calque vide en dessous de l'image
- dans le calque avec le contour, utilise l'outil baguette magique : met la tolérance à 254 (c'est presque le max quoi)
- clique dans les formes à remplir pour obtenir la sélection de l'interieur
- clique sur le calque en dessous et utilise le pot de peinture : met la couleur de remplissage
- clique pour peindre
- fusionne les calques

La méthode par programme, avec certaines polices, ne réussit pas à remplir toutes les surfaces. Du coup je suis obligé de passer par LazPaint pour retoucher certaines images, une seule en l'occurrence, le fou de la police Chess Alpha.

Comment fait-on pour créer le calque vide en dessous de l'image ?

[Roland Chastain]

Ça y est, j'ai compris le principe.

Ça mériterait presque d'en faire un petit tutoriel. Avec la version LazPaint et la version code.

[Roland Chastain]

La nouvelle version d'Eschecs est prête et devrait être publiée d'un jour à l'autre. Un fichier projet MSEide/ideU se trouvant dans le répertoire source/ du dépôt Github permet, en principe, de compiler l'application aussi bien sous Windows que sous Linux.

[Roland Chastain]

La méthode par programme, avec certaines polices, ne réussit pas à remplir toutes les surfaces.

Je m'aperçois que faire les images plus grandes règle le problème.

[Roland Chastain]

Bonjour ! Un premier empaquetage de la nouvelle version d'Eschecs est disponible, pour Windows 32 bit. Les autres plateformes devraient suivre. Je vous laisse découvrir les nouveautés de cette version. Merci pour vos éventuels retours.

https://github.com/rchastain/eschecs/releases

Un grand merci à Fred van Stappen, qui par sa contribution a fait faire un grand pas en avant à ce projet.

[circular17]

Félicitations !

Cela marche nickel sur mon linux 64.

[Roland Chastain]

Bonjour !

Ces jours-ci je travaille sur le cœur de mon moteur d'échecs, l'unité qui génère les coups pour une position donnée et les évalue.

L'unité fonctionne bien, mais comme l'évaluation est récursive, la profondeur est limitée. Au-delà d'une certaine profondeur, le programme ne répond plus ou se plante.

Voici la partie du code qui pose problème.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function TChessPosition.BestEval(const aColor, aDepth, aAlpha: integer): integer;
var
  vValue, vBeta, i: integer;
  vPos: TChessPosition;
  vStop: boolean;
begin
  GenerateMoves;
  i := 0;
  vBeta := -32000 * active * aColor;
  vPos := TChessPosition.Create;
  vStop := FALSE;
  while (i < count) and not vStop do
  begin
    Inc(i);
    vPos.SetPosition(self);
    with vPos.moveList[i] do vPos.MovePiece(f, t, cQueen);
    if (aDepth >= vMinDepth) and (board[moveList[i].t] = cNil) or (aDepth = vMaxDepth) then
      vValue := vPos.Eval(aColor)
    else
      vValue := vPos.BestEval(aColor, aDepth + 1, vBeta);

Je suis en train de chercher comment je pourrais dérécursifier la fonction, pour pouvoir augmenter à volonté la profondeur. Je mets le code en pièce jointe, si quelqu'un veut se pencher sur le problème avec moi.

P.-S. Merci Johann !

[Roland Chastain]

La prochaine version du jeu est sur le feu.

La principale nouveauté est le passage des échecs traditionnels aux échecs 960. Autre nouveauté, la partie peut être sauvegardée dans un fichier PGN. Enfin, le jeu a de nouvelles pièces.

On ne peut plus changer la langue, ni le style de l'échiquier, à partir du menu, mais seulement par les paramètres de la ligne de commande. Par la suite j'ai l'intention de faire un lanceur qui permette de choisir les options.

Le jeu peut être téléchargé sur cette page. Il y a une version Linux et une version Windows (les deux en 64 bits).

En conséquence du passage aux échecs 960, la façon de roquer a changé : il faut déposer le roi sur la tour.

Merci d'avance pour votre éventuelles contributions, quelles qu'elles soient.

[Roland Chastain]

Une nouvelle version est disponible au même endroit.

Donc à présent il y a une petite application séparée qui permet de lancer le jeu avec les options désirées : langage, style de pièces, taille de l'échiquier, temps alloué à l'ordinateur...

[Roland Chastain]

Bonjour ! Un candidat à la publication pour la version 5.0.0 est disponible ici.

[Guesset]

Bonjour Roland,

Avant de te lancer dans la douloureuse "dérécursivation" tu peux déjà retirer aColor des arguments passés puisque tous les appels utilisent la même valeur. Par exemple ainsi (pas optimal mais rendant la modification invisible du reste du programme):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
var aColor : Integer;
function TChessPosition.BestEval(const aClr, aDepth, aAlpha: integer): integer;
begin
   aColor := aClr;
   Return := BestEval2(const aDepth, aAlpha: integer);
end;

BestEval2 reprend le code initial avec un argument en moins donc moins d'occupation sur la pile.

De même, tu peux remplacer l'utilisation de vStop par un break en prenant néanmoins la précaution de remonter moveList[i].v := vValue; avant le test if active = aColor then begin..... Ca devrait ressembler à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
   for i:= 1 to Count do begin
      vPos.SetPosition(self);
      with vPos.moveList[i] do vPos.MovePiece(f, t, cQueen);
      if (aDepth >= vMinDepth) and (board[moveList[i].t] = cNil) or (aDepth = vMaxDepth) 
      then vValue := vPos.Eval(aColor)
      else vValue := vPos.BestEval(aColor, aDepth + 1, vBeta);
      moveList[i].v := vValue;
      if active = aColor 
      then begin 
         vBeta := max(vValue, vBeta);
         if vBeta> aAlpha then break;
      end
      else begin
         vBeta:= min(vValue, vBeta);
         if vBeta< aAlpha then break;
      end;
   end;

Tout cela diminue l'empreinte sur la pile (entre 17 et 25 % selon les options d'alignement) et donc augmente la profondeur d'appel d'autant (à l'ordre 1 ).
Bien sûr il est possible d'augmenter la taille de la pile (40k par défaut je crois) et du tas.
Bon courage

[Guesset]

Bonjour Roland,

Avec retard, je pense que tu peux aussi te passer de aDepth avec une variable globale que chaque entrée dans BestEval2 incrémente et chaque sortie décrémente.

De même, tu pourrais éviter vBeta en utilisant en lieu et place Result.

Ça pourrait ressembler au code suivant (les éventuelles erreurs en moins) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
var
   _Color, _Depth : Integer;
 
function TChessPosition.BestEval(const aColor, aDepth, aAlpha : integer): integer;
begin
   _Color := aColor;
   _Depth := aDepth-1;
   TChessPosition.BestEval2(aAlpha);
end;
 
function TChessPosition.BestEval2(const aAlpha: integer): integer;
var
   vPos  : TChessPosition;
   vValue, i : integer;
begin
   inc(_Depth);
   GenerateMoves;
   Result:= -32000 * active * _Color;
   vPos  := TChessPosition.Create;
   for i := 1 to Count do begin
      vPos.SetPosition(self);
      with vPos.MoveList[i] do vPos.MovePiece(f, t, cQueen);
      if (_Depth >= vMaxDepth) or ((_Depth >= vMinDepth) and (board[moveList[i].t] = cNil))  
      then vValue := vPos.Eval(_Color)
      else vValue := vPos.BestEval2(Result);
      if active = _Color 
      then begin 
         Result := max(vValue, Result);
         if Result > aAlpha then break;
      end
      else begin
         Result := min(vValue, Result);
         if Result < aAlpha then break;
      end;
      MoveList[i].v := vValue;
   end;
   vPos.Free;
   dec(_Depth);
end;

Par ailleurs, il faut espérer que l'utilisation par le créateur du code initial des multiplications par 1 et -1 (couleurs) soient bien optimisées par le compilateur (mais j'ai un doute). Utiliser des couleurs à cWhite=0 et cBlack=$80000000 (ou l'inverse) serait beaucoup plus rapide :

• C1*C2 -> C1 xor C2
• piece_coloree := piece * C1; -> piece_coloree := piece or C1;
• piece := piece_coloree * C1; -> piece := piece_coloree and $7FFFFFFF;
• if piece_coloree > 0 then couleur := cWhite else couleur := cBlack; -> couleur := piece_coloree and cBlack;
• R := -32000 * C1 * C2; -> if C1=C2 then R := -32000 else R := 32000; (plus long mais plus rapide)

De même, utiliser un tableau linéaire pour l'échiquier avec séparation x,y par des multiples de 10 laisse perplexe. Cependant je n'ai pas une vue d'ensemble et si ça marche...

Bonne journée

[Roland Chastain]

@Guesset

Merci beaucoup pour cette contribution ! Je vais essayer les modifications en question.

Pour les couleurs et aussi la représentation de l'échiquier, je pense que l'auteur du programme a moins cherché l'efficacité que la facilité de compréhension. Mais je ne suis pas contre changer certaines choses. Je vais étudier le système que tu proposes pour les couleurs.

Bonne journée à toi également !

[Roland Chastain]

@Guesset

J'ai appliqué les modifications que tu as proposées (sauf pour la notation des couleurs, qui demande encore réflexion).

Soit dit en passant, j'ai vu que tu avais remplacé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if vValue > result then result := vValue;

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

result := Max(vValue, result);

Je me suis demandé si c'était une question de brièveté d'écriture ou s'il y avait aussi une différence d'efficacité.

Maintenant je vais essayer d'augmenter un peu la profondeur pour voir si ça fonctionne et si le programme est un peu plus fort.

[Guesset]

Bonjour Roland,

Utiliser min et max n'est pas fondamental. C'est théoriquement un peu plus rapide. Je n'ai pas vérifié, mais en Delphi cela faisait partie des "not a real function" c'est à dire que c'était plus une instruction du langage qu'une vrai fonction donc mieux optimisée par le compilateur (vraisemblablement un cmp puis un cmov..). Je pense que c'est pareil en Lazarus mais la doc étant ce qu'elle est... En fait c'est surtout plus concis et plus lisible mais c'est une appréciation assez subjective.

Pour les optimisations, il est possible qu'il y ait non seulement un problème de pile d'appels mais également de tas que consomme allègrement les allocations dynamiques lors de la création d'objets comme TChessPosition.

Est ce que tu sais à quelle profondeur ça bloque et à quelle profondeur tu souhaites aller ?

Salut

[Roland Chastain]

@Guesset

Bonjour ! Merci pour ces précisions.

Non, je ne saurais dire exactement à quelle profondeur ça bloque. Ça peut varier d'une partie à l'autre.

Autrement ce que j'aimerais, c'est que la profondeur soit pratiquement illimitée, et que la recherche s'arrête seulement lorsque le temps imparti est écoulé. C'est comme ça que les "vrais" programmes d'échecs fonctionnent. En anglais ils appellent ça je crois iterative deepening.

Là je suis en train de faire des essais pour voir si, avec les modifications que tu as indiquées, le programme supporte une plus grande profondeur. À ce stade ce que je peux dire c'est que la version modifiée du programme fonctionne, ce qui est déjà une bonne nouvelle.

À bientôt pour la suite !

[Roland Chastain]

La version 5.0.0 d'Eschecs est prête, sauf avis contraire.

https://github.com/rchastain/eschecs/releases

Merci de l'essayer, si vous en avez le temps et le désir.

[Guesset]

Bonjour Roland,

Je jette un œil sur le code de TChessPosition qui vraisemblablement joue un rôle au travers de la multiplication des instanciations sur la profondeur limitée atteignable.

Je ne suis pas sûr de tout comprendre mais la MoveList est déclarée avec 100 éléments or s'il ne peut y avoir plus de 100 mouvements, il me semble que la profondeur ne peut excéder cette valeur.

Ensuite, pourquoi recopier systématiquement cette liste d'étape en étape puisque seul le dernier mouvement est nouveau. Je pense qu'il faudrait créer une liste d'étapes (les TChessPosition) et accéder aux mouvements passés au travers des indices de cette liste. Cela se rapprocherait de la gestion manuelle que tu avais évoqué.

Salut