const char *wpstring[] = {" ", "P", "N", "B", "R", "A", "C", "M", "Q", "E", "B", "Q", "W", "H", "N", "D", "H", "L",
- "C", "S", "G", "H", "A", "F", "E", "H", "M", "S", "E", "W", "O", "G", "V", "S", "E", "A", "K", "H", "E"};
+ "C", "S", "G", "H", "A", "F", "E", "H", "M", "S", "E", "W", "O", "G", "V", "S", "E", "A",
+ "K", "H", "E", "W", "G", "L", "C", "H"};
const char *bpstring[] = {" ", "p", "n", "b", "r", "a", "c", "m", "q", "e", "b", "q", "w", "h", "n", "d", "h", "l",
- "c", "s", "g", "h", "a", "f", "e", "h", "m", "s", "e", "w", "o", "g", "v", "s", "e", "a", "k", "h", "e"};
+ "c", "s", "g", "h", "a", "f", "e", "h", "m", "s", "e", "w", "o", "g", "v", "s", "e", "a",
+ "k", "h", "e", "w", "g", "l", "c", "h"};
-int pieceValues[PIECES] = {0, 1, 3, 3, 5, 8, 9, 3, 9, 1, 1, 2, 2, 2, 1, 6, 5, 2, 3, 3, 3, 1, 5, 2, 1, 7, 7, 3, 3, 3, 7, 7, 7, 8, 9, 12, 0, 8, 9};
+int pieceValues[PIECES] = {0, 1, 3, 3, 5, 8, 9, 3, 9, 1, 1, 2, 2, 2, 1, 6, 5, 2, 3, 3, 3, 1, 5, 2, 1, 7, 7, 3, 3, 3, 7, 7, 7, 8, 9, 12,
+ 0, 8, 9, 8, 7, 3, 3, 1};
static const int mach_type = (1<<7) | (1<<8) | (1<<9) | (1<<10) | (1<<11);
#define IsMachineStyle(n) (((1<<(n)) & mach_type) != 0)
{
static const char *wp[] = {" |", " P |", " N |", " B |", " R |", " A |", " C |", " M |", " Q |", " E |", " B |", " Q |",
" W |", " H |", " N |", " D |", " H |", " L |", " C |", " S |", " G |", " H |", " A |", " F |",
- " E |", " H |", " M |", " S |", " E |", " W |", " O |", " G |", " V |", " S |", " E |", " A |", " K |", " H |", " E |"};
+ " E |", " H |", " M |", " S |", " E |", " W |", " O |", " G |", " V |", " S |", " E |", " A |",
+ " K |", " H |", " E |", " W |", " G |", " L |", " C |", " H |"};
static const char *bp[] = {" |", " *P|", " *N|", " *B|", " *R|", " *A|", " *C|", " *M|", " *Q|", " *E|", " *B|", " *Q|",
" *W|", " *H|", " *N|", " *D|", " *H|", " *L|", " *C|", " *S|", " *G|", " *H|", " *A|", " *F|",
- " *E|", " *H|", " *M|", " *S|", " *E|", " *W|", " *O|", " *G|", " *V|", " *S|", " *E|", " *A|", " *K|", " *H|", " *E|"};
+ " *E|", " *H|", " *M|", " *S|", " *E|", " *W|", " *O|", " *G|", " *V|", " *S|", " *E|", " *A|",
+ " *K|", " *H|", " *E|", " *W|", " *G|", " *L|", " *C|", " *H|"};
static char *wsqr = "";
static char *bsqr = "";
static char *top = "\t---------------------------------\n";
{
static const char *wp[] = {"- ", "P ", "N ", "B ", "R ", "A ", "C ", "M ", "Q ", "E ", "B ", "Q ",
"W ", "H ", "N ", "D ", "H ", "L ", "C ", "S ", "G ", "H ", "A ", "F ",
- "E ", "H ", "M ", "S ", "E ", "W ", "O ", "G ", "V ", "S ", "E ", "A ", "K ", "H ", "E "};
+ "E ", "H ", "M ", "S ", "E ", "W ", "O ", "G ", "V ", "S ", "E ", "A ",
+ "K ", "H ", "E ", "W ", "G ", "L ", "C ", "H "};
static const char *bp[] = {"+ ", "p' ", "n' ", "b' ", "r' ", "a' ", "c' ", "m' ", "q' ", "e' ", "b' ", "q' ",
"w' ", "h' ", "n' ", "d' ", "h' ", "l' ", "c' ", "s' ", "g' ", "h' ", "a' ", "f' ",
- "e' ", "h' ", "m' ", "s' ", "e' ", "w' ", "o' ", "g' ", "v' ", "s' ", "e' ", "a' ", "k' ", "h' ", "e' "};
+ "e' ", "h' ", "m' ", "s' ", "e' ", "w' ", "o' ", "g' ", "v' ", "s' ", "e' ", "a' ",
+ "k' ", "h' ", "e' ", "w' ", "g' ", "l' ", "c' ", "h' "};
static char *wsqr = "";
static char *bsqr = "";
static char *top = "";
{
static const char *wp[] = {" ", " P ", " N ", " B ", " R ", " A ", " C ", " M ", " Q ", " E ", " B ", " Q ",
" W ", " H ", " N ", " D ", " H ", " L ", " C ", " S ", " G ", " H ", " A ", " F ",
- " E ", " H ", " M ", " S ", " E ", " W ", " O ", " G ", " V ", " S ", " E ", " A ", " K ", " H ", " E "};
+ " E ", " H ", " M ", " S ", " E ", " W ", " O ", " G ", " V ", " S ", " E ", " A ",
+ " K ", " H ", " E ", " W ", " G ", " L ", " C ", " H "};
static const char *bp[] = {" ", " *P", " *N", " *B", " *R", " *A", " *C", " *M", " *Q", " *E", " *B", " *Q",
" *W", " *H", " *N", " *D", " *H", " *L", " *C", " *S", " *G", " *H", " *A", " *F",
- " *E", " *H", " *M", " *S", " *E", " *W", " *O", " *G", " *V", " *S", " *E", " *A", " *K", " *H", " *E"};
+ " *E", " *H", " *M", " *S", " *E", " *W", " *O", " *G", " *V", " *S", " *E", " *A",
+ " *K", " *H", " *E", " *W", " *G", " *L", " *C", " *H"};
static char *wsqr = "\033[0m";
static char *bsqr = "\033[7m";
static char *top = "\t+------------------------+\n";
{
static const char *wp[] = {" ", " P ", " N ", " B ", " R ", " A ", " C ", " M ", " Q ", " E ", " B ", " Q ",
" W ", " H ", " N ", " D ", " H ", " L ", " C ", " S ", " G ", " H ", " A ", " F ",
- " E ", " H ", " M ", " S ", " E ", " W ", " O ", " G ", " V ", " S ", " E ", " A ", " K ", " H ", " E "};
+ " E ", " H ", " M ", " S ", " E ", " W ", " O ", " G ", " V ", " S ", " E ", " A ",
+ " K ", " H ", " E ", " W ", " G ", " L ", " C ", " H "};
static const char *bp[] = {" ", " *P", " *N", " *B", " *R", " *A", " *C", " *M", " *Q", " *E", " *B", " *Q",
" *W", " *H", " *N", " *D", " *H", " *L", " *C", " *S", " *G", " *H", " *A", " *F",
- " *E", " *H", " *M", " *S", " *E", " *W", " *O", " *G", " *V", " *S", " *E", " *A", " *K", " *H", " *E"};
+ " *E", " *H", " *M", " *S", " *E", " *W", " *O", " *G", " *V", " *S", " *E", " *A",
+ " *K", " *H", " *E", " *W", " *G", " *L", " *C", " *H"};
static char *wsqr = "\033[7m";
static char *bsqr = "\033[0m";
static char *top = "\t+------------------------+\n";
static const char *wp[] = {" ", " o ", " :N:", " <B>", " |R|", " (A)", " [C]", " :M:", " {Q}", " !E!",
" <B>", " {Q}", " .W.", " :H:", " :N:", " <H>", " |D|", " |L|",
" |C|", " !S!", " :G:", " :H:", " {A}", " {F}", " !E!", " (H)", " [M]", " :S:",
- " !E!", " |W|", " *O*", " {G}", " :V:", " (S)", " [E]", " &A&", " =K=", " (H)", " [E]"};
+ " !E!", " |W|", " *O*", " {G}", " :V:", " (S)", " [E]", " &A&",
+ " =K=", " (H)", " [E]", " (W)", " [G]", " <L>", " |C|", " h "};
static const char *bp[] = {" ", " p ", " :n:", " <b>", " |r|", " (a)", " [c]", " :m:", " {q}", " !e!",
" <b>", " {q}", " .w.", " :h:", " :n:", " <h>", " |d|", " |l|",
" |c|", " !s!", " :g:", " :h:", " {a}", " {f}", " !e!", " (h)", " [m]", " :s:",
- " !e!", " |w|", " *o*", " {g}", " :v:", " (s)", " [e]", " &a&", " =k=", " (f)", " [e]"};
+ " !e!", " |w|", " *o*", " {g}", " :v:", " (s)", " [e]", " &a&",
+ " =k=", " (f)", " [e]", " (w)", " [g]", " <l>", " |c|", " h "};
static char *wsqr = "";
static char *bsqr = "";
static char *top = " . . . . . . . . .\n";
static const char *wp[] = {" |", " wp |", " WN |", " WB |", " WR |", " WA |", " WC |", " WM |", " WQ |",
" WE |", " WB |", " WQ |", " WW |", " WH |", " WN |", " WD |", " WH |", " WL |",
" WC |", " WS |", " WG |", " WH |", " WA |", " WF |", " WE |", " WH |", " WM |",
- " WS |", " WE |", " WW |", " WO |", " WG |", " WV |", " WS |", " WE |", " WA |", " WK |", " WH |", " WE |"};
+ " WS |", " WE |", " WW |", " WO |", " WG |", " WV |", " WS |", " WE |", " WA |",
+ " WK |", " WH |", " WE |", " WW |", " WG |", " WL |", " WC |", " Wh |"};
static const char *bp[] = {" |", " bp |", " BN |", " BB |", " BR |", " BA |", " BC |", " BM |", " BQ |",
" BE |", " BB |", " BQ |", " BW |", " BH |", " BN |", " BD |", " BH |", " BL |",
" BC |", " BS |", " BG |", " BH |", " BA |", " BF |", " BE |", " BH |", " BM |",
- " BS |", " BE |", " BW |", " BO |", " BG |", " BV |", " BS |", " BE |", " BA |", " BK |", " BH |", " BE |"};
+ " BS |", " BE |", " BW |", " BO |", " BG |", " BV |", " BS |", " BE |", " BA |",
+ " BK |", " BH |", " BE |", " BW |", " BG |", " BL |", " BC |", " Bh |"};
static char *wsqr = "";
static char *bsqr = "";
static char *top = "\t-----------------------------------------\n";
static int style7(struct game_state_t *b, struct move_t *ml)
{
static const char *wp[] = {" ", " P", " N", " B", " R", " A", " C", " M", " Q", " E", " B", " Q", " W", " H", " N", " D", " H", " L",
- " C", " S", " G", " H", " A", " F", " E", " H", " M", " S", " E", " W", " O", " G", " V", " S", " E", " A", " K", " H", " E"};
+ " C", " S", " G", " H", " A", " F", " E", " H", " M", " S", " E", " W", " O", " G", " V", " S", " E", " A",
+ " K", " H", " E", " W", " G", " L", " C", " H"};
static const char *bp[] = {" -", " p", " n", " b", " r", " a", " c", " m", " q", " e", " b", " q", " w", " h", " n", " d", " h", " l",
- " c", " s", " g", " h", " a", " f", " e", " h", " m", " s", " e", " w", " o", " g", " v", " s", " e", " a", " k", " h", " e"};
+ " c", " s", " g", " h", " a", " f", " e", " h", " m", " s", " e", " w", " o", " g", " v", " s", " e", " a",
+ " k", " h", " e", " w", " g", " l", " c", " h"};
static char *wsqr = "";
static char *bsqr = "";
static char *top = "\t:::::::::::::::::::::\n";
onNewLine = 0;
} else {
switch (c) {
- case 'P':
- onPiece = PAWN;
- break;
- case 'R':
- onPiece = ROOK;
- break;
- case 'N':
- onPiece = KNIGHT;
+ case 'A':
+ onPiece = CARDINAL;
break;
case 'B':
onPiece = BISHOP;
break;
- case 'A':
- onPiece = CARDINAL;
- break;
case 'C':
onPiece = MARSHALL;
break;
- case 'M':
- onPiece = MAN;
- break;
- case 'Q':
- onPiece = QUEEN;
- break;
- case 'T':
- onPiece = ELEPHANT;
+ case 'D':
+ onPiece = SELEPHANT;
break;
case 'E':
onPiece = ALFIL;
break;
- case 't':
- onPiece = ALFIL2;
- break;
- case 'q':
- onPiece = FERZ;
- break;
case 'F':
onPiece = FERZ2;
break;
- case 'W':
- onPiece = WAZIR;
+ case 'G':
+ onPiece = GOLD;
break;
- case 'w':
- onPiece = WOODY;
+ case 'H':
+ onPiece = HORSE;
break;
- case 'p':
- onPiece = PRIESTESS;
+ case 'I':
+ onPiece = DRAGONHORSE;
break;
- case 'r':
- onPiece = MINISTER;
+ case 'J':
+ onPiece = DRAGONKING;
break;
- case 'z':
- onPiece = MAN2;
+ case 'K':
+ onPiece = KING;
break;
- case 'u':
- onPiece = NIGHTRIDER;
+ case 'L':
+ onPiece = LANCE;
break;
- case 'o':
- onPiece = MODERNELEPHANT;
+ case 'M':
+ onPiece = MAN;
break;
- case 's':
- onPiece = MASTODON;
+ case 'N':
+ onPiece = KNIGHT;
break;
- case 'Z':
- onPiece = AMAZON;
+ case 'O':
+ onPiece = CANNON;
+ break;
+ case 'P':
+ onPiece = PAWN;
+ break;
+ case 'Q':
+ onPiece = QUEEN;
+ break;
+ case 'R':
+ onPiece = ROOK;
+ break;
+ case 'S':
+ onPiece = SILVER;
+ break;
+ case 'T':
+ onPiece = ELEPHANT;
+ break;
+ case 'U':
+ onPiece = HAWK;
break;
case 'V':
onPiece = CENTAUR;
break;
- case 'H':
- onPiece = HORSE;
+ case 'W':
+ onPiece = WAZIR;
+ break;
+ case 'X':
+ onPiece = WARLORD;
+ break;
+ case 'Y':
+ onPiece = GENERAL;
+ break;
+ case 'Z':
+ onPiece = AMAZON;
+ break;
+ case 'm':
+ onPiece = MANDARIN;
break;
case 'n':
onPiece = HONORABLEHORSE;
break;
- case 'J':
- onPiece = DRAGONKING;
+ case 'o':
+ onPiece = MODERNELEPHANT;
break;
- case 'I':
- onPiece = DRAGONHORSE;
+ case 'p':
+ onPiece = PRIESTESS;
break;
- case 'L':
- onPiece = LANCE;
+ case 'q':
+ onPiece = FERZ;
break;
- case 'O':
- onPiece = CANNON;
+ case 'r':
+ onPiece = MINISTER;
break;
- case 'S':
- onPiece = SILVER;
+ case 's':
+ onPiece = MASTODON;
break;
- case 'G':
- onPiece = GOLD;
+ case 't':
+ onPiece = ALFIL2;
break;
- case 'm':
- onPiece = MANDARIN;
+ case 'u':
+ onPiece = NIGHTRIDER;
break;
- case 'K':
- onPiece = KING;
+ case 'v':
+ onPiece = HOPLITE;
break;
- case 'D':
- onPiece = SELEPHANT;
+ case 'w':
+ onPiece = WOODY;
break;
- case 'U':
- onPiece = HAWK;
+ case 'x':
+ onPiece = LIEUTENANT;
+ break;
+ case 'y':
+ onPiece = CAPTAIN;
+ break;
+ case 'z':
+ onPiece = MAN2;
break;
case 'a':
case 'b':
return 0;
}
+static int legal_hoplite_move( struct game_state_t *gs, int ff, int fr, int tf, int tr )
+{
+ if (ff == tf) { /* Capture ? */
+ if (gs->board[tf][tr] == NOPIECE) return 0;
+ if (gs->onMove == WHITE) {
+ if(iscolor(gs->board[tf][tr],WHITE)) return 0;
+ if (tr - fr == 1) return 1;
+ } else {
+ if(iscolor(gs->board[tf][tr],BLACK)) return 0;
+ if (fr - tr == 1) return 1;
+ }
+ return 0;
+ }
+ if (ff != tf) {
+ if (gs->board[tf][tr] != NOPIECE) return 0;
+ if (gs->onMove == WHITE) {
+ if (tr == fr+1 && abs(tf-ff) == 1) return 1;
+ if (tr != fr+2 || abs(tf-ff) != 2) return 0;
+ if (fr > gs->pawnDblStep) return 0;
+ return 1;
+ } else {
+ if (tr == fr-1 && abs(tf-ff) == 1) return 1;
+ if (tr != fr-2 || abs(tf-ff) != 2) return 0;
+ if (fr < gs->ranks - 1 - gs->pawnDblStep) return 0;
+ return 1;
+ }
+ }
+ return 0;
+}
+
static int legal_knight_move(struct game_state_t * gs, int ff, int fr, int tf, int tr)
{
int dx, dy;
return legal_ferz_move(gs, ff, fr, tf, tr) || legal_alfil_move(gs, ff, fr, tf, tr);
}
+static int legal_lieutenant_move(struct game_state_t * gs, int ff, int fr, int tf, int tr)
+{
+ return legal_modernelephant_move(gs, ff, fr, tf, tr) ||
+ fr == tr && abs(ff - tf) == 1 && gs->board[tf][tr] == NOPIECE;
+}
+
static int legal_priestess_move(struct game_state_t * gs, int ff, int fr, int tf, int tr)
{
return legal_knight_move(gs, ff, fr, tf, tr) || legal_ferz_move(gs, ff, fr, tf, tr)
}
}
+static void possible_hoplite_moves(struct game_state_t * gs,
+ int onf, int onr,
+ int *posf, int *posr, int *numpos)
+{
+ if (gs->onMove == WHITE) { // in Spartan Chess there are no white hoplites...
+ if (gs->board[onf][onr + 1] != NOPIECE &&
+ iscolor(gs->board[onf][onr + 1], BLACK)) {
+ add_pos(onf, onr + 1, posf, posr, numpos);
+ }
+ if (onf > 0) {
+ if (gs->board[onf - 1][onr + 1] == NOPIECE) {
+ add_pos(onf - 1, onr + 1, posf, posr, numpos);
+ if (onf > 1 && (onr <= gs->pawnDblStep) /*&& (gs->board[onf-2][onr + 2] == NOPIECE)*/)
+ add_pos(onf - 2, onr + 2, posf, posr, numpos);
+ }
+ }
+ if (onf < gs->files-1) {
+ if (gs->board[onf + 1][onr + 1] == NOPIECE) {
+ add_pos(onf + 1, onr + 1, posf, posr, numpos);
+ if (onf < gs->files-2 && (onr <= gs->pawnDblStep) /*&& (gs->board[onf+2][onr + 2] == NOPIECE)*/)
+ add_pos(onf + 2, onr + 2, posf, posr, numpos);
+ }
+ }
+ } else {
+ if (gs->board[onf][onr - 1] != NOPIECE &&
+ iscolor(gs->board[onf][onr - 1], WHITE)) {
+ add_pos(onf, onr - 1, posf, posr, numpos);
+ }
+ if (onf > 0) {
+ if (gs->board[onf - 1][onr - 1] == NOPIECE) {
+ add_pos(onf - 1, onr - 1, posf, posr, numpos);
+ if (onf > 1 && (onr >= gs->ranks - gs->pawnDblStep - 1) /*&& (gs->board[onf - 2][onr - 2] == NOPIECE)*/)
+ add_pos(onf - 2, onr - 2, posf, posr, numpos);
+ }
+ }
+ if (onf < gs->files-1) {
+ if (gs->board[onf + 1][onr - 1] == NOPIECE) {
+ add_pos(onf + 1, onr - 1, posf, posr, numpos);
+ if (onf < gs->files-2 && (onr >= gs->ranks - gs->pawnDblStep - 1) /*&& (gs->board[onf + 2][onr - 2] == NOPIECE)*/)
+ add_pos(onf + 2, onr - 2, posf, posr, numpos);
+ }
+ }
+ }
+}
+
static void possible_knight_moves(struct game_state_t * gs,
int onf, int onr,
int *posf, int *posr, int *numpos)
possible_alfil_moves(gs, onf, onr, posf, posr, numpos);
}
+static void possible_lieutenant_moves(struct game_state_t * gs,
+ int onf, int onr,
+ int *posf, int *posr, int *numpos)
+{
+ possible_modernelephant_moves(gs, onf, onr, posf, posr, numpos);
+ if (onf < gs->files-1 && (gs->board[onf+1][onr] == NOPIECE))
+ add_pos(onf + 1, onr, posf, posr, numpos);
+ if (onf > 0 && (gs->board[onf-1][onr] == NOPIECE))
+ add_pos(onf - 1, onr, posf, posr, numpos);
+}
+
static void possible_priestess_moves(struct game_state_t * gs,
int onf, int onr,
int *posf, int *posr, int *numpos)
case PAWN:
legal = legal_pawn_move(gs, fFile, fRank, tFile, tRank);
break;
+ case HOPLITE:
+ legal = legal_hoplite_move(gs, fFile, fRank, tFile, tRank);
+ break;
case KNIGHT:
legal = legal_knight_move(gs, fFile, fRank, tFile, tRank);
break;
case ROOK:
legal = legal_rook_move(gs, fFile, fRank, tFile, tRank);
break;
+ case WARLORD:
case HAWK:
case CARDINAL:
case PRINCESS:
case AMAZON:
legal = legal_amazon_move(gs, fFile, fRank, tFile, tRank);
break;
+ case CAPTAIN:
case WOODY:
legal = legal_woody_move(gs, fFile, fRank, tFile, tRank);
break;
case WAZIR:
legal = legal_wazir_move(gs, fFile, fRank, tFile, tRank);
break;
+ case LIEUTENANT:
+ legal = legal_lieutenant_move(gs, fFile, fRank, tFile, tRank);
+ break;
case ALFIL:
case ALFIL2:
legal = legal_alfil_move(gs, fFile, fRank, tFile, tRank);
case DRAGONHORSE:
legal = legal_dragonhorse_move(gs, fFile, fRank, tFile, tRank);
break;
+ case GENERAL:
case DRAGONKING:
legal = legal_dragonking_move(gs, fFile, fRank, tFile, tRank);
break;
if ((piecetype(gs->board[mt->fromFile][mt->fromRank]) == PAWN) &&
!gs->palace && // [HGM] XQ: no promotions in xiangqi
((mt->toRank < gs->promoZone) || (mt->toRank >= gs->ranks - gs->promoZone))) {
+ if(promote == KING) return MOVE_ILLEGAL; // no king in normal chess
if(!promote && (mt->toRank == 0 || mt->toRank == gs->ranks-1)) { // promotion obligatory, but not specified
if(gs->promoType != 2) promote = QUEEN; else { // choose a default
for(promote=PIECES-1; promote>PAWN; promote--) if(gs->holding[stm == BLACK][promote-1]) break;
// non-promotion can still be an option for deeper promotion zones
mt->piecePromotionTo = promote ? (promote | stm) : NOPIECE;
if(promote && gs->promoType == 2 && !gs->holding[stm == BLACK][promote-1]) return MOVE_ILLEGAL; // unavailable piece specified
+ } else
+ if ((piecetype(gs->board[mt->fromFile][mt->fromRank]) == HOPLITE) &&
+ ((mt->toRank < gs->promoZone) || (mt->toRank >= gs->ranks - gs->promoZone))) {
+ if(!promote || promote == KING) {
+ int f, r, k=0, king = gs->onMove == WHITE ? W_KING : B_KING;
+ for(r=0; r<gs->ranks;r++) for(f=0; f<gs->files; f++) k += (gs->board[f][r] == king);
+ if(k > 1) { // we already have two kings
+ if(promote == KING) return MOVE_ILLEGAL; // three kings not allowed
+ promote = WARLORD; // use strongest piece as default
+ } else promote = KING; // if no promo-piece given, this could be mate test, so test if promoting to King evades
+ } else
+ if(promote == MASTODON) promote = GENERAL; else
+ if(promote == WOODY) promote = WARLORD; else
+ if(promote == MARSHALL) promote = CAPTAIN; else
+ if(promote != LIEUTENANT) return MOVE_ILLEGAL;
+ mt->piecePromotionTo = (promote | stm);
} else if(gs->drops == 2 && promote && mt->fromRank == (stm == WHITE ? 0 : gs->ranks-1)) { // [HGM] Seirawan-style gating
int i; struct game *g = &game_globals.garray[gs->gameNum];
if(!gs->holding[stm == BLACK][promote-1]) return MOVE_ILLEGAL; // unavailable piece specified
}
}
if (kf < 0) {
- d_printf( "CHESSD: Error game with no king!\n");
- return 0;
+// d_printf( "CHESSD: Error game with no king!\n");
+ return -1;
}
for (InitPieceLoop(gs->board, &f, &r, gs->onMove);
NextPieceLoop(gs->board, &f, &r, gs->onMove, gs->files, gs->ranks);) {
if (legal_move(gs, f, r, kf, kr)) { /* In Check? */
+ if(gs->onMove == WHITE && !strcmp(gs->variant, "spartan")) { // first king is in check, but we might have spare
+//printf("spartan K-capt %c%d%c%d\n",f+'a',r+1,kf+'a',kr+1);
+ gs->board[kf][kr] = B_MAN; // temporarily cure the check on the first King by replacing the latter;
+ r = in_check(gs);
+ gs->board[kf][kr] = B_KING; // and put it back
+//printf("duple = %d\n",r);
+ return r != 0; // if we have no second king (r = -1) or the second is also attacked (r = 1) we are in check.
+ }
return 1;
}
}
case PAWN:
possible_pawn_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
+ case HOPLITE:
+ possible_hoplite_moves(gs, f, r, possiblef, possibler, &numpossible);
+ break;
case KNIGHT:
possible_knight_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
case ROOK:
possible_rook_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
+ case WARLORD:
case HAWK:
case CARDINAL:
case PRINCESS:
case AMAZON:
possible_amazon_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
+ case CAPTAIN:
case WOODY:
possible_woody_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
case MODERNELEPHANT:
possible_modernelephant_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
+ case LIEUTENANT:
+ possible_lieutenant_moves(gs, f, r, possiblef, possibler, &numpossible);
+ break;
case PRIESTESS:
possible_priestess_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
case DRAGONHORSE:
possible_dragonhorse_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
+ case GENERAL:
case DRAGONKING:
possible_dragonking_moves(gs, f, r, possiblef, possibler, &numpossible);
break;
}
gs->board[m->fromFile][m->fromRank] = gs->board[m->toFile][m->toRank];
if (m->piecePromotionTo != NOPIECE) {
- gs->board[m->fromFile][m->fromRank] = PAWN |
+ int piece;
+ switch(piecetype(m->piecePromotionTo)) { // Spartan pieces came from Hoplite, Shogi is problematic
+ case KING:
+ case CAPTAIN:
+ case LIEUTENANT:
+ case WARLORD:
+ case GENERAL: piece = HOPLITE; break;
+ case DRAGONHORSE: piece = BISHOP; break;
+ case DRAGONKING: piece = ROOK; break;
+ case GOLD: // TODO: figure out what original was
+ default: piece = PAWN;
+ }
+ gs->board[m->fromFile][m->fromRank] = piece |
colorval(gs->board[m->fromFile][m->fromRank]);
}
/******************
projects / capablanca.git / commitdiff