Reparse ambiguous move under built-in rules

[xboard.git] / moves.c

diff --git a/moves.c b/moves.c
index 4831046..32cabf7 100644 (file)
--- a/moves.c
+++ b/moves.c
@@ -170,6 +170,8 @@ CompareBoards (Board board1, Board board2)
 
 // [HGM] gen: configurable move generation from Betza notation sent by engine.
 
+Boolean pieceDefs;
+
 //  alphabet      "abcdefghijklmnopqrstuvwxyz"
 char symmetry[] = "FBNW.FFW.NKN.NW.QR....W..N";
 char xStep[]    = "2110.130.102.10.00....0..2";
@@ -250,6 +252,7 @@ MovesFromString (Board board, int flags, int f, int r, char *desc, MoveCallback
        if(!mode) mode = his + 4;// no mode spec, use default = mc
        if(*desc == 'p') mode |= 32, desc++;
        if(*desc == 'g') mode |= 64, desc++;
+       if(*desc == 'o') mode |= 128, desc++;
        if(*desc == 'n') jump = 0, desc++;
        while(*desc == 'j') jump++, desc++;
        dx = xStep[*p-'A'] - '0';                     // step vector of atom
@@ -272,7 +275,9 @@ MovesFromString (Board board, int flags, int f, int r, char *desc, MoveCallback
            x = f; y = r;                             // start square
            do {
                x += vx; y += vy;                     // step to next square
-               if(y < 0 || y >= BOARD_HEIGHT || x < BOARD_LEFT || x >= BOARD_RGHT) break;
+               if(y < 0 || y >= BOARD_HEIGHT) break; // vertically off-board: always done
+               if(x <  BOARD_LEFT) { if(mode & 128) x += BOARD_RGHT - BOARD_LEFT; else break; }
+               if(x >= BOARD_RGHT) { if(mode & 128) x -= BOARD_RGHT - BOARD_LEFT; else break; }
                if(!jump    && board[y - vy + vy/2][x - vx + vx/2] != EmptySquare) break; // blocked
                if(jump > 1 && board[y - vy + vy/2][x - vx + vx/2] == EmptySquare) break; // no hop
                if(board[y][x] < BlackPawn)   occup = 1; else
@@ -529,7 +534,10 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure,
           if(PieceToChar(piece) == '~')
                  piece = (ChessSquare) ( DEMOTED piece );
           if(filter != EmptySquare && piece != filter) continue;
-          if(pieceDesc[piece]) { MovesFromString(board, flags, ff, rf, pieceDesc[piece], callback, closure); continue; } // [HGM] gen
+          if(pieceDefs && pieceDesc[piece]) { // [HGM] gen: use engine-defined moves
+              MovesFromString(board, flags, ff, rf, pieceDesc[piece], callback, closure);
+              continue;
+          }
           if(IS_SHOGI(gameInfo.variant))
                  piece = (ChessSquare) ( SHOGI piece );
 
@@ -1812,6 +1820,8 @@ DisambiguateCallback (Board board, int flags, ChessMove kind, int rf, int ff, in
        (cl->rtIn == -1 || cl->rtIn == rt || wildCard) &&
        (cl->ftIn == -1 || cl->ftIn == ft || wildCard)) {
 
+       if(cl->count && rf == cl->rf && ff == cl->ff) return; // duplicate move
+
        cl->count++;
        if(cl->count == 1 || board[rt][ft] != EmptySquare) {
          // [HGM] oneclick: if multiple moves, be sure we remember capture
@@ -1871,6 +1881,12 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure)
            return;
          }
        }
+    } else if(pieceDefs && closure->count > 1) { // [HGM] gen: move is ambiguous under engine-defined rules
+       DisambiguateClosure spare = *closure;
+       pieceDefs = FALSE; spare.count = 0;     // See if the (erroneous) built-in rules would resolve that
+        GenLegal(board, flags, DisambiguateCallback, (VOIDSTAR) &spare, closure->pieceIn);
+       if(spare.count == 1) *closure = spare;  // It does, so use those in stead (game from file saved before gen patch?)
+       pieceDefs = TRUE;
     }
 
     if (c == 'x') c = NULLCHAR; // get rid of any 'x' (which should never happen?)