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

-:d726e4b46c33
+:0cedda2544da
 #include "chess.h"
 #include <string.h>
 #include <stdlib.h>
 #include <sys/time.h>
+static GameState gamestate_copy_sim(GameState *gamestate) {
+GameState simulation = *gamestate;
+if (simulation.lastmove) {
+MoveList *lastmovecopy = malloc(sizeof(MoveList));
+*lastmovecopy = *(simulation.lastmove);
+simulation.movelist = simulation.lastmove = lastmovecopy;
+}
+return simulation;
+}
 void gamestate_cleanup(GameState *gamestate) {
 MoveList *elem;
 elem = gamestate->movelist;
 while (elem) {
 MoveList *cur = elem;
 }
 addmove(gamestate, move);
 }
-static _Bool validate_move_rules(GameState *gamestate, Move *move) {
+static int validate_move_rules(GameState *gamestate, Move *move) {
 /* validate indices (don't trust opponent) */
 if (!chkidx(move)) {
-return 0;
+return INVALID_POSITION;
 }
 /* must move */
 if (move->fromfile == move->tofile && move->fromrow == move->torow) {
-return 0;
+return INVALID_MOVE_SYNTAX;
 }
 /* does piece exist */
 if ((msrc(gamestate->board, move)&(PIECE_MASK|COLOR_MASK))
 != (move->piece&(PIECE_MASK|COLOR_MASK))) {
-return 0;
+return INVALID_POSITION;
 }
 /* can't capture own pieces */
 if ((mdst(gamestate->board, move) & COLOR_MASK)
 == (move->piece & COLOR_MASK)) {
-return 0;
+return RULES_VIOLATED;
 }
 /* must capture, if and only if destination is occupied */
 if ((mdst(gamestate->board, move) == 0 && move->capture) ||
 (mdst(gamestate->board, move) != 0 && !move->capture)) {
-return 0;
+return INVALID_MOVE_SYNTAX;
 }
 /* validate individual rules */
+_Bool chkrules;
 switch (move->piece & PIECE_MASK) {
 case PAWN:
-return pawn_chkrules(gamestate, move) &&
+chkrules = pawn_chkrules(gamestate, move) &&
 !pawn_isblocked(gamestate, move);
+break;
 case ROOK:
-return rook_chkrules(move) &&
+chkrules = rook_chkrules(move) &&
 !rook_isblocked(gamestate, move);
+break;
 case KNIGHT:
-return knight_chkrules(move); /* knight is never blocked */
+chkrules = knight_chkrules(move); /* knight is never blocked */
+break;
 case BISHOP:
-return bishop_chkrules(move) &&
+chkrules = bishop_chkrules(move) &&
 !bishop_isblocked(gamestate, move);
+break;
 case QUEEN:
-return queen_chkrules(move) &&
+chkrules = queen_chkrules(move) &&
 !queen_isblocked(gamestate, move);
+break;
 case KING:
-return king_chkrules(gamestate, move) &&
+chkrules = king_chkrules(gamestate, move) &&
 !king_isblocked(gamestate, move);
+break;
 default:
-return 0;
+return INVALID_MOVE_SYNTAX;
 }
-}
+return chkrules ? VALID_MOVE_SEMANTICS : RULES_VIOLATED;
-_Bool validate_move(GameState *gamestate, Move *move) {
+}
-// TODO: provide more details via a return code
+int validate_move(GameState *gamestate, Move *move) {
-_Bool result = validate_move_rules(gamestate, move);
+int result = validate_move_rules(gamestate, move);
 /* cancel processing to save resources */
-if (!result) {
+if (result != VALID_MOVE_SEMANTICS) {
-return 0;
+return result;
 }
 /* find kings for check validation */
 uint8_t piececolor = (move->piece & COLOR_MASK);
 opkingrow = row;
 }
 }
 }
-/* simulation move for check validation */
+/* simulate move for check validation */
-GameState simulation = *gamestate;
+GameState simulation = gamestate_copy_sim(gamestate);
 Move simmove = *move;
 apply_move(&simulation, &simmove);
 /* don't move into or stay in check position */
 if (is_covered(&simulation, mykingrow, mykingfile,
 opponent_color(piececolor))) {
-return 0;
+gamestate_cleanup(&simulation);
+if ((move->piece & PIECE_MASK) == KING) {
+return KING_MOVES_INTO_CHECK;
+} else {
+/* last move is always not null in this case */
+return gamestate->lastmove->move.check ?
+KING_IN_CHECK : PIECE_PINNED;
+}
 }
 /* correct check and checkmate flags (move is still valid) */
 Move threats[16];
 uint8_t threatcount;
 if (!canescape) {
 gamestate->checkmate = 1;
 }
 }
-return 1;
+gamestate_cleanup(&simulation);
+return VALID_MOVE_SEMANTICS;
 }
 _Bool get_threats(GameState *gamestate, uint8_t row, uint8_t file,
 uint8_t color, Move *threats, uint8_t *threatcount) {
 Move candidates[32];
 _Bool result = 0;
 for (int i = 0 ; i < candidatecount ; i++) {
-if (validate_move_rules(gamestate, &(candidates[i]))) {
+if (validate_move_rules(gamestate, &(candidates[i]))
+== VALID_MOVE_SEMANTICS) {
 result = 1;
 if (threats && threatcount) {
 threats[(*threatcount)++] = candidates[i];
 }
 }
 kingrow = row;
 }
 }
 }
-GameState simulation = *gamestate;
+GameState simulation = gamestate_copy_sim(gamestate);
 Move simmove = *move;
 apply_move(&simulation, &simmove);
-return is_covered(&simulation, kingrow, kingfile, opponent_color(color));
+_Bool covered = is_covered(&simulation,
+kingrow, kingfile, opponent_color(color));
+gamestate_cleanup(&simulation);
+return covered;
 }
 _Bool get_real_threats(GameState *gamestate, uint8_t row, uint8_t file,
 uint8_t color, Move *threats, uint8_t *threatcount) {
 }
 }
 }
 for (uint8_t i = 0 ; i < candidatecount ; i++) {
-GameState simulation = *gamestate;
+GameState simulation = gamestate_copy_sim(gamestate);
 Move simmove = candidates[i];
 apply_move(&simulation, &simmove);
 if (!is_covered(&simulation, kingrow, kingfile,
 opponent_color(color))) {
 result = 1;
 if (threats && threatcount) {
 threats[(*threatcount)++] = candidates[i];
 }
 }
+gamestate_cleanup(&simulation);
 }
 return result;
 } else {
 return 0;
 }
 }
-#include <ncurses.h>
 static int getlocation(GameState *gamestate, Move *move) {
 uint8_t color = move->piece & COLOR_MASK;
 _Bool incheck = gamestate->lastmove?gamestate->lastmove->move.check:0;
 memset(move, 0, sizeof(Move));
 move->fromfile = POS_UNSPECIFIED;
 move->fromrow = POS_UNSPECIFIED;
 size_t len = strlen(mstr);
+if (len < 1 || len > 6) {
+return INVALID_MOVE_SYNTAX;
+}
 /* evaluate check/checkmate flags */
 if (mstr[len-1] == '+') {
 len--; mstr[len] = '\0';
 move->check = 1;
 /* move (e.g. "Nf3") */
 move->piece = getpiece(mstr[0]);
 move->tofile = fileidx(mstr[1]);
 move->torow = rowidx(mstr[2]);
 }
 } else if (len == 4) {
 move->piece = getpiece(mstr[0]);
 if (!move->piece) {
 move->piece = PAWN;
 move->fromfile = fileidx(mstr[0]);

Mercurial > hg > terminal-chess / file comparison

comparison: src/chess/rules.c

src/chess/rules.c