Moteur : videau de l'ordinateur comme ComputerTurn, match après une partie, Match ID d'un match

Fenêtre de marché et double facultatif à 0 pli (play.c), réponse au
double, règle de Crawford automatique ; commandes double, take et
aftergame d'engine-cli, matchid étendu aux matchs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

engine/include/engine.h

@@ -51,7 +51,8 @@ typedef enum {
     ENGINE_ERROR_INTERNAL,          /* échec signalé par gnubg */
     ENGINE_ERROR_LEVEL,             /* niveau de jeu inconnu */
     ENGINE_ERROR_MOVE,              /* coup joué absent des coups légaux */
-    ENGINE_ERROR_CUBE_ACTION        /* décision de videau inconnue */
+    ENGINE_ERROR_CUBE_ACTION,       /* décision de videau inconnue */
+    ENGINE_ERROR_RESULT             /* résultat de partie invalide */
 } engine_status;
 
 #define ENGINE_MAX_PLY 4
@@ -374,6 +375,71 @@ engine_status engine_level_best_moves(const char *position_id, const char *match
 engine_status engine_level_cube_decision(const char *position_id, const char *match_id,
                                          int level, engine_cube *cube);
 
+/*
+ * Le videau de l'ordinateur à ce niveau, comme le joue gnubg de bureau
+ * (ComputerTurn dans play.c, l. 1312-1398, « Consider doubling ») :
+ * - il ne pense à doubler que s'il a accès au videau (GetDPEq : pas en
+ *   partie Crawford, pas avec un videau mort…) et que le videau vaut moins
+ *   de 4096 (MAX_CUBE) ;
+ * - pré-filtre « fenêtre de marché » : ses chances de gain, évaluées sans
+ *   videau à un pli de moins que le niveau (bruit compris), doivent atteindre
+ *   le point de double à videau mort (GetDoublePointDeadCube) ; sinon il ne
+ *   double pas, sans évaluer la décision complète ;
+ * - dans la fenêtre, il double sur DOUBLE_TAKE, REDOUBLE_TAKE, DOUBLE_PASS,
+ *   REDOUBLE_PASS et DOUBLE_BEAVER ; sur un double « facultatif »
+ *   (OPTIONAL_*), seulement s'il évalue à 0 pli et que ses chances de gain
+ *   dépassent 0,001 (« double if 0-ply except when about to lose game ») ;
+ *   sinon il garde le videau.
+ */
+typedef struct {
+    int available;          /* le joueur au trait a accès au videau */
+    int market_window;      /* le pré-filtre est passé : décision évaluée */
+    int doubles;            /* l'ordinateur double */
+    const char *decision;   /* décision complète (noms d'engine_cube.decision)
+                             * si elle a été évaluée, sinon NULL */
+} engine_level_double;
+
+engine_status engine_level_double_decision(const char *position_id, const char *match_id,
+                                           int level, engine_level_double *result);
+
+/*
+ * L'ordinateur, adversaire du joueur au trait qui vient de doubler, prend-il
+ * ? Comme ComputerTurn (play.c, l. 1139-1235, « normal double by
+ * opponent ») : la décision de videau est évaluée du point de vue de celui
+ * qui double, avec les réglages du niveau de l'ordinateur ; il passe sur
+ * DOUBLE_PASS, TOOGOOD_PASS, REDOUBLE_PASS, TOOGOODRE_PASS et les
+ * OPTIONAL_*_PASS, et prend sinon (Ustagammon ne joue pas les castors :
+ * gnubg prend aussi quand il ne peut pas en faire). position_id et match_id
+ * sont ceux du joueur qui double ; *decision reçoit le nom de la décision.
+ */
+engine_status engine_level_take_decision(const char *position_id, const char *match_id,
+                                         int level, int *takes, const char **decision);
+
+/* ------------------------------------------------------------------ Match */
+
+/* Le match après une partie. */
+typedef struct {
+    int score[2];           /* score après la partie */
+    int match_over;         /* le gagnant a atteint la longueur du match */
+    int crawford;           /* la partie suivante est la partie Crawford */
+} engine_match_after;
+
+/*
+ * Le match après une partie gagnée par winner (0 ou 1, numérotation du
+ * Match ID) pour points points. match_id est celui de la partie jouée : sa
+ * longueur, son score avant la partie et son drapeau Crawford comptent, le
+ * reste est ignoré. Comme gnubg de bureau à la fin d'une partie (play.c,
+ * l. 1817-1820, règle de Crawford automatique) : la partie suivante est la
+ * partie Crawford si le gagnant arrive à un point du but, que son adversaire
+ * n'y est pas et qu'il n'y a pas encore eu de partie Crawford. Qu'une partie
+ * Crawford ait déjà eu lieu se lit dans le Match ID comme gnubg le lit
+ * (play.c, l. 303 et l. 4277) : pas de drapeau Crawford alors qu'un joueur
+ * est à un point du but. En partie libre (longueur 0), le score s'ajoute
+ * seulement. ENGINE_ERROR_RESULT si winner ou points sont invalides.
+ */
+engine_status engine_match_after_game(const char *match_id, int winner, int points,
+                                      engine_match_after *after);
+
 /* ------------------------------------------------------------- Analyse */
 
 /* Appréciation de gnubg pour une perte d'équité (0 ou négative). */