Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-7-sonnet-20250219· AnthropicHugging Face LMArena Human Preference 140K

create a cpp chess perft function

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with gpt-4o-2024-11-20’s answer.
  1. User

    create a cpp chess perft function

  2. Claude Assistant

    Chess Perft Function in C++

    Here's a C++ implementation of a perft (performance test) function for chess. Perft counts the number of leaf nodes at a given depth in the move generation tree, which is useful for testing the correctness of a chess move generator.

    #include <iostream>
    #include <vector>
    #include <string>
    #include <chrono>
    
    // Piece definitions
    enum Piece { EMPTY, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING };
    enum Color { WHITE, BLACK };
    
    // Move structure
    struct Move {
        int from;
        int to;
        Piece promotion;
        bool isCapture;
        bool isCastling;
        bool isEnPassant;
        
        Move(int f, int t, Piece p = EMPTY, bool cap = false, bool castle = false, bool ep = false)
            : from(f), to(t), promotion(p), isCapture(cap), isCastling(castle), isEnPassant(ep) {}
    };
    
    // Board representation
    class ChessBoard {
    private:
        struct Square {
            Piece piece;
            Color color;
            
            Square() : piece(EMPTY), color(WHITE) {}
        };
        
        Square board[64];
        Color sideToMove;
        int castlingRights; // KQkq - 1111 in binary
        int enPassantSquare;
        int halfMoveClock;
        int fullMoveNumber;
        
    public:
        ChessBoard() {
            // Initialize to starting position
            initializeStartingPosition();
        }
        
        void initializeStartingPosition() {
            // Clear the board
            for (int i = 0; i < 64; i++) {
                board[i].piece = EMPTY;
            }
            
            // Set up pawns
            for (int i = 0; i < 8; i++) {
                board[8 + i].piece = PAWN;
                board[8 + i].color = WHITE;
                
                board[48 + i].piece = PAWN;
                board[48 + i].color = BLACK;
            }
            
            // Set up other pieces
            // White pieces
            board[0].piece = ROOK; board[0].color = WHITE;
            board[1].piece = KNIGHT; board[1].color = WHITE;
            board[2].piece = BISHOP; board[2].color = WHITE;
            board[3].piece = QUEEN; board[3].color = WHITE;
            board[4].piece = KING; board[4].color = WHITE;
            board[5].piece = BISHOP; board[5].color = WHITE;
            board[6].piece = KNIGHT; board[6].color = WHITE;
            board[7].piece = ROOK; board[7].color = WHITE;
            
            // Black pieces
            board[56].piece = ROOK; board[56].color = BLACK;
            board[57].piece = KNIGHT; board[57].color = BLACK;
            board[58].piece = BISHOP; board[58].color = BLACK;
            board[59].piece = QUEEN; board[59].color = BLACK;
            board[60].piece = KING; board[60].color = BLACK;
            board[61].piece = BISHOP; board[61].color = BLACK;
            board[62].piece = KNIGHT; board[62].color = BLACK;
            board[63].piece = ROOK; board[63].color = BLACK;
            
            sideToMove = WHITE;
            castlingRights = 15; // 1111 in binary (KQkq)
            enPassantSquare = -1; // No en passant square
            halfMoveClock = 0;
            fullMoveNumber = 1;
        }
        
        // Load position from FEN
        void loadFromFEN(const std::string& fen) {
            // Implementation omitted for brevity
            // In a real implementation, this would parse the FEN string and set up the board
        }
        
        // Generate all legal moves for the current position
        std::vector<Move> generateLegalMoves() {
            std::vector<Move> moves;
            
            // This is a placeholder - a real implementation would generate all legal moves
            // for the current position, including special moves like castling and en passant
            
            // For each piece of the current side to move
            for (int from = 0; from < 64; from++) {
                if (board[from].piece != EMPTY && board[from].color == sideToMove) {
                    // Generate moves for this piece
                    generateMovesForPiece(from, moves);
                }
            }
            
            return moves;
        }
        
        // Generate moves for a specific piece
        void generateMovesForPiece(int from, std::vector<Move>& moves) {
            // This is a placeholder - a real implementation would generate all legal moves
            // for the piece at the given square
            
            // Implementation depends on the piece type
            switch (board[from].piece) {
                case PAWN:
                    generatePawnMoves(from, moves);
                    break;
                case KNIGHT:
                    generateKnightMoves(from, moves);
                    break;
                case BISHOP:
                    generateBishopMoves(from, moves);
                    break;
                case ROOK:
                    generateRookMoves(from, moves);
                    break;
                case QUEEN:
                    generateQueenMoves(from, moves);
                    break;
                case KING:
                    generateKingMoves(from, moves);
                    break;
                default:
                    break;
            }
        }
        
        // These functions would generate moves for each piece type
        void generatePawnMoves(int from, std::vector<Move>& moves) {
            // Implementation omitted for brevity
        }
        
        void generateKnightMoves(int from, std::vector<Move>& moves) {
            // Implementation omitted for brevity
        }
        
        void generateBishopMoves(int from, std::vector<Move>& moves) {
            // Implementation omitted for brevity
        }
        
        void generateRookMoves(int from, std::vector<Move>& moves) {
            // Implementation omitted for brevity
        }
        
        void generateQueenMoves(int from, std::vector<Move>& moves) {
            // Implementation omitted for brevity
        }
        
        void generateKingMoves(int from, std::vector<Move>& moves) {
            // Implementation omitted for brevity
        }
        
        // Make a move on the board
        void makeMove(const Move& move) {
            // Save the captured piece (if any)
            Piece capturedPiece = board[move.to].piece;
            
            // Move the piece
            board[move.to].piece = board[move.from].piece;
            board[move.to].color = board[move.from].color;
            board[move.from].piece = EMPTY;
            
            // Handle promotions
            if (move.promotion != EMPTY) {
                board[move.to].piece = move.promotion;
            }
            
            // Handle en passant captures
            if (move.isEnPassant) {
                int capturedPawnSquare = move.to + (sideToMove == WHITE ? -8 : 8);
                board[capturedPawnSquare].piece = EMPTY;
            }
            
            // Handle castling
            if (move.isCastling) {
                // Move the rook
                if (move.to == 2) { // White queenside
                    board[3].piece = ROOK;
                    board[3].color = WHITE;
                    board[0].piece = EMPTY;
                } else if (move.to == 6) { // White kingside
                    board[5].piece = ROOK;
                    board[5].color = WHITE;
                    board[7].piece = EMPTY;
                } else if (move.to == 58) { // Black queenside
                    board[59].piece = ROOK;
                    board[59].color = BLACK;
                    board[56].piece = EMPTY;
                } else if (move.to == 62) { // Black kingside
                    board[61].piece = ROOK;
                    board[61].color = BLACK;
                    board[63].piece = EMPTY;
                }
            }
            
            // Update castling rights
            updateCastlingRights(move);
            
            // Update en passant square
            updateEnPassantSquare(move);
            
            // Update half move clock
            if (board[move.to].piece == PAWN || move.isCapture) {
                halfMoveClock = 0;
            } else {
                halfMoveClock++;
            }
            
            // Update full move number
            if (sideToMove == BLACK) {
                fullMoveNumber++;
            }
            
            // Switch side to move
            sideToMove = (sideToMove == WHITE) ? BLACK : WHITE;
        }
        
        // Unmake a move on the board
        void unmakeMove(const Move& move, Piece capturedPiece) {
            // Switch side to move back
            sideToMove = (sideToMove == WHITE) ? BLACK : WHITE;
            
            // Move the piece back
            board[move.from].piece = board[move.to].piece;
            board[move.from].color = sideToMove;
            
            // If it was a promotion, change it back to a pawn
            if (move.promotion != EMPTY) {
                board[move.from].piece = PAWN;
            }
            
            // Restore the captured piece or clear the destination square
            if (move.isCapture) {
                board[move.to].piece = capturedPiece;
                board[move.to].color = (sideToMove == WHITE) ? BLACK : WHITE;
            } else {
                board[move.to].piece = EMPTY;
            }
            
            // Handle en passant captures
            if (move.isEnPassant) {
                int capturedPawnSquare = move.to + (sideToMove == WHITE ? -8 : 8);
                board[capturedPawnSquare].piece = PAWN;
                board[capturedPawnSquare].color = (sideToMove == WHITE) ? BLACK : WHITE;
                board[move.to].piece = EMPTY;
            }
            
            // Handle castling
            if (move.isCastling) {
                // Move the rook back
                if (move.to == 2) { // White queenside
                    board[0].piece = ROOK;
                    board[0].color = WHITE;
                    board[3].piece = EMPTY;
                } else if (move.to == 6) { // White kingside
                    board[7].piece = ROOK;
                    board[7].color = WHITE;
                    board[5].piece = EMPTY;
                } else if (move.to == 58) { // Black queenside
                    board[56].piece = ROOK;
                    board[56].color = BLACK;
                    board[59].piece = EMPTY;
                } else if (move.to == 62) { // Black kingside
                    board[63].piece = ROOK;
                    board[63].color = BLACK;
                    board[61].piece = EMPTY;
                }
            }
            
            // Restore castling rights, en passant square, and move counters
            // (In a real implementation, these would be saved before making the move)
        }
        
        void updateCastlingRights(const Move& move) {
            // Implementation omitted for brevity
        }
        
        void updateEnPassantSquare(const Move& move) {
            // Implementation omitted for brevity
        }
        
        // Perft function
        uint64_t perft(int depth) {
            if (depth == 0) return 1;
            
            std::vector<Move> moves = generateLegalMoves();
            uint64_t nodes = 0;
            
            for (const Move& move : moves) {
                Piece capturedPiece = board[move.to].piece;
                makeMove(move);
                nodes += perft(depth - 1);
                unmakeMove(move, capturedPiece);
            }
            
            return nodes;
        }
        
        // Divide function (shows perft results for each move)
        void divide(int depth) {
            std::vector<Move> moves = generateLegalMoves();
            uint64_t total = 0;
            
            for (const Move& move : moves) {
                Piece capturedPiece = board[move.to].piece;
                makeMove(move);
                uint64_t nodes = perft(depth - 1);
                unmakeMove(move, capturedPiece);
                
                // Print move and node count
                std::cout << algebraicNotation(move) << ": " << nodes << std::endl;
                total += nodes;
            }
            
            std::cout << "\nTotal: " << total << std::endl;
        }
        
        // Convert a move to algebraic notation
        std::string algebraicNotation(const Move& move) {
            // Implementation omitted for brevity
            // This would convert a move to algebraic notation like "e2e4"
            return "e2e4"; // Placeholder
        }
    };
    
    // Main function to run perft tests
    int main() {
        ChessBoard board;
        
        // Test perft from the starting position
        std::cout << "Perft test from starting position:" << std::endl;
        
        for (int depth = 1; depth <= 5; depth++) {
            auto start = std::chrono::high_resolution_clock::now();
            uint64_t nodes = board.perft(depth);
            auto end = std::chrono::high_resolution_clock::now();
            
            std::chrono::duration<double> elapsed = end - start;
            
            std::cout << "Depth " << depth << ": " << nodes << " nodes";
            std::cout << " in " << elapsed.count() << " seconds";
            std::cout << " (" << static_cast<uint64_t>(nodes / elapsed.count()) << " nps)" << std::endl;
        }
        
        // You can also test specific positions using FEN
        // board.loadFromFEN("r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 1");
        // board.divide(3);
        
        return 0;
    }
    

    Notes on the Implementation

    1. This is a skeleton implementation that shows the structure of a chess perft function. A complete implementation would require:

      • Full move generation for all piece types
      • Proper handling of special moves (castling, en passant, promotions)
      • Complete board state tracking (castling rights, en passant square, etc.)
    2. The perft function works by:

      • Generating all legal moves at the current position
      • Making each move
      • Recursively calling perft with a reduced depth
      • Unmaking each move to restore the board state
      • Summing the results
    3. The divide function is useful for debugging, as it shows the perft results for each individual move.

    4. For a production-quality chess engine, you would want to optimize this code significantly:

      • Use bitboards instead of piece arrays
      • Implement move generation more efficiently
      • Use a more compact move representation
      • Implement a proper move history stack for unmaking moves

    This implementation should give you a good starting point for understanding how perft works in a chess engine.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.