terminal-chess: comparison src/chess/rules.c

-:efeb98bc69c9
+:0c1371488d87
 case KING: return king_getlocation(gamestate, move);
 default: return INVALID_MOVE_SYNTAX;
 }
 }
-_Bool is_covered(GameState *gamestate,uint8_t row,uint8_t file,uint8_t color) {
+_Bool get_any_threat_for(GameState *gamestate, uint8_t row, uint8_t file,
+uint8_t color, Move *threat) {
 Move threats[16];
 int threatcount = 0;
 for (uint8_t r = 0 ; r < 8 ; r++) {
 for (uint8_t f = 0 ; f < 8 ; f++) {
 if ((gamestate->board[r][f] & COLOR_MASK) == color) {
+memset(&(threats[threatcount]), 0, sizeof(Move));
 threats[threatcount].piece = gamestate->board[r][f];
 threats[threatcount].fromrow = r;
 threats[threatcount].fromfile = f;
 threats[threatcount].torow = row;
 threats[threatcount].tofile = file;
 }
 }
 for (int i = 0 ; i < threatcount ; i++) {
 if (validate_move(gamestate, &(threats[i]))) {
+if (threat) {
+*threat = threats[i];
+}
 return 1;
 }
 }
 return 0;
 } else if (move->tofile == fileidx('c')) {
 gamestate->board[move->torow][fileidx('a')] = 0;
 gamestate->board[move->torow][fileidx('d')] = color|ROOK;
 }
 }
 addmove(gamestate, move);
 }
 _Bool validate_move(GameState *gamestate, Move *move) {
 _Bool result;
 /* does piece exist */
 result = msrc(gamestate->board, move) == move->piece;
 /* can't capture own pieces */
-if ((mdst(gamestate->board, move) & COLOR_MASK)
+uint8_t piececolor = (move->piece & COLOR_MASK);
-== (move->piece & COLOR_MASK)) {
+if ((mdst(gamestate->board, move) & COLOR_MASK) == piececolor) {
 return 0;
 }
 /* validate individual rules */
 switch (move->piece & PIECE_MASK) {
 /* cancel processing to avoid recursion overflow with is_covered() */
 if (!result) {
 return 0;
 }
-/* is piece pinned */
+/* find kings for check validation */
-// TODO: make it so
+uint8_t mykingfile = 0, mykingrow = 0, opkingfile = 0, opkingrow = 0;
+for (uint8_t row = 0 ; row < 8 ; row++) {
+for (uint8_t file = 0 ; file < 8 ; file++) {
+if (gamestate->board[row][file] ==
+(piececolor == WHITE?WKING:BKING)) {
+mykingfile = file;
+mykingrow = row;
+} else if (gamestate->board[row][file] ==
+(piececolor == WHITE?BKING:WKING)) {
+opkingfile = file;
+opkingrow = row;
+}
+}
+}
+/* simulation move for check validation */
+GameState simulation;
+memcpy(&simulation, gamestate, sizeof(GameState));
+apply_move(&simulation, move);
+/* don't move into or stay in check position */
+if (is_covered(&simulation, mykingrow, mykingfile,
+opponent_color(piececolor))) {
+return 0;
+}
 /* correct check and checkmate flags (move is still valid) */
-// TODO: make it so
+Move threat;
+move->check = get_any_threat_for(&simulation, opkingrow, opkingfile,
-return result;
+piececolor, &threat);
+if (move->check) {
+/* determine possible escape fields */
+_Bool canescape = 0;
+for (int dr = -1 ; dr <= 1 && !canescape ; dr++) {
+for (int df = -1 ; df <= 1 && !canescape ; df++) {
+if (!(dr == 0 && df == 0)  &&
+isidx(opkingrow + dr) && isidx(opkingfile + df)) {
+/* escape field neither blocked nor covered */
+if ((simulation.board[opkingrow + dr][opkingfile + df]
+& COLOR_MASK) != opponent_color(piececolor)) {
+canescape |= !is_covered(&simulation,
+opkingrow + dr, opkingfile + df, piececolor);
+}
+}
+}
+}
+/* can't escape, can we capture? */
+if (!canescape) {
+canescape = is_covered(&simulation, threat.fromrow,
+threat.fromfile, opponent_color(piececolor));
+/* can't capture, can we block? */
+// TODO: make it so
+if (!canescape) {
+gamestate->checkmate = 1;
+}
+}
+}
+return 1;
 }
 int eval_move(GameState *gamestate, char *mstr, Move *move) {
 memset(move, 0, sizeof(Move));
 move->fromfile = POS_UNSPECIFIED;

Mercurial > hg > terminal-chess / file comparison

comparison: src/chess/rules.c

src/chess/rules.c