castro

Fills in the provided pointers with the current version numbers.

Represents a square on the chessboard (0-63).

Prints a square's name and index to stdout.

e4 = E4 28

Macro to convert a square index to (row, col) coordinates.

board[COORDS(s)] = ...;` → expands to `board[(s)/8][(s)%8]

Converts a square index (0-63) to algebraic notation (e.g. "e4").

Converts algebraic notation (e.g. "e4") to a square index (0-63).

Returns the rank (0–7) of a square index.

Returns the file (0–7) of a square index.

Checks whether a square index is valid (0–63).

Converts (rank, file) coordinates to a square index.

Converts a square name (e.g. "d2") to an index.

Flips a square vertically (used for mirror board logic).

SR(E2) returns the square index of E7.

Special marker for an invalid or uninitialized square

A 64-bit bitboard where each bit represents a square.

Cardinal and diagonal directions for sliding piece movement or bitboard shifting.

Converts a square index to a bitboard with a single set bit.

Returns the index of the least significant bit set (LSB).

Returns the index of the most significant bit set (MSB).

Shifts a bitboard in a specified direction.

Pops and returns the index of the least significant bit set. The bit is cleared from the input bitboard.

Counts the number of bits set in the bitboard.

Sets the bit corresponding to the square in the bitboard.

Clears the bit corresponding to the square in the bitboard.

Computes pseudo-legal pawn attacks.

Computes pseudo-legal pawn forward pushes.

Computes pawn promotions (non-capturing).

Computes pawn promotion captures.

Computes knight attacks from a given square.

Computes king attacks from a given square.

Computes bishop attacks based on an occupancy bitboard

Computes rook attacks based on an occupancy bitboard

Computes bishop attacks using a sliding attack method.

Computes rook attacks using a sliding attack method.

Computes queen attacks as the union of rook and bishop attacks.

This function initializes the magic tables

Checks whether the king is in check.

Represents a single hash entry (position and repetition count).

Capacity of the repetition hash table (power of two for fast modulo).

Tracks position repetition using Zobrist hashes. Uses open addressing (linear probing). Empty buckets have hash == 0.

Initializes a hash table from a FEN string. Parses the FEN, computes the initial Zobrist hash, and sets up the table.

Initializes a hash table directly from a known Zobrist hash.

Adds a new position hash or updates an existing entry. If the hash already exists, increments the count.

Returns the current repetition count for a position (lookup only).

Decrements the repetition count for a position (used on unmake). Call with the hash that was last added before the move being undone.

Frees all memory used by the hash table.

Maximum number of moves stored in history

Stores the necessary data to undo a move.

Null undo object representing no previous move

Prints the contents of an Undo struct (for debugging).

Stores full game history for repetition detection and undo functionality.

Removes the last move from history (pop operation). Updates position table and count. Decrements the given position hash (the position we're unmaking from), not last_added.

Returns the most recent Undo record from history.

Piece type used for indexing and logic

Used to indicate no piece on a square

Standard starting position in Forsyth-Edwards Notation (FEN)

The board dimensions

The number of different pieces

Core board structure combining bitboards and grid for performance and simplicity.

Records an undo step into the board's history.

Loads and removes the last undo record.

All 12 supported pieces, as characters

Color of pieces

Converts a promotion code to its corresponding character.

Converts a promotion piece character to a numeric code.

Initializes a board from a FEN string. Must be freed with BoardFree().

Heap-allocates and initializes a board from FEN. Must be freed with BoardFree().

Frees heap-allocated board (from BoardInitFenHeap).

Recomputes and stores white, black, empty from bitboards. Call after any direct bitboard change.

Returns a bitboard of all white pieces.

Returns a bitboard of all black pieces.

Returns a bitboard of all opponent pieces.

Returns a bitboard of all enemy pieces (based on current turn).

Returns a bitboard of all empty squares.

Counts the number of a specific piece color/type on the board.

Returns true if the side to move has material other than pawns and the king

Checks if a board has certain castling rights.

Revokes specific castling rights from a board.

Checks if a square is attacked by a given color.

Checks if a square is empty.

Checks if a square is occupied by a given color.

Returns the number of pieces on the board for a given color.

Checks if a specific color is in check.

Checks if the player currently to move is in check.

Returns a deep copy of the board.

Prints a 32-bit unsigned integer (e.g. in binary or hex).

Prints a 64-bit unsigned integer (e.g. in binary or hex).

Prints a visual representation of a bitboard. Useful for debugging. Marks set bits on an 8x8 grid

Prints a list of squares (e.g. legal moves) on the board.

Highlights a bitboard on the board (used for debugging).

Prints the board with a list of highlighted squares.

Prints all bitboards in the board structure (for debugging).

Prints the character grid of the board.

Total number of castling rights encoded (K, Q, k, q)

Zobrist random numbers for each piece on each square. Dimensions: - PIECE_TYPES: 12 (black/white * 6 types) - BOARD_SIZE: 8x8 squares Indexed as [piece][rank][file]

Zobrist keys for each of the 4 castling rights (K, Q, k, q)

Zobrist keys for each en passant file (a-h)

Zobrist key to represent "black to move"

Initializes the Zobrist tables.

Calculates the Zobrist hash of a board. This includes: - Pieces on the board - Side to move - Castling rights - En passant square

Convenience function to calculate a Zobrist hash directly from a FEN string.

Translates piece as a character to expected zobrist index

A 64-bit unsigned integer representing the squares of the chessboard. Each bit corresponds to a square (0-63), where a set bit (1) indicates the presence of a piece or a targeted square, and a cleared bit (0) indicates its absence. This allows for high-performance board manipulation using bitwise operators.

Initializes all masks

Computes the general occupancy into a bitboard

Calculates the blocker mask for a sliding piece

Generates a mask for the diagonal passing through the given square

Generates a mask for the anti-diagonal passing through the given square

Generates a mask for the rank (row) of the given square

Generates a mask for the file (column) of the given square

Retrieves the pre-computed diagonal mask for a square

Retrieves the pre-computed anti-diagonal mask for a square

Retrieves the pre-computed horizontal mask for a square

Retrieves the pre-computed vertical mask for a square

Calculates the single-square forward push for a pawn

Calculates the two-square initial push for a pawn

Generates a mask for squares where a pawn push results in promotion

Generates a mask for diagonal attacks that result in a promotion

Calculates standard diagonal attack squares for a pawn

Generates all possible L-shaped jumps for a knight on a given square

Calculates all diagonal sliding moves for a bishop (ignoring blockers)

Calculates all horizontal and vertical sliding moves for a rook (ignoring blockers)

Calculates the union of rook and bishop moves for a queen

Generates a mask for all adjacent squares reachable by a king

Retrieves pre-computed single push mask

Retrieves pre-computed double push mask

Retrieves pre-computed promotion mask

Retrieves pre-computed promotion attack mask

Retrieves pre-computed pawn attack mask

Retrieves pre-computed knight move mask

Retrieves pre-computed bishop move mask

Retrieves pre-computed rook move mask

Retrieves pre-computed queen move mask

Retrieves pre-computed king move mask

Flags representing special move types.

Types of piece promotions.

Bit flags representing castling rights.

Encoded move type (bitfield). Format: - bits 0–5: from square - bits 6–11: to square - bits 12–14: promotion type - bits 15–17: move flag

Special constant representing no move

Max number of moves in a move list

Represents a dynamic list of moves.

Empty move list constant

Appends a move to a move list.

Appends one move list to another.

Combines two move lists into a new one.

Creates an Undo struct representing a move played on a board.

Decodes a move into its components (used inside a scope).

Checks whether a move is legal and does not leave the king in check.

Returns true if the move captures a piece (or en passant).

Returns true if the move gives check. Temporarily modifies the board (make/unmake).

Piece value for MVV-LVA (pawn=1, knight/bishop=3, rook=5, queen=9, king=0).

Reorders a legal move list for search: hash move first, then captures (MVV-LVA), killers, then checks, then quiet moves.

Encodes a move from components into a 32-bit integer.

Encodes a move from algebraic names ("e2", "e4", etc.).

Decodes a move into from-square, to-square, promotion, and flag.

Sets the move flag field in an existing move.

Sets the promotion field in an existing move.

Applies a move on a bitboard by updating the piece positions.

Undoes a move on a bitboard, reverting the piece to its previous position.

Makes a move and updates board state accordingly. Handles piece movement, captures, and state updates (castling rights, en passant, etc.).

Unmakes the last move and restores previous board state using stored history.

Performs a null move (swapping sides without moving a piece). Used primarily in search algorithms like Null Move Pruning.

Reverts a null move and restores the original side to move and state.

Executes a castling move, updating both the king and the rook positions on the bitboards.

Checks if a move is a castling move based on piece type and move flags.

Executes an en passant capture, removing the opponent's pawn and moving the current pawn.

Checks if a move is an en passant capture by checking the target square and pawn flags.

Checks if a move is a two-square pawn advance from the starting rank.

Checks if a move is a pawn promotion.

Checks if a move is a capture (regular or en passant).

Simulates a move to check if it leaves the friendly king in check (illegal move detection).

Makes a move with full legality rules, ensuring the move is valid and updates all board state.

Applies a move directly to the bitboards, ignoring turn-order or check legality.

Prints a move to stdout in algebraic format (e.g., "e2e4").

Converts an algebraic string (e.g., "e2e4") to an encoded 32-bit Move integer.

Converts a move to a string in algebraic format (e.g., "e2e4").

Compares two moves for equality by checking only the source and destination squares, ignoring internal metadata like flags or search scores.

Compares two moves strictly, ensuring that the squares, promotion piece, and all metadata flags are identical.

Extracts and returns the source (starting) square index from an encoded move.

Extracts and returns the destination (target) square index from an encoded move.

Retrieves the promotion piece type from the move bitfield.

Extracts the metadata flag associated with the move (e.g., double pawn push, en passant, or castling).

Updates the 50-move counter (halfmove clock). The counter is reset if a pawn is moved or a capture occurs; otherwise, it is incremented.

Updates the castling rights bitmask after a move. Rights are lost if the king or a rook moves, or if a rook is captured on its starting square.

Updates the en passant target square. This is set if a pawn makes a double-square push, otherwise it is cleared.

Iterates through all set bits in a destination bitboard and appends a corresponding move to a Moves list, using the provided source square.

Aggregates the destination squares of all moves in a list into a single bitboard representation.

Prints a move on a board (highlighted view).

Debug macro alias for MovePrint

Represents a chess piece. Each piece is defined by a type (character) and a color. - Uppercase letters: white pieces (e.g., 'P', 'N') - Lowercase letters: black pieces (e.g., 'p', 'n')

Prints the contents of a Piece struct (for debugging).

Checks if a piece is a pawn.

Checks if a piece is a knight.

Checks if a piece is a bishop.

Checks if a piece is a rook.

Checks if a piece is a queen.

Checks if a piece is a king.

Checks if a piece has a given color.

Checks if a piece is white.

Checks if a piece is black.

Gets the color of a piece given its character representation (e.g., 'P' for white, 'p' for black).

Returns the Piece located at a specific square on the board by inspecting the active bitboards.

Compares two Piece structs for type and color equality.

Imports a FEN string into a board. Sets up position, castling rights, side to move, en passant, etc.

Exports the current board state to a FEN string.

Maximum length for PGN header fields (Event, Site, etc.)

Represents a move in Standard Algebraic Notation (e.g., "e4", "Nf3").

PGN/notation-based game format. Stores metadata and the list of SAN moves.

Parses a SAN move and applies it to the board and game state.

Shorthand for move_name(board, game, move)

Initializes a Game object with basic metadata and a starting FEN string.

Runs a game move-by-move, showing each updated board. Useful for debugging or terminal-based visualization.

Prints the full PGN representation of a game, including metadata tags and the formatted move list.

Appends a move in Standard Algebraic Notation (SAN) to the game's move history.

Setters for PGN metadata: Sets the event field.

Setters for PGN metadata: Sets the site field.

Setters for PGN metadata: Sets the date field.

Setters for PGN metadata: Sets the white player's name.

Setters for PGN metadata: Sets the black player's name.

Setters for PGN metadata: Sets the starting FEN position.

Setters for PGN metadata: Sets the game result (e.g., "1-0", "0-1", "1/2-1/2").

Parses a standard PGN string and populates the Game object with its metadata and move history.

Serializes the current Game state into a PGN formatted string.

Serializes the Game to PGN format and writes it directly to a specified file path.

Converts a Move to a SAN notation string (e.g., "Nf3", "O-O"). This requires the board state to determine move ambiguity (e.g., which knight moved) and whether the move results in check or checkmate.

Converts a SAN move string back into an internal 32-bit Move. It validates the notation against the current board to find the correct source square and piece type.

Enumeration of possible game outcomes.

String representations of results for PGN output. Matches the Result enum index: - "*" for ongoing - "1-0", "0-1" for wins - "1/2-1/2" for all draws

Human-readable messages describing the result. Matches the Result enum index.

Determines the current result of the game. Checks for checkmate, stalemate, 3-fold repetition, 50-move rule, or insufficient material.

Determines if the current position is checkmate.

Returns true if the position is a draw by 50-move rule, threefold repetition, or insufficient material.

Determines if the current position is stalemate.

Checks if neither player has sufficient material to checkmate.

Determines if the current position has occurred three times (3-fold repetition). Uses the board's `History` and `HashTable` to detect repeated positions.

Enumeration of move types to control legality enforcement.

Generates all pseudo-legal moves for the current position. Includes moves that may leave the king in check.

Generates a bitboard representing all pseudo-legal destination squares for all pieces of the side to move.

Pseudo-legal push moves for pawns, including single and double pushes.

Pseudo-legal pawn attacks. If strict is true, diagonal movement is restricted to squares with capturable enemies.

Pseudo-legal attacks for knights.

Pseudo-legal attacks for bishops.

Pseudo-legal attacks for rooks.

Pseudo-legal attacks for queens.

Pseudo-legal attacks for kings.

Generates a combined bitboard of all squares attacked by a given color.

Generates potential destination squares for a single pawn.

Generates potential destination squares for a single knight.

Generates potential destination squares for a single bishop.

Generates potential destination squares for a single rook.

Generates potential destination squares for a single queen.

Generates potential destination squares for a single king.

Contains pre-calculated data used to accelerate legality checks, such as check evasions and pins.

Pre-calculates the check and pin masks for the current board state.

Returns whether a move is fully legal, ensuring it doesn't leave the friendly king in check.

Generates all strictly legal moves for the current board position.

Generates only legal captures (including en passant). Ideal for quiescence search algorithms.

Generates all legal moves that originate from a specific square.

Returns a bitboard of all legal destination squares for the side to move.

Generates legal pawn moves, applying check and pin constraints.

Generates legal knight moves, applying check and pin constraints.

Generates legal bishop moves, applying check and pin constraints.

Generates legal rook moves, applying check and pin constraints.

Generates legal queen moves, applying check and pin constraints.

Generates legal king moves, ensuring the king does not move into check.

Dispatches to legal or pseudo-legal move generation.

See [https://www.chessprogramming.org/Perft](https://www.chessprogramming.org/Perft)

Pseudo-legal perft: same node count as legal perft, faster (no pin/check pre-filter).

Represents a single entry in a Polyglot-formatted opening book (.bin). This structure maps a specific board position to a recommended move with associated metadata for move selection.

cross-platform u64 macro

See [http://hgm.nubati.net/book_format.html](http://hgm.nubati.net/book_format.html)

Converts a move from the Polyglot 16-bit format (typically used in .bin opening books) to the Castro 32-bit internal move format.

Probes an external Polyglot opening book file to find a move matching the current position's Zobrist hash. If multiple moves exist, it typically selects one based on weight.