From 20fd59a089d86fe47ecab8af04eef4353d7a4da2 Mon Sep 17 00:00:00 2001 From: Disservin Date: Sat, 22 Feb 2025 16:20:23 +0100 Subject: [PATCH 1/3] refactor: simplify square usage without underlying --- docs/pages/move.md | 2 +- include/chess.hpp | 30 ++++++++++++++++++++++++++++++ src/coords.hpp | 30 ++++++++++++++++++++++++++++++ 3 files changed, 61 insertions(+), 1 deletion(-) diff --git a/docs/pages/move.md b/docs/pages/move.md index fe1ce1e..4f0337e 100644 --- a/docs/pages/move.md +++ b/docs/pages/move.md @@ -8,7 +8,7 @@ before checking for captures. Incase you want to manually create a move you can do it like so. ```cpp -Move m = Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_E4); +Move m = Move::make(Square::SQ_E2, Square::SQ_E4); ``` ## Other formats diff --git a/include/chess.hpp b/include/chess.hpp index e55dfb8..645abd8 100644 --- a/include/chess.hpp +++ b/include/chess.hpp @@ -154,6 +154,16 @@ constexpr char tolower(char c) { return (c >= 'A' && c <= 'Z') ? (c - 'A' + 'a') namespace chess { +#define CHESS_DECLARE_RANK(N) \ + static constexpr auto SQ_A##N = underlying::SQ_A##N; \ + static constexpr auto SQ_B##N = underlying::SQ_B##N; \ + static constexpr auto SQ_C##N = underlying::SQ_C##N; \ + static constexpr auto SQ_D##N = underlying::SQ_D##N; \ + static constexpr auto SQ_E##N = underlying::SQ_E##N; \ + static constexpr auto SQ_F##N = underlying::SQ_F##N; \ + static constexpr auto SQ_G##N = underlying::SQ_G##N; \ + static constexpr auto SQ_H##N = underlying::SQ_H##N; + class File { public: enum class underlying : std::uint8_t { FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, NO_FILE }; @@ -276,6 +286,24 @@ class Square { }; // clang-format on +// when c++20 +#if __cplusplus >= 202002L + using enum underlying; +#else + + CHESS_DECLARE_RANK(1) + CHESS_DECLARE_RANK(2) + CHESS_DECLARE_RANK(3) + CHESS_DECLARE_RANK(4) + CHESS_DECLARE_RANK(5) + CHESS_DECLARE_RANK(6) + CHESS_DECLARE_RANK(7) + CHESS_DECLARE_RANK(8) + + static constexpr auto NO_SQ = underlying::NO_SQ; + +#endif + constexpr Square() : sq(underlying::NO_SQ) {} constexpr Square(int sq) : sq(static_cast(sq)) { assert(sq <= 64 && sq >= 0); } @@ -518,6 +546,8 @@ constexpr Square operator+(Square sq, Direction dir) { return static_cast(sq.index() + static_cast(dir)); } +#undef CHESS_DECLARE_RANK + } // namespace chess namespace chess { diff --git a/src/coords.hpp b/src/coords.hpp index eac3152..1c4a884 100644 --- a/src/coords.hpp +++ b/src/coords.hpp @@ -10,6 +10,16 @@ namespace chess { +#define CHESS_DECLARE_RANK(N) \ + static constexpr auto SQ_A##N = underlying::SQ_A##N; \ + static constexpr auto SQ_B##N = underlying::SQ_B##N; \ + static constexpr auto SQ_C##N = underlying::SQ_C##N; \ + static constexpr auto SQ_D##N = underlying::SQ_D##N; \ + static constexpr auto SQ_E##N = underlying::SQ_E##N; \ + static constexpr auto SQ_F##N = underlying::SQ_F##N; \ + static constexpr auto SQ_G##N = underlying::SQ_G##N; \ + static constexpr auto SQ_H##N = underlying::SQ_H##N; + class File { public: enum class underlying : std::uint8_t { FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, NO_FILE }; @@ -132,6 +142,24 @@ class Square { }; // clang-format on +// when c++20 +#if __cplusplus >= 202002L + using enum underlying; +#else + + CHESS_DECLARE_RANK(1) + CHESS_DECLARE_RANK(2) + CHESS_DECLARE_RANK(3) + CHESS_DECLARE_RANK(4) + CHESS_DECLARE_RANK(5) + CHESS_DECLARE_RANK(6) + CHESS_DECLARE_RANK(7) + CHESS_DECLARE_RANK(8) + + static constexpr auto NO_SQ = underlying::NO_SQ; + +#endif + constexpr Square() : sq(underlying::NO_SQ) {} constexpr Square(int sq) : sq(static_cast(sq)) { assert(sq <= 64 && sq >= 0); } @@ -374,4 +402,6 @@ constexpr Square operator+(Square sq, Direction dir) { return static_cast(sq.index() + static_cast(dir)); } +#undef CHESS_DECLARE_RANK + } // namespace chess From 57aac2aaaf4d53a99c8abc8398d2561caf0e8fe3 Mon Sep 17 00:00:00 2001 From: Disservin Date: Sat, 22 Feb 2025 16:27:35 +0100 Subject: [PATCH 2/3] simplify code --- src/board.hpp | 33 +++++---- src/coords.hpp | 4 +- src/movegen.hpp | 2 +- src/uci.hpp | 6 +- tests/bitboard.cpp | 4 +- tests/board.cpp | 16 ++--- tests/coords.cpp | 168 ++++++++++++++++++++++----------------------- tests/move.cpp | 44 +++++------- tests/movelist.cpp | 22 +++--- tests/san.cpp | 130 +++++++++++++++++------------------ tests/uci.cpp | 11 ++- 11 files changed, 211 insertions(+), 229 deletions(-) diff --git a/src/board.hpp b/src/board.hpp index fb04f00..65a6b6b 100644 --- a/src/board.hpp +++ b/src/board.hpp @@ -227,7 +227,7 @@ class Board { // Append information about the en passant square (if any) // and the half-move clock and full move number to the FEN string - if (ep_sq_ == Square::underlying::NO_SQ) + if (ep_sq_ == Square::NO_SQ) ss += " -"; else { ss += ' '; @@ -280,8 +280,8 @@ class Board { hfm_++; plies_++; - if (ep_sq_ != Square::underlying::NO_SQ) key_ ^= Zobrist::enpassant(ep_sq_.file()); - ep_sq_ = Square::underlying::NO_SQ; + if (ep_sq_ != Square::NO_SQ) key_ ^= Zobrist::enpassant(ep_sq_.file()); + ep_sq_ = Square::NO_SQ; if (capture) { removePiece(captured, move.to()); @@ -503,8 +503,8 @@ class Board { prev_states_.emplace_back(key_, cr_, ep_sq_, hfm_, Piece::NONE); key_ ^= Zobrist::sideToMove(); - if (ep_sq_ != Square::underlying::NO_SQ) key_ ^= Zobrist::enpassant(ep_sq_.file()); - ep_sq_ = Square::underlying::NO_SQ; + if (ep_sq_ != Square::NO_SQ) key_ ^= Zobrist::enpassant(ep_sq_.file()); + ep_sq_ = Square::NO_SQ; stm_ = ~stm_; @@ -825,7 +825,7 @@ class Board { } U64 ep_hash = 0ULL; - if (ep_sq_ != Square::underlying::NO_SQ) ep_hash ^= Zobrist::enpassant(ep_sq_.file()); + if (ep_sq_ != Square::NO_SQ) ep_hash ^= Zobrist::enpassant(ep_sq_.file()); U64 stm_hash = 0ULL; if (stm_ == Color::WHITE) stm_hash ^= Zobrist::sideToMove(); @@ -936,7 +936,7 @@ class Board { const auto castling = params[2].has_value() ? *params[2] : "-"; const auto en_passant = params[3].has_value() ? *params[3] : "-"; - const auto ep = en_passant == "-" ? Square::underlying::NO_SQ : Square(en_passant); + const auto ep = en_passant == "-" ? Square::NO_SQ : Square(en_passant); const auto stm = (move_right == "w") ? Color::WHITE : Color::BLACK; CastlingRights cr; @@ -1105,7 +1105,7 @@ class Board { // 14 => any black rook with castling rights, side will be deduced from the file // 15 => black king and black is side to move static std::uint8_t convertMeaning(const CastlingRights &cr, Color stm, Square ep, Square sq, Piece piece) { - if (piece.type() == PieceType::PAWN && ep != Square::underlying::NO_SQ) { + if (piece.type() == PieceType::PAWN && ep != Square::NO_SQ) { if (Square(static_cast(sq.index()) ^ 8) == ep) return 12; } @@ -1143,7 +1143,7 @@ class Board { CastlingRights cr_ = {}; uint16_t plies_ = 0; Color stm_ = Color::WHITE; - Square ep_sq_ = Square::underlying::NO_SQ; + Square ep_sq_ = Square::NO_SQ; uint8_t hfm_ = 0; bool chess960_ = false; @@ -1224,7 +1224,7 @@ class Board { plies_ = parseStringViewToInt(full_move).value_or(1); plies_ = plies_ * 2 - 2; - ep_sq_ = en_passant == "-" ? Square::underlying::NO_SQ : Square(en_passant); + ep_sq_ = en_passant == "-" ? Square::NO_SQ : Square(en_passant); stm_ = (move_right == "w") ? Color::WHITE : Color::BLACK; key_ = 0ULL; cr_.clear(); @@ -1260,8 +1260,7 @@ class Board { static const auto find_rook = [](const Board &board, CastlingRights::Side side, Color color) { const auto king_side = CastlingRights::Side::KING_SIDE; const auto king_sq = board.kingSq(color); - const auto sq_corner = Square(side == king_side ? Square::underlying::SQ_H1 : Square::underlying::SQ_A1) - .relative_square(color); + const auto sq_corner = Square(side == king_side ? Square::SQ_H1 : Square::SQ_A1).relative_square(color); const auto start = side == king_side ? king_sq + 1 : king_sq - 1; @@ -1316,13 +1315,13 @@ class Board { } // check if ep square itself is valid - if (ep_sq_ != Square::underlying::NO_SQ && !((ep_sq_.rank() == Rank::RANK_3 && stm_ == Color::BLACK) || - (ep_sq_.rank() == Rank::RANK_6 && stm_ == Color::WHITE))) { - ep_sq_ = Square::underlying::NO_SQ; + if (ep_sq_ != Square::NO_SQ && !((ep_sq_.rank() == Rank::RANK_3 && stm_ == Color::BLACK) || + (ep_sq_.rank() == Rank::RANK_6 && stm_ == Color::WHITE))) { + ep_sq_ = Square::NO_SQ; } // check if ep square is valid, i.e. if there is a pawn that can capture it - if (ep_sq_ != Square::underlying::NO_SQ) { + if (ep_sq_ != Square::NO_SQ) { bool valid; if (stm_ == Color::WHITE) { @@ -1332,7 +1331,7 @@ class Board { } if (!valid) - ep_sq_ = Square::underlying::NO_SQ; + ep_sq_ = Square::NO_SQ; else key_ ^= Zobrist::enpassant(ep_sq_.file()); } diff --git a/src/coords.hpp b/src/coords.hpp index 1c4a884..43995c3 100644 --- a/src/coords.hpp +++ b/src/coords.hpp @@ -354,7 +354,7 @@ class Square { * @return */ [[nodiscard]] static constexpr Square castling_king_square(bool is_king_side, Color c) noexcept { - return Square(is_king_side ? Square::underlying::SQ_G1 : Square::underlying::SQ_C1).relative_square(c); + return Square(is_king_side ? Square::SQ_G1 : Square::SQ_C1).relative_square(c); } /** @@ -364,7 +364,7 @@ class Square { * @return */ [[nodiscard]] static constexpr Square castling_rook_square(bool is_king_side, Color c) noexcept { - return Square(is_king_side ? Square::underlying::SQ_F1 : Square::underlying::SQ_D1).relative_square(c); + return Square(is_king_side ? Square::SQ_F1 : Square::SQ_D1).relative_square(c); } /** diff --git a/src/movegen.hpp b/src/movegen.hpp index 1f63131..59381a4 100644 --- a/src/movegen.hpp +++ b/src/movegen.hpp @@ -269,7 +269,7 @@ inline void movegen::generatePawnMoves(const Board &board, Movelist &moves, Bitb const Square ep = board.enpassantSq(); - if (ep != Square::underlying::NO_SQ) { + if (ep != Square::NO_SQ) { auto m = generateEPMove(board, checkmask, pin_d, pawns_lr, ep, c); for (const auto &move : m) { diff --git a/src/uci.hpp b/src/uci.hpp index 24cc721..39100a7 100644 --- a/src/uci.hpp +++ b/src/uci.hpp @@ -230,7 +230,7 @@ class uci { } } // Handle moves with specific from square - else if (info.from != Square::underlying::NO_SQ) { + else if (info.from != Square::NO_SQ) { if (move.from() != info.from) { continue; } @@ -270,9 +270,9 @@ class uci { PieceType promotion = PieceType::NONE; - Square from = Square::underlying::NO_SQ; + Square from = Square::NO_SQ; // a valid move always has a to square - Square to = Square::underlying::NO_SQ; + Square to = Square::NO_SQ; // a valid move always has a piece PieceType piece = PieceType::NONE; diff --git a/tests/bitboard.cpp b/tests/bitboard.cpp index 17eea5e..1cbb0c4 100644 --- a/tests/bitboard.cpp +++ b/tests/bitboard.cpp @@ -292,11 +292,11 @@ TEST_SUITE("Bitboard") { const auto str = "00000000\n00000000\n00000000\n00000000\n00000000\n00000000\n00000000\n00000000\n"; CHECK(static_cast(str) == str); - b = Bitboard::fromSquare(Square::underlying::SQ_A1); + b = Bitboard::fromSquare(Square::SQ_A1); const auto str1 = "00000000\n00000000\n00000000\n00000000\n00000000\n00000000\n00000000\n10000000\n"; CHECK(static_cast(str1) == str1); - b = Bitboard::fromSquare(Square::underlying::SQ_A2); + b = Bitboard::fromSquare(Square::SQ_A2); const auto str2 = "00000000\n00000000\n00000000\n00000000\n00000000\n00000000\n00000000\n01000000\n"; CHECK(static_cast(str2) == str2); } diff --git a/tests/board.cpp b/tests/board.cpp index e3c393d..ebb7be8 100644 --- a/tests/board.cpp +++ b/tests/board.cpp @@ -9,17 +9,17 @@ TEST_SUITE("Board") { TEST_CASE("Board makeMove/unmakeMove") { SUBCASE("makeMove") { Board board = Board(); - board.makeMove(Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_E4)); - board.makeMove(Move::make(Square::underlying::SQ_E7, Square::underlying::SQ_E5)); + board.makeMove(Move::make(Square::SQ_E2, Square::SQ_E4)); + board.makeMove(Move::make(Square::SQ_E7, Square::SQ_E5)); - CHECK(board.at(Square::underlying::SQ_E4) == Piece::WHITEPAWN); - CHECK(board.at(Square::underlying::SQ_E5) == Piece::BLACKPAWN); + CHECK(board.at(Square::SQ_E4) == Piece::WHITEPAWN); + CHECK(board.at(Square::SQ_E5) == Piece::BLACKPAWN); - board.unmakeMove(Move::make(Square::underlying::SQ_E7, Square::underlying::SQ_E5)); - board.unmakeMove(Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_E4)); + board.unmakeMove(Move::make(Square::SQ_E7, Square::SQ_E5)); + board.unmakeMove(Move::make(Square::SQ_E2, Square::SQ_E4)); - CHECK(board.at(Square::underlying::SQ_E2) == Piece::WHITEPAWN); - CHECK(board.at(Square::underlying::SQ_E7) == Piece::BLACKPAWN); + CHECK(board.at(Square::SQ_E2) == Piece::WHITEPAWN); + CHECK(board.at(Square::SQ_E7) == Piece::BLACKPAWN); CHECK(board.zobrist() == Board().zobrist()); } diff --git a/tests/coords.cpp b/tests/coords.cpp index 9eba1ee..4d06ee1 100644 --- a/tests/coords.cpp +++ b/tests/coords.cpp @@ -121,171 +121,171 @@ TEST_SUITE("Rank") { TEST_SUITE("Square") { TEST_CASE("Square operator==") { - Square s = Square::underlying::SQ_A1; - CHECK(s == Square::underlying::SQ_A1); + Square s = Square::SQ_A1; + CHECK(s == Square::SQ_A1); } TEST_CASE("Square operator!=") { - Square s = Square::underlying::SQ_A1; - CHECK(s != Square::underlying::SQ_A2); + Square s = Square::SQ_A1; + CHECK(s != Square::SQ_A2); } TEST_CASE("Square operator>=") { - Square s = Square::underlying::SQ_A1; - CHECK(s >= Square::underlying::SQ_A1); + Square s = Square::SQ_A1; + CHECK(s >= Square::SQ_A1); } TEST_CASE("Square operator<=") { - Square s = Square::underlying::SQ_A1; - CHECK(s <= Square::underlying::SQ_A1); + Square s = Square::SQ_A1; + CHECK(s <= Square::SQ_A1); } TEST_CASE("Square operator>") { - Square s = Square::underlying::SQ_A2; - CHECK(s > Square::underlying::SQ_A1); + Square s = Square::SQ_A2; + CHECK(s > Square::SQ_A1); } TEST_CASE("Square operator<") { - Square s = Square::underlying::SQ_A1; - CHECK(s < Square::underlying::SQ_A2); + Square s = Square::SQ_A1; + CHECK(s < Square::SQ_A2); } TEST_CASE("Square operator std::string") { - Square s = Square::underlying::SQ_A1; + Square s = Square::SQ_A1; CHECK(static_cast(s) == "a1"); - s = Square::underlying::SQ_A2; + s = Square::SQ_A2; CHECK(static_cast(s) == "a2"); - s = Square::underlying::SQ_A3; + s = Square::SQ_A3; CHECK(static_cast(s) == "a3"); - s = Square::underlying::SQ_A4; + s = Square::SQ_A4; CHECK(static_cast(s) == "a4"); - s = Square::underlying::SQ_A5; + s = Square::SQ_A5; CHECK(static_cast(s) == "a5"); - s = Square::underlying::SQ_A6; + s = Square::SQ_A6; CHECK(static_cast(s) == "a6"); - s = Square::underlying::SQ_A7; + s = Square::SQ_A7; CHECK(static_cast(s) == "a7"); - s = Square::underlying::SQ_A8; + s = Square::SQ_A8; CHECK(static_cast(s) == "a8"); - s = Square::underlying::SQ_B1; + s = Square::SQ_B1; CHECK(static_cast(s) == "b1"); - s = Square::underlying::SQ_B2; + s = Square::SQ_B2; CHECK(static_cast(s) == "b2"); - s = Square::underlying::SQ_B3; + s = Square::SQ_B3; CHECK(static_cast(s) == "b3"); - s = Square::underlying::SQ_B4; + s = Square::SQ_B4; CHECK(static_cast(s) == "b4"); - s = Square::underlying::SQ_B5; + s = Square::SQ_B5; CHECK(static_cast(s) == "b5"); - s = Square::underlying::SQ_B6; + s = Square::SQ_B6; CHECK(static_cast(s) == "b6"); - s = Square::underlying::SQ_B7; + s = Square::SQ_B7; CHECK(static_cast(s) == "b7"); - s = Square::underlying::SQ_B8; + s = Square::SQ_B8; CHECK(static_cast(s) == "b8"); - s = Square::underlying::SQ_C1; + s = Square::SQ_C1; CHECK(static_cast(s) == "c1"); - s = Square::underlying::SQ_C2; + s = Square::SQ_C2; CHECK(static_cast(s) == "c2"); - s = Square::underlying::SQ_C3; + s = Square::SQ_C3; CHECK(static_cast(s) == "c3"); } TEST_CASE("Square file()") { - Square s = Square::underlying::SQ_A1; + Square s = Square::SQ_A1; CHECK(s.file() == File::FILE_A); - s = Square::underlying::SQ_B1; + s = Square::SQ_B1; CHECK(s.file() == File::FILE_B); - s = Square::underlying::SQ_C1; + s = Square::SQ_C1; CHECK(s.file() == File::FILE_C); } TEST_CASE("Square rank()") { - Square s = Square::underlying::SQ_A1; + Square s = Square::SQ_A1; CHECK(s.rank() == Rank::RANK_1); - s = Square::underlying::SQ_A2; + s = Square::SQ_A2; CHECK(s.rank() == Rank::RANK_2); - s = Square::underlying::SQ_A3; + s = Square::SQ_A3; CHECK(s.rank() == Rank::RANK_3); } TEST_CASE("Square ()") { Square s = Square(File::FILE_A, Rank::RANK_1); - CHECK(s == Square::underlying::SQ_A1); + CHECK(s == Square::SQ_A1); s = Square(File::FILE_B, Rank::RANK_1); - CHECK(s == Square::underlying::SQ_B1); + CHECK(s == Square::SQ_B1); s = Square(File::FILE_C, Rank::RANK_1); - CHECK(s == Square::underlying::SQ_C1); + CHECK(s == Square::SQ_C1); } TEST_CASE("Square ()") { Square s = Square("a1"); - CHECK(s == Square::underlying::SQ_A1); + CHECK(s == Square::SQ_A1); s = Square("b1"); - CHECK(s == Square::underlying::SQ_B1); + CHECK(s == Square::SQ_B1); s = Square("c1"); - CHECK(s == Square::underlying::SQ_C1); + CHECK(s == Square::SQ_C1); } TEST_CASE("is_light") { - Square s = Square::underlying::SQ_A1; + Square s = Square::SQ_A1; CHECK(s.is_light()); - s = Square::underlying::SQ_B1; + s = Square::SQ_B1; CHECK(!s.is_light()); - s = Square::underlying::SQ_C1; + s = Square::SQ_C1; CHECK(s.is_light()); } TEST_CASE("is_dark") { - Square s = Square::underlying::SQ_A1; + Square s = Square::SQ_A1; CHECK(!s.is_dark()); - s = Square::underlying::SQ_B1; + s = Square::SQ_B1; CHECK(s.is_dark()); - s = Square::underlying::SQ_C1; + s = Square::SQ_C1; CHECK(!s.is_dark()); } TEST_CASE("is_valid") { - Square s = Square::underlying::SQ_A1; + Square s = Square::SQ_A1; CHECK(s.is_valid()); - s = Square::underlying::SQ_B1; + s = Square::SQ_B1; CHECK(s.is_valid()); - s = Square::underlying::SQ_C1; + s = Square::SQ_C1; CHECK(s.is_valid()); - s = Square::underlying::NO_SQ; + s = Square::NO_SQ; CHECK(!s.is_valid()); } @@ -296,58 +296,58 @@ TEST_SUITE("Square") { } TEST_CASE("Square distance") { - CHECK(Square::distance(Square::underlying::SQ_A1, Square::underlying::SQ_A1) == 0); - CHECK(Square::distance(Square::underlying::SQ_A1, Square::underlying::SQ_A2) == 1); - CHECK(Square::distance(Square::underlying::SQ_A1, Square::underlying::SQ_B1) == 1); - CHECK(Square::distance(Square::underlying::SQ_A1, Square::underlying::SQ_B2) == 1); + CHECK(Square::distance(Square::SQ_A1, Square::SQ_A1) == 0); + CHECK(Square::distance(Square::SQ_A1, Square::SQ_A2) == 1); + CHECK(Square::distance(Square::SQ_A1, Square::SQ_B1) == 1); + CHECK(Square::distance(Square::SQ_A1, Square::SQ_B2) == 1); } TEST_CASE("Square value_distance") { - CHECK(Square::value_distance(Square::underlying::SQ_A1, Square::underlying::SQ_A1) == 0); - CHECK(Square::value_distance(Square::underlying::SQ_A1, Square::underlying::SQ_A2) == 8); - CHECK(Square::value_distance(Square::underlying::SQ_A1, Square::underlying::SQ_B1) == 1); - CHECK(Square::value_distance(Square::underlying::SQ_A1, Square::underlying::SQ_B2) == 9); + CHECK(Square::value_distance(Square::SQ_A1, Square::SQ_A1) == 0); + CHECK(Square::value_distance(Square::SQ_A1, Square::SQ_A2) == 8); + CHECK(Square::value_distance(Square::SQ_A1, Square::SQ_B1) == 1); + CHECK(Square::value_distance(Square::SQ_A1, Square::SQ_B2) == 9); } TEST_CASE("Square same_color") { - CHECK(Square::same_color(Square::underlying::SQ_A1, Square::underlying::SQ_A1)); - CHECK(!Square::same_color(Square::underlying::SQ_A1, Square::underlying::SQ_A2)); - CHECK(!Square::same_color(Square::underlying::SQ_A1, Square::underlying::SQ_B1)); - CHECK(Square::same_color(Square::underlying::SQ_A1, Square::underlying::SQ_B2)); + CHECK(Square::same_color(Square::SQ_A1, Square::SQ_A1)); + CHECK(!Square::same_color(Square::SQ_A1, Square::SQ_A2)); + CHECK(!Square::same_color(Square::SQ_A1, Square::SQ_B1)); + CHECK(Square::same_color(Square::SQ_A1, Square::SQ_B2)); } TEST_CASE("Square back_rank") { - CHECK(Square::back_rank(Square::underlying::SQ_A1, Color::WHITE)); - CHECK(!Square::back_rank(Square::underlying::SQ_A1, Color::BLACK)); - CHECK(!Square::back_rank(Square::underlying::SQ_A8, Color::WHITE)); - CHECK(Square::back_rank(Square::underlying::SQ_A8, Color::BLACK)); + CHECK(Square::back_rank(Square::SQ_A1, Color::WHITE)); + CHECK(!Square::back_rank(Square::SQ_A1, Color::BLACK)); + CHECK(!Square::back_rank(Square::SQ_A8, Color::WHITE)); + CHECK(Square::back_rank(Square::SQ_A8, Color::BLACK)); } TEST_CASE("Square flip") { - CHECK(Square(Square::underlying::SQ_A1).flip() == Square::underlying::SQ_A8); - CHECK(Square(Square::underlying::SQ_A2).flip() == Square::underlying::SQ_A7); - CHECK(Square(Square::underlying::SQ_A3).flip() == Square::underlying::SQ_A6); + CHECK(Square(Square::SQ_A1).flip() == Square::SQ_A8); + CHECK(Square(Square::SQ_A2).flip() == Square::SQ_A7); + CHECK(Square(Square::SQ_A3).flip() == Square::SQ_A6); } TEST_CASE("Square relative_square") { - CHECK(Square(Square::underlying::SQ_A1).relative_square(Color::WHITE) == Square::underlying::SQ_A1); - CHECK(Square(Square::underlying::SQ_A1).relative_square(Color::BLACK) == Square::underlying::SQ_A8); - CHECK(Square(Square::underlying::SQ_A2).relative_square(Color::WHITE) == Square::underlying::SQ_A2); - CHECK(Square(Square::underlying::SQ_A2).relative_square(Color::BLACK) == Square::underlying::SQ_A7); + CHECK(Square(Square::SQ_A1).relative_square(Color::WHITE) == Square::SQ_A1); + CHECK(Square(Square::SQ_A1).relative_square(Color::BLACK) == Square::SQ_A8); + CHECK(Square(Square::SQ_A2).relative_square(Color::WHITE) == Square::SQ_A2); + CHECK(Square(Square::SQ_A2).relative_square(Color::BLACK) == Square::SQ_A7); } TEST_CASE("Square ep_square") { - CHECK(Square(Square::underlying::SQ_A3).ep_square() == Square::underlying::SQ_A4); - CHECK(Square(Square::underlying::SQ_A4).ep_square() == Square::underlying::SQ_A3); - CHECK(Square(Square::underlying::SQ_A5).ep_square() == Square::underlying::SQ_A6); - CHECK(Square(Square::underlying::SQ_A6).ep_square() == Square::underlying::SQ_A5); + CHECK(Square(Square::SQ_A3).ep_square() == Square::SQ_A4); + CHECK(Square(Square::SQ_A4).ep_square() == Square::SQ_A3); + CHECK(Square(Square::SQ_A5).ep_square() == Square::SQ_A6); + CHECK(Square(Square::SQ_A6).ep_square() == Square::SQ_A5); } TEST_CASE("Square castling_king_square") { - CHECK(Square::castling_king_square(true, Color::WHITE) == Square::underlying::SQ_G1); - CHECK(Square::castling_king_square(false, Color::WHITE) == Square::underlying::SQ_C1); - CHECK(Square::castling_king_square(true, Color::BLACK) == Square::underlying::SQ_G8); - CHECK(Square::castling_king_square(false, Color::BLACK) == Square::underlying::SQ_C8); + CHECK(Square::castling_king_square(true, Color::WHITE) == Square::SQ_G1); + CHECK(Square::castling_king_square(false, Color::WHITE) == Square::SQ_C1); + CHECK(Square::castling_king_square(true, Color::BLACK) == Square::SQ_G8); + CHECK(Square::castling_king_square(false, Color::BLACK) == Square::SQ_C8); } TEST_CASE("Square max") { CHECK(Square::max() == 64); } diff --git a/tests/move.cpp b/tests/move.cpp index 6334f2a..a5e6dc3 100644 --- a/tests/move.cpp +++ b/tests/move.cpp @@ -5,42 +5,30 @@ using namespace chess; TEST_SUITE("Move") { TEST_CASE("from") { - CHECK(Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A2).from() == - Square::underlying::SQ_A1); - CHECK(Move::make(Square::underlying::SQ_H8, Square::underlying::SQ_H1).from() == - Square::underlying::SQ_H8); + CHECK(Move::make(Square::SQ_A1, Square::SQ_A2).from() == Square::SQ_A1); + CHECK(Move::make(Square::SQ_H8, Square::SQ_H1).from() == Square::SQ_H8); } TEST_CASE("to") { - CHECK(Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A2).to() == - Square::underlying::SQ_A2); - CHECK(Move::make(Square::underlying::SQ_H8, Square::underlying::SQ_H1).to() == - Square::underlying::SQ_H1); + CHECK(Move::make(Square::SQ_A1, Square::SQ_A2).to() == Square::SQ_A2); + CHECK(Move::make(Square::SQ_H8, Square::SQ_H1).to() == Square::SQ_H1); } TEST_CASE("typeOf") { - CHECK(Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A2).typeOf() == - Move::NORMAL); - CHECK(Move::make(Square::underlying::SQ_H7, Square::underlying::SQ_H8) - .typeOf() == Move::PROMOTION); - CHECK(Move::make(Square::underlying::SQ_D5, Square::underlying::SQ_C6) - .typeOf() == Move::ENPASSANT); - CHECK(Move::make(Square::underlying::SQ_E8, Square::underlying::SQ_H8) - .typeOf() == Move::CASTLING); + CHECK(Move::make(Square::SQ_A1, Square::SQ_A2).typeOf() == Move::NORMAL); + CHECK(Move::make(Square::SQ_H7, Square::SQ_H8).typeOf() == Move::PROMOTION); + CHECK(Move::make(Square::SQ_D5, Square::SQ_C6).typeOf() == Move::ENPASSANT); + CHECK(Move::make(Square::SQ_E8, Square::SQ_H8).typeOf() == Move::CASTLING); } TEST_CASE("promotionType") { - CHECK(Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A2, - PieceType::BISHOP) - .promotionType() == PieceType::BISHOP); - CHECK(Move::make(Square::underlying::SQ_H7, Square::underlying::SQ_H8, - PieceType::KNIGHT) - .promotionType() == PieceType::KNIGHT); - CHECK(Move::make(Square::underlying::SQ_D5, Square::underlying::SQ_C6, - PieceType::ROOK) - .promotionType() == PieceType::ROOK); - CHECK(Move::make(Square::underlying::SQ_E8, Square::underlying::SQ_H8, - PieceType::QUEEN) - .promotionType() == PieceType::QUEEN); + CHECK(Move::make(Square::SQ_A1, Square::SQ_A2, PieceType::BISHOP).promotionType() == + PieceType::BISHOP); + CHECK(Move::make(Square::SQ_H7, Square::SQ_H8, PieceType::KNIGHT).promotionType() == + PieceType::KNIGHT); + CHECK(Move::make(Square::SQ_D5, Square::SQ_C6, PieceType::ROOK).promotionType() == + PieceType::ROOK); + CHECK(Move::make(Square::SQ_E8, Square::SQ_H8, PieceType::QUEEN).promotionType() == + PieceType::QUEEN); } } \ No newline at end of file diff --git a/tests/movelist.cpp b/tests/movelist.cpp index 756728e..5920b19 100644 --- a/tests/movelist.cpp +++ b/tests/movelist.cpp @@ -6,26 +6,22 @@ using namespace chess; TEST_SUITE("Movelist") { TEST_CASE("add") { Movelist moves; - moves.add(Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A2)); + moves.add(Move::make(Square::SQ_A1, Square::SQ_A2)); CHECK(moves.size() == 1); - CHECK(moves[0] == Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A2)); + CHECK(moves[0] == Move::make(Square::SQ_A1, Square::SQ_A2)); CHECK(moves.empty() == false); } TEST_CASE("find") { Movelist moves; - moves.add(Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A2)); - moves.add(Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A3)); - moves.add(Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A4)); + moves.add(Move::make(Square::SQ_A1, Square::SQ_A2)); + moves.add(Move::make(Square::SQ_A1, Square::SQ_A3)); + moves.add(Move::make(Square::SQ_A1, Square::SQ_A4)); - CHECK(std::find(moves.begin(), moves.end(), Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A2)) != - moves.end()); - CHECK(std::find(moves.begin(), moves.end(), Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A3)) != - moves.end()); - CHECK(std::find(moves.begin(), moves.end(), Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A4)) != - moves.end()); - CHECK(std::find(moves.begin(), moves.end(), Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A5)) == - moves.end()); + CHECK(std::find(moves.begin(), moves.end(), Move::make(Square::SQ_A1, Square::SQ_A2)) != moves.end()); + CHECK(std::find(moves.begin(), moves.end(), Move::make(Square::SQ_A1, Square::SQ_A3)) != moves.end()); + CHECK(std::find(moves.begin(), moves.end(), Move::make(Square::SQ_A1, Square::SQ_A4)) != moves.end()); + CHECK(std::find(moves.begin(), moves.end(), Move::make(Square::SQ_A1, Square::SQ_A5)) == moves.end()); } } diff --git a/tests/san.cpp b/tests/san.cpp index 2d4bc4a..f87a885 100644 --- a/tests/san.cpp +++ b/tests/san.cpp @@ -7,7 +7,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test ambiguous pawn capture") { auto b = Board{"rnbqkbnr/ppp1p1pp/3p1p2/4N3/8/3P4/PPPKPPPP/R1BQ1BNR b kq - 1 7"}; - Move m = Move::make(Square::underlying::SQ_F6, Square::underlying::SQ_E5); + Move m = Move::make(Square::SQ_F6, Square::SQ_E5); CHECK(uci::moveToSan(b, m) == "fxe5"); CHECK(uci::parseSan(b, "fxe5") == m); @@ -16,7 +16,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test ambiguous pawn ep capture") { auto b = Board{"rnbqkbnr/pppppp1p/8/5PpP/8/8/PPPPP2P/RNBQKBNR w KQkq g6 0 2"}; - Move m = Move::make(Square::underlying::SQ_F5, Square::underlying::SQ_G6); + Move m = Move::make(Square::SQ_F5, Square::SQ_G6); CHECK(uci::moveToSan(b, m) == "fxg6"); CHECK(uci::parseSan(b, "fxg6") == m); @@ -25,7 +25,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test ambiguous knight move") { auto b = Board{"rnbqkbnr/ppp3pp/3ppp2/8/8/3P1N1N/PPPKPPPP/R1BQ1B1R w kq - 1 8"}; - Move m = Move::make(Square::underlying::SQ_F3, Square::underlying::SQ_G5); + Move m = Move::make(Square::SQ_F3, Square::SQ_G5); CHECK(uci::moveToSan(b, m) == "Nfg5"); CHECK(uci::parseSan(b, "Nfg5") == m); @@ -34,7 +34,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test ambiguous rook move with check") { auto b = Board{"4k3/8/8/8/8/8/2R3R1/2K5 w - - 0 1"}; - Move m = Move::make(Square::underlying::SQ_C2, Square::underlying::SQ_E2); + Move m = Move::make(Square::SQ_C2, Square::SQ_E2); CHECK(uci::moveToSan(b, m) == "Rce2+"); CHECK(uci::parseSan(b, "Rce2+") == m); @@ -43,7 +43,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test ambiguous rook move with checkmate") { auto b = Board{"7k/8/8/8/8/8/2K3R1/3R4 w - - 0 1"}; - Move m = Move::make(Square::underlying::SQ_D1, Square::underlying::SQ_H1); + Move m = Move::make(Square::SQ_D1, Square::SQ_H1); CHECK(uci::moveToSan(b, m) == "Rh1#"); CHECK(uci::parseSan(b, "Rh1#") == m); @@ -52,7 +52,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Knight move") { auto b = Board{"rnbqkbnr/ppp1p1pp/3p1p2/8/8/3P1N2/PPPKPPPP/R1BQ1BNR w kq - 0 7"}; - Move m = Move::make(Square::underlying::SQ_F3, Square::underlying::SQ_G5); + Move m = Move::make(Square::SQ_F3, Square::SQ_G5); CHECK(uci::moveToSan(b, m) == "Ng5"); CHECK(uci::parseSan(b, "Ng5") == m); @@ -61,7 +61,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Bishop move") { auto b = Board{"rnbqkbnr/pppp1ppp/8/4p3/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 1"}; - Move m = Move::make(Square::underlying::SQ_F1, Square::underlying::SQ_C4); + Move m = Move::make(Square::SQ_F1, Square::SQ_C4); CHECK(uci::moveToSan(b, m) == "Bc4"); CHECK(uci::parseSan(b, "Bc4") == m); @@ -70,7 +70,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Rook move") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPP1PP/R3KR2 w Qkq - 0 1"}; - Move m = Move::make(Square::underlying::SQ_F1, Square::underlying::SQ_F7); + Move m = Move::make(Square::SQ_F1, Square::SQ_F7); CHECK(uci::moveToSan(b, m) == "Rxf7"); CHECK(uci::parseSan(b, "Rxf7") == m); @@ -79,7 +79,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Queen move") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPP1PP/R3KQ1R w KQkq - 0 1"}; - Move m = Move::make(Square::underlying::SQ_F1, Square::underlying::SQ_F7); + Move m = Move::make(Square::SQ_F1, Square::SQ_F7); CHECK(uci::moveToSan(b, m) == "Qxf7+"); CHECK(uci::parseSan(b, "Qxf7+") == m); @@ -88,7 +88,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test King move") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_F1); + Move m = Move::make(Square::SQ_E1, Square::SQ_F1); CHECK(uci::moveToSan(b, m) == "Kf1"); CHECK(uci::parseSan(b, "Kf1") == m); @@ -97,7 +97,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test King Castling Short move") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK2R w KQkq - 0 17"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_H1); + Move m = Move::make(Square::SQ_E1, Square::SQ_H1); CHECK(uci::moveToSan(b, m) == "O-O"); CHECK(uci::parseSan(b, "O-O") == m); @@ -106,7 +106,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test King Castling Long move") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_A1); + Move m = Move::make(Square::SQ_E1, Square::SQ_A1); CHECK(uci::moveToSan(b, m) == "O-O-O"); CHECK(uci::parseSan(b, "O-O-O") == m); @@ -115,7 +115,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test King Castling Short move with Zero") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK2R w KQkq - 0 17"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_H1); + Move m = Move::make(Square::SQ_E1, Square::SQ_H1); CHECK(uci::parseSan(b, "0-0") == m); } @@ -123,7 +123,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test King Castling Long move with Zero") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_A1); + Move m = Move::make(Square::SQ_E1, Square::SQ_A1); CHECK(uci::parseSan(b, "0-0-0") == m); } @@ -131,7 +131,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test King Castling Short move with Annotation") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQK2R w KQkq - 0 17"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_H1); + Move m = Move::make(Square::SQ_E1, Square::SQ_H1); CHECK(uci::parseSan(b, "0-0+?!") == m); } @@ -139,7 +139,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test King Castling Long move with Annotation") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_A1); + Move m = Move::make(Square::SQ_E1, Square::SQ_A1); CHECK(uci::parseSan(b, "0-0-0+?!") == m); } @@ -147,7 +147,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Queen Capture Ambiguity") { auto b = Board{"3k4/8/4b3/8/2Q3Q1/8/8/3K4 w - - 0 1"}; - Move m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_E6); + Move m = Move::make(Square::SQ_C4, Square::SQ_E6); CHECK(uci::moveToSan(b, m) == "Qcxe6"); CHECK(uci::parseSan(b, "Qcxe6") == m); @@ -156,7 +156,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Rook Ambiguity") { auto b = Board{"3k4/8/8/R7/8/8/8/R3K3 w - - 0 1"}; - Move m = Move::make(Square::underlying::SQ_A1, Square::underlying::SQ_A3); + Move m = Move::make(Square::SQ_A1, Square::SQ_A3); CHECK(uci::moveToSan(b, m) == "R1a3"); CHECK(uci::parseSan(b, "R1a3") == m); @@ -165,7 +165,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Rook Capture Ambiguity") { auto b = Board{"2r3k1/4nn2/pq1p1pp1/3Pp3/1pN1P1P1/1P1Q4/P1r1NP2/1K1R3R b - - 2 19"}; - Move m = Move::make(Square::underlying::SQ_C8, Square::underlying::SQ_C4); + Move m = Move::make(Square::SQ_C8, Square::SQ_C4); CHECK(uci::moveToSan(b, m) == "R8xc4"); CHECK(uci::parseSan(b, "R8xc4") == m); @@ -174,7 +174,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Knight Capture Ambiguity") { auto b = Board{"r5k1/5p2/2n2B1p/4P3/p1n3PN/8/P4PK1/1R6 b - - 2 28"}; - Move m = Move::make(Square::underlying::SQ_C6, Square::underlying::SQ_E5); + Move m = Move::make(Square::SQ_C6, Square::SQ_E5); CHECK(uci::moveToSan(b, m) == "N6xe5"); CHECK(uci::parseSan(b, "N6xe5") == m); @@ -183,7 +183,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Pawn Capture Promotion Ambiguity") { auto b = Board{"2k2n2/4P1P1/8/8/8/8/8/2K5 w - - 0 1"}; - Move m = Move::make(Square::underlying::SQ_E7, Square::underlying::SQ_F8, PieceType::QUEEN); + Move m = Move::make(Square::SQ_E7, Square::SQ_F8, PieceType::QUEEN); CHECK(uci::moveToSan(b, m) == "exf8=Q+"); CHECK(uci::parseSan(b, "exf8=Q+") == m); @@ -192,7 +192,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Pawn Push") { auto b = Board{"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"}; - Move m = Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_E4); + Move m = Move::make(Square::SQ_E2, Square::SQ_E4); CHECK(uci::moveToSan(b, m) == "e4"); CHECK(uci::parseSan(b, "e4") == m); @@ -201,7 +201,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Pawn Promotion") { auto b = Board{"8/Pk6/8/5p2/8/8/8/2K5 w - - 1 781"}; - Move m = Move::make(Square::underlying::SQ_A7, Square::underlying::SQ_A8, PieceType::QUEEN); + Move m = Move::make(Square::SQ_A7, Square::SQ_A8, PieceType::QUEEN); CHECK(uci::moveToSan(b, m) == "a8=Q+"); CHECK(uci::parseSan(b, "a8=Q+") == m); @@ -210,7 +210,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Knight Ambiguity") { auto b = Board{"8/8/5K2/2N3P1/3N3n/4k3/3N4/7r w - - 59 97"}; - Move m = Move::make(Square::underlying::SQ_D4, Square::underlying::SQ_B3); + Move m = Move::make(Square::SQ_D4, Square::SQ_B3); CHECK(uci::moveToSan(b, m) == "N4b3"); CHECK(uci::parseSan(b, "N4b3") == m); @@ -219,7 +219,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Knight Capture Ambiguity") { auto b = Board{"8/8/5K2/2N3P1/3N3n/1b2k3/3N4/7r w - - 59 97"}; - Move m = Move::make(Square::underlying::SQ_D4, Square::underlying::SQ_B3); + Move m = Move::make(Square::SQ_D4, Square::SQ_B3); CHECK(uci::moveToSan(b, m) == "N4xb3"); CHECK(uci::parseSan(b, "N4xb3") == m); @@ -229,28 +229,28 @@ TEST_SUITE("SAN Parser") { auto b = Board{"2N1N3/p7/6k1/1p6/2N1N3/2R5/R3Q1P1/2R3K1 w - - 5 55"}; { - Move m = Move::make(Square::underlying::SQ_E4, Square::underlying::SQ_D6); + Move m = Move::make(Square::SQ_E4, Square::SQ_D6); CHECK(uci::moveToSan(b, m) == "Ne4d6"); CHECK(uci::parseSan(b, "Ne4d6") == m); } { - Move m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_D6); + Move m = Move::make(Square::SQ_C4, Square::SQ_D6); CHECK(uci::moveToSan(b, m) == "Nc4d6"); CHECK(uci::parseSan(b, "Nc4d6") == m); } { - Move m = Move::make(Square::underlying::SQ_C8, Square::underlying::SQ_D6); + Move m = Move::make(Square::SQ_C8, Square::SQ_D6); CHECK(uci::moveToSan(b, m) == "Nc8d6"); CHECK(uci::parseSan(b, "Nc8d6") == m); } { - Move m = Move::make(Square::underlying::SQ_E8, Square::underlying::SQ_D6); + Move m = Move::make(Square::SQ_E8, Square::SQ_D6); CHECK(uci::moveToSan(b, m) == "Ne8d6"); CHECK(uci::parseSan(b, "Ne8d6") == m); @@ -261,7 +261,7 @@ TEST_SUITE("SAN Parser") { auto b = Board{"2N1N3/p4k2/3q4/1p6/2N1N3/2R5/R3Q1P1/2R3K1 w - - 0 1"}; { - Move m = Move::make(Square::underlying::SQ_E4, Square::underlying::SQ_D6); + Move m = Move::make(Square::SQ_E4, Square::SQ_D6); CHECK(uci::moveToSan(b, m) == "Ne4xd6+"); CHECK(uci::parseSan(b, "Ne4xd6+") == m); @@ -272,28 +272,28 @@ TEST_SUITE("SAN Parser") { auto b = Board{"4k3/8/8/8/2B1B3/8/2B1BK2/8 w - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_C2, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_C2, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Bc2d3"); CHECK(uci::parseSan(b, "Bc2d3") == m); } { - auto m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_C4, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Bc4d3"); CHECK(uci::parseSan(b, "Bc4d3") == m); } { - auto m = Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_E2, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Be2d3"); CHECK(uci::parseSan(b, "Be2d3") == m); } { - auto m = Move::make(Square::underlying::SQ_E4, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_E4, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Be4d3"); CHECK(uci::parseSan(b, "Be4d3") == m); @@ -304,28 +304,28 @@ TEST_SUITE("SAN Parser") { auto b = Board{"k5r1/8/8/8/2R1R3/8/2R1RK2/8 w - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_C2, Square::underlying::SQ_C3); + auto m = Move::make(Square::SQ_C2, Square::SQ_C3); CHECK(uci::moveToSan(b, m) == "R2c3"); CHECK(uci::parseSan(b, "R2c3") == m); } { - auto m = Move::make(Square::underlying::SQ_C2, Square::underlying::SQ_D2); + auto m = Move::make(Square::SQ_C2, Square::SQ_D2); CHECK(uci::moveToSan(b, m) == "Rcd2"); CHECK(uci::parseSan(b, "Rcd2") == m); } { - auto m = Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_E3); + auto m = Move::make(Square::SQ_E2, Square::SQ_E3); CHECK(uci::moveToSan(b, m) == "R2e3"); CHECK(uci::parseSan(b, "R2e3") == m); } { - auto m = Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_D2); + auto m = Move::make(Square::SQ_E2, Square::SQ_D2); CHECK(uci::moveToSan(b, m) == "Red2"); CHECK(uci::parseSan(b, "Red2") == m); @@ -336,28 +336,28 @@ TEST_SUITE("SAN Parser") { auto b = Board{"1k4r1/8/8/8/2Q1Q3/8/2Q1QK2/8 w - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_C2, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_C2, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Qc2d3"); CHECK(uci::parseSan(b, "Qc2d3") == m); } { - auto m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_C4, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Qc4d3"); CHECK(uci::parseSan(b, "Qc4d3") == m); } { - auto m = Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_E2, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Qe2d3"); CHECK(uci::parseSan(b, "Qe2d3") == m); } { - auto m = Move::make(Square::underlying::SQ_E4, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_E4, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Qe4d3"); CHECK(uci::parseSan(b, "Qe4d3") == m); @@ -368,7 +368,7 @@ TEST_SUITE("SAN Parser") { auto b = Board{"5q1k/4P3/7q/1Q1pQ3/3P4/1KN5/8/5q2 b - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_F8, Square::underlying::SQ_F6); + auto m = Move::make(Square::SQ_F8, Square::SQ_F6); CHECK(uci::moveToSan(b, m) == "Q8f6"); CHECK(uci::parseSan(b, "Q8f6") == m); @@ -379,7 +379,7 @@ TEST_SUITE("SAN Parser") { auto b = Board{"5q1k/4P3/7q/1Q1pQ3/3P3q/1KN5/8/5q2 b - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_H4, Square::underlying::SQ_F6); + auto m = Move::make(Square::SQ_H4, Square::SQ_F6); CHECK(uci::moveToSan(b, m) == "Q4f6"); CHECK(uci::parseSan(b, "Q4f6") == m); @@ -390,14 +390,14 @@ TEST_SUITE("SAN Parser") { auto b = Board{"5q1k/4P3/7q/1Q1pQ3/3P1q1q/1KN5/8/5q2 b - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_H4, Square::underlying::SQ_F6); + auto m = Move::make(Square::SQ_H4, Square::SQ_F6); CHECK(uci::moveToSan(b, m) == "Qh4f6"); CHECK(uci::parseSan(b, "Qh4f6") == m); } { - auto m = Move::make(Square::underlying::SQ_F4, Square::underlying::SQ_F6); + auto m = Move::make(Square::SQ_F4, Square::SQ_F6); CHECK(uci::moveToSan(b, m) == "Qf4f6"); CHECK(uci::parseSan(b, "Qf4f6") == m); @@ -408,14 +408,14 @@ TEST_SUITE("SAN Parser") { auto b = Board{"1r5k/5Rp1/5p1p/4Nb1P/2B5/2P1R1P1/3r1PK1/1r6 b - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_B1, Square::underlying::SQ_B2); + auto m = Move::make(Square::SQ_B1, Square::SQ_B2); CHECK(uci::moveToSan(b, m) == "R1b2"); CHECK(uci::parseSan(b, "R1b2") == m); } { - auto m = Move::make(Square::underlying::SQ_D2, Square::underlying::SQ_B2); + auto m = Move::make(Square::SQ_D2, Square::SQ_B2); CHECK(uci::moveToSan(b, m) == "Rdb2"); CHECK(uci::parseSan(b, "Rdb2") == m); @@ -426,14 +426,14 @@ TEST_SUITE("SAN Parser") { auto b = Board{"1r5k/5Rp1/5p1p/1r2Nb1P/2B5/2P1R1P1/3r1PK1/8 b - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_B5, Square::underlying::SQ_B2); + auto m = Move::make(Square::SQ_B5, Square::SQ_B2); CHECK(uci::moveToSan(b, m) == "Rbb2"); CHECK(uci::parseSan(b, "Rbb2") == m); } { - auto m = Move::make(Square::underlying::SQ_B5, Square::underlying::SQ_B6); + auto m = Move::make(Square::SQ_B5, Square::SQ_B6); CHECK(uci::moveToSan(b, m) == "R5b6"); CHECK(uci::parseSan(b, "R5b6") == m); @@ -444,14 +444,14 @@ TEST_SUITE("SAN Parser") { auto b = Board{"1r5k/5Rp1/5p1p/1r2Nb1P/2B5/2P1R1P1/5PK1/8 b - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_B5, Square::underlying::SQ_B2); + auto m = Move::make(Square::SQ_B5, Square::SQ_B2); CHECK(uci::moveToSan(b, m) == "Rb2"); CHECK(uci::parseSan(b, "Rb2") == m); } { - auto m = Move::make(Square::underlying::SQ_B5, Square::underlying::SQ_B6); + auto m = Move::make(Square::SQ_B5, Square::SQ_B6); CHECK(uci::moveToSan(b, m) == "R5b6"); CHECK(uci::parseSan(b, "R5b6") == m); @@ -462,14 +462,14 @@ TEST_SUITE("SAN Parser") { auto b = Board{"2Bqkb1r/4p2p/8/8/2B5/p7/4B3/RNBQKBNR w KQk - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_A6); + auto m = Move::make(Square::SQ_C4, Square::SQ_A6); CHECK(uci::moveToSan(b, m) == "B4a6"); CHECK(uci::parseSan(b, "B4a6") == m); } { - auto m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_C4, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Bcd3"); CHECK(uci::parseSan(b, "Bcd3") == m); @@ -480,14 +480,14 @@ TEST_SUITE("SAN Parser") { auto b = Board{"3qkb1r/4p2p/8/8/2B5/p7/4B3/RNBQKBNR w KQk - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_A6); + auto m = Move::make(Square::SQ_C4, Square::SQ_A6); CHECK(uci::moveToSan(b, m) == "Ba6"); CHECK(uci::parseSan(b, "Ba6") == m); } { - auto m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_C4, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Bcd3"); CHECK(uci::parseSan(b, "Bcd3") == m); @@ -498,7 +498,7 @@ TEST_SUITE("SAN Parser") { auto b = Board{"7r/4pqbp/5bkp/6nn/2B5/p2r4/4B3/RNBQKBR1 w Q - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_C4, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Bcxd3#"); CHECK(uci::parseSan(b, "Bcxd3#") == m); @@ -509,14 +509,14 @@ TEST_SUITE("SAN Parser") { auto b = Board{"1Q3q1k/4P3/8/3p1N1q/1Q1P4/2N5/2K5/5q2 b - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_F1, Square::underlying::SQ_F5); + auto m = Move::make(Square::SQ_F1, Square::SQ_F5); CHECK(uci::moveToSan(b, m) == "Qfxf5+"); CHECK(uci::parseSan(b, "Qfxf5+") == m); } { - auto m = Move::make(Square::underlying::SQ_H5, Square::underlying::SQ_F5); + auto m = Move::make(Square::SQ_H5, Square::SQ_F5); CHECK(uci::moveToSan(b, m) == "Qhxf5+"); CHECK(uci::parseSan(b, "Qhxf5+") == m); @@ -527,14 +527,14 @@ TEST_SUITE("SAN Parser") { auto b = Board{"1r6/5Rp1/5p1p/1r2Nb1P/2B5/2PR2P1/3r1PK1/3k4 b - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_B5, Square::underlying::SQ_B2); + auto m = Move::make(Square::SQ_B5, Square::SQ_B2); CHECK(uci::moveToSan(b, m) == "Rb2"); CHECK(uci::parseSan(b, "Rb2") == m); } { - auto m = Move::make(Square::underlying::SQ_B5, Square::underlying::SQ_B6); + auto m = Move::make(Square::SQ_B5, Square::SQ_B6); CHECK(uci::moveToSan(b, m) == "R5b6"); CHECK(uci::parseSan(b, "R5b6") == m); @@ -545,7 +545,7 @@ TEST_SUITE("SAN Parser") { auto b = Board{"2r4r/4pqbp/5bkp/6nn/2B5/p2r4/2K1B3/RNBQ1BR1 w - - 0 1"}; { - auto m = Move::make(Square::underlying::SQ_E2, Square::underlying::SQ_D3); + auto m = Move::make(Square::SQ_E2, Square::SQ_D3); CHECK(uci::moveToSan(b, m) == "Bxd3#"); CHECK(uci::parseSan(b, "Bxd3#") == m); @@ -555,7 +555,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Test Pinned Knight Ambiguity") { auto b = Board{"r1k5/5p2/2n2B1p/2R1P3/p1n3PN/8/P4PK1/1R6 b - - 0 1"}; - Move m = Move::make(Square::underlying::SQ_C4, Square::underlying::SQ_E5); + Move m = Move::make(Square::SQ_C4, Square::SQ_E5); CHECK(uci::moveToSan(b, m) == "Nxe5"); CHECK(uci::parseSan(b, "Nxe5") == m); @@ -591,7 +591,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Checkmate castle should have #") { auto b = Board{"RRR5/8/8/8/8/8/PPPPPP2/k3K2R w K - 0 1"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_H1); + Move m = Move::make(Square::SQ_E1, Square::SQ_H1); CHECK(uci::moveToSan(b, m) == "O-O#"); CHECK(uci::parseSan(b, "O-O#") == m); @@ -600,7 +600,7 @@ TEST_SUITE("SAN Parser") { TEST_CASE("Check castle should have +") { auto b = Board{"8/8/8/8/8/8/PPPPPP2/k3K2R w K - 0 1"}; - Move m = Move::make(Square::underlying::SQ_E1, Square::underlying::SQ_H1); + Move m = Move::make(Square::SQ_E1, Square::SQ_H1); CHECK(uci::moveToSan(b, m) == "O-O+"); CHECK(uci::parseSan(b, "O-O+") == m); diff --git a/tests/uci.cpp b/tests/uci.cpp index 42f68cc..ddc25b5 100644 --- a/tests/uci.cpp +++ b/tests/uci.cpp @@ -10,7 +10,7 @@ TEST_SUITE("UCI Move Conversion") { std::string uci = "f6e5"; - CHECK(uci::uciToMove(b, uci) == Move::make(Square::underlying::SQ_F6, Square::underlying::SQ_E5)); + CHECK(uci::uciToMove(b, uci) == Move::make(Square::SQ_F6, Square::SQ_E5)); } TEST_CASE("Test ambiguous pawn ep capture") { @@ -19,8 +19,7 @@ TEST_SUITE("UCI Move Conversion") { std::string uci = "f5g6"; - CHECK(uci::uciToMove(b, uci) == - Move::make(Square::underlying::SQ_F5, Square::underlying::SQ_G6)); + CHECK(uci::uciToMove(b, uci) == Move::make(Square::SQ_F5, Square::SQ_G6)); } TEST_CASE("Test ambiguous knight move") { @@ -29,7 +28,7 @@ TEST_SUITE("UCI Move Conversion") { std::string uci = "f3g5"; - CHECK(uci::uciToMove(b, uci) == Move::make(Square::underlying::SQ_F3, Square::underlying::SQ_G5)); + CHECK(uci::uciToMove(b, uci) == Move::make(Square::SQ_F3, Square::SQ_G5)); } TEST_CASE("Test ambiguous rook move with check") { @@ -47,7 +46,7 @@ TEST_SUITE("UCI Move Conversion") { std::string uci = "d1h1"; - CHECK(uci::uciToMove(b, uci) == Move::make(Square::underlying::SQ_D1, Square::underlying::SQ_H1)); + CHECK(uci::uciToMove(b, uci) == Move::make(Square::SQ_D1, Square::SQ_H1)); } TEST_CASE("Test Knight move") { @@ -56,7 +55,7 @@ TEST_SUITE("UCI Move Conversion") { std::string uci = "f3g5"; - CHECK(uci::uciToMove(b, uci) == Move::make(Square::underlying::SQ_F3, Square::underlying::SQ_G5)); + CHECK(uci::uciToMove(b, uci) == Move::make(Square::SQ_F3, Square::SQ_G5)); } TEST_CASE("Test illegal pawn promotion") { From 813d297e75bc5e0aa41a5d556462a280f790f5f6 Mon Sep 17 00:00:00 2001 From: Disservin Date: Sat, 22 Feb 2025 16:27:52 +0100 Subject: [PATCH 3/3] update lib --- include/chess.hpp | 45 ++++++++++++++++++++++----------------------- 1 file changed, 22 insertions(+), 23 deletions(-) diff --git a/include/chess.hpp b/include/chess.hpp index 645abd8..d9c6d64 100644 --- a/include/chess.hpp +++ b/include/chess.hpp @@ -498,7 +498,7 @@ class Square { * @return */ [[nodiscard]] static constexpr Square castling_king_square(bool is_king_side, Color c) noexcept { - return Square(is_king_side ? Square::underlying::SQ_G1 : Square::underlying::SQ_C1).relative_square(c); + return Square(is_king_side ? Square::SQ_G1 : Square::SQ_C1).relative_square(c); } /** @@ -508,7 +508,7 @@ class Square { * @return */ [[nodiscard]] static constexpr Square castling_rook_square(bool is_king_side, Color c) noexcept { - return Square(is_king_side ? Square::underlying::SQ_F1 : Square::underlying::SQ_D1).relative_square(c); + return Square(is_king_side ? Square::SQ_F1 : Square::SQ_D1).relative_square(c); } /** @@ -1975,7 +1975,7 @@ class Board { // Append information about the en passant square (if any) // and the half-move clock and full move number to the FEN string - if (ep_sq_ == Square::underlying::NO_SQ) + if (ep_sq_ == Square::NO_SQ) ss += " -"; else { ss += ' '; @@ -2028,8 +2028,8 @@ class Board { hfm_++; plies_++; - if (ep_sq_ != Square::underlying::NO_SQ) key_ ^= Zobrist::enpassant(ep_sq_.file()); - ep_sq_ = Square::underlying::NO_SQ; + if (ep_sq_ != Square::NO_SQ) key_ ^= Zobrist::enpassant(ep_sq_.file()); + ep_sq_ = Square::NO_SQ; if (capture) { removePiece(captured, move.to()); @@ -2251,8 +2251,8 @@ class Board { prev_states_.emplace_back(key_, cr_, ep_sq_, hfm_, Piece::NONE); key_ ^= Zobrist::sideToMove(); - if (ep_sq_ != Square::underlying::NO_SQ) key_ ^= Zobrist::enpassant(ep_sq_.file()); - ep_sq_ = Square::underlying::NO_SQ; + if (ep_sq_ != Square::NO_SQ) key_ ^= Zobrist::enpassant(ep_sq_.file()); + ep_sq_ = Square::NO_SQ; stm_ = ~stm_; @@ -2573,7 +2573,7 @@ class Board { } U64 ep_hash = 0ULL; - if (ep_sq_ != Square::underlying::NO_SQ) ep_hash ^= Zobrist::enpassant(ep_sq_.file()); + if (ep_sq_ != Square::NO_SQ) ep_hash ^= Zobrist::enpassant(ep_sq_.file()); U64 stm_hash = 0ULL; if (stm_ == Color::WHITE) stm_hash ^= Zobrist::sideToMove(); @@ -2684,7 +2684,7 @@ class Board { const auto castling = params[2].has_value() ? *params[2] : "-"; const auto en_passant = params[3].has_value() ? *params[3] : "-"; - const auto ep = en_passant == "-" ? Square::underlying::NO_SQ : Square(en_passant); + const auto ep = en_passant == "-" ? Square::NO_SQ : Square(en_passant); const auto stm = (move_right == "w") ? Color::WHITE : Color::BLACK; CastlingRights cr; @@ -2853,7 +2853,7 @@ class Board { // 14 => any black rook with castling rights, side will be deduced from the file // 15 => black king and black is side to move static std::uint8_t convertMeaning(const CastlingRights &cr, Color stm, Square ep, Square sq, Piece piece) { - if (piece.type() == PieceType::PAWN && ep != Square::underlying::NO_SQ) { + if (piece.type() == PieceType::PAWN && ep != Square::NO_SQ) { if (Square(static_cast(sq.index()) ^ 8) == ep) return 12; } @@ -2891,7 +2891,7 @@ class Board { CastlingRights cr_ = {}; uint16_t plies_ = 0; Color stm_ = Color::WHITE; - Square ep_sq_ = Square::underlying::NO_SQ; + Square ep_sq_ = Square::NO_SQ; uint8_t hfm_ = 0; bool chess960_ = false; @@ -2972,7 +2972,7 @@ class Board { plies_ = parseStringViewToInt(full_move).value_or(1); plies_ = plies_ * 2 - 2; - ep_sq_ = en_passant == "-" ? Square::underlying::NO_SQ : Square(en_passant); + ep_sq_ = en_passant == "-" ? Square::NO_SQ : Square(en_passant); stm_ = (move_right == "w") ? Color::WHITE : Color::BLACK; key_ = 0ULL; cr_.clear(); @@ -3008,8 +3008,7 @@ class Board { static const auto find_rook = [](const Board &board, CastlingRights::Side side, Color color) { const auto king_side = CastlingRights::Side::KING_SIDE; const auto king_sq = board.kingSq(color); - const auto sq_corner = Square(side == king_side ? Square::underlying::SQ_H1 : Square::underlying::SQ_A1) - .relative_square(color); + const auto sq_corner = Square(side == king_side ? Square::SQ_H1 : Square::SQ_A1).relative_square(color); const auto start = side == king_side ? king_sq + 1 : king_sq - 1; @@ -3064,13 +3063,13 @@ class Board { } // check if ep square itself is valid - if (ep_sq_ != Square::underlying::NO_SQ && !((ep_sq_.rank() == Rank::RANK_3 && stm_ == Color::BLACK) || - (ep_sq_.rank() == Rank::RANK_6 && stm_ == Color::WHITE))) { - ep_sq_ = Square::underlying::NO_SQ; + if (ep_sq_ != Square::NO_SQ && !((ep_sq_.rank() == Rank::RANK_3 && stm_ == Color::BLACK) || + (ep_sq_.rank() == Rank::RANK_6 && stm_ == Color::WHITE))) { + ep_sq_ = Square::NO_SQ; } // check if ep square is valid, i.e. if there is a pawn that can capture it - if (ep_sq_ != Square::underlying::NO_SQ) { + if (ep_sq_ != Square::NO_SQ) { bool valid; if (stm_ == Color::WHITE) { @@ -3080,7 +3079,7 @@ class Board { } if (!valid) - ep_sq_ = Square::underlying::NO_SQ; + ep_sq_ = Square::NO_SQ; else key_ ^= Zobrist::enpassant(ep_sq_.file()); } @@ -3585,7 +3584,7 @@ inline void movegen::generatePawnMoves(const Board &board, Movelist &moves, Bitb const Square ep = board.enpassantSq(); - if (ep != Square::underlying::NO_SQ) { + if (ep != Square::NO_SQ) { auto m = generateEPMove(board, checkmask, pin_d, pawns_lr, ep, c); for (const auto &move : m) { @@ -4765,7 +4764,7 @@ class uci { } } // Handle moves with specific from square - else if (info.from != Square::underlying::NO_SQ) { + else if (info.from != Square::NO_SQ) { if (move.from() != info.from) { continue; } @@ -4805,9 +4804,9 @@ class uci { PieceType promotion = PieceType::NONE; - Square from = Square::underlying::NO_SQ; + Square from = Square::NO_SQ; // a valid move always has a to square - Square to = Square::underlying::NO_SQ; + Square to = Square::NO_SQ; // a valid move always has a piece PieceType piece = PieceType::NONE;