Discussion :

[Roland Chastain]

Bonjour Jipété ! C'est à la procédure Initialize() que la chaîne doit être passée :

Code :

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

1
2
3
4
5
6
7
var
  p: tPositions;
 
begin
  p := tPositions.Create;
 
  p.current.Initialize('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');

Attention, la chaîne est supposée valide. Si cela t'intéresse, tu trouveras dans mon jeu d'échecs une unité qui permet de vérifier la validité d'une chaîne FEN (dans le dossier validator).

[Jipété]

Bonjour Roland,

et merci de ton rapide retour bien matinal, dis donc !

Bonjour Jipété ! C'est à la procédure Initialize() que la chaîne doit être passée :

Code :

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

1
2
3
4
5
6
7
var
  p: tPositions;
 
begin
  p := tPositions.Create;
 
  p.current.Initialize('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');

J'ai donc à peine modifié le code du début :

Code :

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

1
2
3
4
  (* Initialisation par défaut. Autrement le paramètre attendu est une chaîne de type FEN. *)
  if ParamStr(1) = ''
    then p.current.Initialize('')
      else p.current.Initialize(ParamStr(1));

Mais quelque chose doit m'échapper avec cette manière de travailler en console et la programmation procédurale.

Attention, la chaîne est supposée valide.

Parce que si je lui passe une chaîne valide autre que la position initiale, ça part en erreur...

Alors je vois bien dans le commentaire du début,

L'unité GAME.PAS permet de savoir, pour une position donnée du jeu des échecs,
si un coup est légal, si le roi est en échec, s'il y a mat, etc.

mais je ne vois pas comment l'unité peut me le dire, à part avec ces asserts qui me génèrent à chaque fois une bordée d'injures sur une dizaine de lignes avec Stack Trace et tout le toutim

Si cela t'intéresse, tu trouveras dans mon jeu d'échecs une unité qui permet de vérifier la validité d'une chaîne FEN (dans le dossier validator).

Oui, vu (on en a déjà [à peine] parlé, il me semble, il y a qq jours ; je me penche dessus dès que j'ai réglé le point précédent.

Mais les réponses que j'attendais pour mon autre truc urgentissime sont arrivées hier... Je bascule dans un autre monde (mais je reviendrai ici lire les réponses, pas de panique )

Bonne journée,

[Roland Chastain]

Parce que si je lui passe une chaîne valide autre que la position initiale, ça part en erreur...

C'est normal. Si tu changes la position, les assertions du programme de démonstration ne sont plus vraies.

[Jipété]

C'est normal. Si tu changes la position, les assertions du programme de démonstration ne sont plus vraies.

Oui mais non, car quand on lit ça

L'unité GAME.PAS permet de savoir, pour une position donnée du jeu des échecs,
si un coup est légal, si le roi est en échec, s'il y a mat, etc

on s'attend à un retour genre "coup légal", "échec au roi", etc.

Donc l'unité ne permet pas de savoir précisément en fait, mais juste si le coup est valide ou pas. C'est ça ?

Ou alors j'ai rien compris (ce qui n'est pas impossible, note bien )

[Roland Chastain]

Bonsoir Jipété ! Voici un exemple sans assertions.

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
program testgame;
{$APPTYPE CONSOLE}
{$IFDEF FPC}
{$MODE DELPHI}
{$ENDIF}
 
uses
  game; (* http://pascal.developpez.com/telecharger/detail/id/2833/Eschecs *)
 
const
  FEN_EXAMPLES: array[1..5] of string = (
    // Here's the FEN for the starting position:
 
    'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1',
 
    // And after the move 1. e4:
 
    'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1',
 
    // And then after 1. ... c5:
 
    'rnbqkbnr/pp1ppppp/8/2p5/4P3/8/PPPP1PPP/RNBQKBNR w KQkq c6 0 2',
 
    // And then after 2. Nf3:
 
    'rnbqkbnr/pp1ppppp/8/2p5/4P3/5N2/PPPP1PPP/RNBQKB1R b KQkq - 1 2',
 
    // For two kings on their home squares and a white pawn on e2 (White to move) with
    // thirty eight full moves played with five halfmoves since the last pawn move or
    // capture:
 
    '4k3/8/8/8/8/8/4P3/4K3 w - - 5 39'
);
 
(* http://kirill-kryukov.com/chess/doc/fen.html *)
 
var
  p: TPositions;
 
begin
  p := TPositions.Create;
  p.current.Initialize(FEN_EXAMPLES[2]);   // Initialiser la position.
 
  WriteLn(p.current.activeColor = cBlack); // Est-ce au Noir de jouer ?
  WriteLn(p.current.ForsythEdwards);       // Quelle est la représentation FEN de la position ?
 
  p.GenerateLegalMoves;                    // Générer la liste des coups légaux.
 
  WriteLn(p.IsLegal('e7e5'));              // e7e5 est-il un coup légal ?
  WriteLn(p.state = checkmate);            // Y a-t-il échec et mat ?
  WriteLn(p.current.varCheck);             // Y a-t-il échec ?
 
  p.current.Play('e7e5', cQueen);          // Modifier la position en jouant e7e5.
 
  WriteLn(p.current.ForsythEdwards);       // Obtenir la représentation FEN de la position.
 
  p.Free;
end.

[Roland Chastain]

Bonsoir ! Rien de neuf à l'extérieur mais le code a été retravaillé. Nous avons désormais une unité bgrachessboard.

[Jipété]

Bonsoir Roland,

Bonsoir Jipété ! Voici un exemple sans assertions.

et merci infiniment pour ton bout de code ! Avec les explications et les dialogues, ça devient lumineux !

[gvasseur58]

Bonsoir ! Rien de neuf à l'extérieur mais le code a été retravaillé. Nous avons désormais une unité bgrachessboard.

Bonjour,

C'est très beau Cela dit, j'ai repéré un bogue facile à reproduire (j'ai dérapé avec la souris pour m'en rendre compte ) :
* on clique deux fois sur une pièce ;
* on clique ensuite sur une case vide : un messages d'erreur "case vide" apparaît ;
* on reclique sur la première pièce : la case est déclarée vide
La pièce disparaît ensuite au prochain déplacement d'une autre pièce...

Je n'ai pas encore vu le code, mais il semblerait que l'effacement de la pièce ait lieu préalablement à la vérification de son changement effectif de destination. En gros, la pièce se mange elle-même

Bonne continuation,

Gilles

[Roland Chastain]

Cela dit, j'ai repéré un bogue facile à reproduire (j'ai dérapé avec la souris pour m'en rendre compte ) :

Voilà, c'est réparé. Merci d'avoir attiré mon attention sur ce point.

[gvasseur58]

Voilà, c'est réparé. Merci d'avoir attiré mon attention sur ce point.

Bonjour,

Et pas de souci : cette discussion que je suis sans intervenir souvent est une des plus intéressantes que j'aie jamais vue

En revanche, je voudrais juste revenir sur les classes telles qu'elles apparaissent dans le projet. Prenons par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
TBGRAChessPiece = class
    bitmap: TBGRABitmap;
    x, y: integer;
    id: string;
    constructor Create(aWidth, aHeight: integer);
    destructor Destroy; override;
    procedure Reload(aId: string; aTransparentColor: TBGRAPixel);
    procedure Locate(aX, aY: integer);
  end;

Cette classe ne me plaît pas Je ne veux pas jouer les puristes, mais le fait que les champs soient tous publics pose doublement problème : ils sont modifiables partout dans le reste du code sans garde-fou et ils ne laissent pas de possibilité d'être modifiés sans avoir à vérifier tout le code. Avec des noms comme x et y, ce n'est pas gagné
Je proposerais volontiers une forme plus classique, à l'apparence plus lourde mais à la robustesse éprouvée :

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
TBGRAChessPiece = class
  strict private
    fBitmap: TBGRABitmap;
    fX, fY: integer;
    fId: string;
    procedure SetId(AValue: string);
    procedure SetX(AValue: integer);
    procedure SetY(AValue: integer);
  public
    constructor Create(aWidth, aHeight: integer);
    destructor Destroy; override;
    procedure Reload(aId: string; aTransparentColor: TBGRAPixel);
    procedure Locate(aX, aY: integer);
    property Bitmap: TBGRABitmap read fBitmap write fBitmap;
    property X: integer read fX write SetX default -1;
    property Y: integer read fY write SetY default -1;
    property Id: string read fId write SetId;
  end;

Apparemment, c'est beaucoup plus lourd. En fait, il n'y aura que 3 méthodes en plus qui seront d'ailleurs générées automatiquement par la pression sur Ctrl-Maj-C.
Le code restant n'a même pas à être retouché puisque l'accès est transparent à l'extérieur de la classe. Mais si tu souhaites modifier par la suite les actions accomplies lors de la modification d'une propriété, tu n'auras rien à modifier dans le restant du code : pas d'oublis et pas d'erreurs en vue. (3 modifier dans la même phrase, c'est presque un record )

La remarque me semble encore plus vraie en ce qui concerne la classe TBGRAChessBoard : et si elle devenait un jour un composant ? et si on pouvait proposer à l'utilisateur le choix du fond (marbré, simple, coloré,...)? Sans ce travail préalable, fastidieux mais rentable à terme, ça va être du sport...

Ces remarques n'engagent que moi, bien sûr, et je salue les avancées spectaculaires du programme.

Gilles

NB : Dans le constructeur Create, on fixe déjà X et Y à -1 (comme annoncé dans l'interface), ce qui fait gagner des lignes à chaque création et autant d'occasions d'oublier cette initialisation.

[Roland Chastain]

Merci Gilles, pour les encouragements et les corrections, que j'ai appliquées (peut-être imparfaitement).

Pour ce qui est de faire évoluer le code en composant, c'est une idée très intéressante en soi mais je ne suis pas sûr d'avoir la motivation pour le faire. Je suis content d'avoir une jolie interface graphique mais je ne veux pas y passer trop de temps, autrement je n'avancerai jamais sur les sujets qui sont mon objectif (la programmation d'un moteur, ou encore l'utilisation du protocole UCI).

[gvasseur58]

Merci Gilles, pour les encouragements et les corrections, que j'ai appliquées (peut-être imparfaitement).

Pour ce qui est de faire évoluer le code en composant, c'est une idée très intéressante en soi mais je ne suis pas sûr d'avoir la motivation pour le faire.

Eh oui, tu veux garder la belle part ... et tu as mille fois raison

Je vais regarder le nouveau source, voir comment je peux le traiter avec Lazarus et essayer d'en faire un composant : l'essentiel a été réalisé, je le sais. Je serai donc un inspecteur des travaux finis, ce qui est assez confortable

Bonne continuation,

Gilles

[Roland Chastain]

Je vais regarder le nouveau source, voir comment je peux le traiter avec Lazarus et essayer d'en faire un composant : l'essentiel a été réalisé, je le sais. Je serai donc un inspecteur des travaux finis, ce qui est assez confortable

Alors ça c'est très gentil. J'ai hâte de voir le résultat. Note que si jamais tu veux passer de fpGUI à la LCL, je pense que tu n'auras qu'à modifier l'en-tête de cette fonction :

Code :

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

procedure DrawToCanvas(x, y: integer; aCanvas: TfpgCanvas);

Une autre remarque (mais tu t'en serais aperçu tout seul), c'est que partout dans mon code j'ai supposé que mes cases étaient de 40 pixels sur 40, et je n'ai pas prévu que ce paramètre puisse être changé. Donc soit tu continues sur la même lancée, soit il y aura du travail supplémentaire.

[Roland Chastain]

Il y a un défaut dans la conception de mon échiquier, qui est pratiquement négligeable mais je crois que je n'aurai pas l'esprit tranquille tant que je ne l'aurai pas corrigé.

Il y a 32 pièces, mais il n'y a que 12 images, alors que moi j'en ai déclaré 32. En fait je m'aperçois que mon objet TBGRAChessPiece est une agglomération de données qui n'ont rien à faire ensemble. Je crois qu'il faudrait plutôt partir sur quelque chose de ce genre :

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
type
  TChessPieceColor = (pcWhite, pcBlack);
 
  TChessPieceType = (ptPawn, ptKnight, ptBishop, ptRook, ptQueen, ptKing);
 
  TChessPiece = class
    fX, fY: integer;
    fColor: TChessPieceColor;
    fType: TChessPieceType;
  end;
 
  ...
 
  TBGRAChessBoard = class
      pieces: array[1..32] of TChessPiece;
      pictures: array[TChessPieceColor, TChessPieceType] of BGRABitmap;

Ce qui m'obligerait à tout refaire. Mais ça vaut le coup, non ?

[gvasseur58]

Ce qui m'obligerait à tout refaire. Mais ça vaut le coup, non ?

Bonsoir,

Il est vrai que les nouvelles définitions sont très parlantes sans avoir même jeté un coup d’œil au code source
Cependant, ce n'est pas grave de passer à autre chose : a priori, la partie IA doit être la plus indépendante possible de l'affichage.
Elle peut peut-être s'appuyer sur ces nouvelles structures, mais je crois que tu avais déjà une solution qui fonctionnait dans l'ancienne version, non ?

Gilles

[Roland Chastain]

Bonjour Gilles (et les autres) !

Voilà, j'ai fini de tout refaire. Par contre je n'ai pas encore appliqué la correction que tu avais proposé précédemment : il faut que je prenne un peu de temps pour me familiariser avec ces propriétés que je n'ai pas l'habitude d'utiliser.

Oui, les différentes parties de mon jeu d'échecs sont assez indépendantes les unes des autres, mais je voudrais quand même finir mon échiquier graphique avant de penser à autre chose. J'ai l'intention de monter sur la nouvelle interface graphique les composants de la version précédente du jeu (arbitre, moteur, livre) en les revoyant un peu au passage.

Attention, la case a4 est magique.

[Jipété]

Salut, Roland,

Voilà, j'ai fini de tout refaire.

100 fois sur le métier remets-toi à l'ouvrage qu'il disait, l'autre,

Attention, la case a4 est magique.

Rien trouvé
Essayé avec Ctrl-clic, Shift-clic, se passe rien...
Du coup suis allé regarder un peu dans le code, rien trouvé non plus, mais j'ai découvert un truc qui m'a chagriné :

Code :

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

1
2
3
4
5
6
7
8
9
10
initialization
  loglist := TStringList.Create;
  logfile := ChangeFileExt({$I %FILE%}, '.log');
 
finalization
  with loglist do
  begin
    SaveToFile(logfile);
    Free;
  end;

Ce qui veut dire que si pour une raison ou pour une autre ton prog plante violemment, tu n'auras pas de log... Moi je mettrais ce SaveToFile dans la proc ToLog.
Ok, ça va générer un accès disque à chaque log, mais au moins on aura du log.
Après, bien sûr, chacun fait comme il l'entend, cordonnier est maître chez lui !

Tiens, au fait, tu as abandonné les pièces en police pour revenir à du bitmap ?

Moi aussi, à cause des problèmes de transparence.
Ce qui a engendré ma récente discussion à propos du resize à la volée des images et listes d'images (suite à jeux avec le prog de glenat, où j'utilisais mon échiquier qui me servait juste de bloc-notes et où je me suis rendu compte que les pièces étaient trop grandes.)
Voili voilou,

[Roland Chastain]

Merci pour ton coup d'œil Jipété. Oui, pour le log, tu as raison.

Si tu déplaces une pièce sur la case a4, elle se change en Dame.

Concernant les polices True Type, je continue de m'intéresser au sujet. J'ai fait quelques essais de génération d'images PNG avec Cairo et BGRABitmap. Cette solution me plairait peut-être davantage que d'utiliser directement une police (encore qu'avec la solution basée sur LazFreeType l'installation de la police ne soit pas requise, si j'ai bien compris).

[Jipété]

Si tu déplaces une pièce sur la case a4, elle se change en Dame.

Ah ouais, ça c'est de la promotion

Concernant les polices True Type, je continue de m'intéresser au sujet. J'ai fait quelques essais de génération d'images PNG avec Cairo et BGRABitmap. Cette solution me plairait peut-être davantage que d'utiliser directement une police (encore qu'avec la solution basée sur LazFreeType l'installation de la police ne soit pas requise, si j'ai bien compris).

Si tu arrives à rendre l'intérieur d'une pièce blanche en blanc tout en conservant l'extérieur transparent, tu m'intéresses !
Ou alors il faut utiliser les pièces sur fond hachuré, ça limite l'esthétique, et selon la taille choisie on voit apparaître de fins traits blancs entre les bords de l'échiquier, ça limite aussi...
Enfin, pas moyen de régler la taille des coordonnées (si on choisit de les afficher) ; du coup j'ai abandonné cette voie

Tiens, j'en suis là, avec à droite un essai utilisant les pièces en police truetype, et dessous une copie d'écran de ta dernière livraison, où l'on constate que les images sont un peu en escalier, ce que j'avais constaté aussi lors de mes essais d'hier, effet d'escalier disparaissant en mettant les images dans une liste d'images, à moins que ça soit lié au format png (ou les deux ; comme dit hier, suis pas spécialiste du graphisme, loin de là) ; tu devrais peut-être tenter le coup... :

[Roland Chastain]

Si tu arrives à rendre l'intérieur d'une pièce blanche en blanc tout en conservant l'extérieur transparent, tu m'intéresses !

Voici une idée. J'ai fabriqué (avec Cairo) une image PNG de 160 sur 160 à partir d'un caractère de la police Chess Condal. Puis j'ai redimensionné en 40 sur 40 avec LazPaint (qui fait de très belles réductions). Le résultat est bien meilleur qu'en fabriquant l'image directement en 40 sur 40.

Maintenant, pour le fond, j'ai refait la même chose mais en plus, avant de redimensionner, j'ai rempli l'intérieur de l'image (toujours dans Lazpaint) avec du blanc pas tout à fait blanc (254, 254, 254). Maintenant, dans le code de mon échiquier, j'ai choisi le blanc (255) comme couleur transparente. Eh bien, le principe est bon. Il reste quelques pixels de l'arrière plan (dans mon cas les rayures de la case) qui apparaissent ça et là, ce qui doit pouvoir se corriger je pense. Peut-être faut-il faire les dernières corrections à la main.