commit 4e698dee2fb03a902881aa74a33092053a82612e
parent 24b08195dc653f124987c1973d70760d0f688e50
Author: Dimitrije Dobrota <mail@dimitrijedobrota.com>
Date: Fri, 1 Dec 2023 22:58:17 +0000
Modernize the codebase using clang-tidy
Diffstat:
21 files changed, 148 insertions(+), 142 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -3,7 +3,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
project(
Stellar
- VERSION 9.0.4
+ VERSION 1.1.1
DESCRIPTION "Chess engine written in C++"
HOMEPAGE_URL https://git.dimitrijedobrota.com/stellar.git
LANGUAGES CXX
diff --git a/src/arena/arena.cpp b/src/arena/arena.cpp
@@ -65,10 +65,10 @@ void usage(const char *program) {
}
int main(int argc, char *argv[]) {
- char *engine1 = NULL, *engine2 = NULL;
+ char *engine1 = nullptr, *engine2 = nullptr;
Match::Settings settings1, settings2;
- char c;
+ char c = 0;
while ((c = getopt(argc, argv, "hE:e:D:d:T:t:I:i:G:g:N:")) != -1) {
switch (c) {
case 'E': engine1 = optarg; break;
@@ -93,7 +93,7 @@ int main(int argc, char *argv[]) {
std::vector<std::string> positions;
for (int i = optind; i < argc; i++)
- positions.push_back(!strcmp(argv[i], "-") ? start_position : argv[i]);
+ positions.emplace_back(!strcmp(argv[i], "-") ? start_position : argv[i]);
Arena arena(engine1, engine2);
arena(positions, settings1, settings2);
diff --git a/src/arena/engine.cpp b/src/arena/engine.cpp
@@ -44,7 +44,7 @@ Engine::Engine(const char *file) : file(file) {
Engine::~Engine() {
send("quit");
- waitpid(engine_pid, NULL, 0);
+ waitpid(engine_pid, nullptr, 0);
// kill(engine_pid, SIGKILL);
if (close(fd_to[1]) < 0) logger::error("close");
@@ -68,7 +68,7 @@ void Engine::send(std::string &&command) {
logger::log(std::format("Engine {}: TO {}: {}", id, name.size() ? name : file, command), logger::Info);
}
-std::string Engine::receive(void) {
+std::string Engine::receive() {
int size = 0;
while (true) {
@@ -104,7 +104,7 @@ std::string Engine::receive(void) {
}
}
-[[noreturn]] void Engine::start_engine(void) {
+[[noreturn]] void Engine::start_engine() {
if (close(fd_to[1]) < 0 || close(fd_from[0])) {
logger::error("close");
throw std::runtime_error("close failed");
@@ -115,7 +115,7 @@ std::string Engine::receive(void) {
throw std::runtime_error("dup2 failed");
}
- execl(file, file, (char *)NULL);
+ execl(file, file, (char *)nullptr);
logger::error("execl");
throw std::runtime_error("execl failed");
}
diff --git a/src/arena/engine.hpp b/src/arena/engine.hpp
@@ -11,22 +11,22 @@ class Engine {
~Engine();
- const std::string &get_name(void) const { return name; }
- const std::string &get_author(void) const { return author; }
+ [[nodiscard]] const std::string &get_name() const { return name; }
+ [[nodiscard]] const std::string &get_author() const { return author; }
void send(std::string &&command);
- std::string receive(void);
+ std::string receive();
private:
- [[noreturn]] void start_engine(void);
+ [[noreturn]] void start_engine();
const char *file = nullptr;
- int fd_to[2], fd_from[2];
+ int fd_to[2]{}, fd_from[2]{};
pid_t engine_pid;
std::string name, author;
- char rb[1000];
+ char rb[1000]{};
int rb_size = 0;
std::queue<std::string> q;
diff --git a/src/arena/game.cpp b/src/arena/game.cpp
@@ -16,7 +16,7 @@ Game::Game(const uint16_t match_id, const std::string white, const std::string b
logger::log(std::format("Game {}: started", id), logger::Debug);
}
-const std::string Game::get_moves(void) const {
+const std::string Game::get_moves() const {
std::string res;
if (list.size()) res += (std::string)list[0];
for (int i = 1; i < list.size(); i++)
@@ -43,7 +43,7 @@ const std::string Game::to_san(const Board &board, const Move move) {
if (bit::count(potential) > 1) {
int file[9] = {0}, rank[9] = {0};
- uint8_t square_i;
+ uint8_t square_i = 0;
bitboard_for_each_bit(square_i, potential) {
const std::string crd = square::to_coordinates(static_cast<square::Square>(square_i));
file[crd[0] & 0x3]++;
diff --git a/src/arena/game.hpp b/src/arena/game.hpp
@@ -18,14 +18,14 @@ class Game {
void play(const Move move) { list.push(move); }
- const std::string get_moves(void) const;
- const std::string &get_white(void) const { return white; }
- const std::string &get_black(void) const { return black; }
- const Terminate get_terminate(void) const { return terminate; }
-
- const bool is_win_white(void) const { return !draw && winner == color::WHITE; }
- const bool is_win_black(void) const { return !draw && winner == color::BLACK; }
- const bool is_draw(void) const { return draw; }
+ [[nodiscard]] const std::string get_moves() const;
+ [[nodiscard]] const std::string &get_white() const { return white; }
+ [[nodiscard]] const std::string &get_black() const { return black; }
+ [[nodiscard]] const Terminate get_terminate() const { return terminate; }
+
+ [[nodiscard]] const bool is_win_white() const { return !draw && winner == color::WHITE; }
+ [[nodiscard]] const bool is_win_black() const { return !draw && winner == color::BLACK; }
+ [[nodiscard]] const bool is_draw() const { return draw; }
void set_terminate(const Terminate terminate) { this->terminate = terminate; }
void set_winner(const color::Color winner) { this->winner = winner; }
diff --git a/src/attack/attack.hpp b/src/attack/attack.hpp
@@ -15,7 +15,7 @@
namespace attack {
-typedef U64 (*attack_f)(const square::Square square, U64 occupancy);
+using attack_f = U64 (*)(const square::Square, U64);
}
diff --git a/src/board/board.cpp b/src/board/board.cpp
@@ -1,7 +1,7 @@
-#include <ctype.h>
+#include <cctype>
#include <exception>
-#include <stdio.h>
-#include <string.h>
+#include <cstdio>
+#include <cstring>
#include "board.hpp"
#include "piece.hpp"
@@ -12,7 +12,7 @@
/* Getters */
Board::Board(const std::string &fen) {
- int file = 0, rank = 7, i;
+ int file = 0, rank = 7, i = 0;
for (i = 0; fen[i] != ' '; i++) {
if (isalpha(fen[i])) {
const piece::Piece &piece = piece::get_from_code(fen[i]);
@@ -58,7 +58,7 @@ std::ostream &operator<<(std::ostream &os, const Board &board) {
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
if (!file) os << 8 - rank << " ";
- square::Square square = static_cast<square::Square>((7 - rank) * 8 + file);
+ auto square = static_cast<square::Square>((7 - rank) * 8 + file);
const piece::Piece *piece = board.get_square_piece(square);
os << (piece ? piece->code : '.') << " ";
}
diff --git a/src/board/board.hpp b/src/board/board.hpp
@@ -29,32 +29,32 @@ class Board {
/* Getters */
- inline constexpr U64 get_hash(void) const;
- inline constexpr color::Color get_side(void) const;
- inline constexpr uint8_t get_castle(void) const;
- inline constexpr square::Square get_enpassant(void) const;
+ [[nodiscard]] inline constexpr U64 get_hash() const;
+ [[nodiscard]] inline constexpr color::Color get_side() const;
+ [[nodiscard]] inline constexpr uint8_t get_castle() const;
+ [[nodiscard]] inline constexpr square::Square get_enpassant() const;
- inline constexpr U64 get_bitboard_color(color::Color side) const;
- inline constexpr U64 get_bitboard_occupancy(void) const;
+ [[nodiscard]] inline constexpr U64 get_bitboard_color(color::Color side) const;
+ [[nodiscard]] inline constexpr U64 get_bitboard_occupancy() const;
- inline constexpr U64 get_bitboard_piece(piece::Type piece) const;
- inline constexpr U64 get_bitboard_piece(piece::Type piece, color::Color color) const;
+ [[nodiscard]] inline constexpr U64 get_bitboard_piece(piece::Type piece) const;
+ [[nodiscard]] inline constexpr U64 get_bitboard_piece(piece::Type piece, color::Color color) const;
- inline constexpr U64 get_bitboard_piece_attacks(piece::Type piece, color::Color color,
+ [[nodiscard]] inline constexpr U64 get_bitboard_piece_attacks(piece::Type piece, color::Color color,
square::Square from) const;
- inline constexpr U64 get_bitboard_piece_moves(piece::Type piece, color::Color color,
+ [[nodiscard]] inline constexpr U64 get_bitboard_piece_moves(piece::Type piece, color::Color color,
square::Square from) const;
- inline constexpr U64 get_bitboard_square_land(square::Square land, piece::Type piece,
+ [[nodiscard]] inline constexpr U64 get_bitboard_square_land(square::Square land, piece::Type piece,
color::Color side) const;
- inline constexpr color::Color get_square_piece_color(square::Square square) const;
- inline constexpr piece::Type get_square_piece_type(square::Square square) const;
- inline constexpr const piece::Piece *get_square_piece(square::Square square) const;
+ [[nodiscard]] inline constexpr color::Color get_square_piece_color(square::Square square) const;
+ [[nodiscard]] inline constexpr piece::Type get_square_piece_type(square::Square square) const;
+ [[nodiscard]] inline constexpr const piece::Piece *get_square_piece(square::Square square) const;
/* Setters */
inline constexpr void xor_hash(U64 op);
- inline constexpr void switch_side(void);
+ inline constexpr void switch_side();
inline constexpr void and_castle(uint8_t right);
inline constexpr void set_enpassant(square::Square target);
@@ -69,11 +69,11 @@ class Board {
/* Queries */
- inline constexpr bool is_square_attacked(square::Square square, color::Color side) const;
- inline constexpr bool is_square_occupied(square::Square square) const;
- inline constexpr bool is_piece_attack_square(piece::Type type, color::Color color, square::Square source,
+ [[nodiscard]] inline constexpr bool is_square_attacked(square::Square square, color::Color side) const;
+ [[nodiscard]] inline constexpr bool is_square_occupied(square::Square square) const;
+ [[nodiscard]] inline constexpr bool is_piece_attack_square(piece::Type type, color::Color color, square::Square source,
square::Square target) const;
- inline constexpr bool is_check(void) const;
+ [[nodiscard]] inline constexpr bool is_check() const;
private:
U64 colors[2] = {0};
@@ -84,14 +84,14 @@ class Board {
uint8_t castle = 0;
};
-constexpr color::Color Board::get_side(void) const { return side; }
-constexpr U64 Board::get_hash(void) const { return hash; }
-constexpr uint8_t Board::get_castle(void) const { return castle; }
-constexpr square::Square Board::get_enpassant(void) const { return enpassant; }
+constexpr color::Color Board::get_side() const { return side; }
+constexpr U64 Board::get_hash() const { return hash; }
+constexpr uint8_t Board::get_castle() const { return castle; }
+constexpr square::Square Board::get_enpassant() const { return enpassant; }
constexpr U64 Board::get_bitboard_color(color::Color side) const { return colors[to_underlying(side)]; }
-constexpr U64 Board::get_bitboard_occupancy(void) const {
+constexpr U64 Board::get_bitboard_occupancy() const {
return colors[to_underlying(color::WHITE)] | colors[to_underlying(color::BLACK)];
}
@@ -147,7 +147,7 @@ constexpr void Board::and_castle(uint8_t right) {
hash ^= Zobrist::key_castle(castle);
}
-constexpr void Board::switch_side(void) {
+constexpr void Board::switch_side() {
side = color::other(side);
hash ^= Zobrist::key_side();
}
@@ -195,11 +195,11 @@ constexpr bool Board::is_square_attacked(square::Square square, color::Color sid
for (piece::Type type : piece::TypeIter()) {
if (get_bitboard_piece_attacks(type, side_other, square) & get_bitboard_piece(type, side)) {
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
constexpr bool Board::is_piece_attack_square(piece::Type type, color::Color color, square::Square source,
@@ -207,16 +207,16 @@ constexpr bool Board::is_piece_attack_square(piece::Type type, color::Color colo
return get_bitboard_piece_attacks(type, color, source) & (C64(1) << to_underlying(target));
}
-constexpr bool Board::is_check(void) const {
+constexpr bool Board::is_check() const {
U64 king = pieces[to_underlying(piece::Type::KING)] & colors[to_underlying(side)];
color::Color side_other = (side == color::BLACK) ? color::WHITE : color::BLACK;
- square::Square square = static_cast<square::Square>(bit::lsb_index(king));
+ auto square = static_cast<square::Square>(bit::lsb_index(king));
return is_square_attacked(square, side_other);
}
U64 Zobrist::hash(const Board &board) {
U64 key_final = C64(0);
- uint8_t square;
+ uint8_t square = 0;
for (piece::Type type : piece::TypeIter()) {
int piece_white_index = piece::get_index(type, color::WHITE);
diff --git a/src/board/zobrist.hpp b/src/board/zobrist.hpp
@@ -14,7 +14,7 @@ class Zobrist {
Zobrist() = delete;
static inline U64 hash(const Board &board);
- static inline constexpr U64 key_side(void) { return keys_side; }
+ static inline constexpr U64 key_side() { return keys_side; }
static inline constexpr U64 key_castle(int exp) { return keys_castle[exp]; }
static inline constexpr U64 key_enpassant(square::Square square) {
return keys_enpassant[to_underlying(square)];
@@ -24,7 +24,7 @@ class Zobrist {
}
private:
- typedef std::array<std::array<U64, 64>, 12> key_piece_array;
+ using key_piece_array = std::array<std::array<U64, 64>, 12>;
static inline constexpr const key_piece_array keys_piece = []() constexpr -> key_piece_array {
key_piece_array key_piece;
Random gen(C64(1804289383));
@@ -39,7 +39,7 @@ class Zobrist {
return key_piece;
}();
- typedef std::array<U64, 64> key_enpassant_array;
+ using key_enpassant_array = std::array<U64, 64>;
static inline constexpr const key_enpassant_array keys_enpassant = []() constexpr -> key_enpassant_array {
key_enpassant_array key_enpassant;
Random gen(C32(337245213));
@@ -49,7 +49,7 @@ class Zobrist {
return key_enpassant;
}();
- typedef std::array<U64, 16> key_castle_array;
+ using key_castle_array = std::array<U64, 16>;
static inline constexpr const key_castle_array keys_castle = []() constexpr -> key_castle_array {
key_castle_array key_castle;
Random gen(C32(3642040919));
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
@@ -1,8 +1,8 @@
#include <algorithm>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <cctype>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
#include "attack.hpp"
#include "board.hpp"
@@ -16,11 +16,15 @@
#include "uci.hpp"
#include "utils.hpp"
-#define FULL_DEPTH 4
-#define REDUCTION_LIMIT 3
-#define REDUCTION_MOVE 2
+enum {
+FULL_DEPTH = 4,
+REDUCTION_LIMIT = 3,
+REDUCTION_MOVE = 2
+};
-#define WINDOW 50
+enum {
+WINDOW = 50
+};
namespace engine {
@@ -41,7 +45,7 @@ class TTable {
public:
static inline constexpr const int16_t unknown = 32500;
- TTable() {}
+ TTable() = default;
TTable(U64 size) : table(size, {0}) {}
void clear() { table.clear(); };
@@ -424,7 +428,7 @@ Move search_position(const uci::Settings &settingsr) {
uint8_t max_depth = settings->depth ? settings->depth : MAX_PLY;
for (uint8_t depth = 1; depth <= max_depth; depth++) {
lastBest = pvtable.best();
- follow_pv = 1;
+ follow_pv = true;
int16_t score = negamax(alpha, beta, depth, true);
uci::communicate(settings);
@@ -468,7 +472,7 @@ Move search_position(const uci::Settings &settingsr) {
}
} // namespace engine
-int main(void) {
+int main() {
uci::loop();
return 0;
}
diff --git a/src/engine/evaluate.cpp b/src/engine/evaluate.cpp
@@ -10,7 +10,7 @@
namespace evaluate {
-typedef std::array<U64, 8> mask_fr_array;
+using mask_fr_array = std::array<U64, 8>;
inline constexpr const mask_fr_array mask_rank = []() constexpr -> mask_fr_array {
mask_fr_array mask_rank;
U64 mask = 0xFF;
@@ -45,11 +45,11 @@ inline constexpr const mask_fr_array mask_isolated = []() constexpr -> mask_fr_a
return mask_isolated;
}();
-typedef std::array<std::array<U64, 64>, 2> mask_passed_array;
+using mask_passed_array = std::array<std::array<U64, 64>, 2>;
inline constexpr const mask_passed_array mask_passed = []() constexpr -> mask_passed_array {
mask_passed_array mask_passed;
- U64 maskW, maskB;
+ U64 maskW = 0, maskB = 0;
for (uint8_t file = 0; file < 8; file++) {
maskW = maskB = mask_file[file] | mask_isolated[file];
for (uint8_t rank = 0; rank < 8; rank++) {
@@ -96,7 +96,7 @@ int16_t score_position_side(const Board &board, const color::Color side, const u
bitboard = board.get_bitboard_piece(PAWN, side);
bitboard_for_each_bit(square_i, bitboard) {
- const square::Square square = static_cast<square::Square>(square_i);
+ const auto square = static_cast<square::Square>(square_i);
opening += score::get(PAWN, side, square, OPENING) + score::get(PAWN, OPENING);
endgame += score::get(PAWN, side, square, ENDGAME) + score::get(PAWN, ENDGAME);
@@ -117,21 +117,21 @@ int16_t score_position_side(const Board &board, const color::Color side, const u
bitboard = board.get_bitboard_piece(KNIGHT, side);
bitboard_for_each_bit(square_i, bitboard) {
- const square::Square square = static_cast<square::Square>(square_i);
+ const auto square = static_cast<square::Square>(square_i);
opening += score::get(KNIGHT, side, square, OPENING) + score::get(KNIGHT, OPENING);
endgame += score::get(KNIGHT, side, square, ENDGAME) + score::get(KNIGHT, ENDGAME);
}
bitboard = board.get_bitboard_piece(BISHOP, side);
bitboard_for_each_bit(square_i, bitboard) {
- const square::Square square = static_cast<square::Square>(square_i);
+ const auto square = static_cast<square::Square>(square_i);
opening += score::get(BISHOP, side, square, OPENING) + score::get(BISHOP, OPENING);
endgame += score::get(BISHOP, side, square, ENDGAME) + score::get(BISHOP, ENDGAME);
}
bitboard = board.get_bitboard_piece(ROOK, side);
bitboard_for_each_bit(square_i, bitboard) {
- const square::Square square = static_cast<square::Square>(square_i);
+ const auto square = static_cast<square::Square>(square_i);
opening += score::get(ROOK, side, square, OPENING) + score::get(ROOK, OPENING);
endgame += score::get(ROOK, side, square, ENDGAME) + score::get(ROOK, ENDGAME);
@@ -143,14 +143,14 @@ int16_t score_position_side(const Board &board, const color::Color side, const u
bitboard = board.get_bitboard_piece(QUEEN, side);
bitboard_for_each_bit(square_i, bitboard) {
- const square::Square square = static_cast<square::Square>(square_i);
+ const auto square = static_cast<square::Square>(square_i);
opening += score::get(QUEEN, side, square, OPENING) + score::get(QUEEN, OPENING);
endgame += score::get(QUEEN, side, square, ENDGAME) + score::get(QUEEN, ENDGAME);
}
bitboard = board.get_bitboard_piece(KING, side);
bitboard_for_each_bit(square_i, bitboard) {
- const square::Square square = static_cast<square::Square>(square_i);
+ const auto square = static_cast<square::Square>(square_i);
opening += score::get(KING, side, square, OPENING) + score::get(KING, OPENING);
endgame += score::get(KING, side, square, ENDGAME) + score::get(KING, ENDGAME);
diff --git a/src/engine/uci.cpp b/src/engine/uci.cpp
@@ -35,7 +35,7 @@ inline bool parse_move(const Board &board, Move &move, const std::string &move_s
return false;
}
-void loop(void) {
+void loop() {
static Settings settings;
static std::string line, command;
static Move move;
diff --git a/src/engine/uci.hpp b/src/engine/uci.hpp
@@ -29,8 +29,8 @@ struct Settings {
mutable bool stopped = false;
};
-void loop(void);
-uint32_t get_time_ms(void);
+void loop();
+uint32_t get_time_ms();
void communicate(const uci::Settings *settings);
} // namespace uci
diff --git a/src/move/move.cpp b/src/move/move.cpp
@@ -40,7 +40,7 @@ bool Move::make(Board &board) const {
const color::Color color = board.get_side(), colorOther = color::other(color);
const square::Square source = this->source(), target = this->target();
- const square::Square ntarget =
+ const auto ntarget =
static_cast<square::Square>(to_underlying(this->target()) + (color == color::Color::WHITE ? -8 : +8));
const piece::Type piece = board.get_square_piece_type(source);
@@ -88,12 +88,12 @@ bool Move::make(Board &board) const {
if (!board.is_check()) {
board.switch_side();
- return 1;
+ return true;
}
- return 0;
+ return false;
}
-void Move::print(void) const {
+void Move::print() const {
std::cout << square::to_coordinates(source()) << " ";
std::cout << square::to_coordinates(target()) << " ";
std::cout << (is_promote() ? piece::get_code(promoted()) : '.') << " ";
diff --git a/src/move/move.hpp b/src/move/move.hpp
@@ -35,29 +35,29 @@ struct Move {
return a.source_i == b.source_i && a.target_i == b.target_i && a.flags_i == b.flags_i;
}
- square::Square source(void) const { return static_cast<square::Square>(source_i); }
- square::Square target(void) const { return static_cast<square::Square>(target_i); }
+ [[nodiscard]] square::Square source() const { return static_cast<square::Square>(source_i); }
+ [[nodiscard]] square::Square target() const { return static_cast<square::Square>(target_i); }
- bool is_capture(void) const { return flags_i != PQUIET && (flags_i & CAPTURE); }
- bool is_promote(void) const { return flags_i & 0x8; }
+ [[nodiscard]] bool is_capture() const { return flags_i != PQUIET && (flags_i & CAPTURE); }
+ [[nodiscard]] bool is_promote() const { return flags_i & 0x8; }
- bool is_double(void) const { return flags_i == DOUBLE; }
- bool is_repeatable(void) const { return flags_i == QUIET; }
- bool is_quiet(void) const { return flags_i == QUIET || flags_i == PQUIET; }
+ [[nodiscard]] bool is_double() const { return flags_i == DOUBLE; }
+ [[nodiscard]] bool is_repeatable() const { return flags_i == QUIET; }
+ [[nodiscard]] bool is_quiet() const { return flags_i == QUIET || flags_i == PQUIET; }
- bool is_castle(void) const { return flags_i == CASTLEK || flags_i == CASTLEQ; }
- bool is_castle_king(void) const { return flags_i == CASTLEK; }
- bool is_castle_queen(void) const { return flags_i == CASTLEQ; }
+ [[nodiscard]] bool is_castle() const { return flags_i == CASTLEK || flags_i == CASTLEQ; }
+ [[nodiscard]] bool is_castle_king() const { return flags_i == CASTLEK; }
+ [[nodiscard]] bool is_castle_queen() const { return flags_i == CASTLEQ; }
- bool is_enpassant(void) const { return flags_i == ENPASSANT; }
+ [[nodiscard]] bool is_enpassant() const { return flags_i == ENPASSANT; }
- const piece::Type promoted(void) const { return static_cast<piece::Type>((flags_i & 0x3) + 1); }
+ [[nodiscard]] const piece::Type promoted() const { return static_cast<piece::Type>((flags_i & 0x3) + 1); }
bool make(Board &board) const;
operator std::string() const;
friend std::ostream &operator<<(std::ostream &os, Move move);
- void print(void) const;
+ void print() const;
private:
inline void piece_remove(Board &board, piece::Type type, color::Color color, square::Square square) const;
diff --git a/src/move/movelist.cpp b/src/move/movelist.cpp
@@ -14,7 +14,7 @@
using piece::Type::PAWN;
void MoveList::generate(const Board &board, bool attacks_only) {
- uint8_t src_i, tgt_i;
+ uint8_t src_i = 0, tgt_i = 0;
const color::Color color = board.get_side(), colorOther = color::other(color);
@@ -23,21 +23,21 @@ void MoveList::generate(const Board &board, bool attacks_only) {
U64 bitboard = board.get_bitboard_piece(PAWN, color);
bitboard_for_each_bit(src_i, bitboard) {
- const square::Square src = static_cast<square::Square>(src_i);
- const square::Square tgt = static_cast<square::Square>(tgt_i = src_i + add);
+ const auto src = static_cast<square::Square>(src_i);
+ const auto tgt = static_cast<square::Square>(tgt_i = src_i + add);
if (!attacks_only && !board.is_square_occupied(tgt)) {
if (pawn_canPromote(color, src)) {
- list.push_back({src, tgt, Move::PKNIGHT});
- list.push_back({src, tgt, Move::PBISHOP});
- list.push_back({src, tgt, Move::PROOK});
- list.push_back({src, tgt, Move::PQUEEN});
+ list.emplace_back(src, tgt, Move::PKNIGHT);
+ list.emplace_back(src, tgt, Move::PBISHOP);
+ list.emplace_back(src, tgt, Move::PROOK);
+ list.emplace_back(src, tgt, Move::PQUEEN);
} else {
- list.push_back({src, tgt, Move::PQUIET});
+ list.emplace_back(src, tgt, Move::PQUIET);
// two ahead
- const square::Square tgt = static_cast<square::Square>(tgt_i + add);
+ const auto tgt = static_cast<square::Square>(tgt_i + add);
if (pawn_onStart(color, src) && !board.is_square_occupied(tgt))
- list.push_back({src, tgt, Move::DOUBLE});
+ list.emplace_back(src, tgt, Move::DOUBLE);
}
}
@@ -45,36 +45,36 @@ void MoveList::generate(const Board &board, bool attacks_only) {
U64 attack =
board.get_bitboard_piece_attacks(PAWN, color, src) & board.get_bitboard_color(colorOther);
bitboard_for_each_bit(tgt_i, attack) {
- const square::Square tgt = static_cast<square::Square>(tgt_i);
+ const auto tgt = static_cast<square::Square>(tgt_i);
if (pawn_canPromote(color, src)) {
- list.push_back({src, tgt, Move::PCKNIGHT});
- list.push_back({src, tgt, Move::PCBISHOP});
- list.push_back({src, tgt, Move::PCROOK});
- list.push_back({src, tgt, Move::PCQUEEN});
+ list.emplace_back(src, tgt, Move::PCKNIGHT);
+ list.emplace_back(src, tgt, Move::PCBISHOP);
+ list.emplace_back(src, tgt, Move::PCROOK);
+ list.emplace_back(src, tgt, Move::PCQUEEN);
} else {
- list.push_back({src, tgt, Move::CAPTURE});
+ list.emplace_back(src, tgt, Move::CAPTURE);
}
}
// en passant
const square::Square enpassant = board.get_enpassant();
if (enpassant != square::no_sq && board.is_piece_attack_square(PAWN, color, src, enpassant))
- list.push_back({src, enpassant, Move::ENPASSANT});
+ list.emplace_back(src, enpassant, Move::ENPASSANT);
}
// All piece move
for (const piece::Type type : ++piece::TypeIter()) {
U64 bitboard = board.get_bitboard_piece(type, color);
bitboard_for_each_bit(src_i, bitboard) {
- const square::Square src = static_cast<square::Square>(src_i);
+ const auto src = static_cast<square::Square>(src_i);
U64 attack = board.get_bitboard_piece_moves(type, color, src);
bitboard_for_each_bit(tgt_i, attack) {
- const square::Square tgt = static_cast<square::Square>(tgt_i);
+ const auto tgt = static_cast<square::Square>(tgt_i);
if (board.is_square_occupied(tgt)) {
- list.push_back({src, tgt, Move::CAPTURE});
+ list.emplace_back(src, tgt, Move::CAPTURE);
} else {
if (attacks_only) continue;
- list.push_back({src, tgt, Move::QUIET});
+ list.emplace_back(src, tgt, Move::QUIET);
}
}
}
@@ -88,14 +88,14 @@ void MoveList::generate(const Board &board, bool attacks_only) {
if (board.get_castle() & to_underlying(Board::Castle::WK)) {
if (!board.is_square_occupied(square::f1) && !board.is_square_occupied(square::g1) &&
!board.is_square_attacked(square::f1, color::BLACK))
- list.push_back({square::e1, square::g1, Move::CASTLEK});
+ list.emplace_back(square::e1, square::g1, Move::CASTLEK);
}
if (board.get_castle() & to_underlying(Board::Castle::WQ)) {
if (!board.is_square_occupied(square::d1) && !board.is_square_occupied(square::c1) &&
!board.is_square_occupied(square::b1) &&
!board.is_square_attacked(square::d1, color::BLACK) &&
!board.is_square_attacked(square::c1, color::BLACK))
- list.push_back({square::e1, square::c1, Move::CASTLEQ});
+ list.emplace_back(square::e1, square::c1, Move::CASTLEQ);
}
}
} else {
@@ -103,14 +103,14 @@ void MoveList::generate(const Board &board, bool attacks_only) {
if (board.get_castle() & to_underlying(Board::Castle::BK)) {
if (!board.is_square_occupied(square::f8) && !board.is_square_occupied(square::g8) &&
!board.is_square_attacked(square::f8, color::WHITE))
- list.push_back({square::Square::e8, square::Square::g8, Move::CASTLEK});
+ list.emplace_back(square::Square::e8, square::Square::g8, Move::CASTLEK);
}
if (board.get_castle() & to_underlying(Board::Castle::BQ)) {
if (!board.is_square_occupied(square::d8) && !board.is_square_occupied(square::c8) &&
!board.is_square_occupied(square::b8) &&
!board.is_square_attacked(square::d8, color::WHITE) &&
!board.is_square_attacked(square::c8, color::WHITE))
- list.push_back({square::e8, square::c8, Move::CASTLEQ});
+ list.emplace_back(square::e8, square::c8, Move::CASTLEQ);
}
}
}
diff --git a/src/move/movelist.hpp b/src/move/movelist.hpp
@@ -21,15 +21,15 @@ class MoveList {
if (!legal) return;
int size = 0;
- for (int i = 0; i < list.size(); i++) {
+ for (const auto& move : list) {
Board copy = board;
- if (list[i].make(copy)) list[size++] = list[i];
+ if (move.make(copy)) list[size++] = move;
}
list.resize(size);
}
void clear() { list.clear(); }
- int size() const { return list.size(); }
+ [[nodiscard]] int size() const { return list.size(); }
const Move operator[](size_t idx) const { return list[idx]; }
Move &operator[](size_t idx) { return list[idx]; }
diff --git a/src/perft/perft.cpp b/src/perft/perft.cpp
@@ -10,11 +10,13 @@
// FEN debug positions
#define tricky_position "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1 "
-#define THREAD_MAX 64
+enum {
+THREAD_MAX = 64
+};
class Perft {
public:
- typedef std::counting_semaphore<THREAD_MAX> semaphore_t;
+ using semaphore_t = std::counting_semaphore<THREAD_MAX>;
Perft(semaphore_t &sem) : sem(sem) {}
void operator()(const Board &board_start, Move move, int depth) {
Board board = board_start;
@@ -130,7 +132,7 @@ void usage(const char *program) {
}
int main(int argc, char *argv[]) {
- int c, depth = 1, thread_num = 1;
+ int c = 0, depth = 1, thread_num = 1;
std::string s(start_position);
const char *fen = s.data();
while ((c = getopt(argc, argv, "ht:f:d:")) != -1) {
diff --git a/src/utils/repetition.hpp b/src/utils/repetition.hpp
@@ -7,7 +7,7 @@ class Table {
public:
Table() = default;
- bool is_repetition(const U64 hash) const {
+ [[nodiscard]] bool is_repetition(const U64 hash) const {
for (int i = repetitions.size() - 1; i >= 0; i--) {
if (repetitions[i] == hash) return true;
if (repetitions[i] == hashNull) return false;
@@ -15,9 +15,9 @@ class Table {
return false;
}
- void pop(void) { repetitions.pop_back(); }
- void clear(void) { repetitions.clear(); }
- void push_null(void) { repetitions.push_back(hashNull); }
+ void pop() { repetitions.pop_back(); }
+ void clear() { repetitions.clear(); }
+ void push_null() { repetitions.push_back(hashNull); }
void push_hash(U64 hash) { repetitions.push_back(hash); }
friend std::ostream &operator<<(std::ostream &os, const Table &rtable) {
diff --git a/src/utils/timer.hpp b/src/utils/timer.hpp
@@ -5,9 +5,9 @@
namespace timer {
-inline uint32_t get_ms(void) {
- struct timeval time;
- gettimeofday(&time, NULL);
+inline uint32_t get_ms() {
+ struct timeval time{};
+ gettimeofday(&time, nullptr);
return time.tv_sec * 1000 + time.tv_usec / 1000;
}
