From be7d8e737e7144bd860de497842424aa743be93f Mon Sep 17 00:00:00 2001 From: H.G. Muller Date: Thu, 28 May 2009 21:55:51 -0700 Subject: [PATCH] added Xiangqi perpetual-chase detection --- backend.c | 17 ++++- moves.c | 217 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 232 insertions(+), 2 deletions(-) diff --git a/backend.c b/backend.c index 9c7e1c4..9c49e05 100644 --- a/backend.c +++ b/backend.c @@ -5996,6 +5996,8 @@ FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book h EP_NONE, castlingRights[m-1]) != MT_CHECK) hisPerpetual = 0; // the opponent did not always check } + if(appData.debugMode) fprintf(debugFP, "XQ perpetual test, our=%d, his=%d\n", + ourPerpetual, hisPerpetual); if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, "Xboard adjudication: perpetual checking", GE_XBOARD ); @@ -6003,8 +6005,19 @@ FakeBookMove: // [HGM] book: we jump here to simulate machine moves after book h } if(hisPerpetual && !ourPerpetual) // he is checking us, but did not repeat yet break; // (or we would have caught him before). Abort repetition-checking loop. - // if neither of us is checking all the time, or both are, it is draw - // (illegal-chase forfeits not implemented yet!) + // Now check for perpetual chases + if(!ourPerpetual && !hisPerpetual) { // no perpetual check, test for chase + hisPerpetual = PerpetualChase(k, forwardMostMove); + ourPerpetual = PerpetualChase(k+1, forwardMostMove); + if(ourPerpetual && !hisPerpetual) { // we are actively checking him: forfeit + GameEnds( WhiteOnMove(forwardMostMove) ? WhiteWins : BlackWins, + "Xboard adjudication: perpetual chasing", GE_XBOARD ); + return; + } + if(hisPerpetual && !ourPerpetual) // he is chasing us, but did not repeat yet + break; // Abort repetition-checking loop. + } + // if neither of us is checking or chasing all the time, or both are, it is draw } GameEnds( GameIsDrawn, "Xboard adjudication: repetition draw", GE_XBOARD ); return; diff --git a/moves.c b/moves.c index 64dbae9..67c98ed 100644 --- a/moves.c +++ b/moves.c @@ -1590,4 +1590,221 @@ ChessMove CoordsToAlgebraic(board, flags, epfile, return IllegalMove; } +// [HGM] XQ: the following code serves to detect perpetual chasing (Asian rules) +typedef struct { + /* Input */ + int rf, ff, rt, ft; + /* Output */ + int recaptures; +} ChaseClosure; + +// I guess the following variables logically belong in the closure too, but I was too lazy and used globals + +int preyStackPointer, chaseStackPointer; + +struct { +char rf, ff, rt, ft; +} chaseStack[100]; + +struct { +char rank, file; +} preyStack[100]; + + + + +// there are three new callbacks for use with GenLegal: for adding captures, deleting them, and finding a recapture + +extern void AtacksCallback P((Board board, int flags, ChessMove kind, + int rf, int ff, int rt, int ft, + VOIDSTAR closure)); + +void AttacksCallback(board, flags, kind, rf, ff, rt, ft, closure) + Board board; + int flags; + ChessMove kind; + int rf, ff, rt, ft; + VOIDSTAR closure; +{ // For adding captures that can lead to chase indictment to the chaseStack + if(board[rt][ft] == EmptySquare) return; // non-capture + if(board[rt][ft] == WhitePawn && rt < BOARD_HEIGHT/2) return; // Pawn before river can be chased + if(board[rt][ft] == BlackPawn && rt >= BOARD_HEIGHT/2) return; // Pawn before river can be chased + if(board[rf][ff] == WhitePawn || board[rf][ff] == BlackPawn) return; // Pawns are allowed to chase + if(board[rf][ff] == WhiteWazir || board[rf][ff] == BlackWazir) return; // King is allowed to chase + // move cannot be excluded from being a chase trivially (based on attacker and victim); save it on chaseStack + chaseStack[chaseStackPointer].rf = rf; + chaseStack[chaseStackPointer].ff = ff; + chaseStack[chaseStackPointer].rt = rt; + chaseStack[chaseStackPointer].ft = ft; + chaseStackPointer++; +} + +extern void ExistingAtacksCallback P((Board board, int flags, ChessMove kind, + int rf, int ff, int rt, int ft, + VOIDSTAR closure)); + +void ExistingAttacksCallback(board, flags, kind, rf, ff, rt, ft, closure) + Board board; + int flags; + ChessMove kind; + int rf, ff, rt, ft; + VOIDSTAR closure; +{ // for removing pre-exsting captures from the chaseStack, to be left with newly created ones + int i; + register ChaseClosure *cl = (ChaseClosure *) closure; //closure tells us the move played in the repeat loop + + if(board[rt][ft] == EmptySquare) return; // no capture + if(rf == cl->rf && ff == cl->ff) { // attacks with same piece from new position are not considered new + rf = cl->rt; ff = cl->ft; // doctor their fromSquare so they will be recognized in chaseStack + } + // search move in chaseStack, and delete it if it occurred there (as we know now it is not a new capture) + for(i=0; irt && ft == cl->ft) cl->recaptures++; // count legal recaptures to this square + if(appData.debugMode && board[rt][ft] != EmptySquare) + fprintf(debugFP, "try %c%c%c%c=%d\n", ff+AAA, rf+ONE,ft+AAA, rt+ONE, cl->recaptures); +} + +extern char moveList[MAX_MOVES][MOVE_LEN]; + +int PerpetualChase(int first, int last) +{ // this routine detects if the side to move in the 'first' position is perpetually chasing (when not checking) + int i, j, k, tail; + ChaseClosure cl; + ChessSquare captured; + + preyStackPointer = 0; // clear stack of chased pieces + for(i=first; i= (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) + continue; // C or H attack on R is always chase; leave on chaseStack + + if(attacker == victim) { + if(LegalityTest(boards[i+1], PosFlags(i+1), EP_NONE, initialRights, 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 + j--; /* ! */ continue; + } + + } + + // the attack is on a lower piece, or on a pinned or blocked equal one + // test if the victim is protected by a true protector. First make the capture. + captured = boards[i+1][chaseStack[j].rt][chaseStack[j].ft]; + boards[i+1][chaseStack[j].rt][chaseStack[j].ft] = boards[i+1][chaseStack[j].rf][chaseStack[j].ff]; + boards[i+1][chaseStack[j].rf][chaseStack[j].ff] = EmptySquare; + // Then test if the opponent can recapture + cl.recaptures = 0; // prepare closure to pass recapture square and count moves to it + cl.rt = chaseStack[j].rt; + cl.ft = chaseStack[j].ft; + if(appData.debugMode) { int n; + fprintf(debugFP, "test if we can recapture %c%c\n", cl.ft+AAA, cl.rt+ONE); + } + GenLegal(boards[i+1], PosFlags(i+1), EP_NONE, initialRights, ProtectedCallback, &cl); // try all moves + // unmake the capture + boards[i+1][chaseStack[j].rf][chaseStack[j].ff] = boards[i+1][chaseStack[j].rt][chaseStack[j].ft]; + boards[i+1][chaseStack[j].rt][chaseStack[j].ft] = captured; + // 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--; /* ! */ + } + } + // chaseStack now contains all moves that chased + if(appData.debugMode) { int n; + for(n=0; n