Discussion :

[forum]

Bonjour,

Je vous propose un nouvel élément à utiliser : MATER - Recherche de mat à partir d'une position donnée d'une partie d'échecs.

MATER - Un programme simple de recherche de mat. Valentin Albillo, 1998.

MATER est un programme simple de recherche de mat, implémenté comme une commande MS-DOS. Etant donné 1° une position légale notée au format FEN, 2° la couleur qui a le trait et 3° un nombre de coups, le programme cherche un coup qui aboutit à un mat en un nombre de coups inférieur ou égal à la limite prescrite.

J'avais téléchargé il y a quelques mois le code source de ce programme, ainsi que la page de présentation au format HTM. Or je viens de constater que la page en question est devenue indisponible.

C'est pourquoi je me suis permis d'ajouter le source source et la page de présentation originale dans les sources de developpez.com.

J'ai compilé le code avec Free Pascal 2.6.2, et ajouté deux fichiers BAT faits pour essayer le programme. A noter : le premier champ de la chaîne FEN doit se terminer par un "/" pour être reconnu comme valide par le programme.

Roland Chastain, 22 novembre 2013.

Qu'en pensez-vous ?

[Roland Chastain]

Bizarrement, quand je compile le code avec Virtual Pascal, le programme ne fonctionne pas correctement. L'initialisation de l'échiquier (à partir de la chaîne passée en paramètre) ne se fait pas comme il faut. Je ne sais pas ce qui peut expliquer cette différence.

[Roland Chastain]

J'ai réécrit la fonction FEN2Posit, puisqu'apparemment le problème venait de là. (A noter que pour alléger le code, j'ai supprimé le contrôle de la validité de la chaîne.) A présent le programme fonctionne correctement quel que soit le compilateur.

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
60
61
62
63
64
65
(* 
    converts a string representing a FEN position to an internal 
    representation.
*)
 
FUNCTION FEN2Posit(fen: strg80): boolean;
var
  x, y, i, j: integer;
  c: char;
begin
  x := 1;
  y := 8;
  i := 1;
  with Posit do
  begin
    while i <= Length(fen) do
    begin
      c := fen[i];
      case Upcase(c) of
        'P', 'N', 'B', 'R', 'Q', 'K':
          begin
            case c of
              'p': Board[10 * (10 - y) + x + 1] := BlackPawn;
              'n': Board[10 * (10 - y) + x + 1] := BlackKnight;
              'b': Board[10 * (10 - y) + x + 1] := BlackBishop;
              'r': Board[10 * (10 - y) + x + 1] := BlackRook;
              'q': Board[10 * (10 - y) + x + 1] := BlackQueen;
              'k': Board[10 * (10 - y) + x + 1] := BlackKing;
              'P': Board[10 * (10 - y) + x + 1] := WhitePawn;
              'N': Board[10 * (10 - y) + x + 1] := WhiteKnight;
              'B': Board[10 * (10 - y) + x + 1] := WhiteBishop;
              'R': Board[10 * (10 - y) + x + 1] := WhiteRook;
              'Q': Board[10 * (10 - y) + x + 1] := WhiteQueen;
              'K': Board[10 * (10 - y) + x + 1] := WhiteKing;
            end;
            Inc(x);
          end;
        '1'..'8':
          begin
            j := Ord(c) - Ord('0');
            while j > 0 do
            begin
              Board[10 * (10 - y) + x + 1] := Blank;
              Inc(x);
              Dec(j);
            end;
          end;
        '/':
          begin
            x := 1;
            Dec(y);
          end;
      end;
      Inc(i);
    end;
    if Board[26] = BlackKing then KingCastle[Black] := true else KingCastle[Black] := false;
    if Board[Top] = BlackRook then QueenRookCastle[Black] := true else QueenRookCastle[Black] := false;
    if Board[29] = BlackRook then KingRookCastle[Black] := true else KingRookCastle[Black] := false;
    if Board[96] = WhiteKing then KingCastle[White] := true else KingCastle[White] := false;
    if Board[92] = WhiteRook then QueenRookCastle[White] := true else QueenRookCastle[White] := false;
    if Board[Bot] = WhiteRook then KingRookCastle[White] := true else KingRookCastle[White] := false;
    EnPassantSquare := None;
  end;
  result := true;
end;

Reste une chose bizarre que j'observe : ce qui est affiché dans la console varie d'une fois sur l'autre, avec le même exécutable et le même fichier de commande ! Tantôt tous les caractères sont bien en place, tantôt ils sont mal rangés (mais apparemment les valeurs internes du programme ne sont pas affectées).
Je n'ai observé ce phénomène que lorsque j'ai compilé avec Virtual Pascal. Avez-vous la moindre idée de ce qui pourrait expliquer cela ?

[Alcatîz]

Bonjour,

Merci pour le partage de ce code source !

Reste une chose bizarre que j'observe : ce qui est affiché dans la console varie d'une fois sur l'autre, avec le même exécutable et le même fichier de commande ! Tantôt tous les caractères sont bien en place, tantôt ils sont mal rangés (mais apparemment les valeurs internes du programme ne sont pas affectées).
Je n'ai observé ce phénomène que lorsque j'ai compilé avec Virtual Pascal. Avez-vous la moindre idée de ce qui pourrait expliquer cela ?

Je ne reproduis pas ce problème sur ma machine.

[Roland Chastain]

Merci pour le partage de ce code source !

Merci, Alcatîz, pour ta réponse. Ce programme méritait d'être mis en lieu sûr.

Je ne reproduis pas ce problème sur ma machine.

D'accord, c'est gentil d'avoir regardé. Cela restera un mystère mais heureusement ça n'a pas vraiment d'importance.

Je vais essayer de modifier le programme, de façon à en faire une unité, sans affichage, avec seulement une fonction qui renvoie le résultat trouvé. Avec une profondeur de trois coups, la recherche ne prend qu'une fraction de seconde. Voilà de quoi relever sensiblement le niveau d'un programme.

En attendant, j'apprends pas mal de choses en lisant ce code. Rien que dans la déclaration des types, on trouve déjà des idées intéressantes, je pense par exemple à l'usage qui est fait du type set of :

Code :

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

1
2
3
type
  squares = set of 1..120;
  tArraySquares = array[black..white] of squares;

Je suis seulement ennuyé pour trouver un nom français à mon unité (conformément à ce que j'ai fait pour les autres parties de mon projet). Mateur fait malheureusement penser à tout autre chose.

Tueur ne me plaît pas non plus, quoique ce soit le sens étymologique du mot "mat" (du moins d'après ce que je crois savoir). Peut-être Matador, qui est reçu en français, et qui est moins désagréable à entendre ?

[Roland Chastain]

Reste une chose bizarre que j'observe : ce qui est affiché dans la console varie d'une fois sur l'autre, avec le même exécutable et le même fichier de commande !

J'ai supprimé la variable device, dont je ne voyais pas l'utilité : le problème a disparu.

[Alcatîz]

Peut-être Matador, qui est reçu en français, et qui est moins désagréable à entendre ?

Il me plaît, celui-là !

[Roland Chastain]

Il me plaît, celui-là !

Voici la première version de l'unité Matador.pas.

L'interface de l'unité consiste en une seule fonction, dont les arguments correspondent aux paramètres de la ligne de commande acceptée par le programme original.

Code :

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

1
2
3
4
5
6
function SolveMate(
  const aPiecePlacement: string;
  const aActiveColor: char;
  const aMoveNumber: integer;
  const aComputeAllMoves: boolean
): string;

La fonction renvoie le coup trouvé sous la forme "b6b8", ou une chaîne vide.

[Roland Chastain]

Bonjour !

J'ai donné un grand coup de chiffon dans l'unité Matador (raccourci le code d'une centaine de lignes, remplacé une grande partie des noms par des noms plus explicites). Le code est devenu plus lisible et compréhensible, même s'il reste encore un peu de travail à faire à l'intérieur des procédures.

J'ai complété le programme de test, en incluant tous les exemples de la documentation. Tout fonctionne !

C'est un bien joli programme je trouve, et j'espère encore y retravailler. Une prochaine étape pourrait être de supprimer les goto mais j'ai besoin de réfléchir à deux fois avant de m'y attaquer. Si quelqu'un d'autre veut y mettre la main ou simplement faire une suggestion, n'hésitez pas !

[Roland Chastain]

J'ai fini le renommage des variables et complété la fonction qui lit la chaîne FEN. Du coup l'en-tête de la fonction principale a changé :

Code :

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

  WriteLn('b7a8' = SolveMate('b7/PP6/8/8/7K/6B1/6N1/4R1bk w KQkq -', 3, SEARCH_ALL_MOVES)); // TRUE

[Roland Chastain]

Bonjour !

J'ai retravaillé mon adaptation du programme de V. Albillo. Le programme peut désormais être utilisé soit comme unité, soit comme bibliothèque dynamique.

[Roland Chastain]

Bonjour ! Je vous propose une nouvelle version de Mater, sous la forme d'une librarie dynamique. L'archive inclut des exemples d'utilisation en Basic, en C et en Pascal.

Sur la technique utilisée pour le passage des chaînes de caractères à la DLL, voir cette discussion avec la solution proposée par Paul TOTH (et qui est celle que j'ai adoptée).

Il est à noter qu'il reste possible d'utiliser directement l'unité matercore.

[Roland Chastain]

Bonjour !

Une nouvelle version du programme est disponible. De nombreuses petites corrections ont été apportées. La syntaxe de la ligne de commande a été entièrement refaite. Le programme a été testé sous Linux et sous Windows.

Télécharger Mater

J'ai provisoirement abandonné la compilation du programme sous la forme de bibliothèque dynamique. Il faudra que j'y revienne, en essayant de voir si j'arrive aussi à le faire sous Linux.

Il serait également intéressant d'essayer de compiler avec Delphi, ce que je n'ai pas encore eu le temps de faire.

Comme toujours, vos commentaires sont bienvenus.

Problème du jour : Les blancs jouent et font mat en trois coups.

[Roland Chastain]

Une nouvelle version du programme est disponible. Une erreur importante (relative à la couleur des pions) a été découverte... et corrigée.

Grâce à cette position :



Les blancs font mat en quatre coups.

Le programme fonctionne sous Linux et sous Windows.


Mater for Free Pascal

[anapurna]

Salut

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
60
61
62
63
64
65
(* 
    converts a string representing a FEN position to an internal 
    representation.
*)
 
FUNCTION FEN2Posit(fen: strg80): boolean;
var
  x, y, i, j: integer;
  c: char;
begin
  x := 1;
  y := 8;
  i := 1;
  with Posit do
  begin
    while i <= Length(fen) do
    begin
      c := fen[i];
      case Upcase(c) of
        'P', 'N', 'B', 'R', 'Q', 'K':
          begin
            case c of
              'p': Board[10 * (10 - y) + x + 1] := BlackPawn;
              'n': Board[10 * (10 - y) + x + 1] := BlackKnight;
              'b': Board[10 * (10 - y) + x + 1] := BlackBishop;
              'r': Board[10 * (10 - y) + x + 1] := BlackRook;
              'q': Board[10 * (10 - y) + x + 1] := BlackQueen;
              'k': Board[10 * (10 - y) + x + 1] := BlackKing;
              'P': Board[10 * (10 - y) + x + 1] := WhitePawn;
              'N': Board[10 * (10 - y) + x + 1] := WhiteKnight;
              'B': Board[10 * (10 - y) + x + 1] := WhiteBishop;
              'R': Board[10 * (10 - y) + x + 1] := WhiteRook;
              'Q': Board[10 * (10 - y) + x + 1] := WhiteQueen;
              'K': Board[10 * (10 - y) + x + 1] := WhiteKing;
            end;
            Inc(x);
          end;
        '1'..'8':
          begin
            j := Ord(c) - Ord('0');
            while j > 0 do
            begin
              Board[10 * (10 - y) + x + 1] := Blank;
              Inc(x);
              Dec(j);
            end;
          end;
        '/':
          begin
            x := 1;
            Dec(y);
          end;
      end;
      Inc(i);
    end;
    if Board[26] = BlackKing then KingCastle[Black] := true else KingCastle[Black] := false;
    if Board[Top] = BlackRook then QueenRookCastle[Black] := true else QueenRookCastle[Black] := false;
    if Board[29] = BlackRook then KingRookCastle[Black] := true else KingRookCastle[Black] := false;
    if Board[96] = WhiteKing then KingCastle[White] := true else KingCastle[White] := false;
    if Board[92] = WhiteRook then QueenRookCastle[White] := true else QueenRookCastle[White] := false;
    if Board[Bot] = WhiteRook then KingRookCastle[White] := true else KingRookCastle[White] := false;
    EnPassantSquare := None;
  end;
  result := true;
end;

moi perso je l'aurai écrit de cette la façon ci dessous

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
60
61
62
63
64
65
66
67
68
69
70
(* 
    converts a string representing a FEN position to an internal 
    representation.
*)
 
FUNCTION FEN2Posit(fen: strg80): boolean;
var
  x, y, i, j: integer;
  PosCour : Integer;
  c: char;
begin
  x := 1;
  y := 8;
  i := 1;
  PosCour := 10 * (10 - y) + x + 1; 
  with Posit do
  begin
    while i <= Length(fen) do
    begin
      c := fen[i];
      case Upcase(c) of
        'P', 'N', 'B', 'R', 'Q', 'K':
          begin
            case c of
              'p': Board[PosCour] := BlackPawn;
              'n': Board[PosCour] := BlackKnight;
              'b': Board[PosCour] := BlackBishop;
              'r': Board[PosCour] := BlackRook;
              'q': Board[PosCour] := BlackQueen;
              'k': Board[PosCour] := BlackKing;
              'P': Board[PosCour] := WhitePawn;
              'N': Board[PosCour] := WhiteKnight;
              'B': Board[PosCour] := WhiteBishop;
              'R': Board[PosCour] := WhiteRook;
              'Q': Board[PosCour] := WhiteQueen;
              'K': Board[PosCour] := WhiteKing;
            end;
             Inc(x);
	     PosCour := 10 * (10 - y) + x + 1; 
          end;
        '1'..'8':
          begin
            j := Ord(c) - Ord('0');
            while j > 0 do
            begin
              Board[PosCour] := Blank;
              Inc(x);
              Dec(j);
	      PosCour := 10 * (10 - y) + x + 1; 
            end;
          end;
        '/':
          begin
            x := 1;
            Dec(y);
            PosCour := 10 * (10 - y) + x + 1; 
          end;
      end;
      Inc(i);
    end;
	KingCastle[Black]            := Board[26]  = BlackKing;
	QueenRookCastle[Black]  := Board[Top] = BlackRook;
	KingRookCastle[Black]     := Board[29]  = BlackRook;
	KingCastle[White]            := Board[96]  = WhiteKing;  
	QueenRookCastle[White]  := Board[92]  = WhiteRook;
	KingRookCastle[White]     := Board[Bot] = WhiteRook;
	EnPassantSquare := None;
  end;
  result := true;
end;

le calcul de la position n'intervenant que lors de l'incrémentation ou la décrémentation de x et/ou y il est préférable de faire le calcul juste après
cela me semble plus parlant
je ne connais pas le code complet mes je suis prêt à parié qu'il y a d'autre amélioration à faire
j'ai vu que les majuscules sont blanche et minuscule noir
les nom des pions étant équivalent en noir ou en blancs il doit être possible de jouer avec la symétrie

[Roland Chastain]

@anapurna

Salut ! Je suis preneur de toute suggestion d'amélioration, mais là tu réponds à un message de 2013. Le code a pas mal évolué depuis...

[anapurna]

salut

autant pour moi j'ai pas regardé la date du premier post juste vu le code
effectivement en téléchargeant les source celui-ci a bien évolué

[Roland Chastain]

J'ai bricolé une interface graphique. C'est un projet Lazarus.



L'échiquier est basé sur l'excellent exemple posté ici par ThWilliam.

Vous pouvez déplacer les pièces avec la souris. Pour le moment ça ne sert à rien mais c'est beau. (Je me permets de le dire parce que ce n'est pas moi qui l'ai fait. ) Pour le moment l'échiquier ne sert qu'à afficher la position.

Le programme charge par défaut un fichier contenant 150 000 positions pour lesquelles il existe un mat en deux coups. De quoi s'entraîner pendant quelque temps... Les données proviennent d'un fichier PGN que j'ai téléchargé sur cette page.

Vous pouvez aussi utiliser le fichier de votre choix. Le programme accepte n'importe quel format de fichier, pourvu qu'il contienne des chaînes au format EPD ou FEN: le programme est capable de les détecter.

Le programme enregistre le nom du fichier et l'index de la dernière position chargée, de façon à ce qu'on ne reparte pas du début à chaque fois.

Je n'ai pas pu le tester sous Windows : ça devrait fonctionner, peut-être avec une ou deux choses à retoucher. Voilà, s'il y a des amateurs... J'aimerais bien savoir ce que vous en pensez...

[Roland Chastain]

Nouvelle version de Mater GUI. Inclut un deuxième moteur de recherche (Chest).

Des binaires pour Linux et Windows sont disponibles là.

[Roland Chastain]

Voici la version finale (pour le moment) de ce projet. Ajouté un système de traduction (avec des fichiers *.po). Tout compte fait, c'est très bien ce système, et pas si compliqué que ça peut paraître à première vue.

Ajouté un deuxième moteur de recherche (Chest, redoutable). Les deux moteurs sont appelés dans des fils séparés.

Mater + Mater GUI