X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=moves.c;h=6ccbb1c082d295a68447ada3bb6a942d8ee051ca;hb=9141872e84a1ce7db0c62539d23c6a3f105dd8f8;hp=56bd1dae717d34075aaa6b11032c115554397242;hpb=88082a3882690efd9ea7d3e01ad9d6dd5f5baf86;p=xboard.git

diff --git a/moves.c b/moves.c
index 56bd1da..6ccbb1c 100644
--- a/moves.c
+++ b/moves.c
@@ -60,7 +60,7 @@
 # include <strings.h>
 #endif /* not HAVE_STRING_H */
 #include "common.h"
-#include "backend.h" 
+#include "backend.h"
 #include "moves.h"
 #include "parser.h"
 
@@ -98,10 +98,10 @@ int SameColor(piece1, piece2)
 }
 
 char pieceToChar[] = {
-                        'P', 'N', 'B', 'R', 'Q', 'F', 'E', 'A', 'C', 'W', 'M', 
+                        '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', 
+                        'p', 'n', 'b', 'r', 'q', 'f', 'e', 'a', 'c', 'w', 'm',
+                        'o', 'h', 'i', 'j', 'g', 'd', 'v', 'l', 's', 'u', 'k',
                         'x' };
 char pieceNickName[EmptySquare];
 
@@ -137,7 +137,7 @@ void CopyBoard(to, from)
      Board to, from;
 {
     int i, j;
-    
+
     for (i = 0; i < BOARD_HEIGHT; i++)
       for (j = 0; j < BOARD_WIDTH; j++)
 	to[i][j] = from[i][j];
@@ -150,7 +150,7 @@ int CompareBoards(board1, board2)
      Board board1, board2;
 {
     int i, j;
-    
+
     for (i = 0; i < BOARD_HEIGHT; i++)
       for (j = 0; j < BOARD_WIDTH; j++) {
 	  if (board1[i][j] != board2[i][j])
@@ -179,7 +179,7 @@ void GenPseudoLegal(board, flags, callback, closure)
     int epfile = (signed char)board[EP_STATUS]; // [HGM] gamestate: extract ep status from board
     int promoRank = gameInfo.variant == VariantMakruk ? 3 : 1;
 
-    for (rf = 0; rf < BOARD_HEIGHT; rf++) 
+    for (rf = 0; rf < BOARD_HEIGHT; rf++)
       for (ff = BOARD_LEFT; ff < BOARD_RGHT; ff++) {
           ChessSquare piece;
 
@@ -189,7 +189,7 @@ void GenPseudoLegal(board, flags, callback, closure)
 	      if (!BlackPiece(board[rf][ff])) continue;
 	  }
           m = 0; piece = board[rf][ff];
-          if(PieceToChar(piece) == '~') 
+          if(PieceToChar(piece) == '~')
                  piece = (ChessSquare) ( DEMOTED piece );
           if(gameInfo.variant == VariantShogi)
                  piece = (ChessSquare) ( SHOGI piece );
@@ -235,7 +235,7 @@ void GenPseudoLegal(board, flags, callback, closure)
                   if (rf < BOARD_HEIGHT-1 && ff + s >= BOARD_LEFT && ff + s < BOARD_RGHT &&
 		      ((flags & F_KRIEGSPIEL_CAPTURE) ||
 		       BlackPiece(board[rf + 1][ff + s]))) {
-		      callback(board, flags, 
+		      callback(board, flags,
 			       rf >= BOARD_HEIGHT-1-promoRank ? WhitePromotion : NormalMove,
 			       rf, ff, rf + 1, ff + s, closure);
 		  }
@@ -248,7 +248,7 @@ void GenPseudoLegal(board, flags, callback, closure)
 				   rf, ff, 5, ff + s, closure);
 		      }
 		  }
-	      }		    
+	      }
 	      break;
 
 	    case BlackPawn:
@@ -270,7 +270,7 @@ void GenPseudoLegal(board, flags, callback, closure)
                   break;
               }
 	      if (rf > 0 && board[rf - 1][ff] == EmptySquare) {
-		  callback(board, flags, 
+		  callback(board, flags,
 			   rf <= promoRank ? BlackPromotion : NormalMove,
 			   rf, ff, rf - 1, ff, closure);
 	      }
@@ -285,7 +285,7 @@ void GenPseudoLegal(board, flags, callback, closure)
                   if (rf > 0 && ff + s >= BOARD_LEFT && ff + s < BOARD_RGHT &&
 		      ((flags & F_KRIEGSPIEL_CAPTURE) ||
 		       WhitePiece(board[rf - 1][ff + s]))) {
-		      callback(board, flags, 
+		      callback(board, flags,
 			       rf <= promoRank ? BlackPromotion : NormalMove,
 			       rf, ff, rf - 1, ff + s, closure);
 		  }
@@ -298,7 +298,7 @@ void GenPseudoLegal(board, flags, callback, closure)
 				   rf, ff, 2, ff + s, closure);
 		      }
 		  }
-	      }		    
+	      }
 	      break;
 
             case WhiteUnicorn:
@@ -336,7 +336,7 @@ void GenPseudoLegal(board, flags, callback, closure)
                       callback(board, flags, NormalMove,
                                rf, ff, rf - 2, ff + s, closure);
 		  }
-	      }		    
+	      }
 	      break;
 
             case WhiteCannon:
@@ -387,7 +387,7 @@ void GenPseudoLegal(board, flags, callback, closure)
                       callback(board, flags, NormalMove,
 			       rf, ff, rf - 1, ff + s, closure);
 		  }
-	      }		    
+	      }
 
             case WhiteWazir:
             case BlackWazir:
@@ -407,20 +407,39 @@ void GenPseudoLegal(board, flags, callback, closure)
             case WhiteAlfil:
             case BlackAlfil:
                 /* [HGM] support Shatranj pieces */
-                for (rs = -1; rs <= 1; rs += 2) 
+                for (rs = -1; rs <= 1; rs += 2)
                   for (fs = -1; fs <= 1; fs += 2) {
                       rt = rf + 2 * rs;
                       ft = ff + 2 * fs;
                       if (!(rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT)
                           && ( gameInfo.variant != VariantXiangqi ||
                                board[rf+rs][ff+fs] == EmptySquare && (2*rf < BOARD_HEIGHT) == (2*rt < BOARD_HEIGHT) )
-                         
+
+                          && !SameColor(board[rf][ff], board[rt][ft]))
+                               callback(board, flags, NormalMove,
+                                        rf, ff, rt, ft, closure);
+                      if(gameInfo.variant != VariantFairy && gameInfo.variant != VariantGreat) continue;
+                      rt = rf + rs; // in unknown variant we assume Modern Elephant, which can also do one step
+                      ft = ff + fs;
+                      if (!(rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT)
                           && !SameColor(board[rf][ff], board[rt][ft]))
                                callback(board, flags, NormalMove,
                                         rf, ff, rt, ft, closure);
 		  }
                 break;
 
+            /* Make Dragon-Horse also do Dababba moves outside Shogi, for better disambiguation in variant Fairy */
+	    case WhiteCardinal:
+	    case BlackCardinal:
+              for (d = 0; d <= 1; d++) // Dababba moves that Rook cannot do
+                for (s = -2; s <= 2; s += 4) {
+		      rt = rf + s * d;
+		      ft = ff + s * (1 - d);
+                      if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) continue;
+		      if (SameColor(board[rf][ff], board[rt][ft])) continue;
+		      callback(board, flags, NormalMove, rf, ff, rt, ft, closure);
+		  }
+
             /* Shogi Dragon Horse has to continue with Wazir after Bishop */
             case SHOGI WhiteCardinal:
             case SHOGI BlackCardinal:
@@ -436,8 +455,8 @@ void GenPseudoLegal(board, flags, callback, closure)
             case SHOGI BlackBishop:
 	    case WhiteBishop:
 	    case BlackBishop:
-	      for (rs = -1; rs <= 1; rs += 2) 
-                for (fs = -1; fs <= 1; fs += 2) 
+	      for (rs = -1; rs <= 1; rs += 2)
+                for (fs = -1; fs <= 1; fs += 2)
 		  for (i = 1;; i++) {
 		      rt = rf + (i * rs);
 		      ft = ff + (i * fs);
@@ -477,6 +496,19 @@ void GenPseudoLegal(board, flags, callback, closure)
               }
               break;
 
+            /* Make Dragon-King Dababba & Rook-like outside Shogi, for better disambiguation in variant Fairy */
+	    case WhiteDragon:
+	    case BlackDragon:
+              for (d = 0; d <= 1; d++) // Dababba moves that Rook cannot do
+                for (s = -2; s <= 2; s += 4) {
+		      rt = rf + s * d;
+		      ft = ff + s * (1 - d);
+                      if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT || board[rf+rt>>1][ff+ft>>1] == EmptySquare) continue;
+		      if (SameColor(board[rf][ff], board[rt][ft])) continue;
+		      callback(board, flags, NormalMove, rf, ff, rt, ft, closure);
+		  }
+              goto doRook;
+              
             /* Shogi Dragon King has to continue as Ferz after Rook moves */
             case SHOGI WhiteDragon:
             case SHOGI BlackDragon:
@@ -492,6 +524,7 @@ void GenPseudoLegal(board, flags, callback, closure)
             case SHOGI BlackRook:
 	    case WhiteRook:
 	    case BlackRook:
+          doRook:
               for (d = 0; d <= 1; d++)
                 for (s = -1; s <= 1; s += 2)
 		  for (i = 1;; i++) {
@@ -509,7 +542,7 @@ void GenPseudoLegal(board, flags, callback, closure)
 
 	    case WhiteQueen:
 	    case BlackQueen:
-	      for (rs = -1; rs <= 1; rs++) 
+	      for (rs = -1; rs <= 1; rs++)
 		for (fs = -1; fs <= 1; fs++) {
 		    if (rs == 0 && fs == 0) continue;
 		    for (i = 1;; i++) {
@@ -531,7 +564,7 @@ void GenPseudoLegal(board, flags, callback, closure)
             case SHOGI WhitePawn:
             case SHOGI WhiteFerz:
                   if (rf < BOARD_HEIGHT-1 &&
-                           !SameColor(board[rf][ff], board[rf + 1][ff]) ) 
+                           !SameColor(board[rf][ff], board[rf + 1][ff]) )
                            callback(board, flags, NormalMove,
                                     rf, ff, rf + 1, ff, closure);
               if(piece != SHOGI WhitePawn) goto finishSilver;
@@ -542,7 +575,7 @@ void GenPseudoLegal(board, flags, callback, closure)
             case SHOGI BlackPawn:
             case SHOGI BlackFerz:
                   if (rf > 0 &&
-                           !SameColor(board[rf][ff], board[rf - 1][ff]) ) 
+                           !SameColor(board[rf][ff], board[rf - 1][ff]) )
                            callback(board, flags, NormalMove,
                                     rf, ff, rf - 1, ff, closure);
               if(piece == SHOGI BlackPawn) break;
@@ -551,7 +584,7 @@ void GenPseudoLegal(board, flags, callback, closure)
             case BlackFerz:
             finishSilver:
                 /* [HGM] support Shatranj pieces */
-                for (rs = -1; rs <= 1; rs += 2) 
+                for (rs = -1; rs <= 1; rs += 2)
                   for (fs = -1; fs <= 1; fs += 2) {
                       rt = rf + rs;
                       ft = ff + fs;
@@ -601,12 +634,60 @@ void GenPseudoLegal(board, flags, callback, closure)
                     }
 		  }
 	      break;
+
+	    Amazon:
+	      /* First do Bishop,then continue like Chancellor */
+	      for (rs = -1; rs <= 1; rs += 2)
+                for (fs = -1; fs <= 1; fs += 2)
+		  for (i = 1;; i++) {
+		      rt = rf + (i * rs);
+		      ft = ff + (i * fs);
+                      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;
+		  }
+	      m++;
+	      goto doRook;
+
+	    // Use Lance as Berolina / Spartan Pawn.
+	    case WhiteLance:
+	      if(gameInfo.variant == VariantSuper) goto Amazon;
+	      if (rf < BOARD_HEIGHT-1 && BlackPiece(board[rf + 1][ff]))
+		  callback(board, flags,
+			   rf >= BOARD_HEIGHT-1-promoRank ? WhitePromotion : NormalMove,
+			   rf, ff, rf + 1, ff, closure);
+	      for (s = -1; s <= 1; s += 2) {
+	          if (rf < BOARD_HEIGHT-1 && ff + s >= BOARD_LEFT && ff + s < BOARD_RGHT && board[rf + 1][ff + s] == EmptySquare)
+		      callback(board, flags, 
+			       rf >= BOARD_HEIGHT-1-promoRank ? WhitePromotion : NormalMove,
+			       rf, ff, rf + 1, ff + s, closure);
+	          if (rf == 1 && ff + 2*s >= BOARD_LEFT && ff + 2*s < BOARD_RGHT && board[3][ff + 2*s] == EmptySquare )
+		      callback(board, flags, NormalMove, rf, ff, 3, ff + 2*s, closure);
+	      }
+	      break;
+		
+	    case BlackLance:
+	      if(gameInfo.variant == VariantSuper) goto Amazon;
+	      if (rf > 0 && WhitePiece(board[rf - 1][ff]))
+		  callback(board, flags,
+			   rf <= promoRank ? BlackPromotion : NormalMove,
+			   rf, ff, rf - 1, ff, closure);
+	      for (s = -1; s <= 1; s += 2) {
+	          if (rf > 0 && ff + s >= BOARD_LEFT && ff + s < BOARD_RGHT && board[rf - 1][ff + s] == EmptySquare)
+		      callback(board, flags, 
+			       rf <= promoRank ? BlackPromotion : NormalMove,
+			       rf, ff, rf - 1, ff + s, closure);
+	          if (rf == BOARD_HEIGHT-2 && ff + 2*s >= BOARD_LEFT && ff + 2*s < BOARD_RGHT && board[rf-2][ff + 2*s] == EmptySquare )
+		      callback(board, flags, NormalMove, rf, ff, rf-2, ff + 2*s, closure);
+	      }
+            break;
+
 	    case WhiteFalcon: // [HGM] wild: for wildcards, self-capture symbolizes move to anywhere
 	    case BlackFalcon:
 	    case WhiteCobra:
 	    case BlackCobra:
-	    case WhiteLance:
-	    case BlackLance:
 	      callback(board, flags, NormalMove, rf, ff, rf, ff, closure);
 	      break;
 
@@ -676,7 +757,7 @@ int GenLegal(board, flags, callback, closure)
      VOIDSTAR closure;
 {
     GenLegalClosure cl;
-    int ff, ft, k, left, right;
+    int ff, ft, k, left, right, swap;
     int ignoreCheck = (flags & F_IGNORE_CHECK) != 0;
     ChessSquare wKing = WhiteKing, bKing = BlackKing, *castlingRights = board[CASTLING];
 
@@ -703,7 +784,7 @@ int GenLegal(board, flags, callback, closure)
             board[0][BOARD_RGHT-1] == WhiteRook &&
             castlingRights[0] != NoRights && /* [HGM] check rights */
             ( castlingRights[2] == ff || castlingRights[6] == ff ) &&
-            (ignoreCheck ||                             
+            (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)) &&
@@ -773,10 +854,11 @@ int GenLegal(board, flags, callback, closure)
 	}
     }
 
-  if(flags & F_FRC_TYPE_CASTLING) {
+  if((swap = gameInfo.variant == VariantSChess) || flags & F_FRC_TYPE_CASTLING) {
 
     /* generate all potential FRC castling moves (KxR), ignoring flags */
     /* [HGM] test if the Rooks we find have castling rights */
+    /* In S-Chess we generate RxK for allowed castlings, for gating at Rook square */
 
 
     if ((flags & F_WHITE_ON_MOVE) != 0) {
@@ -795,7 +877,7 @@ int GenLegal(board, flags, callback, closure)
             for(k=left; k<right && ft != NoRights; k++) /* then if not checked */
                 if(!ignoreCheck && CheckTest(board, flags, 0, ff, 0, k, FALSE)) ft = NoRights;
             if(ft != NoRights && board[0][ft] == WhiteRook)
-                callback(board, flags, WhiteHSideCastleFR, 0, ff, 0, ft, closure);
+                callback(board, flags, WhiteHSideCastleFR, 0, swap ? ft : ff, 0, swap ? ff : ft, closure);
 
             ft = castlingRights[1]; /* Rook file if we have A-side rights */
             left  = BOARD_LEFT+2;
@@ -803,11 +885,11 @@ int GenLegal(board, flags, callback, closure)
             if(ff <= BOARD_LEFT+2) { left = ff+1; right = BOARD_LEFT+3; }
             for(k=left; k<=right && ft != NoRights; k++) /* first test if blocked */
                 if(k != ft && board[0][k] != EmptySquare) ft = NoRights;
-            if(ff > BOARD_LEFT+2) 
+            if(ff > BOARD_LEFT+2)
             for(k=left+1; k<=right && ft != NoRights; k++) /* then if not checked */
                 if(!ignoreCheck && CheckTest(board, flags, 0, ff, 0, k, FALSE)) ft = NoRights;
             if(ft != NoRights && board[0][ft] == WhiteRook)
-                callback(board, flags, WhiteASideCastleFR, 0, ff, 0, ft, closure);
+                callback(board, flags, WhiteASideCastleFR, 0, swap ? ft : ff, 0, swap ? ff : ft, closure);
         }
     } else {
         ff = castlingRights[5]; /* King file if we have any rights */
@@ -821,7 +903,7 @@ int GenLegal(board, flags, callback, closure)
             for(k=left; k<right && ft != NoRights; k++) /* then if not checked */
                 if(!ignoreCheck && CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, k, FALSE)) ft = NoRights;
             if(ft != NoRights && board[BOARD_HEIGHT-1][ft] == BlackRook)
-                callback(board, flags, BlackHSideCastleFR, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ft, closure);
+                callback(board, flags, BlackHSideCastleFR, BOARD_HEIGHT-1, swap ? ft : ff, BOARD_HEIGHT-1, swap ? ff : ft, closure);
 
             ft = castlingRights[4]; /* Rook file if we have A-side rights */
             left  = BOARD_LEFT+2;
@@ -829,11 +911,11 @@ int GenLegal(board, flags, callback, closure)
             if(ff <= BOARD_LEFT+2) { left = ff+1; right = BOARD_LEFT+3; }
             for(k=left; k<=right && ft != NoRights; k++) /* first test if blocked */
                 if(k != ft && board[BOARD_HEIGHT-1][k] != EmptySquare) ft = NoRights;
-            if(ff > BOARD_LEFT+2) 
+            if(ff > BOARD_LEFT+2)
             for(k=left+1; k<=right && ft != NoRights; k++) /* then if not checked */
                 if(!ignoreCheck && CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, k, FALSE)) ft = NoRights;
             if(ft != NoRights && board[BOARD_HEIGHT-1][ft] == BlackRook)
-                callback(board, flags, BlackASideCastleFR, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ft, closure);
+                callback(board, flags, BlackASideCastleFR, BOARD_HEIGHT-1, swap ? ft : ff, BOARD_HEIGHT-1, swap ? ff : ft, closure);
         }
     }
 
@@ -873,7 +955,7 @@ void CheckTestCallback(board, flags, kind, rf, ff, rt, ft, closure)
    e.p. capture.  The possibility of castling out of a check along the
    back rank is not accounted for (i.e., we still return nonzero), as
    this is illegal anyway.  Return value is the number of times the
-   king is in check. */ 
+   king is in check. */
 int CheckTest(board, flags, rf, ff, rt, ft, enPassant)
      Board board;
      int flags;
@@ -961,6 +1043,8 @@ if(appData.debugMode) fprintf(debugFP, "LegalDrop: %d @ %d,%d)\n", piece, ft, rt
                 if(board[r][ft] == piece) return IllegalMove; // or there already is a Pawn in file
             // should still test if we mate with this Pawn
         }
+    } else if(gameInfo.variant == VariantSChess) { // only back-rank drops
+        if (rt != (piece < BlackPawn ? 0 : BOARD_HEIGHT-1)) return IllegalMove;
     } else {
         if( (piece == WhitePawn || piece == BlackPawn) &&
             (rt == 0 || rt == BOARD_HEIGHT -1 ) )
@@ -1003,17 +1087,16 @@ ChessMove LegalityTest(board, flags, rf, ff, rt, ft, promoChar)
 
     if(rf == DROP_RANK) return LegalDrop(board, flags, ff, rt, ft);
     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 */
+    /* [HGM] 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)
+       piece == WhiteCobra  || piece == BlackCobra)
         return CheckTest(board, flags, rf, ff, rt, ft, FALSE) ? IllegalMove : NormalMove;
 
     cl.rf = rf;
@@ -1028,42 +1111,53 @@ ChessMove LegalityTest(board, flags, rf, ff, rt, ft, promoChar)
 	return(IllegalMove); // [HGM] losers: if there are legal captures, non-capts are illegal
 
     if(promoChar == 'x') promoChar = NULLCHAR; // [HGM] is this ever the case?
+    if(gameInfo.variant == VariantSChess && promoChar && promoChar != '=' && board[rf][ff] != WhitePawn && board[rf][ff] != BlackPawn) {
+        if(board[rf][ff] < BlackPawn) { // white
+            if(rf != 0) return IllegalMove; // must be on back rank
+            if(board[PieceToNumber(CharToPiece(ToUpper(promoChar)))][BOARD_WIDTH-2] == 0) return ImpossibleMove;// must be in stock
+        } else {
+            if(rf != BOARD_HEIGHT-1) return IllegalMove;
+            if(board[BOARD_HEIGHT-1-PieceToNumber(CharToPiece(ToLower(promoChar)))][1] == 0) return ImpossibleMove;
+        }
+    } else
     if(gameInfo.variant == VariantShogi) {
         /* [HGM] Shogi promotions. '=' means defer */
         if(rf != DROP_RANK && cl.kind == NormalMove) {
             ChessSquare piece = board[rf][ff];
 
             if(promoChar == PieceToChar(BlackQueen)) promoChar = NULLCHAR; /* [HGM] Kludge */
-            if(promoChar != NULLCHAR && promoChar != '+' && promoChar != '=' &&
-               ToUpper(PieceToChar(PROMOTED piece)) != ToUpper(promoChar) )
-                    cl.kind = IllegalMove;
+            if(promoChar == 'd' && (piece == WhiteRook   || piece == BlackRook)   ||
+               promoChar == 'h' && (piece == WhiteBishop || piece == BlackBishop) ||
+               promoChar == 'g' && (piece <= WhiteFerz || piece <= BlackFerz && piece >= BlackPawn) )
+                  promoChar = '+'; // allowed ICS notations
+if(appData.debugMode)fprintf(debugFP,"SHOGI promoChar = %c\n", promoChar ? promoChar : '-');
+            if(promoChar != NULLCHAR && promoChar != '+' && promoChar != '=')
+                return CharToPiece(promoChar) == EmptySquare ? ImpossibleMove : IllegalMove;
             else if(flags & F_WHITE_ON_MOVE) {
                 if( (int) piece < (int) WhiteWazir &&
                      (rf >= BOARD_HEIGHT*2/3 || rt >= BOARD_HEIGHT*2/3) ) {
                     if( (piece == WhitePawn || piece == WhiteQueen) && rt > BOARD_HEIGHT-2 ||
                          piece == WhiteKnight && rt > BOARD_HEIGHT-3) /* promotion mandatory */
-                             cl.kind = promoChar == '=' ? IllegalMove : WhitePromotion;
-                    else /* promotion optional, default is promote */
-                             cl.kind = promoChar == '=' ? WhiteNonPromotion : WhitePromotion;
-                   
-                } else cl.kind = (promoChar == NULLCHAR || promoChar == 'x' || promoChar == '=') ?
-                                            NormalMove : IllegalMove;
+                       cl.kind = promoChar == '=' ? IllegalMove : WhitePromotion;
+                    else /* promotion optional, default is defer */
+                       cl.kind = promoChar == '+' ? WhitePromotion : WhiteNonPromotion;
+                } else cl.kind = promoChar == '+' ? IllegalMove : NormalMove;
             } else {
                 if( (int) piece < (int) BlackWazir && (rf < BOARD_HEIGHT/3 || rt < BOARD_HEIGHT/3) ) {
                     if( (piece == BlackPawn || piece == BlackQueen) && rt < 1 ||
                          piece == BlackKnight && rt < 2 ) /* promotion obligatory */
-                             cl.kind = promoChar == '=' ? IllegalMove : BlackPromotion;
-                    else /* promotion optional, default is promote */
-                             cl.kind = promoChar == '=' ? BlackNonPromotion : BlackPromotion;
-
-                } else cl.kind = (promoChar == NULLCHAR || promoChar == '=') ? NormalMove : IllegalMove;
+                       cl.kind = promoChar == '=' ? IllegalMove : BlackPromotion;
+                    else /* promotion optional, default is defer */
+                       cl.kind = promoChar == '+' ? BlackPromotion : BlackNonPromotion;
+                } else cl.kind = promoChar == '+' ? IllegalMove : NormalMove;
             }
         }
     } else
     if (promoChar != NULLCHAR) {
 	if(promoChar == '=') cl.kind = IllegalMove; else // [HGM] shogi: no deferred promotion outside Shogi
 	if (cl.kind == WhitePromotion || cl.kind == BlackPromotion) {
-	    if(CharToPiece(promoChar) == EmptySquare) cl.kind = ImpossibleMove; // non-existing piece
+	    if(CharToPiece(flags & F_WHITE_ON_MOVE ? ToUpper(promoChar) : ToLower(promoChar)) == EmptySquare)
+                cl.kind = ImpossibleMove; // non-existing piece
 	} else {
 	    cl.kind = IllegalMove;
 	}
@@ -1100,7 +1194,7 @@ int MateTest(board, flags)
     int inCheck, r, f, myPieces=0, hisPieces=0, nrKing=0;
     ChessSquare king = flags & F_WHITE_ON_MOVE ? WhiteKing : BlackKing;
 
-    for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) { 
+    for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<BOARD_RGHT; f++) {
         // [HGM] losers: Count pieces and kings, to detect other unorthodox winning conditions
 	nrKing += (board[r][f] == king);   // stm has king
         if( board[r][f] != EmptySquare ) {
@@ -1141,14 +1235,14 @@ int MateTest(board, flags)
 					myPieces > hisPieces ? MT_STAINMATE : MT_STEALMATE;
 	else if(gameInfo.variant == VariantLosers) return inCheck ? MT_TRICKMATE : MT_STEALMATE;
 	else if(gameInfo.variant == VariantGiveaway) return MT_STEALMATE; // no check exists, stalemated = win
-					    
-        return inCheck ? MT_CHECKMATE 
-		       : (gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShatranj) ? 
+
+        return inCheck ? MT_CHECKMATE
+		       : (gameInfo.variant == VariantXiangqi || gameInfo.variant == VariantShatranj) ?
 			  MT_STAINMATE : MT_STALEMATE;
     }
 }
 
-     
+
 extern void DisambiguateCallback P((Board board, int flags, ChessMove kind,
 				    int rf, int ff, int rt, int ft,
 				    VOIDSTAR closure));
@@ -1165,8 +1259,7 @@ void DisambiguateCallback(board, flags, kind, rf, ff, rt, ft, closure)
 
     // [HGM] wild: for wild-card pieces rt and rf are dummies
     if(piece == WhiteFalcon || piece == BlackFalcon ||
-       piece == WhiteCobra  || piece == BlackCobra  ||
-       piece == WhiteLance  || piece == BlackLance)
+       piece == WhiteCobra  || piece == BlackCobra)
         wildCard = TRUE;
 
     if ((cl->pieceIn == EmptySquare || cl->pieceIn == board[rf][ff]
@@ -1188,7 +1281,7 @@ void DisambiguateCallback(board, flags, kind, rf, ff, rt, ft, closure)
 	  cl->ft = wildCard ? cl->ftIn : ft;
 	  cl->kind = kind;
 	}
-	cl->captures += (board[cl->rt][cl->ft] != EmptySquare); // [HGM] oneclick: count captures
+	cl->captures += (board[rt][ft] != EmptySquare); // [HGM] oneclick: count captures
     }
 }
 
@@ -1211,7 +1304,7 @@ void Disambiguate(board, flags, closure)
     if (closure->count == 0) {
 	/* See if it's an illegal move due to check */
         illegal = 1;
-        GenLegal(board, flags|F_IGNORE_CHECK, DisambiguateCallback, (VOIDSTAR) closure);	
+        GenLegal(board, flags|F_IGNORE_CHECK, DisambiguateCallback, (VOIDSTAR) closure);
 	if (closure->count == 0) {
 	    /* No, it's not even that */
     if (appData.debugMode) { int i, j;
@@ -1226,40 +1319,60 @@ void Disambiguate(board, flags, closure)
     }
 
     if (c == 'x') c = NULLCHAR; // get rid of any 'x' (which should never happen?)
+    if(gameInfo.variant == VariantSChess && c && c != '=' && closure->piece != WhitePawn && closure->piece != BlackPawn) {
+        if(closure->piece < BlackPawn) { // white
+            if(closure->rf != 0) closure->kind = IllegalMove; // must be on back rank
+            if(board[PieceToNumber(CharToPiece(ToUpper(c)))][BOARD_WIDTH-2] == 0) closure->kind = ImpossibleMove;// must be in stock
+        } else {
+            if(closure->rf != BOARD_HEIGHT-1) closure->kind = IllegalMove;
+            if(board[BOARD_HEIGHT-1-PieceToNumber(CharToPiece(ToLower(c)))][1] == 0) closure->kind = ImpossibleMove;
+        }
+    } else
     if(gameInfo.variant == VariantShogi) {
-        /* [HGM] Shogi promotions. On input, '=' means defer, NULL promote. Afterwards, c is set to '+' for promotions, NULL other */
+        /* [HGM] Shogi promotions. On input, '=' means defer, '+' promote. Afterwards, c is set to '+' for promotions, NULL other */
         if(closure->rfIn != DROP_RANK && closure->kind == NormalMove) {
             ChessSquare piece = closure->piece;
-            if(c != NULLCHAR && c != '+' && c != '=' &&
-               ToUpper(PieceToChar(PROMOTED piece)) != ToUpper(c) ) 
-                    closure->kind = IllegalMove; // the only allowed cases are '+', '=' and the promoted partner.
+            if (c == 'd' && (piece == WhiteRook   || piece == BlackRook)   ||
+                c == 'h' && (piece == WhiteBishop || piece == BlackBishop) ||
+                c == 'g' && (piece <= WhiteFerz || piece <= BlackFerz && piece >= BlackPawn) )
+                   c = '+'; // allowed ICS notations
+            if(c != NULLCHAR && c != '+' && c != '=') closure->kind = IllegalMove; // otherwise specifying a piece is illegal
             else if(flags & F_WHITE_ON_MOVE) {
                 if( (int) piece < (int) WhiteWazir &&
                      (closure->rf >= BOARD_HEIGHT-(BOARD_HEIGHT/3) || closure->rt >= BOARD_HEIGHT-(BOARD_HEIGHT/3)) ) {
                     if( (piece == WhitePawn || piece == WhiteQueen) && closure->rt > BOARD_HEIGHT-2 ||
                          piece == WhiteKnight && closure->rt > BOARD_HEIGHT-3) /* promotion mandatory */
-                             closure->kind = c == '=' ? IllegalMove : WhitePromotion;
-                    else /* promotion optional, default is promote */
-                             closure->kind = c == '=' ? WhiteNonPromotion  : WhitePromotion;
-                } else closure->kind = (c == NULLCHAR || c == '=') ? NormalMove : IllegalMove;
+                       closure->kind = c == '=' ? IllegalMove : WhitePromotion;
+                    else /* promotion optional, default is defer */
+                       closure->kind = c == '+' ? WhitePromotion : WhiteNonPromotion; 
+                } else closure->kind = c == '+' ? IllegalMove : NormalMove;
             } else {
                 if( (int) piece < (int) BlackWazir && (closure->rf < BOARD_HEIGHT/3 || closure->rt < BOARD_HEIGHT/3) ) {
                     if( (piece == BlackPawn || piece == BlackQueen) && closure->rt < 1 ||
                          piece == BlackKnight && closure->rt < 2 ) /* promotion obligatory */
-                             closure->kind = c == '=' ? IllegalMove : BlackPromotion;
-                    else /* promotion optional, default is promote */
-                             closure->kind = c == '=' ? BlackNonPromotion  : BlackPromotion;
-                } else closure->kind = (c == NULLCHAR || c == '=') ? NormalMove : IllegalMove;
+                       closure->kind = c == '=' ? IllegalMove : BlackPromotion;
+                    else /* promotion optional, default is defer */
+                       closure->kind = c == '+' ? BlackPromotion : BlackNonPromotion;
+                } else closure->kind = c == '+' ? IllegalMove : NormalMove;
             }
         }
-        c = (closure->kind == WhitePromotion || closure->kind == BlackPromotion) ? '+' : NULLCHAR;
+        if(closure->kind == WhitePromotion || closure->kind == BlackPromotion) c = '+'; else
+        if(closure->kind == WhiteNonPromotion || closure->kind == BlackNonPromotion) c = '=';
     } else
     if (closure->kind == WhitePromotion || closure->kind == BlackPromotion) {
-        if(c == NULLCHAR) c = 'q'; // even in Shatranj, Courier, Makruk, as Apply move corrects this to Ferz (how messy!)
+        if(c == NULLCHAR) { // missing promoChar on mandatory promotion; use default for variant
+            if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || gameInfo.variant == VariantMakruk)
+                c = PieceToChar(BlackFerz);
+            else if(gameInfo.variant == VariantGreat)
+                c = PieceToChar(BlackMan);
+            else
+                c = PieceToChar(BlackQueen);
+        } else if(c == '=') closure->kind = IllegalMove; // no deferral outside Shogi
     } else if (c != NULLCHAR) closure->kind = IllegalMove;
 
     closure->promoChar = ToLower(c); // this can be NULLCHAR! Note we keep original promoChar even if illegal.
-    if(c != '+' && c != NULLCHAR && CharToPiece(c) == EmptySquare) closure->kind = ImpossibleMove; // but we cannot handle non-existing piece types! 
+    if(c != '+' && c != '=' && c != NULLCHAR && CharToPiece(flags & F_WHITE_ON_MOVE ? ToUpper(c) : ToLower(c)) == EmptySquare)
+	closure->kind = ImpossibleMove; // but we cannot handle non-existing piece types!
     if (closure->count > 1) {
 	closure->kind = AmbiguousMove;
     }
@@ -1303,7 +1416,7 @@ void CoordsToAlgebraicCallback(board, flags, kind, rf, ff, rt, ft, closure)
     register CoordsToAlgebraicClosure *cl =
       (CoordsToAlgebraicClosure *) closure;
 
-    if (rt == cl->rt && ft == cl->ft &&
+    if ((rt == cl->rt && ft == cl->ft || rt == rf && ft == ff) && // [HGM] null move matches any toSquare
         (board[rf][ff] == cl->piece
          || PieceToChar(board[rf][ff]) == '~' &&
             (ChessSquare) (DEMOTED board[rf][ff]) == cl->piece)
@@ -1320,7 +1433,7 @@ void CoordsToAlgebraicCallback(board, flags, kind, rf, ff, rt, ft, closure)
 	    } else {
 		cl->either++; /* rank or file will rule out this move */
 	    }
-	}	    
+	}
     }
 }
 
@@ -1338,7 +1451,7 @@ ChessMove CoordsToAlgebraic(board, flags, rf, ff, rt, ft, promoChar, out)
     ChessMove kind;
     char *outp = out, c;
     CoordsToAlgebraicClosure cl;
-    
+
     if (rf == DROP_RANK) {
 	/* Bughouse piece drop */
 	*outp++ = ToUpper(PieceToChar((ChessSquare) ff));
@@ -1400,15 +1513,18 @@ ChessMove CoordsToAlgebraic(board, flags, rf, ff, rt, ft, promoChar, out)
 	}
         return kind;
 
-	
+
       case WhiteKing:
       case BlackKing:
         /* Fabien moved code: FRC castling first (if KxR), wild castling second */
 	/* Code added by Tord:  FRC castling. */
 	if((piece == WhiteKing && board[rt][ft] == WhiteRook) ||
 	   (piece == BlackKing && board[rt][ft] == BlackRook)) {
-	  if(ft > ff) strcpy(out, "O-O"); else strcpy(out, "O-O-O");
-            return LegalityTest(board, flags, rf, ff, rt, ft, promoChar);
+	  if(ft > ff)
+	    safeStrCpy(out, "O-O", MOVE_LEN);
+	  else
+	    safeStrCpy(out, "O-O-O", MOVE_LEN);
+	  return LegalityTest(board, flags, rf, ff, rt, ft, promoChar);
 	}
 	/* End of code added by Tord */
 	/* Test for castling or ICS wild castling */
@@ -1419,9 +1535,9 @@ ChessMove CoordsToAlgebraic(board, flags, rf, ff, rt, ft, promoChar, out)
             ((ff == BOARD_WIDTH>>1 && (ft == BOARD_LEFT+2 || ft == BOARD_RGHT-2)) ||
              (ff == (BOARD_WIDTH-1)>>1 && (ft == BOARD_LEFT+1 || ft == BOARD_RGHT-3)))) {
             if(ft==BOARD_LEFT+1 || ft==BOARD_RGHT-2)
-		strcpy(out, "O-O");
+	      snprintf(out, MOVE_LEN, "O-O%c%c", promoChar ? '/' : 0, ToUpper(promoChar));
             else
-		strcpy(out, "O-O-O");
+	      snprintf(out, MOVE_LEN, "O-O-O%c%c", promoChar ? '/' : 0, ToUpper(promoChar));
 
 	    /* This notation is always unambiguous, unless there are
 	       kings on both the d and e files, with "wild castling"
@@ -1484,60 +1600,24 @@ ChessMove CoordsToAlgebraic(board, flags, rf, ff, rt, ft, promoChar, out)
         if(rt+ONE <= '9')
            *outp++ = rt + ONE;
         else { *outp++ = (rt+ONE-'0')/10 + '0';*outp++ = (rt+ONE-'0')%10 + '0'; }
-	*outp = NULLCHAR;
         if (gameInfo.variant == VariantShogi) {
             /* [HGM] in Shogi non-pawns can promote */
-            if(flags & F_WHITE_ON_MOVE) {
-                if( (int) cl.piece < (int) WhiteWazir &&
-                     (rf >= BOARD_HEIGHT-(BOARD_HEIGHT/3) || rt >= BOARD_HEIGHT-(BOARD_HEIGHT/3)) ) {
-                    if( (piece == WhitePawn || piece == WhiteQueen) && rt > BOARD_HEIGHT-2 ||
-                         piece == WhiteKnight && rt > BOARD_HEIGHT-3) /* promotion mandatory */
-                             cl.kind = promoChar == '=' ? IllegalMove : WhitePromotion;
-                    else cl.kind =  WhitePromotion; /* promotion optional */
-                   
-                } else cl.kind = (promoChar == NULLCHAR || promoChar == 'x' || promoChar == '=') ?
-                                            NormalMove : IllegalMove;
-            } else {
-                if( (int) cl.piece < (int) BlackWazir && (rf < BOARD_HEIGHT/3 || rt < BOARD_HEIGHT/3) ) {
-                    if( (piece == BlackPawn || piece == BlackQueen) && rt < 1 ||
-                         piece == BlackKnight && rt < 2 ) /* promotion obligatory */
-                             cl.kind = promoChar == '=' ? IllegalMove : BlackPromotion;
-                    else cl.kind =  BlackPromotion; /* promotion optional */
-                } else cl.kind = (promoChar == NULLCHAR || promoChar == 'x' || promoChar == '=') ?
-                                            NormalMove : IllegalMove;
-            }
-            if(cl.kind == WhitePromotion || cl.kind == BlackPromotion) {
-                /* for optional promotions append '+' or '=' */
-                if(promoChar == '=') {
-                    *outp++ = '=';
-                    cl.kind = NormalMove;
-                } else *outp++ = '+';
-                *outp = NULLCHAR;
-            } else if(cl.kind == IllegalMove) {
-                /* Illegal move specifies any given promotion */
-                if(promoChar != NULLCHAR && promoChar != 'x') {
-                    *outp++ = '=';
-                    *outp++ = ToUpper(promoChar);
-                    *outp = NULLCHAR;
-                }
-            }
+            *outp++ = promoChar; // Don't bother to correct move type, return value is never used!
         }
+        else if (gameInfo.variant == VariantSChess && promoChar) { // and in S-Chess we have gating
+            *outp++ = '/';
+            *outp++ = ToUpper(promoChar);
+        }
+	*outp = NULLCHAR;
         return cl.kind;
 	
-      /* [HGM] Always long notation for fairies we don't know */
-      case WhiteFalcon:
-      case BlackFalcon:
-      case WhiteLance:
-      case BlackLance:
-      case WhiteGrasshopper:
-      case BlackGrasshopper:
       case EmptySquare:
 	/* Moving a nonexistent piece */
 	break;
     }
-    
+
     /* Not a legal move, even ignoring check.
-       If there was a piece on the from square, 
+       If there was a piece on the from square,
        use style "Ng1g3" or "Ng1xe8";
        if there was a pawn or nothing (!),
        use style "g1g3" or "g1xe8".  Use "x"
@@ -1545,13 +1625,19 @@ ChessMove CoordsToAlgebraic(board, flags, rf, ff, rt, ft, promoChar, out)
        a piece of the same color.
     */
     outp = out;
+    c = 0;
     if (piece != EmptySquare && piece != WhitePawn && piece != BlackPawn) {
+	int r, f;
+      for(r=0; r<BOARD_HEIGHT; r++) for(f=BOARD_LEFT; f<=BOARD_RGHT; f++)
+ 		c += (board[r][f] == piece); // count on-board pieces of given type
 	*outp++ = ToUpper(PieceToChar(piece));
     }
+  if(c != 1) { // [HGM] but if there is only one piece of the mentioned type, no from-square, thank you!
     *outp++ = ff + AAA;
     if(rf+ONE <= '9')
        *outp++ = rf + ONE;
     else { *outp++ = (rf+ONE-'0')/10 + '0';*outp++ = (rf+ONE-'0')%10 + '0'; }
+  }
     if (board[rt][ft] != EmptySquare) *outp++ = 'x';
     *outp++ = ft + AAA;
     if(rt+ONE <= '9')
@@ -1637,8 +1723,8 @@ void ExistingAttacksCallback(board, flags, kind, rf, ff, rt, ft, closure)
     }
     // search move in chaseStack, and delete it if it occurred there (as we know now it is not a new capture)
     for(i=0; i<chaseStackPointer; i++) {
-	if(chaseStack[i].rf == rf && chaseStack[i].ff == ff && 
-	   chaseStack[i].rt == rt && chaseStack[i].ft == ft   ) { 
+	if(chaseStack[i].rf == rf && chaseStack[i].ff == ff &&
+	   chaseStack[i].rt == rt && chaseStack[i].ft == ft   ) {
 	    // move found on chaseStack, delete it by overwriting with move popped from top of chaseStack
 	    chaseStack[i] = chaseStack[--chaseStackPointer];
 	    break;
@@ -1678,9 +1764,9 @@ int PerpetualChase(int first, int last)
 	chaseStackPointer = 0;   // clear stack that is going to hold possible chases
 	// determine all captures possible after the move, and put them on chaseStack
 	GenLegal(boards[i+1], PosFlags(i), AttacksCallback, &cl);
-	if(appData.debugMode) { int n; 
-	    for(n=0; n<chaseStackPointer; n++) 
-                fprintf(debugFP, "%c%c%c%c ", chaseStack[n].ff+AAA, chaseStack[n].rf+ONE, 
+	if(appData.debugMode) { int n;
+	    for(n=0; n<chaseStackPointer; n++)
+                fprintf(debugFP, "%c%c%c%c ", chaseStack[n].ff+AAA, chaseStack[n].rf+ONE,
                                               chaseStack[n].ft+AAA, chaseStack[n].rt+ONE);
             fprintf(debugFP, ": all capts\n");
 	}
@@ -1690,9 +1776,9 @@ int PerpetualChase(int first, int last)
 	cl.rt = moveList[i][3]-ONE;
 	cl.ft = moveList[i][2]-AAA+BOARD_LEFT;
 	GenLegal(boards[i],   PosFlags(i), ExistingAttacksCallback, &cl);
-	if(appData.debugMode) { int n; 
-	    for(n=0; n<chaseStackPointer; n++) 
-                fprintf(debugFP, "%c%c%c%c ", chaseStack[n].ff+AAA, chaseStack[n].rf+ONE, 
+	if(appData.debugMode) { int n;
+	    for(n=0; n<chaseStackPointer; n++)
+                fprintf(debugFP, "%c%c%c%c ", chaseStack[n].ff+AAA, chaseStack[n].rf+ONE,
                                               chaseStack[n].ft+AAA, chaseStack[n].rt+ONE);
             fprintf(debugFP, ": new capts after %c%c%c%c\n", cl.ff+AAA, cl.rf+ONE, cl.ft+AAA, cl.rt+ONE);
 	}
@@ -1704,11 +1790,11 @@ int PerpetualChase(int first, int last)
 	    if(attacker >= (int) BlackPawn) attacker = BLACK_TO_WHITE attacker; // convert to white, as piecee type
 	    if(victim   >= (int) BlackPawn) victim   = BLACK_TO_WHITE victim;
 
-	    if((attacker == WhiteKnight || attacker == WhiteCannon) && victim == WhiteRook) 
+	    if((attacker == WhiteKnight || attacker == WhiteCannon) && victim == WhiteRook)
 		continue; // C or H attack on R is always chase; leave on chaseStack
 
 	    if(attacker == victim) {
-                if(LegalityTest(boards[i+1], PosFlags(i+1), chaseStack[j].rt, 
+                if(LegalityTest(boards[i+1], PosFlags(i+1), chaseStack[j].rt,
                    chaseStack[j].ft, chaseStack[j].rf, chaseStack[j].ff, NULLCHAR) == NormalMove) {
 			// we can capture back with equal piece, so this is no chase but a sacrifice
                         chaseStack[j] = chaseStack[--chaseStackPointer]; // delete the capture from the chaseStack
@@ -1736,13 +1822,13 @@ int PerpetualChase(int first, int last)
 	    // if a recapture was found, piece is protected, and we are not chasing it.
 	    if(cl.recaptures) { // attacked piece was defended by true protector, no chase
 		chaseStack[j] = chaseStack[--chaseStackPointer]; // so delete from chaseStack
-		j--; /* ! */ 
+		j--; /* ! */
 	    }
 	}
 	// chaseStack now contains all moves that chased
-	if(appData.debugMode) { int n; 
-	    for(n=0; n<chaseStackPointer; n++) 
-                fprintf(debugFP, "%c%c%c%c ", chaseStack[n].ff+AAA, chaseStack[n].rf+ONE, 
+	if(appData.debugMode) { int n;
+	    for(n=0; n<chaseStackPointer; n++)
+                fprintf(debugFP, "%c%c%c%c ", chaseStack[n].ff+AAA, chaseStack[n].rf+ONE,
                                               chaseStack[n].ft+AAA, chaseStack[n].rt+ONE);
             fprintf(debugFP, ": chases\n");
 	}
@@ -1768,8 +1854,8 @@ int PerpetualChase(int first, int last)
 	    }
 	}
         preyStackPointer = tail; // keep bottom part of preyStack, popping pieces unchased on move i.
-	if(appData.debugMode) { int n; 
-            for(n=0; n<preyStackPointer; n++) 
+	if(appData.debugMode) { int n;
+            for(n=0; n<preyStackPointer; n++)
                 fprintf(debugFP, "%c%c ", preyStack[n].file+AAA, preyStack[n].rank+ONE);
             fprintf(debugFP, "always chased upto ply %d\n", i);
 	}