MATER - Recherche de mat à partir d'une position donnée d'une partie d'échecs [Sources]

**forum** · 22/11/2013, 20h25

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** · 22/11/2013, 20h41

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** · 23/11/2013, 12h55

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** · 23/11/2013, 16h41

Bonjour,

Merci pour le partage de ce code source !

Envoyé par 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 ! 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** · 23/11/2013, 18h25

Envoyé par Alcatîz

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.

Envoyé par Alcatîz

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 ?

**Alcatîz** · 24/11/2013, 09h34

Envoyé par Roland Chastain

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** · 23/11/2013, 19h07

Envoyé par 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.

**anapurna** · 09/11/2021, 18h13

Salut

Envoyé par Roland Chastain

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** · 09/11/2021, 19h13

@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** · 10/11/2021, 11h05

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** · 04/11/2015, 20h22

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** · 25/02/2020, 10h41

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** · 08/11/2021, 17h49

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 :

Nom : position4.png
Affichages : 241
Taille : 14,6 Ko

Nom : position4.png
Affichages : 241
Taille : 14,6 Ko

Les blancs font mat en quatre coups.

Le programme fonctionne sous Linux et sous Windows.

Mater for Free Pascal

**Jipété** · 02/12/2021, 20h24

Bonsoir Roland,

Rien à voir avec Lazarus, mais j'aimerais bien connaître la solution au problème !

On voit bien dans la copie d'écran que le pion blanc b7 va prendre le fou en a8, que ce coup est considéré comme une nouveauté mais l'écran ne nous renseigne pas sur la promotion du pion (on sait juste que ce n'est ni une dame ni un fou sinon le roi noir ne pourrait pas prendre en g2, d'où pat puisque Fg1 ne peut pas bouger), et je n'arrive pas à "voir" plus loin.
Me faudrait un plateau et des bouts de bois mais grosse flemme de tout sortir.

Ai cherché des solveurs en ligne et n'ayant rien trouvé, je m'en remets à ta gentillesse pour apaiser ma curiosité,

Merci infiniment par avance,

**Roland Chastain** · 02/12/2021, 23h10

Bonsoir JP. Merci pour ta question.

Les deux moteurs indiquent la promotion en cavalier. N veut dire cavalier (knight, K étant déjà pris pour king). Afin d'éviter le pat, comme tu l'as bien vu. Mais on pourrait aussi bien l'éviter avec une promotion en tour...

Ensuite, le noir a un seul coup possible (prendre le cavalier en G2). Par contre au coup suivant il y a plusieurs possibilités, et là, je suis comme toi : j'ai du mal à voir la suite. Il faudrait explorer toutes les branches de l'arbre.

Chest (le deuxième moteur) donne une séquence de coups jusqu'au mat. Tu peux la voir si tu lances Mater GUI depuis un terminal.

Code X :

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

1
2
3
[Chest] Best move bxa8=N
[Chest] Distance to mate 3
[Chest] Principal variation bxa8=N Kxg2 Nb6 Bh2 a8=Q#

Mais c'est une séquence parmi d'autres, puisqu'au deuxième coup le blanc a d'autres possibilités que Nb6. Je ne sais pas exactement comment le programme détermine la "variation principale". Peut-être que c'est la première qu'il trouve.

Moralité : pour le commun des mortels, voir un mat en trois coups c'est déjà très difficile. C'est pourquoi j'ai inclus dans le programme une collection de mats en deux coups, ce qui me paraissait offrir une difficulté raisonnable pour un humain.

Ce qui serait intéressant, ce serait que le programme indique toutes les séquences possibles jusqu'au mat. Il faudrait que j'essaie de le modifier dans ce sens. Mais tu imagines ce que ça pourrait donner à la profondeur 4, 5... Ça deviendrait vite énorme.

**Jipété** · 03/12/2021, 12h02

Bonjour Roland,

et merci pour ces précisions, qui me font me rendre compte que j'ai oublié plein de trucs, sans compter que Wikipedia sur ce coup ne m'a pas bien aidé (ou je n'étais pas en forme : hier fut un peu laborieux) :

Envoyé par Roland Chastain

N veut dire cavalier (knight, K étant déjà pris pour king).

C pour Cavalier ici : https://fr.wikipedia.org/wiki/%C3%89...on_des_parties
et
N : Nouveauté théorique là : https://fr.wikipedia.org/wiki/%C3%89...on_des_parties

Envoyé par Roland Chastain

Code :

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

[Chest] Principal variation bxa8=N Kxg2 Nb6 Bh2 a8=Q#

Bon sang mais c'est bien sûr ! a8=Q après avoir libéré la place par Nb6 !

J'étais tellement obnubilé par la recherche d'une soluce à partir de bxa8=Tour que j'essayais ensuite de la faire glisser vers f8, g8, h8 pour rien,

Envoyé par Roland Chastain

Mais c'est une séquence parmi d'autres, puisqu'au deuxième coup le blanc a d'autres possibilités que Nb6. Je ne sais pas exactement comment le programme détermine la "variation principale". Peut-être que c'est la première qu'il trouve.

et que les autres amènent au même résultat.

Envoyé par Roland Chastain

Moralité : pour le commun des mortels, voir un mat en trois coups c'est déjà très difficile. C'est pourquoi j'ai inclus dans le programme une collection de mats en deux coups, ce qui me paraissait offrir une difficulté raisonnable pour un humain.

Pas trop d'accord avec toi sur les problèmes à 3 coups : me souviens dans ma jeunesse en avoir résolu quelques uns (évidemment, je n'arrive pas aujourd'hui à remettre la main dessus…)

Envoyé par Roland Chastain

Ce qui serait intéressant, ce serait que le programme indique toutes les séquences possibles jusqu'au mat. Il faudrait que j'essaie de le modifier dans ce sens. Mais tu imagines ce que ça pourrait donner à la profondeur 4, 5... Ça deviendrait vite énorme.

Laisse tomber (sauf si ça t'excite les neurones,

), ça deviendrait vite inutilisable, sauf si on n'a vraiment que ça à faire,

Merci à toi et bonne journée,

MATER - Recherche de mat à partir d'une position donnée d'une partie d'échecs [Sources]

Codes sources à télécharger Pascal

Vue hybride

Discussions similaires

Partager

Partager