Internal API Reference

Transposition table entry.

• key: Zobrist hash of the position (for collision checking)
• value: evaluation score
• depth: search depth at which this value was computed
• node_type: type of node (EXACT, LOWERBOUND, UPPERBOUND)
• best_move: best move found from this position

Clear bit at square sq.

compute_eval_and_phase(board::Board) -> (Int, Int)

Compute the evaluation score (from White's perspective) and the game phase value from scratch for a given board.

Count the number of bits set in a UInt64.

Reconstruct the principal variation (PV) from the transposition table

Return file (1..8) and rank (1..8) for a square index

Try to find a magic number for a given square.

• sq: square index 0–63
• masks: precomputed mask table (bishop or rook)
• attack_fn: function (sq, occ) → attacks
• tries: number of random candidates to attempt

Flip a piece-square table vertically (white → black perspective). Input is a 64-element vector (row-major, starting at A8). Returns a new 64-element vector with ranks mirrored.

Compute game phase (0 = endgame, 1 = opening). A simple heuristic: count non-pawn, non-king material.

Generate pseudo-legal bishop moves for the given side

• board: Board struct

Returns: Vector of Move

Compute magic numbers for all squares.

• masks: precomputed mask table (bishop or rook)
• attack_fn: function (sq, occ) → attacks

Generate pseudo-legal pawn moves in-place

• board: Board struct
• moves: preallocated buffer to append moves

Returns: number of moves added

Generate pseudo-legal pawn moves for the side to move

• board: Board struct

Returns: Vector of Move

Generate pseudo-legal queen moves for the given side

• board: Board struct

Returns: Vector of Move

Generate pseudo-legal rook moves for the given side

• board: Board struct

Returns: Vector of Move

Generate pseudo-legal moves for a sliding piece using magic bitboards.

• bb_piece: bitboard of the moving piece
• masktable, attacktable, magic_table: precomputed tables
• friendlypieces, enemypieces: arrays of piece indices

Check for fifty-move rule

• board: Board struct

Returns: Bool

Check for insufficient material to mate

• board: Board struct

Returns: Bool

Check for threefold repetition

• board: Board struct

Returns: Bool

Get the square index of the king for the given side

• board: Board struct
• side: Side (WHITE or BLACK)

Returns: Int (square index 0..63)

Apply a null move (pass) to the board, modifying it in place. Used for null-move pruning.

Heuristic to score moves for ordering:

• Promotions are prioritized highest.
• Captures are prioritized higher.
• Moves giving check are prioritized.
• Quiet moves get a lower score.

Generate all possible occupancy bitboards for the given mask

Check if a square index is on the board

Return the piece type at a given square (0..63) using bitboards.

piece_from_symbol(c::AbstractChar, side::Symbol)

Return the piece constant corresponding to promotion symbol c and the moving side (:white or :black).

Return the PSQT value of a piece on a given square.

• piece: Piece.WPAWN..Piece.BKING
• square: 0..63 (a1=0, h8=63)
• phase: Float64 in [0.0, 1.0], where 1.0 = opening, 0.0 = endgame

Set bit at square sq.

Generic sliding attack generator.

• sq: square index
• occ: occupancy bitboard
• directions: list of (df, dr) directions

Generic sliding mask generator.

• sq: square index (0..63)
• directions: list of (df, dr) directions

Check if a square is attacked by the given side.

• board: Board struct
• sq: Int (square index 0..63)
• attacker: Side (WHITE or BLACK)

Returns: Bool

Map algebraic notation (e.g. 'e3') → square index (0..63).

Map (file, rank) → square index (0..63). file=1→a, rank=1→1.

Store a killer move for the given ply. Only quiet moves (non-captures) are stored.

• m: the move to store
• ply: the current ply

Check if bit at square sq is set.

Get index in transposition table from hash.

Look up a position in the transposition table.

• hash: Zobrist hash of the position
• depth: current search depth
• α: alpha value
• β: beta value

Returns a tuple (value, best_move, hit) where hit is true if a valid entry was found.

Store an entry in the transposition table.

Undo a null move, restoring the previous board state.