Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
99 changes: 99 additions & 0 deletions Chess/InplaceVector.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,99 @@
#pragma once

#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <type_traits>

namespace SimpleChessEngine {

template <std::size_t capacity>
using SmallestSizeType = std::conditional_t<
capacity <= std::numeric_limits<std::uint8_t>::max(), std::uint8_t,
std::conditional_t<capacity <= std::numeric_limits<std::uint16_t>::max(),
std::uint16_t, std::size_t>>;

template <class T, std::size_t N>
requires std::is_trivially_copyable_v<T> &&
std::is_trivially_default_constructible_v<T>
class InplaceVector {
public:
using value_type = T;
using size_type = SmallestSizeType<N>;
using difference_type = std::ptrdiff_t;
using reference = T&;
using const_reference = const T&;
using pointer = T*;
using const_pointer = const T*;
using iterator = T*;
using const_iterator = const T*;

constexpr InplaceVector() noexcept = default;

[[nodiscard]] static constexpr std::size_t capacity() noexcept { return N; }
[[nodiscard]] constexpr size_type size() const noexcept { return size_; }
[[nodiscard]] constexpr bool empty() const noexcept { return size_ == 0; }

[[nodiscard]] constexpr iterator begin() noexcept { return elements_.data(); }
[[nodiscard]] constexpr const_iterator begin() const noexcept {
return elements_.data();
}
[[nodiscard]] constexpr iterator end() noexcept { return begin() + size_; }
[[nodiscard]] constexpr const_iterator end() const noexcept {
return begin() + size_;
}

[[nodiscard]] constexpr reference operator[](size_type index) noexcept {
assert(index < size_);
return elements_[index];
}
[[nodiscard]] constexpr const_reference operator[](
size_type index) const noexcept {
assert(index < size_);
return elements_[index];
}
[[nodiscard]] constexpr reference front() noexcept { return (*this)[0]; }
[[nodiscard]] constexpr const_reference front() const noexcept {
return (*this)[0];
}
[[nodiscard]] constexpr reference back() noexcept {
assert(!empty());
return *(end() - 1);
}
[[nodiscard]] constexpr const_reference back() const noexcept {
assert(!empty());
return *(end() - 1);
}

constexpr reference unchecked_push_back(const T& value) noexcept {
assert(size_ < N);
return elements_[size_++] = value;
}

constexpr reference unchecked_push_front(const T& value) noexcept {
assert(size_ < N);
const T inserted = value;
std::move_backward(begin(), end(), end() + 1);
++size_;
return front() = inserted;
}

template <class Predicate>
friend constexpr size_type erase_if(InplaceVector& vector,
Predicate predicate) {
const auto kept_end =
std::remove_if(vector.begin(), vector.end(), predicate);
const auto erased = static_cast<size_type>(vector.end() - kept_end);
vector.size_ = static_cast<size_type>(kept_end - vector.begin());
return erased;
}

private:
std::array<T, N> elements_;
size_type size_ = 0;
};

} // namespace SimpleChessEngine
144 changes: 72 additions & 72 deletions Chess/MoveGenerator.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -9,17 +9,18 @@
namespace SimpleChessEngine {
template <>
void MoveGenerator::GenerateMovesForPiece<Piece::kKing>(
PseudoLegalMove*& moves, Position& position, Bitboard target) const;
PseudoLegalMoves& moves, Position& position, Bitboard target) const;

template MoveGenerator::Moves MoveGenerator::GenerateMoves<
template MoveGenerator::LegalMoves MoveGenerator::GenerateLegalMoves<
MoveGenerator::Type::kAll>(Position& position) const;
template MoveGenerator::Moves MoveGenerator::GenerateMoves<
template MoveGenerator::LegalMoves MoveGenerator::GenerateLegalMoves<
MoveGenerator::Type::kQuiescence>(Position& position) const;


MoveGenerator::~MoveGenerator() = default;

void MoveGenerator::GenerateCastling(PseudoLegalMove*& moves,
const Position& position) {
void MoveGenerator::GenerateCastling(PseudoLegalMoves& moves,
const Position& position) {
if (position.IsUnderCheck()) {
return;
}
Expand All @@ -33,14 +34,15 @@ void MoveGenerator::GenerateCastling(PseudoLegalMove*& moves,
const auto side_idx = static_cast<size_t>(castling_side);
const auto king_to = kKingCastlingDestination[color_idx][side_idx];

*moves++ = PseudoLegalMove(
Move::Make<MoveType::kCastling>(king_square, king_to));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kCastling>(king_square, king_to)));
}
}
}

template <Piece piece>
void MoveGenerator::GenerateMovesForPiece(PseudoLegalMove*& moves, Position& position,
void MoveGenerator::GenerateMovesForPiece(PseudoLegalMoves& moves,
Position& position,
const Bitboard target) const {
static_assert(piece != Piece::kPawn && piece != Piece::kKing);

Expand All @@ -52,7 +54,7 @@ void MoveGenerator::GenerateMovesForPiece(PseudoLegalMove*& moves, Position& pos

template <>
void MoveGenerator::GenerateMovesForPiece<Piece::kPawn>(
PseudoLegalMove*& moves, Position& position, const Bitboard target) const {
PseudoLegalMoves& moves, Position& position, const Bitboard target) const {
const auto us = position.GetSideToMove();
const auto us_idx = static_cast<size_t>(us);
const auto them = Flip(us);
Expand All @@ -77,7 +79,7 @@ void MoveGenerator::GenerateMovesForPiece<Piece::kPawn>(
while (push.Any()) {
const auto to = push.PopFirstBit();
const auto from = Shift(to, opposite_direction);
*moves++ = PseudoLegalMove(Move(from, to));
moves.unchecked_push_back(PseudoLegalMove(Move(from, to)));
}

auto double_push = Shift(double_push_pawns, direction) & valid_squares;
Expand All @@ -86,7 +88,7 @@ void MoveGenerator::GenerateMovesForPiece<Piece::kPawn>(
while (double_push.Any()) {
const auto to = double_push.PopFirstBit();
const auto from = Shift(Shift(to, opposite_direction), opposite_direction);
*moves++ = PseudoLegalMove(Move(from, to));
moves.unchecked_push_back(PseudoLegalMove(Move(from, to)));
}

const auto attacks =
Expand All @@ -113,7 +115,7 @@ void MoveGenerator::GenerateMovesForPiece<Piece::kPawn>(
while (attack_squares.Any()) {
const auto to = attack_squares.PopFirstBit();
const auto from = Shift(to, opposite_attacks[attack_direction]);
*moves++ = PseudoLegalMove(Move(from, to));
moves.unchecked_push_back(PseudoLegalMove(Move(from, to)));
}
}

Expand All @@ -126,7 +128,7 @@ void MoveGenerator::GenerateMovesForPiece<Piece::kPawn>(
if (attack_to.Any()) {
const auto to = en_croissant_square.value();
const auto from = Shift(to, opposite_attacks[attack_direction]);
*moves++ = PseudoLegalMove(Move::Make<MoveType::kEnPassant>(from, to));
moves.unchecked_push_back(PseudoLegalMove(Move::Make<MoveType::kEnPassant>(from, to)));
}
}
}
Expand All @@ -140,14 +142,14 @@ void MoveGenerator::GenerateMovesForPiece<Piece::kPawn>(
const auto to = promotion_push.PopFirstBit();
const auto from = Shift(to, opposite_direction);

*moves++ = PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kQueen));
*moves++ = PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kKnight));
*moves++ = PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kRook));
*moves++ = PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kBishop));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kQueen)));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kKnight)));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kRook)));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kBishop)));
}

for (size_t attack_direction = 0; attack_direction < attacks.size();
Expand All @@ -159,21 +161,22 @@ void MoveGenerator::GenerateMovesForPiece<Piece::kPawn>(
const auto to = attack_squares.PopFirstBit();
const auto from = Shift(to, opposite_attacks[attack_direction]);

*moves++ = PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kQueen));
*moves++ = PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kKnight));
*moves++ = PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kRook));
*moves++ = PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kBishop));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kQueen)));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kKnight)));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kRook)));
moves.unchecked_push_back(PseudoLegalMove(
Move::Make<MoveType::kPromotion>(from, to, Piece::kBishop)));
}
}
}

template <MoveGenerator::Type type>
PseudoLegalMove* MoveGenerator::GeneratePseudoLegal(Position& position,
PseudoLegalMove* moves) const {
MoveGenerator::PseudoLegalMoves MoveGenerator::GeneratePseudoLegalMoves(
Position& position) const {
PseudoLegalMoves moves;
const auto us = position.GetSideToMove();
const auto them = Flip(us);
auto target = ~position.GetPieces(us);
Expand All @@ -199,24 +202,17 @@ PseudoLegalMove* MoveGenerator::GeneratePseudoLegal(Position& position,
target &= ray;
pawn_target &= ray;
}
auto* pawn_begin = moves;
GenerateMovesForPiece<Piece::kPawn>(moves, position,
pawn_target & ~position.GetPieces(us));
auto* pawn_end = moves;
moves = pawn_begin;
for (auto* p = pawn_begin; p != pawn_end; ++p) {
if constexpr (type == Type::kQuiets) {
if (p->IsEnPassant()) continue;
}
if (p->IsEnPassant() && checkers.Any()) {
const auto captured =
static_cast<BitIndex>(p->To() + (us == Player::kWhite ? -8 : 8));
if (!checkers.Test(captured) &&
!Between(king_square, checkers.GetFirstBit()).Test(p->To()))
continue;
}
*moves++ = *p;
}
erase_if(moves, [&](const PseudoLegalMove move) {
if (!move.IsEnPassant()) return false;
if constexpr (type == Type::kQuiets) return true;
if (checkers.None()) return false;
const auto captured =
static_cast<BitIndex>(move.To() + (us == Player::kWhite ? -8 : 8));
return !checkers.Test(captured) &&
!Between(king_square, checkers.GetFirstBit()).Test(move.To());
});
auto generate = [&]<Piece piece>() {
GenerateMovesForPiece<piece>(moves, position, target);
};
Expand All @@ -233,40 +229,43 @@ PseudoLegalMove* MoveGenerator::GeneratePseudoLegal(Position& position,
}

template <MoveGenerator::Type type>
MoveGenerator::Moves MoveGenerator::GenerateMoves(Position& position) const {
std::array<PseudoLegalMove, kMaxMovesPerPosition> moves;
auto* end = GeneratePseudoLegal<type>(position, moves.data());
MoveGenerator::LegalMoves MoveGenerator::GenerateLegalMoves(
Position& position) const {
const auto pseudo_legal = GeneratePseudoLegalMoves<type>(position);
position.ComputePins(position.GetSideToMove());
Moves legal;
legal.reserve(end - moves.data());
for (auto* p = moves.data(); p != end; ++p) {
if (position.IsLegal(*p)) legal.push_back(LegalMove(static_cast<Move>(*p)));
LegalMoves legal;
for (const auto move : pseudo_legal) {
if (position.IsLegal(move)) {
legal.unchecked_push_back(LegalMove(static_cast<Move>(move)));
}
}
return legal;
}

bool MoveGenerator::HasLegalMove(Position& position) const {
std::array<PseudoLegalMove, kMaxMovesPerPosition> moves;
auto* end = GeneratePseudoLegal<Type::kAll>(position, moves.data());
const auto pseudo_legal = GeneratePseudoLegalMoves<Type::kAll>(position);
position.ComputePins(position.GetSideToMove());
return std::any_of(moves.data(), end,
[&position](Move move) {
return position.IsLegal(move);
});
return std::ranges::any_of(pseudo_legal,
[&position](const PseudoLegalMove move) {
return position.IsLegal(move);
});
}

template PseudoLegalMove* MoveGenerator::GeneratePseudoLegal<MoveGenerator::Type::kAll>(
Position&, PseudoLegalMove*) const;
template PseudoLegalMove*
MoveGenerator::GeneratePseudoLegal<MoveGenerator::Type::kCaptures>(Position&,
PseudoLegalMove*) const;
template PseudoLegalMove* MoveGenerator::GeneratePseudoLegal<MoveGenerator::Type::kQuiets>(
Position&, PseudoLegalMove*) const;
template PseudoLegalMove* MoveGenerator::GeneratePseudoLegal<
MoveGenerator::Type::kQuiescence>(Position&, PseudoLegalMove*) const;
template MoveGenerator::PseudoLegalMoves
MoveGenerator::GeneratePseudoLegalMoves<MoveGenerator::Type::kAll>(
Position&) const;
template MoveGenerator::PseudoLegalMoves
MoveGenerator::GeneratePseudoLegalMoves<MoveGenerator::Type::kCaptures>(
Position&) const;
template MoveGenerator::PseudoLegalMoves
MoveGenerator::GeneratePseudoLegalMoves<MoveGenerator::Type::kQuiets>(
Position&) const;
template MoveGenerator::PseudoLegalMoves
MoveGenerator::GeneratePseudoLegalMoves<MoveGenerator::Type::kQuiescence>(
Position&) const;

template <>
void MoveGenerator::GenerateMovesForPiece<Piece::kKing>(PseudoLegalMove*& moves,
void MoveGenerator::GenerateMovesForPiece<Piece::kKing>(PseudoLegalMoves& moves,
Position& position,
Bitboard target) const {
GenerateMovesFromSquare<Piece::kKing>(
Expand All @@ -275,7 +274,8 @@ void MoveGenerator::GenerateMovesForPiece<Piece::kKing>(PseudoLegalMove*& moves,
}

template <Piece piece>
void MoveGenerator::GenerateMovesFromSquare(PseudoLegalMove*& moves, Position& position,
void MoveGenerator::GenerateMovesFromSquare(PseudoLegalMoves& moves,
Position& position,
const BitIndex from,
Bitboard target) const {
assert(position.GetPieceAt(from) == piece);
Expand All @@ -289,7 +289,7 @@ void MoveGenerator::GenerateMovesFromSquare(PseudoLegalMove*& moves, Position& p

while (valid_moves.Any()) {
const auto to = valid_moves.PopFirstBit();
*moves++ = PseudoLegalMove(Move(from, to));
moves.unchecked_push_back(PseudoLegalMove(Move(from, to)));
}
}
} // namespace SimpleChessEngine
Loading
Loading