The chess engine implements move generation and position analysis using bitboards. The engine focuses on efficient move calculation through optimized bitboard operations and lookup tables.

The engine uses two primary methods for move generation:

1. standardMoves: Generates all regular piece moves
2. castleMoves: Generates castling moves separately

func standardMoves(pos *Position, first bool) []Move

The standard move generator:

• Uses a move pool to reduce allocations
• Generates moves for each piece type
• Handles promotions for pawns
• Validates moves against check
• Supports early exit with first flag for single move validation

Key optimizations:

• Pre-allocated move array pool (maxPossibleMoves = 218)
• Reuse of Move struct for temporary operations
• Bitboard operations for quick move validation
• Early filtering of invalid squares

func castleMoves(pos *Position) []Move

Generates castling moves with validation for:

• Castle rights
• Empty squares between king and rook
• Squares not under attack
• King not in check

func isInCheck(pos *Position) bool

Determines if the current side to move is in check by:

1. Locating the king
2. Checking for attacks on the king square

func squaresAreAttacked(pos *Position, sqs ...Square) bool

Efficiently determines if squares are under attack using:

• Directional attack patterns (diagonal, horizontal, vertical)
• Piece-specific move patterns
• Optimized bitboard operations

The engine validates moves through several steps:

1. Basic move generation
2. Check validation
3. Pin detection
4. Special move validation (castling, en passant)

The engine uses pre-calculated lookup tables for piece movements:

var (
    bbFiles         [8]bitboard  // File masks
    bbRanks         [8]bitboard  // Rank masks
    bbDiagonals     [64]bitboard // Diagonal masks
    bbAntiDiagonals [64]bitboard // Anti-diagonal masks
    bbKnightMoves   [64]bitboard // Knight move patterns
    bbBishopMoves   [64]bitboard // Bishop move patterns
    bbRookMoves     [64]bitboard // Rook move patterns
    bbQueenMoves    [64]bitboard // Queen move patterns
    bbKingMoves     [64]bitboard // King move patterns
)

func linearAttack(occupied, pos, mask bitboard) bitboard

Generates sliding piece attacks (rook, bishop, queen) using:

1. Occupation patterns
2. Position masks
3. Direction masks

func pawnMoves(pos *Position, sq Square) bitboard

Handles complex pawn move generation including:

• Single and double pushes
• Capture moves
• En passant captures
• Promotion validation

1. Move Pool

var movePool = sync.Pool{
    New: func() interface{} {
        return &[maxPossibleMoves]Move{}
    },
}

• Reuses move arrays to reduce allocations
• Pre-sized for maximum possible moves
• Thread-safe implementation

The engine uses efficient bitboard operations for:

1. Move Generation
   • Piece movement patterns
   • Attack detection
   • Pin detection
2. Position Analysis
   • Square control
   • King safety
   • Piece mobility

1. First Move Flag
   • Quick validation of single moves
   • Early return for move existence checks
2. Attack Detection
   • Quick checks before detailed analysis
   • Efficient filtering of impossible attacks

func (engine) Status(pos *Position) Method

Determines game status by analyzing:

1. Check status
2. Available moves
3. Special conditions (stalemate, checkmate)