X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=moves.c;h=58cbfc008c47f8f794aa83acc0ebb1fe348d2bbf;hb=fa76217dec3666d46e537483a60ea7b9e9568e33;hp=deb245f06332a3809e5d00ad512eca15477fb47b;hpb=93077be9f3009b8eb6ad64067f31d000aaf284c3;p=xboard.git

diff --git a/moves.c b/moves.c
index deb245f..58cbfc0 100644
--- a/moves.c
+++ b/moves.c
@@ -117,91 +117,27 @@ ChessSquare PromoPiece(moveType)
 	return WhiteKing;
       case BlackPromotionKing:
 	return BlackKing;
-#ifdef FAIRY
       case WhitePromotionChancellor:
         return WhiteMarshall;
       case BlackPromotionChancellor:
         return BlackMarshall;
       case WhitePromotionArchbishop:
-        return WhiteCardinal;
+        return WhiteAngel;
       case BlackPromotionArchbishop:
-        return BlackCardinal;
-#endif
-    }
-}
-
-ChessMove PromoCharToMoveType(whiteOnMove, promoChar)
-     int whiteOnMove;
-     int promoChar;
-{
-    if (whiteOnMove) {
-	switch (promoChar) {
-	  case 'n':
-	  case 'N':
-	    return WhitePromotionKnight;
-	  case 'b':
-	  case 'B':
-	    return WhitePromotionBishop;
-	  case 'r':
-	  case 'R':
-	    return WhitePromotionRook;
-#ifdef FAIRY
-          case 'a':
-          case 'A':
-            return WhitePromotionArchbishop;
-          case 'c':
-          case 'C':
-            return WhitePromotionChancellor;
-#endif
-	  case 'q':
-	  case 'Q':
-	    return WhitePromotionQueen;
-	  case 'k':
-	  case 'K':
-	    return WhitePromotionKing;
-	  case NULLCHAR:
-	  default:
-	    return NormalMove;
-	}
-    } else {
-	switch (promoChar) {
-	  case 'n':
-	  case 'N':
-	    return BlackPromotionKnight;
-	  case 'b':
-	  case 'B':
-	    return BlackPromotionBishop;
-	  case 'r':
-	  case 'R':
-	    return BlackPromotionRook;
-#ifdef FAIRY
-          case 'a':
-          case 'A':
-            return BlackPromotionArchbishop;
-          case 'c':
-          case 'C':
-            return BlackPromotionChancellor;
-#endif
-	  case 'q':
-	  case 'Q':
-	    return BlackPromotionQueen;
-	  case 'k':
-	  case 'K':
-	    return BlackPromotionKing;
-	  case NULLCHAR:
-	  default:
-	    return NormalMove;
-	}
+        return BlackAngel;
+      case WhitePromotionCentaur:
+        return WhiteSilver;
+      case BlackPromotionCentaur:
+        return BlackSilver;
     }
 }
 
 char pieceToChar[] = {
-                        'P', 'N', 'B', 'R', 'Q', 'F', 
-    'W', 'E', 'M', 'O', 'U', 'H', 'A', 'C', 'G', 'S',
-    'K',                'p', 'n', 'b', 'r', 'q', 'f', 
-    'w', 'e', 'm', 'o', 'u', 'h', 'a', 'c', 'g', 's',
-    'k', 'x'
-  };
+                        'P', 'N', 'B', 'R', 'Q', 'F', 'E', 'A', 'C', 'W', 'M', 
+                        'O', 'H', 'I', 'J', 'G', 'D', 'V', 'L', 's', 'U', 'K',
+                        'p', 'n', 'b', 'r', 'q', 'f', 'e', 'a', 'c', 'w', 'm', 
+                        'o', 'h', 'i', 'j', 'g', 'd', 'v', 'l', 's', 'u', 'k', 
+                        'x' };
 
 char PieceToChar(p)
      ChessSquare p;
@@ -210,7 +146,7 @@ char PieceToChar(p)
     return pieceToChar[(int) p];
 }
 
-int PieceToNumber(p)
+int PieceToNumber(p)  /* [HGM] holdings: count piece type, ignoring non-participating piece types */
      ChessSquare p;
 {
     int i=0;
@@ -229,6 +165,52 @@ ChessSquare CharToPiece(c)
      return EmptySquare;
 }
 
+ChessMove PromoCharToMoveType(whiteOnMove, promoChar)
+     int whiteOnMove;
+     int promoChar;
+{	/* [HGM] made dependent on CharToPiece to alow alternate piece letters */
+	ChessSquare piece = CharToPiece(whiteOnMove ? ToUpper(promoChar) : ToLower(promoChar) );
+	if(promoChar == NULLCHAR) return NormalMove;
+
+	switch(piece) {
+		case WhiteQueen:
+			return WhitePromotionQueen;
+		case WhiteRook:
+			return WhitePromotionRook;
+		case WhiteBishop:
+			return WhitePromotionBishop;
+		case WhiteKnight:
+			return WhitePromotionKnight;
+		case WhiteKing:
+			return WhitePromotionKing;
+		case WhiteAngel:
+			return WhitePromotionArchbishop;
+		case WhiteMarshall:
+			return WhitePromotionChancellor;
+		case WhiteSilver:
+			return WhitePromotionCentaur;
+		case BlackQueen:
+			return BlackPromotionQueen;
+		case BlackRook:
+			return BlackPromotionRook;
+		case BlackBishop:
+			return BlackPromotionBishop;
+		case BlackKnight:
+			return BlackPromotionKnight;
+		case BlackKing:
+			return BlackPromotionKing;
+		case BlackAngel:
+			return BlackPromotionArchbishop;
+		case BlackMarshall:
+			return BlackPromotionChancellor;
+		case BlackSilver:
+			return BlackPromotionCentaur;
+		default:
+			// not all promotion implemented yet! Take Queen for those we don't know.
+			return (whiteOnMove ? WhitePromotionQueen : BlackPromotionQueen);
+	}
+}
+
 void CopyBoard(to, from)
      Board to, from;
 {
@@ -519,8 +501,8 @@ void GenPseudoLegal(board, flags, epfile, callback, closure)
               m++;
 
             /* Capablanca Archbishop continues as Knight                  */
-            case WhiteCardinal:
-            case BlackCardinal:
+            case WhiteAngel:
+            case BlackAngel:
               m++;
 
             /* Shogi Bishops are ordinary Bishops */
@@ -570,8 +552,8 @@ void GenPseudoLegal(board, flags, epfile, callback, closure)
               break;
 
             /* Shogi Dragon King has to continue as Ferz after Rook moves */
-            case SHOGI WhiteMarshall:
-            case SHOGI BlackMarshall:
+            case SHOGI WhiteDragon:
+            case SHOGI BlackDragon:
               m++;
 
             /* Capablanca Chancellor sets flag to continue as Knight      */
@@ -596,7 +578,7 @@ void GenPseudoLegal(board, flags, epfile, callback, closure)
 		      if (board[rt][ft] != EmptySquare) break;
 		  }
                 if(m==1) goto mounted;
-                if(m==2) goto walking;
+                if(m==2) goto finishGold;
 	      break;
 
 	    case WhiteQueen:
@@ -643,7 +625,7 @@ void GenPseudoLegal(board, flags, epfile, callback, closure)
                   for (fs = -1; fs <= 1; fs += 2) {
                       rt = rf + rs;
                       ft = ff + fs;
-                      if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) break;
+                      if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) continue;
                       if (!SameColor(board[rf][ff], board[rt][ft]) &&
                           (gameInfo.variant != VariantXiangqi || InPalace(rt, ft) ) )
                                callback(board, flags, NormalMove,
@@ -651,6 +633,9 @@ void GenPseudoLegal(board, flags, epfile, callback, closure)
 		  }
                 break;
 
+	    case WhiteSilver:
+	    case BlackSilver:
+		m++; // [HGM] superchess: use for Centaur
             case WhiteMan:
             case BlackMan:
             case SHOGI WhiteKing:
@@ -668,7 +653,26 @@ void GenPseudoLegal(board, flags, epfile, callback, closure)
 		    callback(board, flags, NormalMove,
 			     rf, ff, rt, ft, closure);
 		}
+		if(m==1) goto mounted;
+	      break;
+
+	    case WhiteNightrider:
+	    case BlackNightrider:
+	      for (i = -1; i <= 1; i += 2)
+		for (j = -1; j <= 1; j += 2)
+		  for (s = 1; s <= 2; s++) {  int k;
+                    for(k=1;; k++) {
+		      rt = rf + k*i*s;
+		      ft = ff + k*j*(3-s);
+                      if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) break;
+		      if (SameColor(board[rf][ff], board[rt][ft])) break;
+		      callback(board, flags, NormalMove,
+			       rf, ff, rt, ft, closure);
+		      if (board[rt][ft] != EmptySquare) break;
+                    }
+		  }
 	      break;
+
 	  }
       }
 }
@@ -736,8 +740,9 @@ int GenLegal(board, flags, epfile, castlingRights, callback, closure)
      VOIDSTAR closure;
 {
     GenLegalClosure cl;
-    int ff, ft;
+    int ff, ft, k, left, right;
     int ignoreCheck = (flags & F_IGNORE_CHECK) != 0;
+    ChessSquare wKing = WhiteKing, bKing = BlackKing;
 
     cl.cb = callback;
     cl.cl = closure;
@@ -747,10 +752,14 @@ int GenLegal(board, flags, epfile, castlingRights, callback, closure)
 	CheckTest(board, flags, -1, -1, -1, -1, FALSE)) return TRUE;
 
     /* Generate castling moves */
+    if(gameInfo.variant == VariantKnightmate) { /* [HGM] Knightmate */
+        wKing = WhiteUnicorn; bKing = BlackUnicorn;
+    }
+
     for (ff = BOARD_WIDTH>>1; ff >= (BOARD_WIDTH-1)>>1; ff-- /*ics wild 1*/) {
 	if ((flags & F_WHITE_ON_MOVE) &&
 	    (flags & F_WHITE_KCASTLE_OK) &&
-            board[0][ff] == WhiteKing &&
+            board[0][ff] == wKing &&
             board[0][ff + 1] == EmptySquare &&
             board[0][ff + 2] == EmptySquare &&
             board[0][BOARD_RGHT-3] == EmptySquare &&
@@ -761,15 +770,16 @@ int GenLegal(board, flags, epfile, castlingRights, callback, closure)
             (ignoreCheck ||                             
 	     (!CheckTest(board, flags, 0, ff, 0, ff + 1, FALSE) &&
               !CheckTest(board, flags, 0, ff, 0, BOARD_RGHT-3, FALSE) &&
+              (gameInfo.variant != VariantJanus || !CheckTest(board, flags, 0, ff, 0, BOARD_RGHT-2, FALSE)) &&
 	      !CheckTest(board, flags, 0, ff, 0, ff + 2, FALSE)))) {
 
 	    callback(board, flags,
                      ff==BOARD_WIDTH>>1 ? WhiteKingSideCastle : WhiteKingSideCastleWild,
-                     0, ff, 0, ff + ((gameInfo.boardWidth+2)>>2), closure);
+                     0, ff, 0, ff + ((gameInfo.boardWidth+2)>>2) + (gameInfo.variant == VariantJanus), closure);
 	}
 	if ((flags & F_WHITE_ON_MOVE) &&
 	    (flags & F_WHITE_QCASTLE_OK) &&
-	    board[0][ff] == WhiteKing &&
+            board[0][ff] == wKing &&
 	    board[0][ff - 1] == EmptySquare &&
 	    board[0][ff - 2] == EmptySquare &&
             board[0][BOARD_LEFT+2] == EmptySquare &&
@@ -779,7 +789,7 @@ int GenLegal(board, flags, epfile, castlingRights, callback, closure)
             ( castlingRights[2] == ff || castlingRights[6] == ff ) &&
 	    (ignoreCheck ||
 	     (!CheckTest(board, flags, 0, ff, 0, ff - 1, FALSE) &&
-              !CheckTest(board, flags, 0, ff, 0, BOARD_LEFT+3,      FALSE) &&
+              !CheckTest(board, flags, 0, ff, 0, BOARD_LEFT+3, FALSE) &&
 	      !CheckTest(board, flags, 0, ff, 0, ff - 2, FALSE)))) {
 
 	    callback(board, flags,
@@ -788,7 +798,7 @@ int GenLegal(board, flags, epfile, castlingRights, callback, closure)
 	}
 	if (!(flags & F_WHITE_ON_MOVE) &&
 	    (flags & F_BLACK_KCASTLE_OK) &&
-	    board[BOARD_HEIGHT-1][ff] == BlackKing &&
+            board[BOARD_HEIGHT-1][ff] == bKing &&
 	    board[BOARD_HEIGHT-1][ff + 1] == EmptySquare &&
 	    board[BOARD_HEIGHT-1][ff + 2] == EmptySquare &&
             board[BOARD_HEIGHT-1][BOARD_RGHT-3] == EmptySquare &&
@@ -799,15 +809,16 @@ int GenLegal(board, flags, epfile, castlingRights, callback, closure)
 	    (ignoreCheck ||
 	     (!CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff + 1, FALSE) &&
               !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, BOARD_RGHT-3, FALSE) &&
+              (gameInfo.variant != VariantJanus || !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, BOARD_RGHT-2, FALSE)) &&
 	      !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff + 2, FALSE)))) {
 
 	    callback(board, flags,
 		     ff==BOARD_WIDTH>>1 ? BlackKingSideCastle : BlackKingSideCastleWild,
-                     BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff + ((gameInfo.boardWidth+2)>>2), closure);
+                     BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff + ((gameInfo.boardWidth+2)>>2) + (gameInfo.variant == VariantJanus), closure);
 	}
 	if (!(flags & F_WHITE_ON_MOVE) &&
 	    (flags & F_BLACK_QCASTLE_OK) &&
-	    board[BOARD_HEIGHT-1][ff] == BlackKing &&
+            board[BOARD_HEIGHT-1][ff] == bKing &&
 	    board[BOARD_HEIGHT-1][ff - 1] == EmptySquare &&
 	    board[BOARD_HEIGHT-1][ff - 2] == EmptySquare &&
             board[BOARD_HEIGHT-1][BOARD_LEFT+2] == EmptySquare &&
@@ -817,8 +828,8 @@ int GenLegal(board, flags, epfile, castlingRights, callback, closure)
             ( castlingRights[5] == ff || castlingRights[7] == ff ) &&
 	    (ignoreCheck ||
 	     (!CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff - 1, FALSE) &&
-              !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, BOARD_LEFT+3,      FALSE) &&
-	      !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff - 1, FALSE)))) {
+              !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, BOARD_LEFT+3, FALSE) &&
+              !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff - 2, FALSE)))) {
 
 	    callback(board, flags,
 		     ff==BOARD_WIDTH>>1 ? BlackQueenSideCastle : BlackQueenSideCastleWild,
@@ -826,41 +837,71 @@ int GenLegal(board, flags, epfile, castlingRights, callback, closure)
 	}
     }
 
-    /* PUSH Fabien */
+  if(gameInfo.variant == VariantFischeRandom) {
 
     /* generate all potential FRC castling moves (KxR), ignoring flags */
-    /* [HGM] Tord! Help requested! */
-
-    if ((flags & F_WHITE_ON_MOVE) != 0) {
+    /* [HGM] test if the Rooks we find have castling rights */
 
-       for (ff = BOARD_LEFT+1; ff < BOARD_RGHT-1; ff++) {
-          if (board[0][ff] == WhiteKing) {
-             for (ft = BOARD_LEFT+0; ft < BOARD_RGHT; ft++) {
-                if (board[0][ft] == WhiteRook) {
-                   callback(board, flags, 
-                            (ft > ff) ? WhiteHSideCastleFR : WhiteASideCastleFR,
-                            0, ff, 0, ft, closure);
-                }
-             }
-          }
-       }
 
+    if ((flags & F_WHITE_ON_MOVE) != 0) {
+        ff = castlingRights[2]; /* King file if we have any rights */
+        if(ff > 0 && board[0][ff] == WhiteKing) {
+    if (appData.debugMode) {
+        fprintf(debugFP, "FRC castling, %d %d %d %d %d %d\n",
+                castlingRights[0],castlingRights[1],ff,castlingRights[3],castlingRights[4],castlingRights[5]);
+    }
+            ft = castlingRights[0]; /* Rook file if we have H-side rights */
+            left  = ff+1;
+            right = BOARD_RGHT-2;
+            if(ff == BOARD_RGHT-2) left = right = ff-1;    /* special case */
+            for(k=left; k<=right && ft >= 0; k++) /* first test if blocked */
+                if(k != ft && board[0][k] != EmptySquare) ft = -1;
+            for(k=left; k<right && ft >= 0; k++) /* then if not checked */
+                if(!ignoreCheck && CheckTest(board, flags, 0, ff, 0, k, FALSE)) ft = -1;
+            if(ft >= 0 && board[0][ft] == WhiteRook)
+                callback(board, flags, WhiteHSideCastleFR, 0, ff, 0, ft, closure);
+
+            ft = castlingRights[1]; /* Rook file if we have A-side rights */
+            left  = BOARD_LEFT+2;
+            right = ff-1;
+            if(ff <= BOARD_LEFT+2) { left = ff+1; right = BOARD_LEFT+3; }
+            for(k=left; k<=right && ft >= 0; k++) /* first test if blocked */
+                if(k != ft && board[0][k] != EmptySquare) ft = -1;
+            if(ff > BOARD_LEFT+2) 
+            for(k=left+1; k<=right && ft >= 0; k++) /* then if not checked */
+                if(!ignoreCheck && CheckTest(board, flags, 0, ff, 0, k, FALSE)) ft = -1;
+            if(ft >= 0 && board[0][ft] == WhiteRook)
+                callback(board, flags, WhiteASideCastleFR, 0, ff, 0, ft, closure);
+        }
     } else {
-
-       for (ff = BOARD_LEFT+1; ff < BOARD_RGHT-1; ff++) {
-          if (board[BOARD_HEIGHT-1][ff] == BlackKing) {
-             for (ft = BOARD_LEFT+0; ft < BOARD_RGHT; ft++) {
-                if (board[BOARD_HEIGHT-1][ft] == BlackRook) {
-                   callback(board, flags, 
-                            (ft > ff) ? BlackHSideCastleFR : BlackASideCastleFR,
-                            BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ft, closure);
-                }
-             }
-          }
-       }
+        ff = castlingRights[5]; /* King file if we have any rights */
+        if(ff > 0 && board[BOARD_HEIGHT-1][ff] == BlackKing) {
+            ft = castlingRights[3]; /* Rook file if we have H-side rights */
+            left  = ff+1;
+            right = BOARD_RGHT-2;
+            if(ff == BOARD_RGHT-2) left = right = ff-1;    /* special case */
+            for(k=left; k<=right && ft >= 0; k++) /* first test if blocked */
+                if(k != ft && board[BOARD_HEIGHT-1][k] != EmptySquare) ft = -1;
+            for(k=left; k<right && ft >= 0; k++) /* then if not checked */
+                if(!ignoreCheck && CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, k, FALSE)) ft = -1;
+            if(ft >= 0 && board[BOARD_HEIGHT-1][ft] == BlackRook)
+                callback(board, flags, BlackHSideCastleFR, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ft, closure);
+
+            ft = castlingRights[4]; /* Rook file if we have A-side rights */
+            left  = BOARD_LEFT+2;
+            right = ff-1;
+            if(ff <= BOARD_LEFT+2) { left = ff+1; right = BOARD_LEFT+3; }
+            for(k=left; k<=right && ft >= 0; k++) /* first test if blocked */
+                if(k != ft && board[BOARD_HEIGHT-1][k] != EmptySquare) ft = -1;
+            if(ff > BOARD_LEFT+2) 
+            for(k=left+1; k<=right && ft >= 0; k++) /* then if not checked */
+                if(!ignoreCheck && CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, k, FALSE)) ft = -1;
+            if(ft >= 0 && board[BOARD_HEIGHT-1][ft] == BlackRook)
+                callback(board, flags, BlackASideCastleFR, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ft, closure);
+        }
     }
 
-    /* POP Fabien */
+  }
 
     return FALSE;
 }
@@ -976,9 +1017,9 @@ void LegalityTestCallback(board, flags, kind, rf, ff, rt, ft, closure)
 {
     register LegalityTestClosure *cl = (LegalityTestClosure *) closure;
 
-    if (appData.debugMode) {
-        fprintf(debugFP, "Legality test: %c%c%c%c\n", ff+AAA, rf+ONE, ft+AAA, rt+ONE);
-    }
+//    if (appData.debugMode) {
+//        fprintf(debugFP, "Legality test: %c%c%c%c\n", ff+AAA, rf+ONE, ft+AAA, rt+ONE);
+//    }
     if (rf == cl->rf && ff == cl->ff && rt == cl->rt && ft == cl->ft)
       cl->kind = kind;
 }
@@ -989,8 +1030,20 @@ ChessMove LegalityTest(board, flags, epfile, castlingRights, rf, ff, rt, ft, pro
      int rf, ff, rt, ft, promoChar;
      char castlingRights[];
 {
-    LegalityTestClosure cl;
+    LegalityTestClosure cl; ChessSquare piece = board[rf][ff];
     
+    if (appData.debugMode) {
+        int i;
+        for(i=0; i<6; i++) fprintf(debugFP, "%d ", castlingRights[i]);
+        fprintf(debugFP, "Legality test? %c%c%c%c\n", ff+AAA, rf+ONE, ft+AAA, rt+ONE);
+    }
+    /* [HGM] Lance, Cobra and Falcon are wildcard pieces; consider all their moves legal */
+    /* (perhaps we should disallow moves that obviously leave us in check?)              */
+    if(piece == WhiteFalcon || piece == BlackFalcon ||
+       piece == WhiteCobra  || piece == BlackCobra  ||
+       piece == WhiteLance  || piece == BlackLance)
+        return NormalMove;
+
     cl.rf = rf;
     cl.ff = ff;
     cl.rt = rt;
@@ -1078,7 +1131,7 @@ int MateTest(board, flags, epfile, castlingRights)
     if (cl.count > 0) {
 	return inCheck ? MT_CHECK : MT_NONE;
     } else {
-        return inCheck || gameInfo.variant == VariantXiangqi ?
+        return inCheck || gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShatranj ?
                          MT_CHECKMATE : MT_STALEMATE;
     }
 }
@@ -1125,6 +1178,11 @@ void Disambiguate(board, flags, epfile, closure)
     closure->count = 0;
     closure->rf = closure->ff = closure->rt = closure->ft = 0;
     closure->kind = ImpossibleMove;
+    if (appData.debugMode) {
+        fprintf(debugFP, "Disambiguate in:  %d(%d,%d)-(%d,%d) = %d (%c)\n",
+                             closure->pieceIn,closure->ffIn,closure->rfIn,closure->ftIn,closure->rtIn,
+                             closure->promoCharIn, closure->promoCharIn >= ' ' ? closure->promoCharIn : '-');
+    }
     GenLegal(board, flags, epfile, initialRights, DisambiguateCallback, (VOIDSTAR) closure);
     if (closure->count == 0) {
 	/* See if it's an illegal move due to check */
@@ -1133,31 +1191,39 @@ void Disambiguate(board, flags, epfile, closure)
 		 (VOIDSTAR) closure);	
 	if (closure->count == 0) {
 	    /* No, it's not even that */
+    if (appData.debugMode) { int i, j;
+	for(i=BOARD_HEIGHT-1; i>=0; i--) {
+		for(j=0; j<BOARD_WIDTH; j++)
+		        fprintf(debugFP, "%3d", (int) board[i][j]);
+	        fprintf(debugFP, "\n");
+	}
+    }
 	    return;
 	}
     }
 
-    if (appData.debugMode) {
-        fprintf(debugFP, "Disambiguate in:  %d(%d,%d)-(%d,%d) = %d (%c)\n",
-        closure->pieceIn,closure->ffIn,closure->rfIn,closure->ftIn,closure->rtIn,closure->promoCharIn,closure->promoCharIn);
-    }
     if(gameInfo.variant == VariantShogi) {
         /* [HGM] Shogi promotions. '=' means defer */
         if(closure->rfIn != DROP_RANK && closure->kind == NormalMove) {
             ChessSquare piece = closure->piece;
-
+#if 0
     if (appData.debugMode) {
         fprintf(debugFP, "Disambiguate A:   %d(%d,%d)-(%d,%d) = %d (%c)\n",
-        closure->pieceIn,closure->ffIn,closure->rfIn,closure->ftIn,closure->rtIn,closure->promoCharIn,closure->promoCharIn);
+                          closure->pieceIn,closure->ffIn,closure->rfIn,closure->ftIn,closure->rtIn,
+                          closure->promoCharIn,closure->promoCharIn);
     }
+#endif
             if(c != NULLCHAR && c != 'x' && c != '+' && c != '=' &&
                ToUpper(PieceToChar(PROMOTED piece)) != ToUpper(c) ) 
                     closure->kind = IllegalMove;
             else if(flags & F_WHITE_ON_MOVE) {
+#if 0
     if (appData.debugMode) {
         fprintf(debugFP, "Disambiguate B:   %d(%d,%d)-(%d,%d) = %d (%c)\n",
-        closure->pieceIn,closure->ffIn,closure->rfIn,closure->ftIn,closure->rtIn,closure->promoCharIn,closure->promoCharIn);
+                          closure->pieceIn,closure->ffIn,closure->rfIn,closure->ftIn,closure->rtIn,
+                          closure->promoCharIn,closure->promoCharIn);
     }
+#endif
                 if( (int) piece < (int) WhiteWazir &&
                      (closure->rf > BOARD_HEIGHT-4 || closure->rt > BOARD_HEIGHT-4) ) {
                     if( (piece == WhitePawn || piece == WhiteQueen) && closure->rt > BOARD_HEIGHT-2 ||
@@ -1191,13 +1257,16 @@ void Disambiguate(board, flags, epfile, closure)
 	    closure->kind = IllegalMove;
 	}
     }
+#if 0
     if (appData.debugMode) {
         fprintf(debugFP, "Disambiguate C:   %d(%d,%d)-(%d,%d) = %d (%c)\n",
-        closure->pieceIn,closure->ffIn,closure->rfIn,closure->ftIn,closure->rtIn,closure->promoCharIn,closure->promoCharIn);
+                          closure->pieceIn,closure->ffIn,closure->rfIn,closure->ftIn,closure->rtIn,
+                          closure->promoCharIn,closure->promoCharIn);
     }
+#endif
     /* [HGM] returns 'q' for optional promotion, 'n' for mandatory */
     if(closure->promoCharIn != '=')
-        closure->promoChar = ToLower(PieceToChar(PromoPiece(closure->kind)));
+        closure->promoChar = ToLower(closure->promoCharIn);
     else closure->promoChar = '=';
     if (closure->promoChar == 'x') closure->promoChar = NULLCHAR;
     if (closure->count > 1) {
@@ -1212,10 +1281,11 @@ void Disambiguate(board, flags, epfile, closure)
     }
     if(closure->kind == IllegalMove)
     /* [HGM] might be a variant we don't understand, pass on promotion info */
-        closure->promoChar = closure->promoCharIn;
+        closure->promoChar = ToLower(closure->promoCharIn);
     if (appData.debugMode) {
         fprintf(debugFP, "Disambiguate out: %d(%d,%d)-(%d,%d) = %d (%c)\n",
-        closure->piece,closure->ff,closure->rf,closure->ft,closure->rt,closure->promoChar,closure->promoChar);
+        closure->piece,closure->ff,closure->rf,closure->ft,closure->rt,closure->promoChar,
+	closure->promoChar >= ' ' ? closure->promoChar:'-');
     }
 }
 
@@ -1299,7 +1369,7 @@ ChessMove CoordsToAlgebraic(board, flags, epfile,
     if(PieceToChar(piece)=='~') piece = (ChessSquare)(DEMOTED piece);
 
   if (appData.debugMode)
-          fprintf(debugFP, "CoordsToAlgebraic, piece=%d\n", (int)piece);
+          fprintf(debugFP, "CoordsToAlgebraic, piece=%d (%d,%d)-(%d,%d) %c\n", (int)piece,ff,rf,ft,rt,promoChar >= ' ' ? promoChar : '-');
     switch (piece) {
       case WhitePawn:
       case BlackPawn:
@@ -1330,6 +1400,8 @@ ChessMove CoordsToAlgebraic(board, flags, epfile,
 	}
 	/* Use promotion suffix style "=Q" */
 	*outp = NULLCHAR;
+  if (appData.debugMode)
+          fprintf(debugFP, "movetype=%d, promochar=%d=%c\n", (int)kind, promoChar, promoChar >= ' ' ? promoChar : '-');
         if (promoChar != NULLCHAR) {
             if(gameInfo.variant == VariantShogi) {
                 /* [HGM] ... but not in Shogi! */
@@ -1470,8 +1542,10 @@ ChessMove CoordsToAlgebraic(board, flags, epfile,
         return cl.kind;
 	
       /* [HGM] Always long notation for fairies we don't know */
-      case WhiteNightrider:
-      case BlackNightrider:
+      case WhiteFalcon:
+      case BlackFalcon:
+      case WhiteLance:
+      case BlackLance:
       case WhiteGrasshopper:
       case BlackGrasshopper:
       case EmptySquare: