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

-:d1420f5c5704
+:619f07c95894
 move->movetime = cur - last;
 }
 }
 size_t piece_moves_allowed(const GameState *gamestate,
-Row r, File f, Move *moves) {
+Rank r, File f, Move *moves) {
 Piece p = piece_at(gamestate, r, f);
 Color c = piece_color(p);
 switch (piece_type(p)) {
 case KING:
 return king_moves_allowed(gamestate, c, r, f, moves);
 static bool check_stalemate(const GameState *gamestate) {
 Color next_player = gamestate->movecount % 2 == 0 ? WHITE : BLACK;
 /* scan the board for pieces of the next player's color */
 Move moves[QUEEN_MOVES_MAX];
-for (Row r = 0; r < 8; r++) {
+for (Rank r = 0; r < 8; r++) {
 for (File f = 0; f < 8; f++) {
 if (piece_color(piece_at(gamestate, r, f)) == next_player
 && piece_moves_allowed(gamestate, r, f, moves) > 0) {
 return false;
 }
 /* count the available pieces */
 unsigned piece_count[7] = {0};
 unsigned op_piece_count[7] = {0};
 bool has_bbishop = false, has_wbishop = false;
 bool op_has_bbishop = false, op_has_wbishop = false;
-for (Row r = 0 ; r < 8 ; r++) {
+for (Rank r = 0 ; r < 8 ; r++) {
 for (File f = 0 ; f < 8 ; f++) {
 Piece p = piece_at(gamestate, r, f);
 if (piece_color(p) == color) {
 piece_count[piece_type(p)]++;
 if (piece_type(p) == BISHOP) {
 /* applies the move without recalculating gamestate flags */
 static void apply_move_internal(GameState *gamestate, Move *move) {
 /* en passant capture */
 if (move->capture && piece_type(move->piece) == PAWN &&
-piece_at(gamestate, mdst(move)) == 0) {
+piece_at(gamestate, move->torank, move->tofile) == 0) {
-piece_remove(gamestate, move->fromrow, move->tofile);
+piece_remove(gamestate, move->fromrank, move->tofile);
 }
 /* remove old en passant threats */
 for (File file = 0 ; file < 8 ; file++) {
 enpassant_threat_remove(gamestate, 3, file);
 enpassant_threat_remove(gamestate, 4, file);
 }
 /* move (and maybe capture or promote) */
-piece_remove(gamestate, msrc(move));
+piece_remove(gamestate, move->fromrank, move->fromfile);
 if (move->promotion) {
-piece_set(gamestate, mdst(move), move->promotion);
+piece_set(gamestate, move->torank, move->tofile, move->promotion);
 } else {
-piece_set(gamestate, mdst(move), move->piece);
+piece_set(gamestate, move->torank, move->tofile, move->piece);
 }
 /* add new en passant threat */
 if (piece_type(move->piece) == PAWN && (
-(move->fromrow == 1 && move->torow == 3) ||
+(move->fromrank == 1 && move->torank == 3) ||
-(move->fromrow == 6 && move->torow == 4))) {
+(move->fromrank == 6 && move->torank == 4))) {
-enpassant_threat_add(gamestate, move->torow, move->tofile);
+enpassant_threat_add(gamestate, move->torank, move->tofile);
 }
 /* castling */
 if (piece_type(move->piece) == KING && move->fromfile == fileidx('e')) {
 const Color color = piece_color(move->piece);
 if (move->tofile == fileidx('g')) {
-gamestate->board[move->torow][fileidx('h')] = 0;
+gamestate->board[move->torank][fileidx('h')] = 0;
-gamestate->board[move->torow][fileidx('f')] = mkpiece(ROOK, color);
+gamestate->board[move->torank][fileidx('f')] = mkpiece(ROOK, color);
 } else if (move->tofile == fileidx('c')) {
-gamestate->board[move->torow][fileidx('a')] = 0;
+gamestate->board[move->torank][fileidx('a')] = 0;
-gamestate->board[move->torow][fileidx('d')] = mkpiece(ROOK, color);
+gamestate->board[move->torank][fileidx('d')] = mkpiece(ROOK, color);
 }
 }
 /* add move to the moves array and the new position to the FEN array */
 if (gamestate->movecount == gamestate->movecapacity) {
 /* find the opposing king */
 Color piececolor = piece_color(move->piece);
 Color oppcolor = opponent_color(piececolor);
 File opkingfile = 0;
-Row opkingrow = 0;
+Rank opkingrank = 0;
-for (Row row = 0 ; row < 8 ; row++) {
+for (Rank rank = 0 ; rank < 8 ; rank++) {
 for (File file = 0 ; file < 8 ; file++) {
-Piece p = piece_at(&simulation, row, file);
+Piece p = piece_at(&simulation, rank, file);
 if (p == mkpiece(KING, oppcolor)) {
 opkingfile = file;
-opkingrow = row;
+opkingrank = rank;
 }
 }
 }
 /* determine if the opposing king is now threatened */
 Move threats[16];
 size_t threatcount;
-bool incheck = get_threats(&simulation, opkingrow, opkingfile,
+bool incheck = get_threats(&simulation, opkingrank, opkingfile,
 piececolor, threats, &threatcount);
 if (!incheck) {
 gamestate_cleanup(&simulation);
 return 0;
 /* determine possible escape fields */
 bool canescape = false;
 for (int dr = -1 ; dr <= 1 && !canescape ; dr++) {
 for (int df = -1 ; df <= 1 && !canescape ; df++) {
 if (dr == 0 && df == 0) continue;
-Row er = opkingrow + dr;
+Rank er = opkingrank + dr;
 File ef = opkingfile + df;
 if (!isidx(er) || !isidx(ef)) continue;
 /* check if piece of the king's color blocks the field */
 if (piece_color(simulation.board[er][ef]) == oppcolor)
 if (piece_color(simulation.board[er][ef]) == piececolor) {
 /* test if the king can fight back */
 GameState sim_retaliate = gamestate_copy_sim(&simulation);
 Move move_retaliate = {0};
 move_retaliate.piece = mkpiece(KING, oppcolor);
-move_retaliate.fromrow = opkingrow;
+move_retaliate.fromrank = opkingrank;
 move_retaliate.fromfile = opkingfile;
-move_retaliate.torow = er;
+move_retaliate.torank = er;
 move_retaliate.tofile = ef;
 move_retaliate.capture = true;
 apply_move_internal(&sim_retaliate, &move_retaliate);
 canescape = !is_covered(&sim_retaliate, er, ef, piececolor);
 gamestate_cleanup(&sim_retaliate);
 }
 /* can't escape, can the king be rescued? */
 if (!canescape && threatcount == 1) {
 canescape = is_protected(&simulation,
-threats[0].fromrow, threats[0].fromfile, oppcolor);
+threats[0].fromrank, threats[0].fromfile, oppcolor);
 }
 /* can't capture, can he block? */
 if (!canescape && threatcount == 1) {
 Move *threat = &(threats[0]);
 unsigned tptype = piece_type(threat->piece);
 /* knight, pawns and the king cannot be blocked */
 if (tptype == BISHOP || tptype == ROOK || tptype == QUEEN) {
-if (threat->fromrow == threat->torow) {
+if (threat->fromrank == threat->torank) {
-/* rook aspect (on row) */
+/* rook aspect (on rank) */
 int d = threat->tofile > threat->fromfile ? 1 : -1;
 File file = threat->fromfile;
 while (!canescape && file != threat->tofile - d) {
 file += d;
 canescape |= is_protected(&simulation,
-threat->torow, file, oppcolor);
+threat->torank, file, oppcolor);
 }
 } else if (threat->fromfile == threat->tofile) {
 /* rook aspect (on file) */
-int d = threat->torow > threat->fromrow ? 1 : -1;
+int d = threat->torank > threat->fromrank ? 1 : -1;
-Row row = threat->fromrow;
+Rank rank = threat->fromrank;
-while (!canescape && row != threat->torow - d) {
+while (!canescape && rank != threat->torank - d) {
-row += d;
+rank += d;
 canescape |= is_protected(&simulation,
-row, threat->tofile, oppcolor);
+rank, threat->tofile, oppcolor);
 }
 } else {
 /* bishop aspect */
-int dr = threat->torow > threat->fromrow ? 1 : -1;
+int dr = threat->torank > threat->fromrank ? 1 : -1;
 int df = threat->tofile > threat->fromfile ? 1 : -1;
-Row row = threat->fromrow;
+Rank rank = threat->fromrank;
 File file = threat->fromfile;
 while (!canescape && file != threat->tofile - df
-&& row != threat->torow - dr) {
+&& rank != threat->torank - dr) {
-row += dr;
+rank += dr;
 file += df;
-canescape |= is_protected(&simulation, row, file,
+canescape |= is_protected(&simulation, rank, file,
 oppcolor);
 }
 }
 }
 }
 }
 } else if (piece_type(move->piece) != KING) {
 /* resolve ambiguities, if any */
 Move candidates[16];
 size_t ccount;
-if (get_real_candidates(gamestate, move->torow, move->tofile,
+if (get_real_candidates(gamestate, move->torank, move->tofile,
 piece_color(move->piece), candidates, &ccount)) {
-unsigned int ambrows = 0, ambfiles = 0, ambpiece = 0;
+unsigned int ambranks = 0, ambfiles = 0, ambpiece = 0;
 for (size_t i = 0 ; i < ccount ; i++) {
 if (candidates[i].piece == move->piece) {
 ambpiece++;
-if (candidates[i].fromrow == move->fromrow) {
+if (candidates[i].fromrank == move->fromrank) {
-ambrows++;
+ambranks++;
 }
 if (candidates[i].fromfile == move->fromfile) {
 ambfiles++;
 }
 }
 }
-/* neither file, nor row are ambiguous, name file */
+/* neither file, nor rank are ambiguous, name file */
-if (ambpiece > 1 && ambrows == 1 && ambfiles == 1) {
+if (ambpiece > 1 && ambranks == 1 && ambfiles == 1) {
 /* this is most likely the case with Knights
 * in diagonal opposition */
 string[idx++] = filechr(move->fromfile);
 } else {
-/* ambiguous row, name file */
+/* ambiguous rank, name file */
-if (ambrows > 1) {
+if (ambranks > 1) {
 string[idx++] = filechr(move->fromfile);
 }
-/* ambiguous file, name row */
+/* ambiguous file, name rank */
 if (ambfiles > 1) {
-string[idx++] = rowchr(move->fromrow);
+string[idx++] = rankchr(move->fromrank);
 }
 }
 }
 }
 string[idx++] = 'x';
 }
 /* destination */
 string[idx++] = filechr(move->tofile);
-string[idx++] = rowchr(move->torow);
+string[idx++] = rankchr(move->torank);
 /* promotion? */
 if (move->promotion) {
 string[idx++] = '=';
 string[idx++] = getpiecechr(move->promotion);
 static int validate_move_rules(const GameState *gamestate, const Move *move) {
 assert((move->piece & ~(PIECE_MASK|COLOR_MASK)) == 0);
 /* validate indices (don't trust opponent) */
-if (!isidx(move->fromrow) || !isidx(move->fromfile) ||
+if (!isidx(move->fromrank) || !isidx(move->fromfile) ||
-!isidx(move->torow) || !isidx(move->tofile)) {
+!isidx(move->torank) || !isidx(move->tofile)) {
 return INVALID_MOVE_SYNTAX;
 }
 /* must move */
-if (move->fromfile == move->tofile && move->fromrow == move->torow) {
+if (move->fromfile == move->tofile && move->fromrank == move->torank) {
 return RULES_VIOLATED;
 }
 /* does piece exist */
-if (piece_at(gamestate, msrc(move)) != move->piece) {
+if (piece_at(gamestate, move->fromrank, move->fromfile) != move->piece) {
 return PIECE_NOT_FOUND;
 }
 /* is there any piece at the destination? */
-Piece piece_at_dst = piece_at(gamestate, mdst(move));
+Piece piece_at_dst = piece_at(gamestate, move->torank, move->tofile);
 /* can't capture own pieces */
 if (piece_color(piece_at_dst) == piece_color(move->piece)) {
 return RULES_VIOLATED;
 }
 /* must capture, if and only if destination is occupied... */
 if (!((piece_at_dst == 0) ^ move->capture)) {
 /* ... or the capture happens en passant */
 if (!move->capture || piece_type(move->piece) != PAWN ||
 !enpassant_threat_exists(gamestate,
-move->fromrow, move->tofile)) {
+move->fromrank, move->tofile)) {
 return RULES_VIOLATED;
 }
 }
 /* validate individual rules */
 Move simmove = *move;
 apply_move_internal(&simulation, &simmove);
 Color piececolor = piece_color(move->piece);
 Color oppcolor = opponent_color(piececolor);
 File kingfile = 0;
-Row kingrow = 0;
+Rank kingrank = 0;
-for (Row row = 0 ; row < 8 ; row++) {
+for (Rank rank = 0 ; rank < 8 ; rank++) {
 for (File file = 0 ; file < 8 ; file++) {
-Piece p = piece_at(&simulation, row, file);
+Piece p = piece_at(&simulation, rank, file);
 if (p == mkpiece(KING, piececolor)) {
 kingfile = file;
-kingrow = row;
+kingrank = rank;
 }
 }
 }
-if (is_covered(&simulation, kingrow, kingfile, oppcolor)) {
+if (is_covered(&simulation, kingrank, kingfile, oppcolor)) {
 if (piece_type(move->piece) == KING) {
 result = KING_MOVES_INTO_CHECK;
 } else {
 if (is_check_position(gamestate)) {
 result = KING_IN_CHECK;
 }
 return VALID_MOVE_SEMANTICS;
 }
-Piece piece_at(const GameState *gamestate, Row row, File file) {
+Piece piece_at(const GameState *gamestate, Rank rank, File file) {
-return gamestate->board[row][file] & (PIECE_MASK|COLOR_MASK);
+return gamestate->board[rank][file] & (PIECE_MASK|COLOR_MASK);
 }
-void piece_set(GameState *gamestate, Row row, File file, Piece piece) {
+void piece_set(GameState *gamestate, Rank rank, File file, Piece piece) {
-gamestate->board[row][file] = piece;
+gamestate->board[rank][file] = piece;
 }
-bool get_candidates(const GameState *gamestate, Row row, File file,
+bool get_candidates(const GameState *gamestate, Rank rank, File file,
 Color color, Move *moves, size_t *movecount) {
 Move candidates[32];
 size_t ccount = 0;
-for (Row r = 0 ; r < 8 ; r++) {
+for (Rank r = 0 ; r < 8 ; r++) {
 for (File f = 0 ; f < 8 ; f++) {
 Piece p = piece_at(gamestate, r, f);
 if (piece_color(p) == color) {
 /* non-capturing move */
 memset(&(candidates[ccount]), 0, sizeof(Move));
 candidates[ccount].piece = p;
-candidates[ccount].fromrow = r;
+candidates[ccount].fromrank = r;
 candidates[ccount].fromfile = f;
-candidates[ccount].torow = row;
+candidates[ccount].torank = rank;
 candidates[ccount].tofile = file;
-if (piece_type(p) == PAWN && (row == 0 || row == 7)) {
+if (piece_type(p) == PAWN && (rank == 0 || rank == 7)) {
 /* the exact piece for promotion does not matter */
 candidates[ccount].promotion = mkpiece(QUEEN, color);
 }
 ccount++;
 }
 return result;
 }
-bool get_threats(const GameState *gamestate, Row row, File file,
+bool get_threats(const GameState *gamestate, Rank rank, File file,
 Color color, Move *threats, size_t *threatcount) {
 /* simulate a capturing move on the target position */
 Color opcolor = opponent_color(color);
 GameState simulation = gamestate_copy_sim(gamestate);
-if (piece_color(piece_at(&simulation, row, file)) != opcolor) {
+if (piece_color(piece_at(&simulation, rank, file)) != opcolor) {
 /* set a fake pawn if the field is not occupied by the opponent */
-piece_set(&simulation, row, file, mkpiece(PAWN, opcolor));
+piece_set(&simulation, rank, file, mkpiece(PAWN, opcolor));
 }
 Move candidates[16];
 size_t ccount = 0;
-for (Row r = 0 ; r < 8 ; r++) {
+for (Rank r = 0 ; r < 8 ; r++) {
 for (File f = 0 ; f < 8 ; f++) {
 Piece p = piece_at(&simulation, r, f);
 if (piece_color(p) == color) {
 memset(&(candidates[ccount]), 0, sizeof(Move));
 candidates[ccount].piece = p;
-candidates[ccount].fromrow = r;
+candidates[ccount].fromrank = r;
 candidates[ccount].fromfile = f;
-candidates[ccount].torow = row;
+candidates[ccount].torank = rank;
 candidates[ccount].tofile = file;
 candidates[ccount].capture = true;
-if (piece_type(p) == PAWN && (row == 0 || row == 7)) {
+if (piece_type(p) == PAWN && (rank == 0 || rank == 7)) {
 /* the exact piece for promotion does not matter */
 candidates[ccount].promotion = mkpiece(QUEEN, color);
 }
 ccount++;
 }
 GameState simulation = gamestate_copy_sim(gamestate);
 Move simmove = *move;
 apply_move_internal(&simulation, &simmove);
 File kingfile = 0;
-Row kingrow = 0;
+Rank kingrank = 0;
-for (Row row = 0 ; row < 8 ; row++) {
+for (Rank rank = 0 ; rank < 8 ; rank++) {
 for (File file = 0 ; file < 8 ; file++) {
-if (piece_at(&simulation, row, file) == mkpiece(KING, color)) {
+if (piece_at(&simulation, rank, file) == mkpiece(KING, color)) {
 kingfile = file;
-kingrow = row;
+kingrank = rank;
 }
 }
 }
 bool covered = is_covered(&simulation,
-kingrow, kingfile, opponent_color(color));
+kingrank, kingfile, opponent_color(color));
 gamestate_cleanup(&simulation);
 return covered;
 }
-bool get_real_candidates(const GameState *gamestate, Row row, File file,
+bool get_real_candidates(const GameState *gamestate, Rank rank, File file,
 Color color, Move *moves, size_t *movecount) {
 if (movecount) {
 *movecount = 0;
 }
 Move candidates[16];
 size_t ccount;
-if (get_candidates(gamestate, row, file, color, candidates, &ccount)) {
+if (get_candidates(gamestate, rank, file, color, candidates, &ccount)) {
 bool result = false;
 for (size_t i = 0 ; i < ccount ; i++) {
 if (!is_pinned(gamestate, &candidates[i])) {
 result = true;
 if (moves && movecount) {
 } else {
 return false;
 }
 }
-bool get_real_threats(const GameState *gamestate, Row row, File file,
+bool get_real_threats(const GameState *gamestate, Rank rank, File file,
 Color color, Move *threats, size_t *threatcount) {
 if (threatcount) {
 *threatcount = 0;
 }
 Move candidates[16];
 size_t ccount;
-if (get_threats(gamestate, row, file, color, candidates, &ccount)) {
+if (get_threats(gamestate, rank, file, color, candidates, &ccount)) {
 bool result = false;
 for (size_t i = 0 ; i < ccount ; i++) {
 if (!is_pinned(gamestate, &candidates[i])) {
 result = true;
 if (threats && threatcount) {
 Move candidates[16], *candidate = NULL;
 size_t candidatecount;
 /* determine all candidate moves and sort out the invalid ones */
-if (get_candidates(gamestate, move->torow, move->tofile, color,
+if (get_candidates(gamestate, move->torank, move->tofile, color,
 candidates, &candidatecount)) {
 bool found = false;
 for (size_t i = 0 ; i < candidatecount ; i++) {
-/* filter by partial fromrow/fromfile information */
+/* filter by partial fromrank/fromfile information */
 if (candidates[i].piece == move->piece &&
-(move->fromrow == POS_UNSPECIFIED ||
+(move->fromrank == POS_UNSPECIFIED ||
-move->fromrow == candidates[i].fromrow) &&
+move->fromrank == candidates[i].fromrank) &&
 (move->fromfile == POS_UNSPECIFIED ||
 move->fromfile == candidates[i].fromfile)) {
 /* found a candidate, here it does not matter if it's valid! */
 found = true;
 return PIECE_NOT_FOUND;
 }
 }
 /* found a candidate, copy the source location */
-move->fromrow = candidate->fromrow;
+move->fromrank = candidate->fromrank;
 move->fromfile = candidate->fromfile;
 return VALID_MOVE_SYNTAX;
 } else {
 return PIECE_NOT_FOUND;
 }
 }
 static int eval_move1(const char *pstr, Move *move, Color color) {
 memset(move, 0, sizeof(Move));
 move->fromfile = POS_UNSPECIFIED;
-move->fromrow = POS_UNSPECIFIED;
+move->fromrank = POS_UNSPECIFIED;
 size_t len = strlen(pstr);
 if (len < 1 || len > 6) {
 return INVALID_MOVE_SYNTAX;
 }
 if (len == 2) {
 /* pawn move (e.g. "e4") */
 move->piece = mkpiece(PAWN, color);
 move->tofile = fileidx(mstr[0]);
-move->torow = rowidx(mstr[1]);
+move->torank = rankidx(mstr[1]);
 } else if (len == 3) {
 if (strcmp(mstr, "O-O") == 0) {
 /* king side castling */
 move->piece = mkpiece(KING, color);
 move->fromfile = fileidx('e');
 move->tofile = fileidx('g');
-move->fromrow = move->torow = color == WHITE ? 0 : 7;
+move->fromrank = move->torank = color == WHITE ? 0 : 7;
 } else {
 /* move (e.g. "Nf3") */
 move->piece = getpiece(mstr[0], color);
 move->tofile = fileidx(mstr[1]);
-move->torow = rowidx(mstr[2]);
+move->torank = rankidx(mstr[2]);
 }
 } else if (len == 4) {
 move->piece = getpiece(mstr[0], color);
 if (move->piece == 0) {
 move->piece = mkpiece(PAWN, color);
 if (piece_type(move->piece) == PAWN) {
 /* invalidate the result */
 move->piece = 0;
 }
 } else {
-move->fromrow = rowidx(mstr[1]);
+move->fromrank = rankidx(mstr[1]);
 }
 }
 move->tofile = fileidx(mstr[2]);
-move->torow = rowidx(mstr[3]);
+move->torank = rankidx(mstr[3]);
 } else if (len == 5) {
 if (strcmp(mstr, "O-O-O") == 0) {
 /* queen side castling "O-O-O" */
 move->piece = mkpiece(KING, color);
 move->fromfile = fileidx('e');
 move->tofile = fileidx('c');
-move->fromrow = move->torow = color == WHITE ? 0 : 7;
+move->fromrank = move->torank = color == WHITE ? 0 : 7;
 } else {
 move->piece = getpiece(mstr[0], color);
 if (mstr[2] == 'x') {
 move->capture = true;
 if (move->piece) {
 /* capture (e.g. "Ndxf3" or "R1xh3") */
 if (isfile(mstr[1])) {
 move->fromfile = fileidx(mstr[1]);
-} else if (isrow(mstr[1])) {
+} else if (isrank(mstr[1])) {
-move->fromrow = rowidx(mstr[1]);
+move->fromrank = rankidx(mstr[1]);
 } else {
 return INVALID_MOVE_SYNTAX;
 }
 } else {
 /* long notation capture (e.g. "e5xf6") */
 move->piece = mkpiece(PAWN, color);
 move->fromfile = fileidx(mstr[0]);
-move->fromrow = rowidx(mstr[1]);
+move->fromrank = rankidx(mstr[1]);
 }
 } else {
 /* long notation move (e.g. "Nc5a4") */
 move->fromfile = fileidx(mstr[1]);
-move->fromrow = rowidx(mstr[2]);
+move->fromrank = rankidx(mstr[2]);
 }
 move->tofile = fileidx(mstr[3]);
-move->torow = rowidx(mstr[4]);
+move->torank = rankidx(mstr[4]);
 }
 } else if (len == 6) {
 /* long notation capture (e.g. "Nc5xf3") */
 if (mstr[3] == 'x') {
 move->capture = true;
 move->piece = getpiece(mstr[0], color);
 move->fromfile = fileidx(mstr[1]);
-move->fromrow = rowidx(mstr[2]);
+move->fromrank = rankidx(mstr[2]);
 move->tofile = fileidx(mstr[4]);
-move->torow = rowidx(mstr[5]);
+move->torank = rankidx(mstr[5]);
 }
 }
 if (!move->piece) {
 return INVALID_MOVE_SYNTAX;
 }
 if (piece_type(move->piece) == PAWN
-&& move->torow == (color==WHITE?7:0)
+&& move->torank == (color==WHITE?7:0)
 && !move->promotion) {
 return NEED_PROMOTION;
 }
 /* up to this point
 * destination indices must be specified and valid
 * source indices must either be valid or unspecified
 */
-if (!isidxr(move->fromrow) || !isidxr(move->fromfile) ||
+if (!isidxr(move->fromrank) || !isidxr(move->fromfile) ||
-!isidx(move->torow) || !isidx(move->tofile)) {
+!isidx(move->torank) || !isidx(move->tofile)) {
 return INVALID_MOVE_SYNTAX;
 }
 return VALID_MOVE_SYNTAX;
 }
 static int eval_move2(const GameState *gamestate,
 const char *mstr, Color color, Move *move, bool lazy) {
 int result = eval_move1(mstr, move, color);
 if (result == VALID_MOVE_SYNTAX) {
 if (move->fromfile == POS_UNSPECIFIED
-|| move->fromrow == POS_UNSPECIFIED) {
+|| move->fromrank == POS_UNSPECIFIED) {
 result = getlocation(gamestate, move);
 }
 if (result == VALID_MOVE_SYNTAX) {
 /* correct check/checkmate flags */
 if (lazy) {
 int check_move(const char *mstr, Color color) {
 Move move;
 return eval_move1(mstr, &move, color);
 }
-bool is_protected(const GameState *gamestate, Row row, File file, Color color) {
+bool is_protected(const GameState *gamestate, Rank rank, File file, Color color) {
 Move candidates[16];
 size_t ccount;
 /* we need all candidates - not only threats! */
-if (get_candidates(gamestate, row, file, color, candidates, &ccount)) {
+if (get_candidates(gamestate, rank, file, color, candidates, &ccount)) {
 for (size_t i = 0 ; i < ccount ; i++) {
 /* skip the king */
 if (piece_type(candidates[i].piece) == KING) continue;
 /* skip pinned pieces */
 if (is_pinned(gamestate, &candidates[i])) continue;
 return snprintf(str, 6, "%02u:%02u", minutes, seconds);
 }
 }
 size_t filter_moves_allowed(const GameState *gamestate,
-Color c, Row r, File f, Move *moves, moves_generator_func func) {
+Color c, Rank r, File f, Move *moves, moves_generator_func func) {
 /* worst case: the queen has the most moves */
 Move candidates[QUEEN_MOVES_MAX];
 size_t candidatecount = func(gamestate, c, r, f, candidates);
 size_t count = 0;

Mercurial > hg > terminal-chess / file comparison

comparison: src/chess/rules.c

src/chess/rules.c