Conversion d'un octet en ensemble

Version imprimable

Bonjour !

J'ai mis la main sur une version en Pascal du programme d'échecs TSCP (Tom Kerrigan's Simple Chess Program). Au cas où cela intéresserait quelqu'un, voici le lien vers cette version en Pascal : TSCPPAS.ZIP

Il y a un endroit du programme que je ne comprends pas trop.

Voici la déclaration du type TCastlePermissions :
Code:

1 2 3 type TCastlePermission = (AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside); TCastlePermissions = set of TCastlePermission;
Voici la constante castle_mask :
Code:

1 2 3 4 5 6 7 8 9 10 castle_mask: array[0..63] of byte = ( 7, 15, 15, 15, 3, 15, 15, 11, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 13, 15, 15, 15, 12, 15, 15, 14 );
Maintenant, on a une variable castle de type TCastlePermissions, dont la valeur est modifiée de la façon suivante :

Code:

castle := castle - TCastlePermissions(castle_mask[m.from]) - TCastlePermissions(castle_mask[m.ToNdx]);

Ce que je comprends pas, c'est le rapport qu'il y a entre une valeur de type Byte et une valeur de type set of TCastlePermission. :roll:

Il est à noter que le code se compile sans problème avec Delphi 7 et avec Virtual Pascal. En revanche Free Pascal le refuse :

Citation:

board.pas(595,22) Error: Illegal type conversion: "Byte" to "TCastlePermissions"
board.pas(595,64) Error: Illegal type conversion: "Byte" to "TCastlePermissions"

Pourriez-vous m'éclairer un peu (et éventuellement me donner une solution pour pouvoir compiler avec Free Pascal) ?

Salut Roland

Si je me souviens bien, pas le temps de chercher, un ensemble est une suite de bits contigus (dont la taille dépend de l'énuméré sous-jacent).
Ton tableau de constantes représente donc des configurations d'ensembles prédéfinies.
Les opérations réalisées font donc des opérations bit à bit, tu peux transforme le code sur les énumérés par des opérations bit à bit (and, or, not) comme on le ferait en langage C :
Code:

1 2 3 4 5 6 var b: Byte; begin b := Byte(castle) and (not castle_mask[m.from]) and (not castle_mask[m.ToNdx]); End;
une solution consiste aussi à écrire une fonction de conversion explicite (pas testée):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 function Byte2CastlePermissions(b: Byte): CastlePermissions; var i : TCastlePermission; p: Byte; begin Result := []; p := 1; for i := Low(TCastlePermission) to High(TCastlePermission) do begin if ((p and b) = p) then Include(Result, i); p := 2 * p; // on voir pourquoi la conversion est hasardeuse,si le nombre d'énumérée est trop grand, on explose la capacité d'un byte. end; End;
Au sujet du refus par FreePascal, peut être est-ce dû au typage statique et au fait que, dans l'absolu, une telle conversion ne peut pas toujours aboutir (taille de l'ensemble en mémoire dépendant de l'énuméré)

Appronfondis en lisant la doc, pas trop le temps ce matin.

Citation:

Envoyé par Roland Chastain

Bonjour !
Ce que je comprends pas, c'est le rapport qu'il y a entre une valeur de type Byte et une valeur de type set of TCastlePermission. :roll:

Aucun rapport, sauf quand on fait des trucs de cochons comme l'auteur de ton programme.

Normalement castle_mask aurait du être défini comme

Code:

castle_mask: array[0..63] of TCastlePermissions

Je suppose que castle_mask a été défini comme un tableau de byte soit pour contourner une limitation de TurboPascal (mais j'en doute) soit pour taper moins de code.

As tu essayé de compiler en mode tp ? FreePascal accepte peut être ce genre de bidouilles dans ce mode.

Néanmoins le mieux est de corriger cette mauvaise définition à mon avis. Pour ça tu vas devoir retrouver à quel ensemble correspond chaque valeur du tableau. Ensuite tu donnes le bons type au tableau et l'initialise comme il faut.

Ce programme devrait pouvoir t'aider :
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 program Castle; {$mode TP} type TCastlePermission = (AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside); TCastlePermissions = set of TCastlePermission; const castle_mask: array[0..63] of byte = ( 7, 15, 15, 15, 3, 15, 15, 11, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 13, 15, 15, 15, 12, 15, 15, 14 ); castle_perm_string : array [TCastlePermission] of String = ('AllowWhiteKingSide', 'AllowWhiteQueenSide', 'AllowBlackKingSide', 'AllowBlackQueenside'); var I : Integer; P : TCastlePermission; Premier : Boolean; begin for I := 0 to 63 do begin Premier := true; Write('castle_mask[', I, '] = ['); for P := Low(TCastlePermission) to High(TCastlePermission) do begin if P in TCastlePermissions(castle_mask[I]) then begin if not Premier then Write(', '); Write(castle_perm_string[P]); Premier := false; end; end; WriteLn('];'); end; end.
Il fonctionne sous FreePascal mais tu devrais idéalement l'utiliser sous Turbo Pascal car je ne sais pas si FreePascal et Turbo Pascal utilise la même représentation binaire des ensembles.

Merci pour vos réponses (que je vais prendre le temps d'étudier) : ça fait plaisir. :ccool:

D'après les renseignements que j'ai pu trouver, le programme aurait été écrit pour Delphi 5. Apparemment c'est un travail inachevé. On ne peut même pas jouer, la conversion de la chaîne saisie n'étant pas faite comme il faut ! Voici la correction à appliquer.
Code:

1 2 3 4 5 6 7 8 9 (* from := Ord(s[1]) - Ord('a'); Inc(from, 8 * (8 - Ord(s[2]) - Ord('0'))); ToNdx := Ord(s[3]) - Ord('a'); Inc(ToNdx, 8 * (8 - Ord(s[4]) - Ord('0'))); *) from := 8 * (7 - Ord(s[2]) + Ord('1')) + Ord(s[1]) - Ord('a'); ToNdx := 8 * (7 - Ord(s[4]) + Ord('1')) + Ord(s[3]) - Ord('a');
Le jeu de l'ordinateur semble fonctionner mais ça reste à voir, notamment en ce qui concerne les coups spéciaux. :)

Voilà, j'étudie vos suggestions et reviens vers vous très vite.

11/12/2014, 11h37
e-ric
Je partage à moitié l'avis de Yamer, le but de l'auteur était sans doute de bénéficier à la fois des énumérés pour la lisibilité et le tableau de byte pour la déclaration directe en constante. L'inconvénient du choix de l'auteur du programme réside dans les conversions de données répétitives et visiblement condamnées dans Free Pascal, on perd en clarté.

Ce type de code peut avoir du sens si tu enregistres un ensemble dans une base SQL ou un fichier binaire (par un fichier typé de Pascal).

Transformer le type du tableau comme proposé par Yamer est une excellente idée, il faut initialiser le tableau dans une procédure au démarrage de ton programme.

La conversion de Byte vers TCastlePermissions peut se faire à l'aide de la routine que j'ai proposé ou manuellement en sachant que le bit à mettre à 1 dans l'équivalent mémoire de TCastlePermissions selon la valeur cp TCastlePermission est donné par Ord(cp). On a par exemple
13 = 1 + 4 + 8 = 2^0 + 2^2 + 2^3 <=> [AllowWhiteKingSide, AllowBlackKingSide, AllowBlackQueenside]
sur le même principe :
* 15 <=> [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside]
* 0 <=> []

L'usage de ma routine est plus sûr je pense (en corrigeant la signature qui est fausse, je viens de le voir)

Une autre solution consiste à se débarasser des énuméré et d'utiliser des cosntante entières avec des masques de bits (opérateurs and, or, not) :
Code:

1 2 3 4 5 cpAllowWhiteKingSide : byte = 1; cpAllowWhiteQueenSide : byte = 2; cpAllowBlackKingSide : byte = 4; cpAllowBlackQueenside : byte =8;
C'est plus explicite.

C'est clair?
11/12/2014, 11h56
Roland Chastain

@e-ric

Merci pour ces explications complémentaires. Oui, je crois que j'ai compris. Les exemples de conversion que tu donnes concordent d'ailleurs avec les résultats du petit programme proposé par yamer. Je crois que j'ai aussi compris ce que l'auteur du programme a voulu faire.

Je suis en train d'équiper le programme de fonctions de débogage pour pouvoir m'assurer de la validité des données. Ensuite je vais tester les différentes solutions que vous avez proposées.

Coucou

En rapport avec le programme fourni par Yamer:

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
 
program Castle;
 
{$mode TP}
 
type
  TCastlePermission = (AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside);
  TCastlePermissions = set of TCastlePermission;
 
const
  castle_mask: array[0..63] of byte = (
      7, 15, 15, 15,  3, 15, 15, 11,
      15, 15, 15, 15, 15, 15, 15, 15,
      15, 15, 15, 15, 15, 15, 15, 15,
      15, 15, 15, 15, 15, 15, 15, 15,
      15, 15, 15, 15, 15, 15, 15, 15,
      15, 15, 15, 15, 15, 15, 15, 15,
      15, 15, 15, 15, 15, 15, 15, 15,
      13, 15, 15, 15, 12, 15, 15, 14
      );
 
  castle_perm_string : array [TCastlePermission] of String = ('AllowWhiteKingSide', 
    'AllowWhiteQueenSide', 'AllowBlackKingSide', 'AllowBlackQueenside');
var
  I : Integer;
  P : TCastlePermission;
  Premier : Boolean;
begin
  for I := 0 to 63 do
  begin
    Premier := true;
    Write('castle_mask[', I, '] = [');
    for P := Low(TCastlePermission) to High(TCastlePermission) do
    begin
      if P in TCastlePermissions(castle_mask[I]) then
      begin
        if not Premier then Write(', ');
 
        Write(castle_perm_string[P]);
        Premier := false;
      end;
    end;
    WriteLn('];');
  end;
end.

Ne retombe-t-on pas sur le même problème (Conversion d'un byte vers un TCastlePermissions) ?

cdlt

11/12/2014, 14h59
yamer

Citation:

Envoyé par e-ric

Ne retombe-t-on pas sur le même problème (Conversion d'un byte vers un TCastlePermissions) ?

Bien sûr mais ce programme est juste un outil à utiliser pour convertir une fois pour toutes les bytes du tableau en TCastlePermissions. A mon avis il faut choisir une voie et s'y tenir. Soit on utilise des ensembles soit des bytes avec des constantes entières. J'ai une préférence pour les ensembles qui donne à mon sens des programmes plus lisibles.
11/12/2014, 15h06
e-ric

Les ensembles permettent un grand nombre de valeur : 256 en fait (soit des tableaux de 256 bits), ils peuvent être intéressants pour cela, ils facilitent grandement la lecture du code et laisse au compilateur le soin des calculs sur les masques binaires, c'est confortable. Mais il faut prendre des précautions si on veut enregistrer de telles données dans une base SQL par exemple.

Tu as raison, il faut choisir une solution et s'y tenir.

@+

Grâce à vos explications, je viens de m'apercevoir qu'il y avait un problème de conception dans le programme. Il fait le contraire de ce qu'il faudrait ! Il conserve ce qu'il faudrait exclure, et exclut ce qu'il faudrait conserver. Voyez le code suivant, dans lequel on simule un mouvement au départ ou à destination de la case 0 (a8).

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
 
program TestCastle;
 
{$MODE TP}
 
type
  TCastlePermission = (AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside);
  TCastlePermissions = set of TCastlePermission;
 
var
  castle: TCastlePermissions;
 
const
  castle_mask: array[0..63] of byte = (
     7, 15, 15, 15,  3, 15, 15, 11,
    15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15,
    13, 15, 15, 15, 12, 15, 15, 14
  );
 
begin
  castle := [AllowWhiteKingSide..AllowBlackQueenSide]; 
  castle := castle - TCastlePermissions(castle_mask[0]); // ligne actuelle
  WriteLn(AllowBlackQueenSide in castle); // TRUE
  WriteLn(AllowWhiteQueenSide in castle); // FALSE
  // C'est le contraire du résultat logiquement attendu, puisqu'un mouvement sur
  // la case 0 (a8) devrait exclure la valeur "AllowBlackQueenSide".
 
  castle := [AllowWhiteKingSide..AllowBlackQueenSide];
  castle := castle * TCastlePermissions(castle_mask[0]); // correction
  WriteLn(AllowBlackQueenSide in castle); // FALSE
  WriteLn(AllowWhiteQueenSide in castle); // TRUE
  // C'est le résultat correct.
 
  ReadLn;
end.

Décidément, c'est la deuxième grosse erreur que je trouve.

11/12/2014, 16h14
Roland Chastain

Citation:

Envoyé par yamer

Bien sûr mais ce programme est juste un outil à utiliser pour convertir une fois pour toutes les bytes du tableau en TCastlePermissions.

Oui, d'accord, je n'avais pas vu ça comme ça. Effectivement, ton programme permet de fabriquer le code qui initialise un tableau de TCastlePermissions. Cette fois, j'ai compris. J'ai donc deux possibilités (avec la fonction proposée par e-ric). :ccool:

Bien, j'ai opté pour la fonction mais je garde l'autre possibilité en réserve. Merci pour votre aide et pour cette discussion très instructive.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function CastlePermissions(const b: byte): TCastlePermissions;
var
  p: TCastlePermission;
begin
  result := [];
  for p := Low(TCastlePermission) to High(TCastlePermission) do
  begin
    if b and (1 shl Ord(p)) <> 0 then
      Include(result, p);
  end;
end;
 
function MakeMove(m: TMove): boolean;
begin
  ...
  castle := castle * CastlePermissions(castle_mask[m.from]);
  castle := castle * CastlePermissions(castle_mask[m.ToNdx]);

Pour être tout à fait complet, j'ajoute que le tableau de TCastlePermissions peut être déclaré comme un tableau de constantes. Vous le saviez sûrement mais personnellement j'avais un doute. Voici donc ce que j'ai obtenu en modifiant légèrement le programme de yamer :

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
program TestConstArray;
 
{$IFDEF VPASCAL}
{$PMTYPE VIO}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF}
 
type
  TCastlePermission = (AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside);
  TCastlePermissions = set of TCastlePermission;
 
const
  CASTLE_PERMISSIONS: array[0..63] of TCastlePermissions = (
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteKingSide, AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside],
    [AllowWhiteQueenSide, AllowBlackKingSide, AllowBlackQueenside]
  );
 
var
  ps: TCastlePermissions;
 
begin
  ps := CASTLE_PERMISSIONS[0];
 
  WriteLn(AllowBlackQueenSide in ps); // FALSE
  WriteLn(AllowWhiteQueenSide in ps); // TRUE
 
  ReadLn;
end.

Du coup c'est cette solution-là que je vais retenir. Je tâcherai seulement de raccourcir un peu le nom des constantes. :)

C'est beau le Pascal. :heart:

12/12/2014, 09h59
Roland Chastain

Enfin, pour rendre justice à l'auteur de ce programme, je dois dire qu'il s'agissait juste (comme on l'apprend en lisant cette discussion) d'une adaptation rapide d'un code source en C, afin de comparer la vitesse d'exécution des deux programmes. C'est pourquoi également l'implémentation du protocole XBoard manque dans la version Delphi, à mon grand regret.

Quand j'aurai fini de revoir le programme, je le posterai dans les sources.
12/12/2014, 11h17
yamer

Tu pourrais aussi envisager de changer

Code:

CASTLE_PERMISSIONS: array[0..63] of TCastlePermissions

en

Code:

CASTLE_PERMISSIONS: array[0..7, 0..7] of TCastlePermissions

ou

Code:

CASTLE_PERMISSIONS: array[1..8, 1..8] of TCastlePermissions
12/12/2014, 12h16
Roland Chastain

Merci pour la suggestion. C'est une bonne idée mais à ce moment-là il serait bon de faire la même modification partout dans le programme. Je vais y penser.