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

-:4dcfb4c58b6d
+:d726e4b46c33
 case 'K': return KING;
 default: return 0;
 }
 }
-static int getlocation(GameState *gamestate, Move *move) {
-uint8_t piece = move->piece & PIECE_MASK;
-switch (piece) {
-case PAWN: return pawn_getlocation(gamestate, move);
-case ROOK: return rook_getlocation(gamestate, move);
-case KNIGHT: return knight_getlocation(gamestate, move);
-case BISHOP: return bishop_getlocation(gamestate, move);
-case QUEEN: return queen_getlocation(gamestate, move);
-case KING: return king_getlocation(gamestate, move);
-default: return INVALID_MOVE_SYNTAX;
-}
-}
 void apply_move(GameState *gamestate, Move *move) {
 uint8_t piece = move->piece & PIECE_MASK;
 uint8_t color = move->piece & COLOR_MASK;
 /* en passant capture */
 if (move->fromfile == move->tofile && move->fromrow == move->torow) {
 return 0;
 }
 /* does piece exist */
-if (msrc(gamestate->board, move) != move->piece) {
+if ((msrc(gamestate->board, move)&(PIECE_MASK|COLOR_MASK))
+!= (move->piece&(PIECE_MASK|COLOR_MASK))) {
 return 0;
 }
 /* can't capture own pieces */
 if ((mdst(gamestate->board, move) & COLOR_MASK)
 == (move->piece & COLOR_MASK)) {
+return 0;
+}
+/* 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;
 }
 /* validate individual rules */
 switch (move->piece & PIECE_MASK) {
 return 0;
 }
 }
 _Bool validate_move(GameState *gamestate, Move *move) {
+// TODO: provide more details via a return code
 _Bool result = validate_move_rules(gamestate, move);
 /* cancel processing to save resources */
 if (!result) {
 }
 }
 }
 /* simulation move for check validation */
-GameState simulation;
+GameState simulation = *gamestate;
-memcpy(&simulation, gamestate, sizeof(GameState));
+Move simmove = *move;
-apply_move(&simulation, 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;
 }
 return 1;
 }
+_Bool get_threats(GameState *gamestate, uint8_t row, uint8_t file,
+uint8_t color, Move *threats, uint8_t *threatcount) {
+Move candidates[32];
+int candidatecount = 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) {
+// non-capturing move
+memset(&(candidates[candidatecount]), 0, sizeof(Move));
+candidates[candidatecount].piece = gamestate->board[r][f];
+candidates[candidatecount].fromrow = r;
+candidates[candidatecount].fromfile = f;
+candidates[candidatecount].torow = row;
+candidates[candidatecount].tofile = file;
+candidatecount++;
+// capturing move
+memcpy(&(candidates[candidatecount]),
+&(candidates[candidatecount-1]), sizeof(Move));
+candidates[candidatecount].capture = 1;
+candidatecount++;
+}
+}
+}
+if (threatcount) {
+*threatcount = 0;
+}
+_Bool result = 0;
+for (int i = 0 ; i < candidatecount ; i++) {
+if (validate_move_rules(gamestate, &(candidates[i]))) {
+result = 1;
+if (threats && threatcount) {
+threats[(*threatcount)++] = candidates[i];
+}
+}
+}
+return result;
+}
+_Bool is_pinned(GameState *gamestate, Move *move) {
+uint8_t color = move->piece & COLOR_MASK;
+uint8_t kingfile = 0, kingrow = 0;
+for (uint8_t row = 0 ; row < 8 ; row++) {
+for (uint8_t file = 0 ; file < 8 ; file++) {
+if (gamestate->board[row][file] == (color|KING)) {
+kingfile = file;
+kingrow = row;
+}
+}
+}
+GameState simulation = *gamestate;
+Move simmove = *move;
+apply_move(&simulation, &simmove);
+return is_covered(&simulation, kingrow, kingfile, opponent_color(color));
+}
+_Bool get_real_threats(GameState *gamestate, uint8_t row, uint8_t file,
+uint8_t color, Move *threats, uint8_t *threatcount) {
+if (threatcount) {
+*threatcount = 0;
+}
+Move candidates[16];
+uint8_t candidatecount;
+if (get_threats(gamestate, row, file, color, candidates, &candidatecount)) {
+_Bool result = 0;
+uint8_t kingfile = 0, kingrow = 0;
+for (uint8_t row = 0 ; row < 8 ; row++) {
+for (uint8_t file = 0 ; file < 8 ; file++) {
+if (gamestate->board[row][file] == (color|KING)) {
+kingfile = file;
+kingrow = row;
+}
+}
+}
+for (uint8_t i = 0 ; i < candidatecount ; i++) {
+GameState simulation = *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];
+}
+}
+}
+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;
+Move threats[16], *threat = NULL;
+uint8_t threatcount;
+if (get_threats(gamestate, move->torow, move->tofile, color,
+threats, &threatcount)) {
+// find threats for the specified position
+for (uint8_t i = 0 ; i < threatcount ; i++) {
+if ((threats[i].piece & (PIECE_MASK | COLOR_MASK))
+== move->piece &&
+(move->fromrow == POS_UNSPECIFIED ||
+move->fromrow == threats[i].fromrow) &&
+(move->fromfile == POS_UNSPECIFIED ||
+move->fromfile == threats[i].fromfile)) {
+if (threat) {
+return AMBIGUOUS_MOVE;
+} else {
+threat = &(threats[i]);
+}
+}
+}
+// can't threaten specified position
+if (!threat) {
+return INVALID_POSITION;
+}
+// found threat is no real threat
+if (is_pinned(gamestate, threat)) {
+return incheck?KING_IN_CHECK:PIECE_PINNED;
+} else {
+memcpy(move, threat, sizeof(Move));
+return VALID_MOVE_SYNTAX;
+}
+} else {
+return INVALID_POSITION;
+}
+}
 int eval_move(GameState *gamestate, char *mstr, Move *move) {
 memset(move, 0, sizeof(Move));
 move->fromfile = POS_UNSPECIFIED;
 move->fromrow = POS_UNSPECIFIED;
 } else {
 return INVALID_MOVE_SYNTAX;
 }
 }
-_Bool get_threats(GameState *gamestate, uint8_t row, uint8_t file,
-uint8_t color, Move *threats, uint8_t *threatcount) {
-Move candidates[16];
-int candidatecount = 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(&(candidates[candidatecount]), 0, sizeof(Move));
-candidates[candidatecount].piece = gamestate->board[r][f];
-candidates[candidatecount].fromrow = r;
-candidates[candidatecount].fromfile = f;
-candidates[candidatecount].torow = row;
-candidates[candidatecount].tofile = file;
-candidatecount++;
-}
-}
-}
-if (threatcount) {
-*threatcount = 0;
-}
-_Bool result = 0;
-for (int i = 0 ; i < candidatecount ; i++) {
-if (validate_move_rules(gamestate, &(candidates[i]))) {
-result = 1;
-if (threats && threatcount) {
-threats[(*threatcount)++] = candidates[i];
-}
-}
-}
-return result;
-}
-_Bool get_real_threats(GameState *gamestate, uint8_t row, uint8_t file,
-uint8_t color, Move *threats, uint8_t *threatcount) {
-Move candidates[16];
-uint8_t candidatecount;
-if (get_threats(gamestate, row, file, color, candidates, &candidatecount)) {
-if (threatcount) {
-*threatcount = 0;
-}
-_Bool result = 0;
-uint8_t kingfile = 0, kingrow = 0;
-for (uint8_t row = 0 ; row < 8 ; row++) {
-for (uint8_t file = 0 ; file < 8 ; file++) {
-if ((gamestate->board[row][file] & COLOR_MASK) == color) {
-kingfile = file;
-kingrow = row;
-}
-}
-}
-for (uint8_t i = 0 ; i < candidatecount ; i++) {
-GameState simulation;
-memcpy(&simulation, gamestate, sizeof(GameState));
-apply_move(&simulation, &(candidates[i]));
-if (!is_covered(&simulation, kingrow, kingfile,
-opponent_color(color))) {
-result = 1;
-if (threats && threatcount) {
-threats[(*threatcount)++] = candidates[i];
-}
-}
-}
-return result;
-} else {
-return 0;
-}
-}
 _Bool is_protected(GameState *gamestate, uint8_t row, uint8_t file,
 uint8_t color) {
 Move threats[16];
 uint8_t threatcount;

Mercurial > hg > terminal-chess / file comparison

comparison: src/chess/rules.c

src/chess/rules.c