IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Contribuez Pascal Discussion :

Projet d'un programme de jeu d'échecs


Sujet :

Contribuez Pascal

  1. #341
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    3 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 3 828
    Points : 13 685
    Points
    13 685
    Billets dans le blog
    8
    Par défaut
    @Guesset

    Bonjour ! Merci pour ton aide.

    Oui, pour la liste de coups qui est recopiée à chaque fois, je vois ce que tu veux dire. Il y aurait peut-être moyen d'éviter cela. C'est la liste des coups possibles pour une position donnée. Je recrée à chaque fois une copie de la position parce que je n'ai pas de procédure pour annuler le coup précédemment essayé. Mais c'est vrai que ça n'a pas d'intérêt de recopier la liste. Peut-être pourrait-on sortir la liste de la classe et en faire, à la place, une variable globale ?

    Mes essais en conditions réelles (c'est-à-dire un tournoi automatisé entre "moteurs") n'ont pas été très concluants. Plusieurs fois le programme s'est planté, mais je n'ai pas eu le temps de chercher d'où cela venait. Je ne sais même pas si cela a quelque chose à voir avec les modifications que j'ai faites récemment. La seule chose que j'ai remarquée (en surveillant le programme dans le gestionnaire des tâches), c'est qu'il utilise apparemment peu de mémoire (environ 1Mo) mais beaucoup de processeur (parfois plus de 50%, ce qui est trop je pense).

    Merci encore pour ton aide, qui m'encourage à essayer d'améliorer ce petit programme. À bientôt pour la suite !

  2. #342
    Membre expérimenté

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    506
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 506
    Points : 1 560
    Points
    1 560
    Par défaut
    Bonjour Roland,

    Citation Envoyé par Roland Chastain Voir le message
    Autrement ce que j'aimerais, c'est que la profondeur soit pratiquement illimitée, et que la recherche s'arrête seulement lorsque le temps imparti est écoulé.
    Sauf erreur cela induira un changement majeur de recherche de la meilleure solution.

    Actuellement le programme fait un parcours en profondeur de l'arbre des coups possibles. Nous sommes donc obligés de fixer une profondeur maximale pour l'obliger à remonter (avec l'hypothèse fausse d'une profondeur infinie mais très grande, en général bien au delà de nos possibilités de calcul). Sinon il se perdrait dans la première suite de branches (ou les premières si elles sont très mauvaises).

    Pour pouvoir faire une recherche limitée par le temps, il me semble qu'il est nécessaire de passer à une recherche en largeur. Ainsi, à un temps donné nous avons toujours une quasi même profondeur (à 1 près) pour toutes les branches (les pires exceptées éventuellement). Le problème est la croissance très rapide du nombre de nœuds en fonction de la profondeur (avec un arbre binaire nous aurions 2n+1-1 nœuds simultanés pour une profondeur n contre seulement n nœuds en parcours en profondeur). En effet, le parcours en profondeur ne remontant quasiment jamais (il descend tant que le gong n'a pas retentit), il ne libère aucun nœud tant que l'on ne force pas l'arrêt.

    Illustrations (sur arbre binaire c'est plus simple et plus optimiste avec une série géométrique de raison 2 seulement) ?
    Nom : Arbre en profondeur.png
Affichages : 138
Taille : 70,0 Ko
    En profondeur mais en douceur

    Nom : Arbre en largeur.png
Affichages : 127
Taille : 61,8 Ko
    En grande largeur

    Salut
    Philippe
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  3. #343
    Expert confirmé
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    mai 2002
    Messages
    3 148
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2002
    Messages : 3 148
    Points : 5 268
    Points
    5 268
    Par défaut
    Salut.

    Pour les échecs ce n'est pas un parcours d'arbre global. Ils utilisent un algo avec une coupe alpha beta (ou min max) pour optimiser la recherche et ne parcourir que les branches susceptibles d’être gagnantes.

    Un lien intéressant ici.
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

  4. #344
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    3 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 3 828
    Points : 13 685
    Points
    13 685
    Billets dans le blog
    8
    Par défaut
    Bonjour !

    Merci Philippe pour ces schémas, qui aident bien à se représenter les choses. Je ne vois pas encore très bien comment mettre la chose en œuvre mais ça va venir.

    Je me souviens d'avoir vu, dans un programme fait par quelqu'un d'autre, que pour calculer une position il rejouait tous les coups depuis le début (au lieu de créer, comme je fais, une copie de la position précédente et de jouer le dernier coup). Ce serait peut-être une idée ?

    @anapurna

    Merci pour ton message. Effectivement, il faut aussi penser à élaguer au fur et à mesure.

    Quel casse-tête !

    P.-S. Une lecture intéressante. Pour la petite histoire, j'avais essayé, avec l'aide de Paul Toth, de traduire ce programme en Pascal mais c'était bien au-dessus de mes forces.

  5. #345
    Expert confirmé
    Avatar de anapurna
    Homme Profil pro
    Développeur informatique
    Inscrit en
    mai 2002
    Messages
    3 148
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Arts - Culture

    Informations forums :
    Inscription : mai 2002
    Messages : 3 148
    Points : 5 268
    Points
    5 268
    Par défaut
    salut

    déjà c'est mort il utilise des goto c'est de la programmation "spaghetti"

    elle n'est aucunement optimisé

    tu as vu cette algo
    Nom : algo005.png
Affichages : 110
Taille : 44,6 Ko
    Nous souhaitons la vérité et nous trouvons qu'incertitude. [...]
    Nous sommes incapables de ne pas souhaiter la vérité et le bonheur, et sommes incapables ni de certitude ni de bonheur.
    Blaise Pascal
    PS : n'oubliez pas le tag

  6. #346
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    3 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 3 828
    Points : 13 685
    Points
    13 685
    Billets dans le blog
    8
    Par défaut
    @anapurna

    Effectivement ce passage de l'article est intéressant. J'y retrouve des notions dont j'entends toujours parler dans les discussions sur les programmes d'échecs (tables de transposition, hachage, etc.). Il faut que je trouve le temps de me pencher sérieusement sur tout ça.

  7. #347
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    3 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 3 828
    Points : 13 685
    Points
    13 685
    Billets dans le blog
    8
    Par défaut
    Bonjour !

    On peut désormais jouer contre le programme Alouette sur lichess.org :

    https://lichess.org/@/AlouetteChessEngine

    Enfin, quand mon ordinateur est allumé...

  8. #348
    Responsable Pascal, Lazarus et Assembleur


    Avatar de Alcatîz
    Homme Profil pro
    Ressources humaines
    Inscrit en
    mars 2003
    Messages
    7 776
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ressources humaines
    Secteur : Service public

    Informations forums :
    Inscription : mars 2003
    Messages : 7 776
    Points : 56 540
    Points
    56 540
    Billets dans le blog
    2
    Par défaut
    Bonjour Roland,

    Bravo, j'imagine que ton bot a dû être intensivement testé par les admins de lichess.org ?
    Citation Envoyé par Roland Chastain Voir le message
    Enfin, quand mon ordinateur est allumé...
    Ce qui explique sans doute pourquoi le bot décline mes défis.
    Règles du forum
    Cours et tutoriels Pascal, Delphi, Lazarus et Assembleur
    Avant de poser une question, consultez les FAQ Pascal, Delphi, Lazarus et Assembleur
    Mes tutoriels et sources Pascal

    Le problème en ce bas monde est que les imbéciles sont sûrs d'eux et fiers comme des coqs de basse cour, alors que les gens intelligents sont emplis de doute. [Bertrand Russell]
    La tolérance atteindra un tel niveau que les personnes intelligentes seront interdites de toute réflexion afin de ne pas offenser les imbéciles. [Fiodor Mikhaïlovitch Dostoïevski]

  9. #349
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    3 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 3 828
    Points : 13 685
    Points
    13 685
    Billets dans le blog
    8
    Par défaut
    Citation Envoyé par Alcatîz Voir le message
    Bonjour Roland,

    Bravo, j'imagine que ton bot a dû être intensivement testé par les admins de lichess.org ?

    Ce qui explique sans doute pourquoi le bot décline mes défis.
    Bonjour Alcatîz ! Merci pour ton message.

    Non, le programme n'a pas été testé par les gens de lichess.org : il n'y a pas de procédure d'admission particulière, il suffit de créer un compte. Pour connecter le programme à lichess, j'ai utilisé ceci :

    https://github.com/ShailChoksi/lichess-bot

    Ç'aurait pu être intéressant de tout faire en Pascal... Un jour peut-être ?

    Oui, j'ai vu que tu avais défié le programme et qu'il avait refusé : je ne sais pas pourquoi. Mon ordinateur était bien allumé pourtant. Une explication possible, c'est que le type de partie que tu as proposée ne corresponde pas aux options du programme. C'est ce qui m'est arrivé ce matin quand je l'ai essayé la première fois. Ou alors peut-être que l'ordinateur était en veille. En tout cas merci d'avoir essayé.

  10. #350
    Rédacteur/Modérateur

    Avatar de Roland Chastain
    Homme Profil pro
    Enseignant
    Inscrit en
    décembre 2011
    Messages
    3 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : décembre 2011
    Messages : 3 828
    Points : 13 685
    Points
    13 685
    Billets dans le blog
    8
    Par défaut
    Bonjour !

    Un mot pour vous présenter Moustique II, qui est un moteur d'échecs utilisant le protocole CECP (plus connu sous le nom de protocole XBoard ou WinBoard).

    Le programme principal (l'interface XBoard) est la réécriture littérale d'un exemple en C de Harm Geert Muller.

    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
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
     
    (********************************************************)
    (* Example of a WinBoard-protocol driver, by H.G.Muller *)
    (* Rewritten in Pascal by R. Chastain                   *)
    (********************************************************)
     
    uses
    {$IFDEF UNIX}
      CThreads, CWString,
    {$ENDIF}
      SysUtils, Classes, ChessPlayer, ChessPlayerTypes, Log;
     
    const
    // four different constants, with values for WHITE and BLACK that suit your engine
      WHITE   = 1;
      BLACK   = 2;
      NONE    = 0;
      ANALYZE = 3;
     
    // some value that cannot occur as a valid move
      INVALID = 666;
     
    // some parameter of your engine
      MAXMOVES = 500;  (* maximum game length  *)
      MAXPLY   = 60;   (* maximum search depth *)
     
      OFF = 0;
      ON_ = 1;
     
      DEFAULT_FEN = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1';
     
    type
      TMOVE = integer;                         // in this example moves are encoded as an int      
     
    var
      moveNr: integer = 0;                     // part of game state; incremented by MakeMove
      gameMove: array[0..MAXMOVES-1] of TMOVE; // holds the game history
     
    // Some routines your engine should have to do the various essential things
    function MakeMove(const stm: integer; const move_: TMOVE): integer; forward; // performs move, and returns new side to move
    procedure UnMake(const move_: TMOVE); forward;                               // unmakes the move;
    function SetUp(const fen: string): integer; forward;                         // sets up the position from the given FEN, and returns the new side to move
    procedure SetMemorySize(const n: integer); forward;                          // if n is different from last time, resize all tables to make memory usage below n MB
    function MoveToText(const move_: TMOVE): string; forward;                    // converts the move from your internal format to text like e2e2, e1g1, a7a8q.
    function ParseMove(const moveText: string): integer; forward;                // converts a long-algebraic text move to your internal move format
    function SearchBestMove(const stm, timeLeft, mps, timeControl, inc_, timePerMove: integer; var move_, ponderMove: TMOVE): integer; forward;
    procedure PonderUntilInput(const stm: integer); forward;                     // Search current position for stm, deepening forever until there is input.
     
    // Some global variables that control your engine's behavior
    var
      ponder,
      randomize_,
      postThinking,
      resign,                  // engine-defined option
      contemptFactor: integer; // likewise
     
    procedure Send(const AMessage: string);
    begin
      ToLog({$I %FILE%}, {$I %LINE%}, Format('<< %s', [AMessage]));
      WriteLn(AMessage);
      Flush(output);
    end;
     
    type
      TSender = class(TThread)
        private
          FText: string;
        protected
          procedure Execute; override;
        public
          constructor Create(const AText: string; const ACreateSuspended: boolean = TRUE);
        end;
     
    constructor TSender.Create(const AText: string; const ACreateSuspended: boolean);
    begin
      inherited Create(ACreateSuspended);
      FreeOnTerminate := TRUE;
      FText := AText;
    end;
     
    procedure TSender.Execute;
    begin
      Send(FText);
    end;
     
    function TakeBack(const n: integer): integer; // reset the game and then replay it to the desired point
    var
      last, stm, nr: integer;
    begin
      stm := SetUp('');
      last := moveNr - n;
      if last < 0 then last := 0;
      for nr := 0 to Pred(moveNr) do stm := MakeMove(stm, gameMove[nr]);
      result := stm;
    end;
     
    procedure PrintResult(const stm, score: integer);
    begin
      if score = 0 then Send('1/2-1/2');
      if (score > 0) and (stm = WHITE) or (score < 0) and (stm = BLACK) then Send('1-0')
      else Send('0-1');
    end;
     
    function main: integer;
    var
      stm: integer;                                 // side to move
      engineSide: integer = NONE;                   // side played by engine
      timeLeft: integer;
      mps, timeControl, inc_, timePerMove: integer; // time-control parameters, to be used by Search
      maxDepth: integer;                            // used by search
      move_, ponderMove: integer;
      inBuf: string;
      command: string;
      score: integer;
      min: integer;
      sec: integer = 0;
      //newStm: integer;
      nping: integer;
      sender: TSender;
    label
      noPonder;
    begin
      ToLog({$I %FILE%}, {$I %LINE%}, ParamStr(0), TRUE);
      while {not EOF}TRUE do // infinite loop
      begin
        ToLog({$I %FILE%}, {$I %LINE%}, Format('stm=%d engineSide=%d', [stm, engineSide]));
        Flush(output);                   // make sure everything is printed before we do something that might take time
        if stm = engineSide then         // if it is the engine's turn to move, set it thinking, and let it move
        begin
          score := SearchBestMove(stm, timeLeft, mps, timeControl, inc_, timePerMove, move_, ponderMove);
          if move_ = INVALID then        // game apparently ended
          begin
            engineSide := NONE;          // so stop playing
            PrintResult(stm, score);
          end else
          begin
            stm := MakeMove(stm, move_); // assumes MakeMove returns new side to moves
            gameMove[moveNr] := move_;   // remember game
            Inc(moveNr);
            Send(Format('move %s', [MoveToText(move_)]));
            (*
            sender := TSender.Create(Format('move %s', [MoveToText(move_)]));
            sender.Start;
            *)
          end;
        end;
     
        (*
        Flush(output); // make sure everything is printed before we do something that might take time
        // now it is not our turn (anymore)
        if engineSide = ANALYZE then       // in analysis, we always ponder the position
            PonderUntilInput(stm)
        else
        if (engineSide <> NONE) and (ponder = ON_) and (moveNr <> 0) then // ponder while waiting for input
        begin
          if ponderMove = INVALID then      // if we have no move to ponder on, ponder the position
            PonderUntilInput(stm)
          else
          begin
            newStm := MakeMove(stm, ponderMove);
            PonderUntilInput(newStm);
            UnMake(ponderMove);
          end;
        end;
        *)
        noPonder:
        ReadLn(inBuf);
        ToLog({$I %FILE%}, {$I %LINE%}, Format('>> %s', [inBuf]));
        SScanf(inBuf, '%s', [@command]);
     
        if command = 'quit' then
          Break;
        if command = 'force' then begin engineSide := NONE;      Continue; end;
        if command = 'analyze' then begin engineSide := ANALYZE; Continue; end;
        if command = 'exit' then begin engineSide := NONE;       Continue; end;
        if command = 'otim' then goto noPonder; // do not start pondering after receiving time commands, as move will follow immediately
        if command = 'time' then begin SScanf(inBuf, 'time %d', @timeLeft); goto noPonder; end;
        if command = 'level' then
        begin
          if (SScanf(inBuf, 'level %d %d %d', [@mps, @min, @inc_]) = 3) // if this does not work, it must be min:sec format
          or (SScanf(inBuf, 'level %d %d:%d %d', [@mps, @min, @sec, @inc_]) = 4) then
            ;
          timeControl := 60 * min + sec;
          timePerMove := -1;
          Continue;
        end;
        if command = 'protover' then
        begin
          //Send('feature ping=1 setboard=1 colors=0 usermove=1 memory=1 debug=1 reuse=0 sigint=0 sigterm=0 myname="Moustique"');
          Send('feature ping=1 setboard=1 usermove=1 memory=1 sigint=0 sigterm=0 myname="Moustique II 0.1"');
          Send('feature done=1');
          Continue;
        end;
        if command = 'option' then // setting of engine-define option; find out which
        begin
          (*
          if(sscanf(inBuf+7, "Resign=%d",   &resign)         == 1) continue;
          if(sscanf(inBuf+7, "Contempt=%d", &contemptFactor) == 1) continue;
          continue;
          *)
        end;
        if command = 'sd' then begin SScanf(inBuf, 'sd %d', [@maxDepth]); Continue; end;
        if command = 'st' then begin SScanf(inBuf, 'st %d', [@timePerMove]); Continue; end;
        if command = 'memory' then begin SetMemorySize(StrToIntDef(Copy(inBuf, 8), 0)); Continue; end;
        if command = 'ping' then begin SScanf(inBuf, 'ping %d', [@nping]); Send(Format('pong %d', [nping])); Continue; end;
        if command = 'new' then begin engineSide := BLACK; stm := Setup(DEFAULT_FEN); maxDepth := MAXPLY; randomize_ := OFF; Continue; end;
        if command = 'setboard' then begin  engineSide := NONE;  stm := Setup(Copy(inBuf, 10)); Continue; end;
        if command = 'easy' then begin ponder := OFF; Continue; end;
        if command = 'hard' then begin ponder := ON_; Continue; end;
        if command = 'undo' then begin stm := TakeBack(1); Continue; end;
        if command = 'remove' then begin stm := TakeBack(2); Continue; end;
        if command = 'go' then begin engineSide := stm; Continue; end;
        if command = 'post' then begin postThinking := ON_; Continue; end;
        if command = 'nopost' then begin postThinking := OFF; Continue; end;
        if command = 'random' then begin randomize_ := ON_; Continue; end;
        if command = 'hint' then begin if ponderMove <> INVALID then Send(Format('Hint: %s', [MoveToText(ponderMove)])); Continue; end;
        if command = 'book' then Continue;
        // ignored commands:
        if command = 'xboard' then Continue;
        if command = 'computer' then Continue;
        if command = 'name' then Continue;
        if command = 'ics' then Continue;
        if command = 'accepted' then Continue;
        if command = 'rejected' then Continue;
        if command = 'variant' then Continue;
        if command = '' then Continue;
        if command = 'usermove' then
        begin
          move_ := ParseMove(Copy(inBuf, 10));
          if move_ = INVALID then Send('Illegal move')
          else
          begin
            stm := MakeMove(stm, move_);
            ponderMove := INVALID;
            Inc(moveNr);
            gameMove[moveNr] := move_;  // remember game
          end;
          Continue;
        end;
        ToLog({$I %FILE%}, {$I %LINE%}, Format('Unknown command: "%s"', [inBuf]));
      end;
      result := 0;
    end;
     
    var
      LChessPlayer: TChessPlayer;
     
    function MakeMove(const stm: integer; const move_: TMOVE): integer;
    begin
      ToLog({$I %FILE%}, {$I %LINE%}, Format('MakeMove(%d, %d)', [stm, move_]));
      if LChessPlayer.PlayMove(move_) then
      begin
        if stm = WHITE then
          result := BLACK
        else
          result := WHITE;
      end else
        ToLog({$I %FILE%}, {$I %LINE%}, Format('Coup refusé par le joueur d''échecs artificiel : %d', [move_]));
      ToLog({$I %FILE%}, {$I %LINE%}, Format('MakeMove = %d', [result]));
    end;
     
    procedure UnMake(const move_: TMOVE);
    begin
    end;
     
    function SetUp(const fen: string): integer;
    begin
      ToLog({$I %FILE%}, {$I %LINE%}, Format('SetUp(%s)', [fen]));
      LChessPlayer.SetPosition(fen);
      result := WHITE;
      ToLog({$I %FILE%}, {$I %LINE%}, Format('SetUp = %d', [result]));
    end;
     
    procedure SetMemorySize(const n: integer);
    begin
    end;
     
    function MoveToText(const move_: TMOVE): string;
    begin
      //Log(Format('%s MoveToText(%d)', [TimeToStr(Time), move_]));
      result := ChessPlayerTypes.MoveToStr(move_);
    end;
     
    function ParseMove(const moveText: string): integer;
    begin
      //Log(Format('%s ParseMove(%s)', [TimeToStr(Time), moveText]));
      result := ChessPlayerTypes.MoveToInt(moveText);
    end;
     
    function SearchBestMove(const stm, timeLeft, mps, timeControl, inc_, timePerMove: integer; var move_, ponderMove: TMOVE): integer;
    begin
      //Log(Format('%s SearchBestMove(...)', [TimeToStr(Time)]));
      move_ := LChessPlayer.BestMove;
      result := 0;
    end;
     
    procedure PonderUntilInput(const stm: integer);
    begin
    end;
     
    begin
      LChessPlayer := TChessPlayer.Create;
      ExitCode := main;
      LChessPlayer.Free;
    end.
    Je n'ai eu ensuite qu'à y insérer les unités du programme Moustique, bricolées pour être compatibles avec les types déclarés dans le programme principal.

    Je n'ai testé le moteur que sous Linux, avec XBoard.

    Le code source complet se trouve ici.

    https://gitlab.com/rchastain/moustique-ii

Discussions similaires

  1. [Flash Pascal] Projet d'un programme permettant de visualiser une position du jeu des échecs
    Par Roland Chastain dans le forum Flash Pascal
    Réponses: 11
    Dernier message: 21/06/2015, 09h05
  2. Projet Jeu d'échec
    Par Layla dans le forum Langage
    Réponses: 10
    Dernier message: 23/12/2010, 13h06
  3. Jeu d'échec borland soap
    Par rpoulin dans le forum Web & réseau
    Réponses: 2
    Dernier message: 20/10/2005, 05h02
  4. Help ! Programmer un jeu vidéo
    Par Jay Bee dans le forum DirectX
    Réponses: 7
    Dernier message: 18/03/2004, 18h38
  5. Help ! Programmer un jeu vidéo...
    Par Jay Bee dans le forum OpenGL
    Réponses: 3
    Dernier message: 05/03/2004, 15h34

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo