Implement Search

Board.cpp

@@ -32,6 +32,45 @@ Piece::Optional Board::piece(const Square &square) const {
     return Piece(c, t);
 }
 
+int Board::evaluate() const {
+    int score = evaluate(mTurn);
+    score -= evaluate(!mTurn);
+
+    return score;
+}
+
+int Board::evaluate(const PieceColor color) const {
+    // Pawns
+    int score = 0;
+
+    BitBoard bb;
+    BitBoard colorMask = mPieceBBs[toIndex(color)];
+    for (int i = 2; i < 8; i++) {
+        bb = mPieceBBs[i] & colorMask;
+        while (bb) {
+            bb.pop();
+            score += mPieceValue[i];
+        }
+    }
+
+    return score;
+}
+
+bool Board::isCheckMate() const {
+    auto moves = MoveVec();
+    pseudoLegalMoves(moves);
+
+    if (!moves.empty())
+        return false;
+
+    BoardState bs = BoardState(&mPieceBBs, mOccupiedBB, mTurn, mCR, mEPS);
+    auto attacked = MoveGenerator::generateAttackedSquares(bs, ~mOccupiedBB, !mTurn);
+
+    return attacked & mPieceBBs[toIndex(PieceType::King)] & mPieceBBs[toIndex(mTurn)];
+
+    return moves.empty();
+}
+
 void Board::setTurn(PieceColor turn) {
     mTurn = turn;
 }
@@ -143,10 +182,11 @@ void Board::handlePawnDoubleAdvance(const Move &move, BitBoard bb, const Piece &
 }
 
 void Board::pseudoLegalMoves(MoveVec &moves) const {
-    auto occupied = mOccupiedBB;
-    while(occupied) {
-        auto to = Square(occupied.pop());
-        pseudoLegalMovesFrom(to, moves);
+    auto pieces = mPieceBBs[toIndex(mTurn)];
+
+    while (pieces) {
+        auto sq = Square(pieces.pop());
+        pseudoLegalMovesFrom(sq, moves);
     }
 }
 
@@ -158,29 +198,21 @@ void Board::pseudoLegalMovesFrom(const Square &from, Board::MoveVec &moves) cons
     }
 
     BoardState bs = BoardState(&mPieceBBs, mOccupiedBB, mTurn, mCR, mEPS);
-    auto p = Piece(mTurn, pieceType(fromBB));
 
-    BitBoard movesBB;
-    switch (p.type()) {
+    switch (pieceType(fromBB)) {
     case PieceType::Pawn: MoveGenerator::generatePawnMoves(bs, from, moves);
-        return;
+        break;
     case PieceType::Knight: MoveGenerator::generateKnightMoves(bs, from, moves);
-        return;
+        break;
     case PieceType::Bishop: MoveGenerator::generateBishopMoves(bs, from, moves);
-        return;
+        break;
     case PieceType::Rook: MoveGenerator::generateRookMoves(bs, from, moves);
-        return;
+        break;
     case PieceType::Queen: MoveGenerator::generateQueenMoves(bs, from, moves);
-        return;
-
+        break;
     case PieceType::King: MoveGenerator::generateKingMoves(bs, from, moves);
         break;
     }
-
-    while (movesBB) {
-        auto to = Square(movesBB.pop());
-        moves.emplace_back(from, to, std::nullopt);
-    }
 }
 void Board::handleCastlingRights(const Piece &piece, const BitBoard &bb) {
     if (piece.type() != PieceType::King && piece.type() != PieceType::Rook) {