extern signed char initialRights[BOARD_FILES]; /* [HGM] all rights enabled, set in InitPosition */
int quickFlag;
char *pieceDesc[EmptySquare];
+char *defaultDesc[EmptySquare] = {
+ "fmWfceFifmnD", "N", "B", "R", "Q",
+ "F", "A", "BN", "RN", "W", "K",
+ "mRcpR", "N0", "BW", "RF", "gQ",
+ "", "", "QN", "", "N", "",
+ "", "", "", "", "",
+ "", "", "", "", "", "",
+ "", "", "", "", "",
+ "", "", "", "", "", "K"
+};
int
WhitePiece (ChessSquare piece)
int i=0;
ChessSquare start = (int)p >= (int)BlackPawn ? BlackPawn : WhitePawn;
- while(start++ != p) if(pieceToChar[(int)start-1] != '.') i++;
+ while(start++ != p) if(pieceToChar[start-1] != '.' && pieceToChar[start-1] != '+') i++;
return i;
}
return TRUE;
}
+char defaultName[] = "PNBRQ......................................K" // white
+ "pnbrq......................................k"; // black
+char shogiName[] = "PNBRLS...G.++++++..........................K" // white
+ "pnbrls...g.++++++..........................k"; // black
+char xqName[] = "PH.R.AE..K.C................................" // white
+ "ph.r.ae..k.c................................"; // black
+
+char *
+CollectPieceDescriptors ()
+{ // make a line of piece descriptions for use in the PGN Piece tag:
+ // dump all engine defined pieces, and pieces with non-standard names,
+ // but suppress black pieces that are the same as their white counterpart
+ ChessSquare p;
+ static char buf[MSG_SIZ];
+ char *m, c, d, *pieceName = defaultName;
+ int len;
+ *buf = NULLCHAR;
+ if(!pieceDefs) return "";
+ if(gameInfo.variant == VariantChu) return ""; // for now don't do this for Chu Shogi
+ if(gameInfo.variant == VariantShogi) pieceName = shogiName;
+ if(gameInfo.variant == VariantXiangqi) pieceName = xqName;
+ for(p=WhitePawn; p<EmptySquare; p++) {
+ if((c = pieceToChar[p]) == '.' || c == '~') continue; // does not participate
+ m = pieceDesc[p]; d = (c == '+' ? pieceToChar[DEMOTED p] : c);
+ if(p >= BlackPawn && pieceToChar[BLACK_TO_WHITE p] == toupper(c)
+ && (c != '+' || pieceToChar[DEMOTED BLACK_TO_WHITE p] == d)) { // black member of normal pair
+ char *wm = pieceDesc[BLACK_TO_WHITE p];
+ if(!m && !wm || m && wm && !strcmp(wm, m)) continue; // moves as a white piece
+ } else // white or unpaired black
+ if((p < BlackPawn || CharToPiece(toupper(d)) != EmptySquare) && // white or lone black
+ !pieceDesc[p] /*&& pieceName[p] == c*/) continue; // orthodox piece known by its usual name
+// TODO: listing pieces because of unusual name can only be done if we have accurate Betza of all defaults
+ if(!m) m = defaultDesc[p];
+ len = strlen(buf);
+ snprintf(buf+len, MSG_SIZ-len, "%s%s%c:%s", len ? ";" : "", c == '+' ? "+" : "", d, m);
+ }
+ return buf;
+}
+
// [HGM] gen: configurable move generation from Betza notation sent by engine.
Boolean pieceDefs;
int mine, his, dir, bit, occup, i;
if(flags & F_WHITE_ON_MOVE) his = 2, mine = 1; else his = 1, mine = 2;
while(*p) { // more moves to go
- int expo = 1, dx, dy, x, y, mode, dirSet, retry=0, initial=0, jump=1;
+ int expo = 1, dx, dy, x, y, mode, dirSet, retry=0, initial=0, jump=1, skip = 0;
if(*p == 'i') initial = 1, desc = ++p;
while(islower(*p)) p++; // skip prefixes
if(!isupper(*p)) return; // syntax error: no atom
} else desc++;
dirSet |= b;
}
- dirSet &= 0x99; if(!dirSet) dirSet = 0x99;
+ dirSet &= 0x55; if(!dirSet) dirSet = 0x55;
break;
case 'R': expo = 0; // rook, slide
case 'W': // orthogonal atom (non-deg 4-fold)
while(islower(*desc) && (i = dirType[*desc-'a']) != '0') {
int b = dirs2[*desc-'a']; // when alone, use narrow version
if(desc[1] == 'h') b = dirs1[*desc-'a'], desc += 2; // dirs1 is wide version
- else if(islower(desc[1]) && i < '4'
- && ((i | dirType[desc[1]-'a']) & 3) == 3) { // combinable (perpendicular dim)
+ else if(*desc == desc[1] || islower(desc[1]) && i < '4'
+ && ((i | dirType[desc[1]-'a']) & 3) == 3) { // combinable (perpendicular dim or same)
b = dirs1[*desc-'a'] & dirs2[desc[1]-'a']; // intersect wide & perp narrow
desc += 2;
} else desc++;
if(expo > 1 && dx == 0 && dy == 0) { // castling indicated by O + number
mode |= 16; dy = 1;
}
+ if(dy == 1) skip = jump - 1, jump = 1; // on W & F atoms 'j' = skip first square
do {
for(dir=0, bit=1; dir<8; dir++, bit += bit) { // loop over directions
- int i = expo, hop = mode, vx, vy;
+ int i = expo, j = skip, hop = mode, vx, vy;
if(!(bit & dirSet)) continue; // does not move in this direction
+ if(dy != 1) j = 0; //
vx = dx*rot[dir][0] + dy*rot[dir][1]; // rotate step vector
vy = dx*rot[dir][2] + dy*rot[dir][3];
x = f; y = r; // start square
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(j) { j--; continue; } // skip irrespective of occupation
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
/* [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) && gameInfo.variant != VariantChu)
+ piece == WhiteCobra || piece == BlackCobra) && gameInfo.variant != VariantChu && !pieceDesc[piece])
return CheckTest(board, flags, rf, ff, rt, ft, FALSE) ? IllegalMove : NormalMove;
cl.rf = rf;
projects / xboard.git / blobdiff