commit b9f9ac98b25274ffa436386189298cc72c885dc2
parent e861582a1bd04c63bd30253a0fbfc8c97f15162e
Author: Dimitrije Dobrota <mail@dimitrijedobrota.com>
Date: Fri, 11 Aug 2023 15:10:42 +0200
Merge branch 'constexpr' into cpp
Diffstat:
30 files changed, 640 insertions(+), 731 deletions(-)
diff --git a/.clang-format b/.clang-format
@@ -36,7 +36,7 @@ AllowAllParametersOfDeclarationOnNextLine: true
AllowShortEnumsOnASingleLine: false
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: false
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: false
@@ -77,7 +77,7 @@ BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
-ColumnLimit: 80
+ColumnLimit: 110
CommentPragmas: '^ IWYU pragma:'
QualifierAlignment: Leave
CompactNamespaces: false
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -3,7 +3,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
project(
Stellar
- VERSION 0.0.18
+ VERSION 0.0.19
DESCRIPTION "Chess engine written in C"
HOMEPAGE_URL https://git.dimitrijedobrota.com/stellar.git
LANGUAGES C CXX
@@ -13,4 +13,10 @@ set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fconstexpr-ops-limit=1000000000")
+
add_subdirectory(src)
diff --git a/src/attacks/CMakeLists.txt b/src/attacks/CMakeLists.txt
@@ -1,35 +0,0 @@
-add_library(attacks OBJECT
- attacks.cpp
- internal.cpp
- magic.cpp
-)
-
-target_include_directories(attacks
- PUBLIC "${PROJECT_SOURCE_DIR}/src/include"
- PRIVATE "internal"
-)
-
-
-project(
- MagicGenerator
- VERSION 1.0.0
- DESCRIPTION "Generator of magic numbers for bishup and rook attacks"
- LANGUAGES CXX
-)
-
-
-add_executable(magic
- internal.cpp
- magic.cpp
- magic_generate.cpp
-)
-
-target_link_libraries(magic
- PRIVATE random
-)
-
-set_target_properties(magic PROPERTIES
- VERSION ${PROJECT_VERSION}
- SOVERSION ${PROJECT_VERSION_MAJOR}
- RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
-)
diff --git a/src/attacks/attacks.cpp b/src/attacks/attacks.cpp
@@ -1,99 +0,0 @@
-#include "attacks.hpp"
-#include "internal.hpp"
-#include "magic.hpp"
-#include "utils_cpp.hpp"
-
-#define UNUSED(x) (void)(x)
-
-U64 attacks_wpawn_get(Square square, U64 occupancy) {
- UNUSED(occupancy);
- return pawn_attacks[to_underlying(Color::WHITE)][to_underlying(square)];
-}
-
-U64 attacks_bpawn_get(Square square, U64 occupancy) {
- UNUSED(occupancy);
- return pawn_attacks[to_underlying(Color::BLACK)][to_underlying(square)];
-}
-
-U64 attacks_knight_get(Square square, U64 occupancy) {
- UNUSED(occupancy);
- return knight_attacks[to_underlying(square)];
-}
-
-U64 attacks_king_get(Square square, U64 occupancy) {
- UNUSED(occupancy);
- return king_attacks[to_underlying(square)];
-}
-
-U64 attacks_bishop_get(Square square, U64 occupancy) {
- int square_i = to_underlying(square);
- occupancy &= bishop_masks[square_i];
- occupancy = hash(occupancy, bishop_magic_numbers[square_i],
- bishop_relevant_bits[square_i]);
- return bishop_attacks[square_i][occupancy];
-}
-
-U64 attacks_rook_get(Square square, U64 occupancy) {
- int square_i = to_underlying(square);
- occupancy &= rook_masks[square_i];
- occupancy = hash(occupancy, rook_magic_numbers[square_i],
- rook_relevant_bits[square_i]);
- return rook_attacks[square_i][occupancy];
-}
-
-U64 attacks_queen_get(Square square, U64 occupancy) {
- return (attacks_bishop_get(square, occupancy) |
- attacks_rook_get(square, occupancy));
-}
-
-void attacks_init_leapers(void) {
- for (Square square : SquareIter()) {
- uint8_t square_i = to_underlying(square);
- pawn_attacks[to_underlying(Color::WHITE)][square_i] =
- pawn_mask(Color::WHITE, square);
- pawn_attacks[to_underlying(Color::BLACK)][square_i] =
- pawn_mask(Color::BLACK, square);
- knight_attacks[square_i] = knight_mask(square);
- king_attacks[square_i] = king_mask(square);
- }
-}
-
-void attacks_init_sliders(int bishop) {
- for (Square square : SquareIter()) {
- uint8_t square_i = to_underlying(square);
- U64 attack_mask;
-
- if (bishop) {
- bishop_masks[square_i] = bishop_mask(square);
- attack_mask = bishop_masks[square_i];
- } else {
- rook_masks[square_i] = rook_mask(square);
- attack_mask = rook_masks[square_i];
- }
-
- int relevant_bits = bit_count(attack_mask);
- int occupancy_indicies = 1 << relevant_bits;
-
- for (int index = 0; index < occupancy_indicies; index++) {
- U64 occupancy = set_occupancy(index, relevant_bits, attack_mask);
- if (bishop) {
- int magic_index =
- (occupancy * bishop_magic_numbers[square_i]) >>
- (64 - bishop_relevant_bits[square_i]);
- bishop_attacks[square_i][magic_index] =
- bishop_on_the_fly(square, occupancy);
- } else {
- int magic_index = hash(occupancy, rook_magic_numbers[square_i],
- rook_relevant_bits[square_i]);
- rook_attacks[square_i][magic_index] =
- rook_on_the_fly(square, occupancy);
- }
- }
- }
-}
-
-void attacks_init(void) {
- attacks_init_leapers();
- attacks_init_sliders(0);
- attacks_init_sliders(1);
-}
diff --git a/src/attacks/internal.cpp b/src/attacks/internal.cpp
@@ -1,148 +0,0 @@
-#include "internal.hpp"
-#include "utils_cpp.hpp"
-
-#include <algorithm> // std::min
-
-U64 king_attacks[64];
-U64 knight_attacks[64];
-U64 pawn_attacks[2][64];
-U64 rook_attacks[64][4096]; // 2048K
-U64 bishop_attacks[64][512]; // 256 K
-
-U64 rook_masks[64];
-U64 bishop_masks[64];
-
-// clang-format off
-const int bishop_relevant_bits[64] = {
- 6, 5, 5, 5, 5, 5, 5, 6,
- 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 7, 7, 7, 7, 5, 5,
- 5, 5, 7, 9, 9, 7, 5, 5,
- 5, 5, 7, 9, 9, 7, 5, 5,
- 5, 5, 7, 7, 7, 7, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5,
- 6, 5, 5, 5, 5, 5, 5, 6,
-};
-
-const int rook_relevant_bits[64] = {
- 12, 11, 11, 11, 11, 11, 11, 12,
- 11, 10, 10, 10, 10, 10, 10, 11,
- 11, 10, 10, 10, 10, 10, 10, 11,
- 11, 10, 10, 10, 10, 10, 10, 11,
- 11, 10, 10, 10, 10, 10, 10, 11,
- 11, 10, 10, 10, 10, 10, 10, 11,
- 11, 10, 10, 10, 10, 10, 10, 11,
- 12, 11, 11, 11, 11, 11, 11, 12,
-};
-// clang-format on
-
-int hash(U64 key, U64 magic, int relevant_bits) {
- return (key * magic) >> (64 - relevant_bits);
-}
-
-U64 set_occupancy(int index, int bits_in_mask, U64 attack_mask) {
- U64 occupancy = C64(0);
-
- for (int count = 0; count < bits_in_mask; count++) {
- uint8_t square = bit_lsb_index(attack_mask);
- bit_pop(attack_mask, square);
-
- if (index & (1 << count)) bit_set(occupancy, square);
- }
-
- return occupancy;
-}
-
-U64 attacks_slide_mask(Square square, U64 block, const direction_f dir[4],
- int len[4]) {
- U64 bitboard = C64(0), attacks = C64(0), tmp;
- int i, j;
-
- bit_set(bitboard, to_underlying(square));
- for (i = 0; i < 4; i++) {
- for (j = 0, tmp = bitboard; j < len[i]; j++) {
- attacks |= tmp = (dir[i])(tmp);
- if (tmp & block) break;
- }
- }
- return attacks;
-}
-
-// Mask Attacks
-
-const direction_f attacks_bishop_direction[4] = {noEaOne, noWeOne, soEaOne,
- soWeOne};
-const direction_f attacks_rook_direction[4] = {westOne, soutOne, eastOne,
- nortOne};
-
-U64 pawn_mask(Color side, Square square) {
- U64 bitboard = C64(0);
-
- bit_set(bitboard, to_underlying(square));
- if (side == Color::WHITE)
- return noWeOne(bitboard) | noEaOne(bitboard);
- else
- return soWeOne(bitboard) | soEaOne(bitboard);
-}
-
-U64 knight_mask(Square square) {
- U64 bitboard = C64(0), attacks = C64(0), tmp;
-
- bit_set(bitboard, to_underlying(square));
- tmp = nortOne(nortOne(bitboard));
- attacks |= westOne(tmp) | eastOne(tmp);
- tmp = soutOne(soutOne(bitboard));
- attacks |= westOne(tmp) | eastOne(tmp);
- tmp = westOne(westOne(bitboard));
- attacks |= soutOne(tmp) | nortOne(tmp);
- tmp = eastOne(eastOne(bitboard));
- attacks |= soutOne(tmp) | nortOne(tmp);
-
- return attacks;
-}
-
-U64 king_mask(Square square) {
- U64 bitboard = C64(0), attacks = C64(0);
-
- bit_set(bitboard, to_underlying(square));
- attacks |= westOne(bitboard) | eastOne(bitboard);
- attacks |= soutOne(bitboard) | nortOne(bitboard);
- attacks |= soutOne(bitboard) | nortOne(bitboard);
- attacks |= soEaOne(bitboard) | noEaOne(bitboard);
- attacks |= soWeOne(bitboard) | noWeOne(bitboard);
-
- return attacks;
-}
-
-U64 bishop_mask(Square square) {
- uint8_t square_i = to_underlying(square);
- int tr = square_i / 8, tf = square_i % 8;
- int len[4] = {std::min(7 - tf, 7 - tr) - 1, std::min(tf, 7 - tr) - 1,
- std::min(7 - tf, tr) - 1, std::min(tf, tr) - 1};
- return attacks_slide_mask(square, C64(0), attacks_bishop_direction, len);
-}
-
-U64 rook_mask(Square square) {
- uint8_t square_i = to_underlying(square);
- int tr = square_i / 8, tf = square_i % 8;
- int len[4] = {tf - 1, tr - 1, 6 - tf, 6 - tr};
-
- return attacks_slide_mask(square, C64(0), attacks_rook_direction, len);
-}
-
-U64 bishop_on_the_fly(Square square, U64 block) {
- uint8_t square_i = to_underlying(square);
- int tr = square_i / 8, tf = square_i % 8;
- int len[4] = {std::min(7 - tf, 7 - tr), std::min(tf, 7 - tr),
- std::min(7 - tf, tr), std::min(tf, tr)};
-
- return attacks_slide_mask(square, block, attacks_bishop_direction, len);
-}
-
-U64 rook_on_the_fly(Square square, U64 block) {
- uint8_t square_i = to_underlying(square);
- int tr = square_i / 8, tf = square_i % 8;
- int len[4] = {tf, tr, 7 - tf, 7 - tr};
-
- return attacks_slide_mask(square, block, attacks_rook_direction, len);
-}
diff --git a/src/attacks/internal.hpp b/src/attacks/internal.hpp
@@ -1,30 +0,0 @@
-#ifndef STELLAR_ATTAKCS_INTERNAL_H
-#define STELLAR_ATTAKCS_INTERNAL_H
-
-#include "utils_cpp.hpp"
-
-extern U64 king_attacks[64]; // king attack table [square]
-extern U64 knight_attacks[64]; // knight attack table [square]
-extern U64 pawn_attacks[2][64]; // pawn attack table [side][square]
-extern U64 rook_attacks[64][4096]; // rook attack table [square][occupancies]
-extern U64 bishop_attacks[64][512]; // bishop attack table [square][occupancies]
-
-extern U64 rook_masks[64]; // rook attack mask
-extern U64 bishop_masks[64]; // bishop attack mask
-
-extern const int rook_relevant_bits[64];
-extern const int bishop_relevant_bits[64];
-
-int hash(U64 key, U64 magic, int relevant_bits);
-
-U64 set_occupancy(int index, int bits_in_mask, U64 attack_mask);
-
-U64 bishop_mask(Square square);
-U64 bishop_on_the_fly(Square square, U64 block);
-U64 king_mask(Square square);
-U64 knight_mask(Square square);
-U64 pawn_mask(Color side, Square square);
-U64 rook_mask(Square square);
-U64 rook_on_the_fly(Square square, U64 block);
-
-#endif
diff --git a/src/attacks/magic.cpp b/src/attacks/magic.cpp
@@ -1,51 +0,0 @@
-#include "magic.hpp"
-
-const U64 bishop_magic_numbers[64] = {
- C64(0x40040844404084), C64(0x2004208a004208), C64(0x10190041080202),
- C64(0x108060845042010), C64(0x581104180800210), C64(0x2112080446200010),
- C64(0x1080820820060210), C64(0x3c0808410220200), C64(0x4050404440404),
- C64(0x21001420088), C64(0x24d0080801082102), C64(0x1020a0a020400),
- C64(0x40308200402), C64(0x4011002100800), C64(0x401484104104005),
- C64(0x801010402020200), C64(0x400210c3880100), C64(0x404022024108200),
- C64(0x810018200204102), C64(0x4002801a02003), C64(0x85040820080400),
- C64(0x810102c808880400), C64(0xe900410884800), C64(0x8002020480840102),
- C64(0x220200865090201), C64(0x2010100a02021202), C64(0x152048408022401),
- C64(0x20080002081110), C64(0x4001001021004000), C64(0x800040400a011002),
- C64(0xe4004081011002), C64(0x1c004001012080), C64(0x8004200962a00220),
- C64(0x8422100208500202), C64(0x2000402200300c08), C64(0x8646020080080080),
- C64(0x80020a0200100808), C64(0x2010004880111000), C64(0x623000a080011400),
- C64(0x42008c0340209202), C64(0x209188240001000), C64(0x400408a884001800),
- C64(0x110400a6080400), C64(0x1840060a44020800), C64(0x90080104000041),
- C64(0x201011000808101), C64(0x1a2208080504f080), C64(0x8012020600211212),
- C64(0x500861011240000), C64(0x180806108200800), C64(0x4000020e01040044),
- C64(0x300000261044000a), C64(0x802241102020002), C64(0x20906061210001),
- C64(0x5a84841004010310), C64(0x4010801011c04), C64(0xa010109502200),
- C64(0x4a02012000), C64(0x500201010098b028), C64(0x8040002811040900),
- C64(0x28000010020204), C64(0x6000020202d0240), C64(0x8918844842082200),
- C64(0x4010011029020020),
-};
-
-const U64 rook_magic_numbers[64] = {
- C64(0x8a80104000800020), C64(0x140002000100040), C64(0x2801880a0017001),
- C64(0x100081001000420), C64(0x200020010080420), C64(0x3001c0002010008),
- C64(0x8480008002000100), C64(0x2080088004402900), C64(0x800098204000),
- C64(0x2024401000200040), C64(0x100802000801000), C64(0x120800800801000),
- C64(0x208808088000400), C64(0x2802200800400), C64(0x2200800100020080),
- C64(0x801000060821100), C64(0x80044006422000), C64(0x100808020004000),
- C64(0x12108a0010204200), C64(0x140848010000802), C64(0x481828014002800),
- C64(0x8094004002004100), C64(0x4010040010010802), C64(0x20008806104),
- C64(0x100400080208000), C64(0x2040002120081000), C64(0x21200680100081),
- C64(0x20100080080080), C64(0x2000a00200410), C64(0x20080800400),
- C64(0x80088400100102), C64(0x80004600042881), C64(0x4040008040800020),
- C64(0x440003000200801), C64(0x4200011004500), C64(0x188020010100100),
- C64(0x14800401802800), C64(0x2080040080800200), C64(0x124080204001001),
- C64(0x200046502000484), C64(0x480400080088020), C64(0x1000422010034000),
- C64(0x30200100110040), C64(0x100021010009), C64(0x2002080100110004),
- C64(0x202008004008002), C64(0x20020004010100), C64(0x2048440040820001),
- C64(0x101002200408200), C64(0x40802000401080), C64(0x4008142004410100),
- C64(0x2060820c0120200), C64(0x1001004080100), C64(0x20c020080040080),
- C64(0x2935610830022400), C64(0x44440041009200), C64(0x280001040802101),
- C64(0x2100190040002085), C64(0x80c0084100102001), C64(0x4024081001000421),
- C64(0x20030a0244872), C64(0x12001008414402), C64(0x2006104900a0804),
- C64(0x1004081002402),
-};
diff --git a/src/attacks/magic.hpp b/src/attacks/magic.hpp
@@ -1,9 +0,0 @@
-#ifndef STELLAR_ATTACKS_MAGIC_H
-#define STELLAR_ATTACKS_MAGIC_H
-
-#include "utils_cpp.hpp"
-
-extern const U64 bishop_magic_numbers[64];
-extern const U64 rook_magic_numbers[64];
-
-#endif
diff --git a/src/attacks/magic_generate.cpp b/src/attacks/magic_generate.cpp
@@ -1,69 +0,0 @@
-#include "internal.hpp"
-#include "random.hpp"
-#include "utils_cpp.hpp"
-
-#include <inttypes.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-const char *FORMAT = "C64(0x%llx),\n";
-
-U64 generate_magic_number() {
- return random_get_U64() & random_get_U64() & random_get_U64();
-}
-
-U64 find_magic_number(Square square, int relevant_bits, int bishop) {
- U64 occupancies[4096], attacks[4096], used_attacks[4096];
- U64 attack_mask = bishop ? bishop_mask(square) : rook_mask(square);
- int occupancy_indicies = 1 << relevant_bits;
-
- for (int index = 0; index < occupancy_indicies; index++) {
- occupancies[index] = set_occupancy(index, relevant_bits, attack_mask);
- attacks[index] = bishop ? bishop_on_the_fly(square, occupancies[index])
- : rook_on_the_fly(square, occupancies[index]);
- }
-
- for (int random_count = 0; random_count < 100000000; random_count++) {
- U64 magic_number = generate_magic_number();
- if (bit_count((attack_mask * magic_number) & C64(0xFF00000000000000)) <
- 6)
- continue;
-
- memset(used_attacks, C64(0), sizeof(used_attacks));
- int index, fail;
-
- for (index = 0, fail = 0; !fail && index < occupancy_indicies;
- index++) {
- int magic_index =
- hash(occupancies[index], magic_number, relevant_bits);
-
- if (used_attacks[magic_index] == C64(0))
- used_attacks[magic_index] = attacks[index];
- else if (used_attacks[magic_index] != attacks[index])
- fail = 1;
- }
-
- if (!fail) return magic_number;
- }
-
- return C64(0);
-}
-
-int main(void) {
- random_state_reset();
-
- printf("Bishup Magic Numbers:\n");
- for (Square square : SquareIter())
- printf(FORMAT,
- find_magic_number(
- square, bishop_relevant_bits[to_underlying(square)], 1));
-
- printf("Rook Magic Numbers:\n");
- for (Square square : SquareIter())
- printf(FORMAT,
- find_magic_number(square,
- rook_relevant_bits[to_underlying(square)], 0));
- return 0;
-}
diff --git a/src/board/board.cpp b/src/board/board.cpp
@@ -10,18 +10,25 @@
/* Getters */
-Color Board::get_side(void) const { return side; }
-U64 Board::get_hash(void) const { return hash; }
-uint8_t Board::get_castle(void) const { return castle; }
-Square Board::get_enpassant(void) const { return enpassant; }
+Color Board::get_side(void) const {
+ return side;
+}
+U64 Board::get_hash(void) const {
+ return hash;
+}
+uint8_t Board::get_castle(void) const {
+ return castle;
+}
+Square Board::get_enpassant(void) const {
+ return enpassant;
+}
U64 Board::get_bitboard_color(Color side) const {
return colors[to_underlying(side)];
}
U64 Board::get_bitboard_occupancy(void) const {
- return colors[to_underlying(Color::WHITE)] |
- colors[to_underlying(Color::BLACK)];
+ return colors[to_underlying(Color::WHITE)] | colors[to_underlying(Color::BLACK)];
}
U64 Board::get_bitboard_piece(piece::Type piece) const {
@@ -36,45 +43,43 @@ U64 Board::get_bitboard_piece(piece::Type piece, Color color) const {
return pieces[to_underlying(piece)] & colors[to_underlying(color)];
}
-U64 Board::get_bitboard_piece_attacks(piece::Type piece, Color color,
- Square square) const {
+U64 Board::get_bitboard_piece_attacks(piece::Type piece, Color color, Square square) const {
return get_bitboard_piece_attacks(piece::get(piece, color), square);
}
-U64 Board::get_bitboard_piece_attacks(const piece::Piece &piece,
- Square square) const {
- return piece.attacks(square, get_bitboard_occupancy());
+U64 Board::get_bitboard_piece_attacks(const piece::Piece &piece, Square square) const {
+ return piece(square, get_bitboard_occupancy());
}
Color Board::get_square_piece_color(Square square) const {
- if (bit_get(colors[to_underlying(Color::WHITE)], to_underlying(square)))
- return Color::WHITE;
- if (bit_get(colors[to_underlying(Color::BLACK)], to_underlying(square)))
- return Color::BLACK;
+ if (bit_get(colors[to_underlying(Color::WHITE)], to_underlying(square))) return Color::WHITE;
+ if (bit_get(colors[to_underlying(Color::BLACK)], to_underlying(square))) return Color::BLACK;
throw std::exception();
}
piece::Type Board::get_square_piece_type(Square square) const {
for (piece::Type type : piece::TypeIter()) {
- if (bit_get(pieces[to_underlying(type)], to_underlying(square)))
- return type;
+ if (bit_get(pieces[to_underlying(type)], to_underlying(square))) return type;
}
throw std::exception();
}
const piece::Piece *Board::get_square_piece(Square square) const {
try {
- return &piece::get(get_square_piece_type(square),
- get_square_piece_color(square));
- } catch (std::exception e) {
+ return &piece::get(get_square_piece_type(square), get_square_piece_color(square));
+ } catch (std::exception &e) {
return nullptr;
}
}
/* Setters */
-void Board::xor_hash(U64 op) { hash ^= op; }
-void Board::and_castle(uint8_t right) { castle &= right; }
+void Board::xor_hash(U64 op) {
+ hash ^= op;
+}
+void Board::and_castle(uint8_t right) {
+ castle &= right;
+}
void Board::switch_side(void) {
side = (side == Color::BLACK) ? Color::WHITE : Color::BLACK;
@@ -133,8 +138,7 @@ bool Board::is_square_attacked(Square square, Color side) const {
}
bool Board::is_check(void) const {
- U64 king =
- pieces[to_underlying(piece::Type::KING)] & colors[to_underlying(side)];
+ U64 king = pieces[to_underlying(piece::Type::KING)] & colors[to_underlying(side)];
Color side_other = (side == Color::BLACK) ? Color::WHITE : Color::BLACK;
Square square = static_cast<Square>(bit_lsb_index(king));
return is_square_attacked(square, side_other);
@@ -144,8 +148,7 @@ Board::Board(const std::string &fen) {
int file = 0, rank = 7, i;
for (i = 0; fen[i] != ' '; i++) {
if (isalpha(fen[i])) {
- set_piece(piece::get_from_code(fen[i]),
- static_cast<Square>(rank * 8 + file));
+ set_piece(piece::get_from_code(fen[i]), static_cast<Square>(rank * 8 + file));
file++;
} else if (isdigit(fen[i])) {
file += fen[i] - '0';
diff --git a/src/board/zobrist.cpp b/src/board/zobrist.cpp
@@ -8,8 +8,12 @@ U64 enpassant_keys[64];
U64 piece_keys[12][64];
U64 side_key;
-U64 zobrist_key_side(void) { return side_key; }
-U64 zobrist_key_castle(int exp) { return castle_keys[exp]; }
+U64 zobrist_key_side(void) {
+ return side_key;
+}
+U64 zobrist_key_castle(int exp) {
+ return castle_keys[exp];
+}
U64 zobrist_key_enpassant(Square square) {
return enpassant_keys[to_underlying(square)];
}
@@ -40,7 +44,9 @@ void init_hash_keys() {
side_key = random_get_U64();
}
-void zobrist_init(void) { init_hash_keys(); }
+void zobrist_init(void) {
+ init_hash_keys();
+}
U64 zobrist_hash(const Board &board) {
U64 key_final = C64(0);
diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
@@ -5,10 +5,8 @@ add_executable(engine
)
target_link_libraries(engine
- PRIVATE attacks
PRIVATE board
PRIVATE moves
- PRIVATE piece
PRIVATE random
)
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
@@ -3,7 +3,7 @@
#include <stdlib.h>
#include <string.h>
-#include "attacks.hpp"
+#include "attack.hpp"
#include "board.hpp"
#include "moves.hpp"
#include "score.hpp"
@@ -65,7 +65,9 @@ int evaluate(const Board &board) {
return score;
}
-int is_repetition() { return 0; }
+int is_repetition() {
+ return 0;
+}
int stats_move_make(Stats &stats, Board ©, Move move, int flag) {
copy = stats.board;
@@ -110,7 +112,7 @@ int quiescence(Stats &stats, int alpha, int beta) {
Board copy;
std::vector<MoveE> list = move_list_generate(stats.board);
Score_move_list(stats, list);
- move_list_sort_pv(list, stats, (Move){0});
+ move_list_sort_pv(list, stats, {0});
move_list_sort(list);
for (const auto [move, _] : list) {
@@ -170,8 +172,7 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) {
// null move pruning
if (stats.ply && depth > 2 && staticEval >= beta) {
stats_move_make_pruning(stats, copy);
- score = -negamax(stats, -beta, -beta + 1,
- depth - 1 - REDUCTION_MOVE, false);
+ score = -negamax(stats, -beta, -beta + 1, depth - 1 - REDUCTION_MOVE, false);
stats_move_unmake(stats, copy);
if (score >= beta) return beta;
}
@@ -186,16 +187,13 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) {
score += Score_value(piece::Type::PAWN);
if (score < beta && depth < 4) {
- if (scoreNew < beta)
- return (scoreNew > score) ? scoreNew : score;
+ if (scoreNew < beta) return (scoreNew > score) ? scoreNew : score;
}
}
// futility pruning condition
static const int margin[] = {0, 100, 300, 500};
- if (depth < 4 && abs(alpha) < MATE_SCORE &&
- staticEval + margin[depth] <= alpha)
- futility = 1;
+ if (depth < 4 && abs(alpha) < MATE_SCORE && staticEval + margin[depth] <= alpha) futility = 1;
}
std::vector<MoveE> list = move_list_generate(stats.board);
@@ -210,8 +208,7 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) {
legal_moves++;
// futility pruning
- if (futility && searched && !move_capture(move) &&
- !move_promote(move) && !stats.board.is_check()) {
+ if (futility && searched && !move_capture(move) && !move_promote(move) && !stats.board.is_check()) {
stats_move_unmake(stats, copy);
continue;
}
@@ -220,15 +217,12 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) {
score = -negamax(stats, -beta, -alpha, depth - 1, true);
} else {
// Late Move Reduction
- if (!pv_node && searched >= FULL_DEPTH &&
- depth >= REDUCTION_LIMIT && !isCheck && !move_capture(move) &&
- !move_promote(move) &&
+ if (!pv_node && searched >= FULL_DEPTH && depth >= REDUCTION_LIMIT && !isCheck &&
+ !move_capture(move) && !move_promote(move) &&
(move_source(move) != move_source(stats.killer[0][stats.ply]) ||
- move_target(move) !=
- move_target(stats.killer[0][stats.ply])) &&
+ move_target(move) != move_target(stats.killer[0][stats.ply])) &&
(move_source(move) != move_source(stats.killer[1][stats.ply]) ||
- move_target(move) !=
- move_target(stats.killer[1][stats.ply]))) {
+ move_target(move) != move_target(stats.killer[1][stats.ply]))) {
score = -negamax(stats, -alpha - 1, -alpha, depth - 2, true);
} else
score = alpha + 1;
@@ -249,8 +243,7 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) {
if (score > alpha) {
if (!move_capture(move)) {
- stats.history[move_piece(move).index][move_target(move)] +=
- depth;
+ stats.history[move_piece(move).index][move_target(move)] += depth;
}
alpha = score;
@@ -259,8 +252,7 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) {
stats_pv_store(stats, move);
if (score >= beta) {
- stats.ttable.write(stats, bestMove, beta, depth,
- HasheFlag::Beta);
+ stats.ttable.write(stats, bestMove, beta, depth, HasheFlag::Beta);
if (!move_capture(move)) {
stats.killer[1][stats.ply] = stats.killer[0][stats.ply];
@@ -284,8 +276,7 @@ int negamax(Stats &stats, int alpha, int beta, int depth, bool null) {
}
void move_print_UCI(Move move) {
- printf("%s%s",
- square_to_coordinates(static_cast<Square>(move_source(move))),
+ printf("%s%s", square_to_coordinates(static_cast<Square>(move_source(move))),
square_to_coordinates(static_cast<Square>(move_target(move))));
if (move_promote(move)) printf("%c", (move_piece_promote(move).code));
}
@@ -309,14 +300,13 @@ void search_position(Board &board, int depth) {
if (stats.pv_length[0]) {
if (score > -MATE_VALUE && score < -MATE_SCORE) {
- printf("info score mate %d depth %d nodes %ld pv ",
- -(score + MATE_VALUE) / 2 - 1, crnt, stats.nodes);
+ printf("info score mate %d depth %d nodes %ld pv ", -(score + MATE_VALUE) / 2 - 1, crnt,
+ stats.nodes);
} else if (score > MATE_SCORE && score < MATE_VALUE) {
- printf("info score mate %d depth %d nodes %ld pv ",
- (MATE_VALUE - score) / 2 + 1, crnt, stats.nodes);
- } else {
- printf("info score cp %d depth %d nodes %ld pv ", score, crnt,
+ printf("info score mate %d depth %d nodes %ld pv ", (MATE_VALUE - score) / 2 + 1, crnt,
stats.nodes);
+ } else {
+ printf("info score cp %d depth %d nodes %ld pv ", score, crnt, stats.nodes);
}
for (int i = 0; i < stats.pv_length[0]; i++) {
@@ -364,7 +354,9 @@ void Instruction_free(Instruction **p) {
delete (*p);
}
-char *Instruction_token(Instruction *self) { return self->token; }
+char *Instruction_token(Instruction *self) {
+ return self->token;
+}
char *Instruction_token_n(Instruction *self, int n) {
while (isspace(*self->crnt) && *self->crnt != '\0')
self->crnt++;
@@ -376,8 +368,7 @@ char *Instruction_token_n(Instruction *self, int n) {
char *p = self->token;
while (n--) {
- while (!isspace(*self->crnt) && *self->crnt != '\0' &&
- *self->crnt != ';')
+ while (!isspace(*self->crnt) && *self->crnt != '\0' && *self->crnt != ';')
*p++ = *self->crnt++;
if (*self->crnt == '\0') {
p++;
@@ -405,8 +396,7 @@ Move parse_move(Board &board, char *move_string) {
for (const auto [move, _] : list) {
if (move_source(move) == source && move_target(move) == target) {
if (move_string[4]) {
- if (tolower(move_piece_promote(move).code) != move_string[4])
- continue;
+ if (tolower(move_piece_promote(move).code) != move_string[4]) continue;
}
result = move;
break;
@@ -444,7 +434,7 @@ Board *Instruction_parse(Instruction *self, Board &board) {
if (strcmp(token, "moves") == 0) {
while ((token = Instruction_token_next(self))) {
Move move = parse_move(board, token);
- if (!move_cmp(move, (Move){0})) {
+ if (!move_cmp(move, {0})) {
move_make(move, board, 0);
} else {
printf("Invalid move %s!\n", token);
@@ -456,8 +446,7 @@ Board *Instruction_parse(Instruction *self, Board &board) {
if (strcmp(token, "go") == 0) {
int depth = 6;
- for (token = Instruction_token_next(self); token;
- token = Instruction_token_next(self)) {
+ for (token = Instruction_token_next(self); token; token = Instruction_token_next(self)) {
if (token && strcmp(token, "depth") == 0) {
token = Instruction_token_next(self);
@@ -509,7 +498,6 @@ void uci_loop(void) {
/* MAIN */
void init(void) {
- attacks_init();
zobrist_init();
}
diff --git a/src/engine/transposition.cpp b/src/engine/transposition.cpp
@@ -2,8 +2,7 @@
#include "board.hpp"
#include "score.hpp"
-int TTable::read(const Stats &stats, Move *best, int alpha, int beta,
- int depth) const {
+int TTable::read(const Stats &stats, Move *best, int alpha, int beta, int depth) const {
U64 hash = stats.board.get_hash();
const Hashe &phashe = table[hash % table.size()];
@@ -15,18 +14,15 @@ int TTable::read(const Stats &stats, Move *best, int alpha, int beta,
if (score > MATE_SCORE) score -= stats.ply;
if (phashe.flag == HasheFlag::Exact) return score;
- if ((phashe.flag == HasheFlag::Alpha) && (score <= alpha))
- return alpha;
- if ((phashe.flag == HasheFlag::Beta) && (score >= beta))
- return beta;
+ if ((phashe.flag == HasheFlag::Alpha) && (score <= alpha)) return alpha;
+ if ((phashe.flag == HasheFlag::Beta) && (score >= beta)) return beta;
}
*best = phashe.best;
}
return TTABLE_UNKNOWN;
}
-void TTable::write(const Stats &stats, Move best, int score, int depth,
- HasheFlag flag) {
+void TTable::write(const Stats &stats, Move best, int score, int depth, HasheFlag flag) {
U64 hash = stats.board.get_hash();
Hashe &phashe = table[hash % table.size()];
diff --git a/src/engine/transposition.hpp b/src/engine/transposition.hpp
@@ -28,13 +28,14 @@ struct Hashe {
class TTable {
public:
- TTable(U64 size) : table(size, {0}) {}
-
- void clear() { table.clear(); };
- void write(const Stats &stats, Move best, int score, int depth,
- HasheFlag flag);
- int read(const Stats &stats, Move *best, int alpha, int beta,
- int depth) const;
+ TTable(U64 size) : table(size, {0}) {
+ }
+
+ void clear() {
+ table.clear();
+ };
+ void write(const Stats &stats, Move best, int score, int depth, HasheFlag flag);
+ int read(const Stats &stats, Move *best, int alpha, int beta, int depth) const;
private:
std::vector<Hashe> table;
diff --git a/src/include/attack.hpp b/src/include/attack.hpp
@@ -0,0 +1,337 @@
+#ifndef STELLAR_ATTAKCS_INTERNAL_H
+#define STELLAR_ATTAKCS_INTERNAL_H
+
+#include "magic.hpp"
+#include "utils_cpp.hpp"
+
+#include <array>
+
+namespace attack {
+
+class Slider {
+ public:
+ virtual constexpr U32 hash(U64 key, Square square) const = 0;
+ virtual constexpr U64 mask(Square square) const = 0;
+ virtual constexpr U64 mask_fly(Square square, U64 block) const = 0;
+
+ static inline constexpr U64 occupancy(U64 index, uint8_t bits_in_mask, U64 attack_mask) {
+ U64 occupancy = C64(0);
+
+ for (uint8_t count = 0; count < bits_in_mask; count++) {
+ uint8_t square = bit_lsb_index(attack_mask);
+ bit_pop(attack_mask, square);
+
+ if (bit_get(index, count)) bit_set(occupancy, square);
+ }
+
+ return occupancy;
+ }
+
+ protected:
+ static inline constexpr U64 mask_slide(Square square, U64 block, const direction_f dir[4],
+ const int len[4]) {
+ U64 bitboard = C64(0), attacks = C64(0);
+ bit_set(bitboard, to_underlying(square));
+ for (int i = 0; i < 4; i++) {
+ U64 tmp = bitboard;
+ for (int j = 0; j < len[i]; j++) {
+ attacks |= tmp = (dir[i])(tmp);
+ if (tmp & block) break;
+ }
+ }
+ return attacks;
+ }
+};
+
+class SliderRook : public Slider {
+ public:
+ virtual constexpr U32 hash(U64 key, Square square) const override {
+ uint8_t square_i = to_underlying(square);
+ return (key * rook_magic_numbers[square_i]) >> (64 - relevant_bits[square_i]);
+ }
+
+ virtual constexpr U64 mask(Square square) const override {
+ return masks[to_underlying(square)];
+ }
+
+ virtual constexpr U64 mask_fly(Square square, U64 block) const override {
+ uint8_t square_i = to_underlying(square);
+ int tr = square_i / 8, tf = square_i % 8;
+ int len[4] = {tf, tr, 7 - tf, 7 - tr};
+
+ return mask_slide(square, block, dir, len);
+ }
+
+ private:
+ static inline constexpr const direction_f dir[4] = {westOne, soutOne, eastOne, nortOne};
+
+ // clang-format off
+ static inline constexpr const int relevant_bits[64] = {
+ 12, 11, 11, 11, 11, 11, 11, 12,
+ 11, 10, 10, 10, 10, 10, 10, 11,
+ 11, 10, 10, 10, 10, 10, 10, 11,
+ 11, 10, 10, 10, 10, 10, 10, 11,
+ 11, 10, 10, 10, 10, 10, 10, 11,
+ 11, 10, 10, 10, 10, 10, 10, 11,
+ 11, 10, 10, 10, 10, 10, 10, 11,
+ 12, 11, 11, 11, 11, 11, 11, 12,
+ };
+ // clang-format on
+
+ static inline constexpr const std::array<U64, 64> masks = []() constexpr -> std::array<U64, 64> {
+ std::array<U64, 64> masks;
+ for (const Square square : SquareIter()) {
+ const uint8_t square_i = to_underlying(square);
+ const int tr = square_i / 8, tf = square_i % 8;
+ const int len[4] = {tf - 1, tr - 1, 6 - tf, 6 - tr};
+
+ masks[square_i] = mask_slide(square, C64(0), dir, len);
+ }
+ return masks;
+ }();
+};
+
+class SliderBishop : public Slider {
+ public:
+ virtual constexpr U32 hash(U64 key, Square square) const override {
+ uint8_t square_i = to_underlying(square);
+ return (key * bishop_magic_numbers[square_i]) >> (64 - relevant_bits[square_i]);
+ }
+
+ virtual constexpr U64 mask(Square square) const override {
+ return masks[to_underlying(square)];
+ }
+
+ virtual constexpr U64 mask_fly(Square square, U64 block) const override {
+ uint8_t square_i = to_underlying(square);
+ int tr = square_i / 8, tf = square_i % 8;
+ int len[4] = {std::min(7 - tf, 7 - tr), std::min(tf, 7 - tr), std::min(7 - tf, tr), std::min(tf, tr)};
+
+ return mask_slide(square, block, dir, len);
+ }
+
+ private:
+ static inline constexpr const direction_f dir[4] = {noEaOne, noWeOne, soEaOne, soWeOne};
+
+ // clang-format off
+ static inline constexpr const int relevant_bits[64] = {
+ 6, 5, 5, 5, 5, 5, 5, 6,
+ 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 7, 7, 7, 7, 5, 5,
+ 5, 5, 7, 9, 9, 7, 5, 5,
+ 5, 5, 7, 9, 9, 7, 5, 5,
+ 5, 5, 7, 7, 7, 7, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5,
+ 6, 5, 5, 5, 5, 5, 5, 6,
+ };
+ // clang-format on
+
+ static inline constexpr const std::array<U64, 64> masks = []() constexpr -> std::array<U64, 64> {
+ std::array<U64, 64> masks;
+ for (const Square square : SquareIter()) {
+
+ uint8_t square_i = to_underlying(square);
+ int tr = square_i / 8, tf = square_i % 8;
+ int len[4] = {std::min(7 - tf, 7 - tr) - 1, std::min(tf, 7 - tr) - 1, std::min(7 - tf, tr) - 1,
+ std::min(tf, tr) - 1};
+ masks[square_i] = mask_slide(square, C64(0), dir, len);
+ }
+ return masks;
+ }();
+};
+
+inline constexpr const SliderRook slider_rook;
+inline constexpr const SliderBishop slider_bishop;
+
+class Attack {
+ public:
+ virtual constexpr U64 operator()(Square square, U64 occupancy) const = 0;
+
+ protected:
+ template <std::size_t size> using slider_attack_array = std::array<std::array<U64, size>, 64>;
+
+ static inline constexpr const auto slider_attacks =
+ []<std::size_t size>(const Slider &slider) constexpr -> slider_attack_array<size> {
+ slider_attack_array<size> attacks;
+ for (const Square square : SquareIter()) {
+ uint8_t square_i = to_underlying(square);
+ U64 attack_mask = slider.mask(square);
+ uint8_t relevant_bits = bit_count(attack_mask);
+ U64 occupancy_indices = C64(1) << relevant_bits;
+
+ for (U64 idx = 0; idx < occupancy_indices; idx++) {
+ U64 occupancy = Slider::occupancy(idx, relevant_bits, attack_mask);
+ U32 magic_index = slider.hash(occupancy, square);
+ attacks[square_i][magic_index] = slider.mask_fly(square, occupancy);
+ }
+ }
+ return attacks;
+ };
+};
+
+class Rook : public Attack {
+ public:
+ virtual constexpr U64 operator()(Square square, U64 occupancy) const override {
+ occupancy &= slider_rook.mask(square);
+ occupancy = slider_rook.hash(occupancy, square);
+ return attacks[to_underlying(square)][occupancy];
+ }
+
+ private:
+ static inline constexpr const slider_attack_array<4096> attacks =
+ slider_attacks.operator()<4096>(slider_rook);
+};
+
+class Bishop : public Attack {
+ public:
+ virtual constexpr U64 operator()(Square square, U64 occupancy) const override {
+ occupancy &= slider_bishop.mask(square);
+ occupancy = slider_bishop.hash(occupancy, square);
+ return attacks[to_underlying(square)][occupancy];
+ }
+
+ private:
+ static inline constexpr const slider_attack_array<512> attacks =
+ slider_attacks.operator()<512>(slider_bishop);
+};
+
+class King : public Attack {
+ public:
+ constexpr King() {
+ }
+
+ virtual constexpr U64 operator()(Square square, U64 occupancy) const override {
+ return attacks[to_underlying(square)];
+ }
+
+ private:
+ static constexpr U64 mask(Square square) {
+ U64 bitboard = C64(0), attacks = C64(0);
+
+ bit_set(bitboard, to_underlying(square));
+ attacks |= westOne(bitboard) | eastOne(bitboard);
+ attacks |= soutOne(bitboard) | nortOne(bitboard);
+ attacks |= soutOne(bitboard) | nortOne(bitboard);
+ attacks |= soEaOne(bitboard) | noEaOne(bitboard);
+ attacks |= soWeOne(bitboard) | noWeOne(bitboard);
+
+ return attacks;
+ }
+
+ typedef std::array<U64, 64> attack_array;
+ const attack_array attacks = []() -> attack_array {
+ std::array<U64, 64> attacks;
+ for (const Square square : SquareIter())
+ attacks[to_underlying(square)] = mask(square);
+ return attacks;
+ }();
+};
+
+class Knight : public Attack {
+ public:
+ constexpr Knight() {
+ }
+
+ virtual constexpr U64 operator()(Square square, U64 occupancy) const override {
+ return attacks[to_underlying(square)];
+ }
+
+ private:
+ static constexpr U64 mask(Square square) {
+ U64 bitboard = C64(0), attacks = C64(0), tmp;
+
+ bit_set(bitboard, to_underlying(square));
+ tmp = nortOne(nortOne(bitboard));
+ attacks |= westOne(tmp) | eastOne(tmp);
+ tmp = soutOne(soutOne(bitboard));
+ attacks |= westOne(tmp) | eastOne(tmp);
+ tmp = westOne(westOne(bitboard));
+ attacks |= soutOne(tmp) | nortOne(tmp);
+ tmp = eastOne(eastOne(bitboard));
+ attacks |= soutOne(tmp) | nortOne(tmp);
+
+ return attacks;
+ }
+
+ typedef std::array<U64, 64> attack_array;
+ const attack_array attacks = []() -> attack_array {
+ std::array<U64, 64> attacks;
+ for (const Square square : SquareIter())
+ attacks[to_underlying(square)] = mask(square);
+ return attacks;
+ }();
+};
+
+class PawnW : public Attack {
+ public:
+ constexpr PawnW() {
+ }
+
+ virtual constexpr U64 operator()(Square square, U64 occupancy) const override {
+ return attacks[to_underlying(square)];
+ }
+
+ private:
+ static constexpr U64 mask(Square square) {
+ U64 bitboard = C64(0);
+
+ bit_set(bitboard, to_underlying(square));
+ return noWeOne(bitboard) | noEaOne(bitboard);
+ }
+
+ typedef std::array<U64, 64> attack_array;
+ const attack_array attacks = []() -> attack_array {
+ std::array<U64, 64> attacks;
+ for (const Square square : SquareIter())
+ attacks[to_underlying(square)] = mask(square);
+ return attacks;
+ }();
+};
+
+class PawnB : public Attack {
+ public:
+ constexpr PawnB() {
+ }
+
+ virtual constexpr U64 operator()(Square square, U64 occupancy) const override {
+ return attacks[to_underlying(square)];
+ }
+
+ private:
+ static constexpr U64 mask(Square square) {
+ U64 bitboard = C64(0);
+
+ bit_set(bitboard, to_underlying(square));
+ return soWeOne(bitboard) | soEaOne(bitboard);
+ }
+
+ typedef std::array<U64, 64> attack_array;
+ const attack_array attacks = []() -> attack_array {
+ std::array<U64, 64> attacks;
+ for (const Square square : SquareIter())
+ attacks[to_underlying(square)] = mask(square);
+ return attacks;
+ }();
+};
+
+inline constexpr const Rook rook;
+inline constexpr const Bishop bishop;
+inline constexpr const King king;
+inline constexpr const Knight knight;
+inline constexpr const PawnW pawnW;
+inline constexpr const PawnB pawnB;
+
+class Queen : public Attack {
+ public:
+ constexpr Queen() {
+ }
+
+ virtual constexpr U64 operator()(Square square, U64 occupancy) const override {
+ return rook(square, occupancy) | bishop(square, occupancy);
+ }
+};
+
+inline constexpr const Queen queen;
+
+} // namespace attack
+#endif
diff --git a/src/include/attacks.hpp b/src/include/attacks.hpp
@@ -1,17 +0,0 @@
-#ifndef STELLAR_ATTACKS_H
-#define STELLAR_ATTACKS_H
-
-#include "utils_cpp.hpp"
-
-void attacks_init(void);
-
-typedef U64 (*attack_get_f)(Square square, U64 occupancy);
-U64 attacks_wpawn_get(Square square, U64 occupancy);
-U64 attacks_bpawn_get(Square square, U64 occupancy);
-U64 attacks_knight_get(Square square, U64 occupancy);
-U64 attacks_king_get(Square square, U64 occupancy);
-U64 attacks_bishop_get(Square square, U64 occupancy);
-U64 attacks_rook_get(Square square, U64 occupancy);
-U64 attacks_queen_get(Square square, U64 occupancy);
-
-#endif
diff --git a/src/include/board.hpp b/src/include/board.hpp
@@ -17,7 +17,8 @@ class Board {
BQ = 8
};
- Board() {}
+ Board() {
+ }
Board(const std::string &fen);
friend std::ostream &operator<<(std::ostream &os, const Board &board);
@@ -36,10 +37,8 @@ class Board {
U64 get_bitboard_piece(piece::Type piece, Color color) const;
U64 get_bitboard_piece(const piece::Piece &piece) const;
- U64 get_bitboard_piece_attacks(piece::Type piece, Color color,
- Square square) const;
- U64 get_bitboard_piece_attacks(const piece::Piece &piece,
- Square square) const;
+ U64 get_bitboard_piece_attacks(piece::Type piece, Color color, Square square) const;
+ U64 get_bitboard_piece_attacks(const piece::Piece &piece, Square square) const;
// exception if not found
Color get_square_piece_color(Square square) const;
@@ -77,7 +76,6 @@ class Board {
uint8_t castle = 0;
};
-const piece::Piece &board_square_piece(const Board *self, Square square,
- Color side);
+const piece::Piece &board_square_piece(const Board *self, Square square, Color side);
#endif
diff --git a/src/include/magic.hpp b/src/include/magic.hpp
@@ -0,0 +1,44 @@
+#ifndef STELLAR_ATTACKS_MAGIC_H
+#define STELLAR_ATTACKS_MAGIC_H
+
+#include "utils_cpp.hpp"
+
+static inline constexpr const U64 bishop_magic_numbers[64] = {
+ C64(0x40040844404084), C64(0x2004208a004208), C64(0x10190041080202), C64(0x108060845042010),
+ C64(0x581104180800210), C64(0x2112080446200010), C64(0x1080820820060210), C64(0x3c0808410220200),
+ C64(0x4050404440404), C64(0x21001420088), C64(0x24d0080801082102), C64(0x1020a0a020400),
+ C64(0x40308200402), C64(0x4011002100800), C64(0x401484104104005), C64(0x801010402020200),
+ C64(0x400210c3880100), C64(0x404022024108200), C64(0x810018200204102), C64(0x4002801a02003),
+ C64(0x85040820080400), C64(0x810102c808880400), C64(0xe900410884800), C64(0x8002020480840102),
+ C64(0x220200865090201), C64(0x2010100a02021202), C64(0x152048408022401), C64(0x20080002081110),
+ C64(0x4001001021004000), C64(0x800040400a011002), C64(0xe4004081011002), C64(0x1c004001012080),
+ C64(0x8004200962a00220), C64(0x8422100208500202), C64(0x2000402200300c08), C64(0x8646020080080080),
+ C64(0x80020a0200100808), C64(0x2010004880111000), C64(0x623000a080011400), C64(0x42008c0340209202),
+ C64(0x209188240001000), C64(0x400408a884001800), C64(0x110400a6080400), C64(0x1840060a44020800),
+ C64(0x90080104000041), C64(0x201011000808101), C64(0x1a2208080504f080), C64(0x8012020600211212),
+ C64(0x500861011240000), C64(0x180806108200800), C64(0x4000020e01040044), C64(0x300000261044000a),
+ C64(0x802241102020002), C64(0x20906061210001), C64(0x5a84841004010310), C64(0x4010801011c04),
+ C64(0xa010109502200), C64(0x4a02012000), C64(0x500201010098b028), C64(0x8040002811040900),
+ C64(0x28000010020204), C64(0x6000020202d0240), C64(0x8918844842082200), C64(0x4010011029020020),
+};
+
+static inline constexpr const U64 rook_magic_numbers[64] = {
+ C64(0x8a80104000800020), C64(0x140002000100040), C64(0x2801880a0017001), C64(0x100081001000420),
+ C64(0x200020010080420), C64(0x3001c0002010008), C64(0x8480008002000100), C64(0x2080088004402900),
+ C64(0x800098204000), C64(0x2024401000200040), C64(0x100802000801000), C64(0x120800800801000),
+ C64(0x208808088000400), C64(0x2802200800400), C64(0x2200800100020080), C64(0x801000060821100),
+ C64(0x80044006422000), C64(0x100808020004000), C64(0x12108a0010204200), C64(0x140848010000802),
+ C64(0x481828014002800), C64(0x8094004002004100), C64(0x4010040010010802), C64(0x20008806104),
+ C64(0x100400080208000), C64(0x2040002120081000), C64(0x21200680100081), C64(0x20100080080080),
+ C64(0x2000a00200410), C64(0x20080800400), C64(0x80088400100102), C64(0x80004600042881),
+ C64(0x4040008040800020), C64(0x440003000200801), C64(0x4200011004500), C64(0x188020010100100),
+ C64(0x14800401802800), C64(0x2080040080800200), C64(0x124080204001001), C64(0x200046502000484),
+ C64(0x480400080088020), C64(0x1000422010034000), C64(0x30200100110040), C64(0x100021010009),
+ C64(0x2002080100110004), C64(0x202008004008002), C64(0x20020004010100), C64(0x2048440040820001),
+ C64(0x101002200408200), C64(0x40802000401080), C64(0x4008142004410100), C64(0x2060820c0120200),
+ C64(0x1001004080100), C64(0x20c020080040080), C64(0x2935610830022400), C64(0x44440041009200),
+ C64(0x280001040802101), C64(0x2100190040002085), C64(0x80c0084100102001), C64(0x4024081001000421),
+ C64(0x20030a0244872), C64(0x12001008414402), C64(0x2006104900a0804), C64(0x1004081002402),
+};
+
+#endif
diff --git a/src/include/moves.hpp b/src/include/moves.hpp
@@ -27,9 +27,8 @@ struct MoveE {
int score;
};
-Move move_encode(uint8_t src, uint8_t tgt, const piece::Piece *piece,
- const piece::Piece *capture, const piece::Piece *promote,
- bool dbl, bool enpassant, bool castle);
+Move move_encode(uint8_t src, uint8_t tgt, const piece::Piece *piece, const piece::Piece *capture,
+ const piece::Piece *promote, bool dbl, bool enpassant, bool castle);
std::vector<MoveE> move_list_generate(const Board &board);
int move_make(Move move, Board &board, int flag);
void move_list_sort(std::vector<MoveE> &list);
diff --git a/src/include/piece.hpp b/src/include/piece.hpp
@@ -1,7 +1,7 @@
#ifndef STELLAR_PIECE_H
#define STELLAR_PIECE_H
-#include "attacks.hpp"
+#include "attack.hpp"
#include "utils_cpp.hpp"
#include <cctype>
@@ -21,73 +21,84 @@ typedef Iterator<Type, Type::PAWN, Type::KING> TypeIter;
class Piece {
public:
+ constexpr U64 operator()(Square square, U64 occupancy) const {
+ return attack(square, occupancy);
+ }
+
const Type type;
const Color color;
const char code;
const char *symbol;
- const attack_get_f attacks;
const uint8_t index;
protected:
- constexpr Piece(Type type, Color color, char code, const char *symbol,
- attack_get_f attacks)
- : type(type), color(color), code(code), symbol(symbol),
- attacks(attacks), index(index_calc(color, type)) {}
+ constexpr Piece(Type type, Color color, char code, const char *symbol, const attack::Attack &attack)
+ : type(type), color(color), code(code), symbol(symbol), index(index_calc(color, type)),
+ attack(attack) {
+ }
constexpr uint8_t index_calc(Color color, Type type) {
return to_underlying(color) * 6 + to_underlying(type);
}
+
+ private:
+ const attack::Attack &attack;
};
class Pawn : public Piece {
public:
constexpr Pawn(Color color)
- : Piece(Type::PAWN, color, color == Color::WHITE ? 'P' : 'p',
- color == Color::WHITE ? "■ " : "■ ",
- color == Color::WHITE ? attacks_wpawn_get : attacks_bpawn_get) {
+ : Piece(Type::PAWN, color, color == Color::WHITE ? 'P' : 'p', color == Color::WHITE ? "■ " : "■ ",
+ color == Color::WHITE ? *(attack::Attack *)&attack::pawnW
+ : *(attack::Attack *)&attack::pawnB) {
}
};
class Knight : public Piece {
public:
constexpr Knight(Color color)
- : Piece(Type::KNIGHT, color, color == Color::WHITE ? 'N' : 'n',
- color == Color::WHITE ? "■ " : "■ ", attacks_knight_get) {}
+ : Piece(Type::KNIGHT, color, color == Color::WHITE ? 'N' : 'n', color == Color::WHITE ? "■ " : "■ ",
+ attack::knight) {
+ }
};
class Bishop : public Piece {
public:
constexpr Bishop(Color color)
- : Piece(Type::BISHOP, color, color == Color::WHITE ? 'B' : 'b',
- color == Color::WHITE ? "■ " : "■ ", attacks_bishop_get) {}
+ : Piece(Type::BISHOP, color, color == Color::WHITE ? 'B' : 'b', color == Color::WHITE ? "■ " : "■ ",
+ attack::bishop) {
+ }
};
class Rook : public Piece {
public:
constexpr Rook(Color color)
- : Piece(Type::ROOK, color, color == Color::WHITE ? 'R' : 'r',
- color == Color::WHITE ? "■ " : "■ ", attacks_rook_get) {}
+ : Piece(Type::ROOK, color, color == Color::WHITE ? 'R' : 'r', color == Color::WHITE ? "■ " : "■ ",
+ attack::rook) {
+ }
};
class Queen : public Piece {
public:
constexpr Queen(Color color)
- : Piece(Type::QUEEN, color, color == Color::WHITE ? 'Q' : 'q',
- color == Color::WHITE ? "■ " : "■ ", attacks_queen_get) {}
+ : Piece(Type::QUEEN, color, color == Color::WHITE ? 'Q' : 'q', color == Color::WHITE ? "■ " : "■ ",
+ attack::queen) {
+ }
};
class King : public Piece {
public:
constexpr King(Color color)
- : Piece(Type::KING, color, color == Color::WHITE ? 'K' : 'k',
- color == Color::WHITE ? "■ " : "■ ", attacks_king_get) {}
+ : Piece(Type::KING, color, color == Color::WHITE ? 'K' : 'k', color == Color::WHITE ? "■ " : "■ ",
+ attack::king) {
+ }
};
const constexpr Piece table[2][6] = {
- {Pawn(Color::WHITE), Knight(Color::WHITE), Bishop(Color::WHITE),
- Rook(Color::WHITE), Queen(Color::WHITE), King(Color::WHITE)},
- {Pawn(Color::BLACK), Knight(Color::BLACK), Bishop(Color::BLACK),
- Rook(Color::BLACK), Queen(Color::BLACK), King(Color::BLACK)},
+ {Pawn(Color::WHITE), Knight(Color::WHITE), Bishop(Color::WHITE), Rook(Color::WHITE), Queen(Color::WHITE),
+ King(Color::WHITE)},
+ {Pawn(Color::BLACK), Knight(Color::BLACK), Bishop(Color::BLACK), Rook(Color::BLACK), Queen(Color::BLACK),
+ King(Color::BLACK)},
};
constexpr const Piece &get(Type type, Color color) {
diff --git a/src/include/utils_cpp.hpp b/src/include/utils_cpp.hpp
@@ -5,8 +5,7 @@
#include <exception>
#include <type_traits>
-template <typename E>
-constexpr typename std::underlying_type<E>::type to_underlying(E e) noexcept {
+template <typename E> constexpr typename std::underlying_type<E>::type to_underlying(E e) noexcept {
return static_cast<typename std::underlying_type<E>::type>(e);
}
@@ -15,20 +14,28 @@ template <typename C, C beginVal, C endVal> class Iterator {
int val;
public:
- constexpr Iterator(const C &f) : val(static_cast<val_t>(f)) {}
- constexpr Iterator() : val(static_cast<val_t>(beginVal)) {}
+ constexpr Iterator(const C &f) : val(static_cast<val_t>(f)) {
+ }
+ constexpr Iterator() : val(static_cast<val_t>(beginVal)) {
+ }
constexpr Iterator operator++() {
++val;
return *this;
}
- constexpr C operator*() { return static_cast<C>(val); }
- constexpr Iterator begin() { return *this; }
+ constexpr C operator*() {
+ return static_cast<C>(val);
+ }
+ constexpr Iterator begin() {
+ return *this;
+ }
constexpr Iterator end() {
// static const Iterator endIter = ++Iterator(endVal);
// return endIter;
return ++Iterator(endVal);
}
- constexpr bool operator!=(const Iterator &i) { return val != i.val; }
+ constexpr bool operator!=(const Iterator &i) {
+ return val != i.val;
+ }
};
#define C64(constantU64) constantU64##ULL
@@ -77,11 +84,19 @@ inline const char *square_to_coordinates(Square square) {
// clang-format on
// useful bit functions
-#define bit_get(bitboard, square) (((bitboard) >> (square)) & C64(1))
-#define bit_set(bitboard, square) ((bitboard) |= C64(1) << (square))
-#define bit_pop(bitboard, square) ((bitboard) &= ~(C64(1) << (square)))
+constexpr bool bit_get(const U64 &bitboard, uint8_t square) {
+ return (bitboard >> (square)) & C64(1);
+}
+
+constexpr void bit_set(U64 &bitboard, uint8_t square) {
+ bitboard |= (C64(1) << square);
+}
+
+constexpr void bit_pop(U64 &bitboard, uint8_t square) {
+ bitboard &= ~(C64(1) << (square));
+}
-inline uint8_t bit_count(U64 bitboard) {
+constexpr uint8_t bit_count(U64 bitboard) {
#if __has_builtin(__builtin_popcountll)
return __builtin_popcountll(bitboard);
#endif
@@ -92,7 +107,7 @@ inline uint8_t bit_count(U64 bitboard) {
return count;
}
-inline uint8_t bit_lsb_index(U64 bitboard) {
+constexpr uint8_t bit_lsb_index(U64 bitboard) {
#if __has_builtin(__builtin_ffsll)
return __builtin_ffsll(bitboard) - 1;
#endif
@@ -103,25 +118,40 @@ inline uint8_t bit_lsb_index(U64 bitboard) {
#define bit_lsb_pop(bitboard) ((bitboard) &= (bitboard) & ((bitboard)-1))
-#define bitboard_for_each_bit(var, bb) \
+#define bitboard_for_each_bit(var, bb) \
for (var = bit_lsb_index(bb); bb; bit_lsb_pop(bb), var = bit_lsb_index(bb))
// board moving
-const U64 universe = C64(0xffffffffffffffff);
-const U64 notAFile = C64(0xfefefefefefefefe);
-const U64 notHFile = C64(0x7f7f7f7f7f7f7f7f);
+inline constexpr const U64 universe = C64(0xffffffffffffffff);
+inline constexpr const U64 notAFile = C64(0xfefefefefefefefe);
+inline constexpr const U64 notHFile = C64(0x7f7f7f7f7f7f7f7f);
typedef U64 (*direction_f)(U64);
-inline U64 soutOne(U64 b) { return b >> 8; }
-inline U64 nortOne(U64 b) { return b << 8; }
-inline U64 eastOne(U64 b) { return (b & notHFile) << 1; }
-inline U64 westOne(U64 b) { return (b & notAFile) >> 1; }
-inline U64 soEaOne(U64 b) { return (b & notHFile) >> 7; }
-inline U64 soWeOne(U64 b) { return (b & notAFile) >> 9; }
-inline U64 noEaOne(U64 b) { return (b & notHFile) << 9; }
-inline U64 noWeOne(U64 b) { return (b & notAFile) << 7; }
-
-#define start_position \
- "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 "
+inline constexpr U64 soutOne(U64 b) {
+ return b >> 8;
+}
+inline constexpr U64 nortOne(U64 b) {
+ return b << 8;
+}
+inline constexpr U64 eastOne(U64 b) {
+ return (b & notHFile) << 1;
+}
+inline constexpr U64 westOne(U64 b) {
+ return (b & notAFile) >> 1;
+}
+inline constexpr U64 soEaOne(U64 b) {
+ return (b & notHFile) >> 7;
+}
+inline constexpr U64 soWeOne(U64 b) {
+ return (b & notAFile) >> 9;
+}
+inline constexpr U64 noEaOne(U64 b) {
+ return (b & notHFile) << 9;
+}
+inline constexpr U64 noWeOne(U64 b) {
+ return (b & notAFile) << 7;
+}
+
+#define start_position "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 "
#endif
diff --git a/src/moves/moves.cpp b/src/moves/moves.cpp
@@ -4,12 +4,13 @@
#include <algorithm>
#include <iomanip>
-int move_cmp(Move a, Move b) { return *(uint32_t *)&a == *(uint32_t *)&b; }
+int move_cmp(Move a, Move b) {
+ return *(uint32_t *)&a == *(uint32_t *)&b;
+}
-Move move_encode(uint8_t src, uint8_t tgt, const piece::Piece *piece,
- const piece::Piece *capture, const piece::Piece *promote,
- bool dbl, bool enpassant, bool castle) {
- return (Move){
+Move move_encode(uint8_t src, uint8_t tgt, const piece::Piece *piece, const piece::Piece *capture,
+ const piece::Piece *promote, bool dbl, bool enpassant, bool castle) {
+ return {
.source = src,
.target = tgt,
.piece = piece->index,
@@ -24,8 +25,7 @@ Move move_encode(uint8_t src, uint8_t tgt, const piece::Piece *piece,
}
void move_list_sort(std::vector<MoveE> &list) {
- std::sort(list.begin(), list.end(),
- [](const MoveE &a, const MoveE &b) { return a.score < b.score; });
+ std::sort(list.begin(), list.end(), [](const MoveE &a, const MoveE &b) { return a.score < b.score; });
}
void move_list_print(const std::vector<MoveE> &list) {
diff --git a/src/moves/moves_generate.cpp b/src/moves/moves_generate.cpp
@@ -3,36 +3,27 @@
#include "piece.hpp"
#include "utils_cpp.hpp"
-#define pawn_canPromote(color, source) \
- ((color == Color::WHITE && source >= Square::a7 && \
- source <= Square::h7) || \
+#define pawn_canPromote(color, source) \
+ ((color == Color::WHITE && source >= Square::a7 && source <= Square::h7) || \
(color == Color::BLACK && source >= Square::a2 && source <= Square::h2))
-#define pawn_onStart(color, source) \
- ((color == Color::BLACK && source >= Square::a7 && \
- source <= Square::h7) || \
+#define pawn_onStart(color, source) \
+ ((color == Color::BLACK && source >= Square::a7 && source <= Square::h7) || \
(color == Color::WHITE && source >= Square::a2 && source <= Square::h2))
-#define pawn_promote(source, target, piece, capture) \
- res.push_back( \
- {move_encode(source, target, &piece, capture, \
- &piece::get(piece::Type::KNIGHT, color), 0, 0, 0), \
- 0}); \
- res.push_back( \
- {move_encode(source, target, &piece, capture, \
- &piece::get(piece::Type::BISHOP, color), 0, 0, 0), \
- 0}); \
- res.push_back( \
- {move_encode(source, target, &piece, capture, \
- &piece::get(piece::Type::ROOK, color), 0, 0, 0), \
- 0}); \
- res.push_back( \
- {move_encode(source, target, &piece, capture, \
- &piece::get(piece::Type::QUEEN, color), 0, 0, 0), \
- 0});
+#define pawn_promote(source, target, piece, capture) \
+ res.push_back( \
+ {move_encode(source, target, &piece, capture, &piece::get(piece::Type::KNIGHT, color), 0, 0, 0), \
+ 0}); \
+ res.push_back( \
+ {move_encode(source, target, &piece, capture, &piece::get(piece::Type::BISHOP, color), 0, 0, 0), \
+ 0}); \
+ res.push_back( \
+ {move_encode(source, target, &piece, capture, &piece::get(piece::Type::ROOK, color), 0, 0, 0), 0}); \
+ res.push_back( \
+ {move_encode(source, target, &piece, capture, &piece::get(piece::Type::QUEEN, color), 0, 0, 0), 0});
std::vector<MoveE> move_list_generate(const Board &board) {
- Move move;
uint8_t src_i, tgt_i;
Color color = board.get_side();
@@ -54,43 +45,34 @@ std::vector<MoveE> move_list_generate(const Board &board) {
if (pawn_canPromote(color, src)) {
pawn_promote(src_i, tgt_i, piece, nullptr);
} else {
- res.push_back(
- {move_encode(src_i, tgt_i, &piece, 0, 0, 0, 0, 0), 0});
+ res.push_back({move_encode(src_i, tgt_i, &piece, 0, 0, 0, 0, 0), 0});
// two ahead
Square tgt = static_cast<Square>(tgt_i + add);
if (pawn_onStart(color, src) && !board.is_square_occupied(tgt))
- res.push_back(
- {move_encode(src_i, tgt_i + add, &piece, 0, 0, 1, 0, 0),
- 0});
+ res.push_back({move_encode(src_i, tgt_i + add, &piece, 0, 0, 1, 0, 0), 0});
}
}
// capture
- U64 attack = board.get_bitboard_piece_attacks(piece, src) &
- board.get_bitboard_color(colorOther);
+ U64 attack = board.get_bitboard_piece_attacks(piece, src) & board.get_bitboard_color(colorOther);
bitboard_for_each_bit(tgt_i, attack) {
Square tgt = static_cast<Square>(tgt_i);
const piece::Piece *capture = board.get_square_piece(tgt);
if (pawn_canPromote(color, src)) {
pawn_promote(src_i, tgt_i, piece, capture);
} else {
- res.push_back(
- {move_encode(src_i, tgt_i, &piece, capture, 0, 0, 0, 0),
- 0});
+ res.push_back({move_encode(src_i, tgt_i, &piece, capture, 0, 0, 0, 0), 0});
}
}
// en passant
if (board.get_enpassant() != Square::no_sq &&
- board.get_bitboard_piece_attacks(piece,
- static_cast<Square>(src_i)) &
+ board.get_bitboard_piece_attacks(piece, static_cast<Square>(src_i)) &
(C64(1) << to_underlying(board.get_enpassant())))
- res.push_back(
- {move_encode(src_i, to_underlying(board.get_enpassant()),
- &piece, &piece::get(piece::Type::PAWN, colorOther),
- 0, 0, 1, 0),
- 0});
+ res.push_back({move_encode(src_i, to_underlying(board.get_enpassant()), &piece,
+ &piece::get(piece::Type::PAWN, colorOther), 0, 0, 1, 0),
+ 0});
}
// All piece move
@@ -100,66 +82,53 @@ std::vector<MoveE> move_list_generate(const Board &board) {
U64 bitboard = board.get_bitboard_piece(piece);
bitboard_for_each_bit(src_i, bitboard) {
Square src = static_cast<Square>(src_i);
- U64 attack = board.get_bitboard_piece_attacks(piece, src) &
- ~board.get_bitboard_color(color);
+ U64 attack = board.get_bitboard_piece_attacks(piece, src) & ~board.get_bitboard_color(color);
bitboard_for_each_bit(tgt_i, attack) {
Square tgt = static_cast<Square>(tgt_i);
res.push_back(
- {move_encode(src_i, tgt_i, &piece,
- board.get_square_piece(tgt), 0, 0, 0, 0),
- 0});
+ {move_encode(src_i, tgt_i, &piece, board.get_square_piece(tgt), 0, 0, 0, 0), 0});
}
}
}
// Castling
if (color == Color::WHITE) {
- static const piece::Piece &piece =
- piece::get(piece::Type::KING, Color::WHITE);
+ static const piece::Piece &piece = piece::get(piece::Type::KING, Color::WHITE);
if (board.get_castle() & to_underlying(Board::Castle::WK)) {
- if (!board.is_square_occupied(Square::f1) &&
- !board.is_square_occupied(Square::g1) &&
+ if (!board.is_square_occupied(Square::f1) && !board.is_square_occupied(Square::g1) &&
!board.is_square_attacked(Square::e1, Color::BLACK) &&
!board.is_square_attacked(Square::f1, Color::BLACK))
- res.push_back({move_encode(to_underlying(Square::e1),
- to_underlying(Square::g1), &piece, 0,
- 0, 0, 0, 1),
- 0});
+ res.push_back(
+ {move_encode(to_underlying(Square::e1), to_underlying(Square::g1), &piece, 0, 0, 0, 0, 1),
+ 0});
}
if (board.get_castle() & to_underlying(Board::Castle::WQ)) {
- if (!board.is_square_occupied(Square::d1) &&
- !board.is_square_occupied(Square::c1) &&
+ if (!board.is_square_occupied(Square::d1) && !board.is_square_occupied(Square::c1) &&
!board.is_square_occupied(Square::b1) &&
!board.is_square_attacked(Square::e1, Color::BLACK) &&
!board.is_square_attacked(Square::d1, Color::BLACK))
- res.push_back({move_encode(to_underlying(Square::e1),
- to_underlying(Square::c1), &piece, 0,
- 0, 0, 0, 1),
- 0});
+ res.push_back(
+ {move_encode(to_underlying(Square::e1), to_underlying(Square::c1), &piece, 0, 0, 0, 0, 1),
+ 0});
}
} else {
- static const piece::Piece &piece =
- piece::get(piece::Type::KING, Color::BLACK);
+ static const piece::Piece &piece = piece::get(piece::Type::KING, Color::BLACK);
if (board.get_castle() & to_underlying(Board::Castle::BK)) {
- if (!board.is_square_occupied(Square::f8) &&
- !board.is_square_occupied(Square::g8) &&
+ if (!board.is_square_occupied(Square::f8) && !board.is_square_occupied(Square::g8) &&
!board.is_square_attacked(Square::e8, Color::WHITE) &&
!board.is_square_attacked(Square::f8, Color::WHITE))
- res.push_back({move_encode(to_underlying(Square::e8),
- to_underlying(Square::g8), &piece, 0,
- 0, 0, 0, 1),
- 0});
+ res.push_back(
+ {move_encode(to_underlying(Square::e8), to_underlying(Square::g8), &piece, 0, 0, 0, 0, 1),
+ 0});
}
if (board.get_castle() & to_underlying(Board::Castle::BQ)) {
- if (!board.is_square_occupied(Square::d8) &&
- !board.is_square_occupied(Square::c8) &&
+ if (!board.is_square_occupied(Square::d8) && !board.is_square_occupied(Square::c8) &&
!board.is_square_occupied(Square::b8) &&
!board.is_square_attacked(Square::e8, Color::WHITE) &&
!board.is_square_attacked(Square::d8, Color::WHITE))
- res.push_back({move_encode(to_underlying(Square::e8),
- to_underlying(Square::c8), &piece, 0,
- 0, 0, 0, 1),
- 0});
+ res.push_back(
+ {move_encode(to_underlying(Square::e8), to_underlying(Square::c8), &piece, 0, 0, 0, 0, 1),
+ 0});
}
}
diff --git a/src/moves/moves_make.cpp b/src/moves/moves_make.cpp
@@ -25,8 +25,7 @@ void _piece_set(Board &board, const piece::Piece &piece, Square square) {
board.xor_hash(zobrist_key_piece(piece, square));
}
-void _piece_move(Board &board, const piece::Piece &piece, Square source,
- Square target) {
+void _piece_move(Board &board, const piece::Piece &piece, Square source, Square target) {
_piece_remove(board, piece, source);
_piece_set(board, piece, target);
}
@@ -40,8 +39,7 @@ int move_make(Move move, Board &board, int flag) {
const Color color = board.get_side();
const Square source = static_cast<Square>(move_source(move));
const Square target = static_cast<Square>(move_target(move));
- const Square ntarget = static_cast<Square>(
- move_target(move) + (color == Color::WHITE ? -8 : +8));
+ const Square ntarget = static_cast<Square>(move_target(move) + (color == Color::WHITE ? -8 : +8));
if (!move_capture(move)) {
if (move_promote(move)) {
@@ -68,18 +66,12 @@ int move_make(Move move, Board &board, int flag) {
board.set_enpassant(move_double(move) ? ntarget : Square::no_sq);
if (move_castle(move)) {
- static constexpr const piece::Piece &rook_white =
- piece::get(piece::Type::ROOK, Color::WHITE);
- static constexpr const piece::Piece &rook_black =
- piece::get(piece::Type::ROOK, Color::BLACK);
- if (target == Square::g1)
- _piece_move(board, rook_white, Square::h1, Square::f1);
- if (target == Square::c1)
- _piece_move(board, rook_white, Square::a1, Square::d1);
- if (target == Square::g8)
- _piece_move(board, rook_black, Square::h8, Square::f8);
- if (target == Square::c8)
- _piece_move(board, rook_black, Square::a8, Square::d8);
+ static constexpr const piece::Piece &rook_white = piece::get(piece::Type::ROOK, Color::WHITE);
+ static constexpr const piece::Piece &rook_black = piece::get(piece::Type::ROOK, Color::BLACK);
+ if (target == Square::g1) _piece_move(board, rook_white, Square::h1, Square::f1);
+ if (target == Square::c1) _piece_move(board, rook_white, Square::a1, Square::d1);
+ if (target == Square::g8) _piece_move(board, rook_black, Square::h8, Square::f8);
+ if (target == Square::c8) _piece_move(board, rook_black, Square::a8, Square::d8);
}
board.xor_hash(zobrist_key_castle(board.get_castle()));
diff --git a/src/perft/CMakeLists.txt b/src/perft/CMakeLists.txt
@@ -6,10 +6,8 @@ if(WITH_FULL_COUNT)
endif()
target_link_libraries(perft
- PRIVATE attacks
PRIVATE board
PRIVATE moves
- PRIVATE piece
PRIVATE random
)
diff --git a/src/perft/perft.cpp b/src/perft/perft.cpp
@@ -4,7 +4,7 @@
#include <stdlib.h>
#include <unistd.h>
-#include "attacks.hpp"
+#include "attack.hpp"
#include "board.hpp"
#include "moves.hpp"
#include "perft.hpp"
@@ -12,8 +12,7 @@
#include "zobrist.hpp"
// FEN debug positions
-#define tricky_position \
- "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1 "
+#define tricky_position "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1 "
void perft_result_print(PerftResult res) {
printf(" - Perft Results -\n\n");
@@ -48,17 +47,16 @@ void perft_result_add(PerftResult *base, PerftResult *add) {
typedef std::vector<MoveE> MoveList;
-void perft_driver(Board &board, MoveList *moveList, int depth,
- PerftResult *result) {
- moveList[depth] = move_list_generate(board);
+void perft_driver(Board &board, int depth, PerftResult *result) {
+ MoveList moveList = move_list_generate(board);
Board copy;
- for (const auto [move, _] : moveList[depth]) {
+ for (const auto [move, _] : moveList) {
copy = board;
if (!move_make(move, copy, 0)) continue;
if (depth != 1) {
- perft_driver(copy, moveList, depth - 1, result);
+ perft_driver(copy, depth - 1, result);
} else {
result->node++;
#ifdef USE_FULL_COUNT
@@ -85,8 +83,6 @@ struct perf_shared {
void *perft_thread(void *arg) {
PerftResult result = {0};
perf_shared *shared = (perf_shared *)arg;
- MoveList moveList[shared->depth + 1];
-
Board board = Board(shared->fen), copy;
while (1) {
@@ -99,13 +95,14 @@ void *perft_thread(void *arg) {
Move move = shared->list[shared->index++].move;
pthread_mutex_unlock(&shared->mutex);
- result = (PerftResult){0};
+ result = {0};
copy = board;
if (!move_make(move, copy, 0)) continue;
+ // std::cout << copy << std::endl;
if (shared->depth != 1) {
- perft_driver(copy, moveList, shared->depth - 1, &result);
+ perft_driver(copy, shared->depth - 1, &result);
} else {
result.node++;
#ifdef USE_FULL_COUNT
@@ -121,8 +118,8 @@ void *perft_thread(void *arg) {
}
PerftResult perft_test(const char *fen, int depth, int thread_num) {
- pthread_t threads[thread_num];
- perf_shared shared = (perf_shared){
+ pthread_t *threads = new pthread_t(thread_num);
+ perf_shared shared = {
.list = move_list_generate(Board(fen)),
.depth = depth,
.fen = fen,
@@ -135,12 +132,13 @@ PerftResult perft_test(const char *fen, int depth, int thread_num) {
for (int i = 0; i < thread_num; i++)
pthread_join(threads[i], NULL);
+ delete threads;
return shared.result;
}
int main(int argc, char *argv[]) {
int c, depth = 1, thread_num = 1;
- std::string s(tricky_position);
+ std::string s(start_position);
const char *fen = s.data();
while ((c = getopt(argc, argv, "t:f:d:")) != -1) {
switch (c) {
@@ -160,7 +158,6 @@ int main(int argc, char *argv[]) {
}
}
- attacks_init();
zobrist_init();
PerftResult res = perft_test(fen, depth, thread_num);
diff --git a/src/piece/CMakeLists.txt b/src/piece/CMakeLists.txt
@@ -1,7 +0,0 @@
-add_library(piece OBJECT
- piece.cpp
-)
-
-target_include_directories(piece
- PUBLIC "${PROJECT_SOURCE_DIR}/src/include"
-)
diff --git a/src/piece/piece.cpp b/src/piece/piece.cpp
@@ -1 +0,0 @@
-#include "piece.hpp"
diff --git a/src/utils/random.cpp b/src/utils/random.cpp
@@ -2,7 +2,9 @@
U32 state = C32(1804289383);
-void random_state_reset() { state = C32(1804289383); }
+void random_state_reset() {
+ state = C32(1804289383);
+}
U32 random_get_U32() {
U32 number = state;
