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

Version imprimable

Voir 40 message(s) de cette discussion en une page

22/11/2013, 19h25
forum

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

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.

:arrow: Qu'en pensez-vous ?
22/11/2013, 19h41
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. :roll:

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:

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 ?

23/11/2013, 15h41
Alcatîz

Bonjour,

Merci pour le partage de ce code source ! :ccool:

Citation:

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.
23/11/2013, 17h25
Roland Chastain
Citation:

Envoyé par Alcatîz

Merci pour le partage de ce code source ! :ccool:

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

Citation:

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:

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 ?
23/11/2013, 18h07
Roland Chastain

Citation:

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.
24/11/2013, 08h34
Alcatîz

Citation:

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à ! :)
24/11/2013, 20h19
Roland Chastain
Citation:

Envoyé par Alcatîz

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:

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.
17/11/2014, 21h29
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 !
19/11/2014, 23h10
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:

WriteLn('b7a8' = SolveMate('b7/PP6/8/8/7K/6B1/6N1/4R1bk w KQkq -', 3, SEARCH_ALL_MOVES)); // TRUE
23/04/2015, 14h00
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.
04/11/2015, 19h22
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.
25/02/2020, 09h41
Roland Chastain

2 pièce(s) jointe(s)

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.

:arrow: 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. :)
08/11/2021, 16h49
Roland Chastain

1 pièce(s) jointe(s)

Mater 1.1.20211107

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 :

Pièce jointe 608319

Les blancs font mat en quatre coups. ;)

Le programme fonctionne sous Linux et sous Windows.

Mater for Free Pascal

Salut

Citation:

Envoyé par Roland Chastain

Code:

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:

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

09/11/2021, 18h13
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...
10/11/2021, 10h05
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é
11/11/2021, 14h03
Roland Chastain

1 pièce(s) jointe(s)

Mater GUI

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

Pièce jointe 608620

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

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...
16/11/2021, 19h01
Roland Chastain

Mater GUI 0.2.1

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

Des binaires pour Linux et Windows sont disponibles là.
29/11/2021, 18h18
Roland Chastain

Mater 1.1 r20211124

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.

:arrow: Mater + Mater GUI

https://gitlab.com/rchastain/mater/-...screenshot.png

Voir 40 message(s) de cette discussion en une page