ChessEngine.py

"""
Rules and state management for the chess engine.
"""
# ChessEngine.py
from ChessAI import ZOBRIST_PIECE, ZOBRIST_SIDE, ZOBRIST_CASTLING, ZOBRIST_ENPASSANT, piece_score, piece_position_scores, scoreBoard

try:
    import cengine as _ce
except Exception:
    _ce = None

def _has_native(*names: str) -> bool:
    return _ce is not None and all(hasattr(_ce, name) for name in names)


_HAVE_NATIVE_ATTACKS = _has_native("_is_square_attacked_bb", "_compute_attacked_mask")
_HAVE_NATIVE_PINS = _has_native("_check_pins_and_checks")
_HAVE_NATIVE_KNIGHT_STEPS = _has_native("_gen_knight_steps")
_HAVE_NATIVE_KING_STEPS = _has_native("_gen_king_steps")
_HAVE_NATIVE_PAWN_STEPS = _has_native("_gen_pawn_steps_from")
_HAVE_NATIVE_ROOK_STEPS = _has_native("_gen_rook_steps_from")
_HAVE_NATIVE_BISHOP_STEPS = _has_native("_gen_bishop_steps_from")
_HAVE_NATIVE_QUEEN_STEPS = _has_native("_gen_queen_steps_from")

# --- Precomputed attack masks (bitboards) for knights and kings ---
def _precompute_attack_masks():
    KNIGHT_DELTAS = ((-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1))
    KING_DELTAS   = ((-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1))
    knight_masks = [0] * 64
    king_masks   = [0] * 64
    for sq in range(64):
        r, c = divmod(sq, 8)
        m = 0
        for dr, dc in KNIGHT_DELTAS:
            rr, cc = r + dr, c + dc
            if 0 <= rr < 8 and 0 <= cc < 8:
                m |= 1 << (rr*8 + cc)
        knight_masks[sq] = m
        m = 0
        for dr, dc in KING_DELTAS:
            rr, cc = r + dr, c + dc
            if 0 <= rr < 8 and 0 <= cc < 8:
                m |= 1 << (rr*8 + cc)
        king_masks[sq] = m
    return tuple(knight_masks), tuple(king_masks)

KNIGHT_ATTACKS, KING_ATTACKS = _precompute_attack_masks()

# Hoisted direction constants for reuse (avoid re-allocations in hot paths)
DELTAS_KNIGHT = ((-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1))
DELTAS_KING   = ((-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1))
DIRS_BISHOP   = ((-1,-1),(-1,1),(1,-1),(1,1))
DIRS_ROOK     = ((-1,0),(1,0),(0,-1),(0,1))
NOT_FILE_A = 0xFEFEFEFEFEFEFEFE  # clear file A (bits 0 of each byte)
NOT_FILE_H = 0x7F7F7F7F7F7F7F7F  # clear file H (bits 7 of each byte)

class GameState:
    def __init__(self):
        """
        Board is an 8x8 2d list, each element in list has 2 characters.
        The first character represents the color of the piece: 'b' or 'w'.
        The second character represents the type of the piece: 'R', 'N', 'B', 'Q', 'K' or 'p'.
        "--" represents an empty space with no piece.
        """
        self.board = [
            ["bR", "bN", "bB", "bQ", "bK", "bB", "bN", "bR"],
            ["bp", "bp", "bp", "bp", "bp", "bp", "bp", "bp"],
            ["--", "--", "--", "--", "--", "--", "--", "--"],
            ["--", "--", "--", "--", "--", "--", "--", "--"],
            ["--", "--", "--", "--", "--", "--", "--", "--"],
            ["--", "--", "--", "--", "--", "--", "--", "--"],
            ["wp", "wp", "wp", "wp", "wp", "wp", "wp", "wp"],
            ["wR", "wN", "wB", "wQ", "wK", "wB", "wN", "wR"]]
        
        # self.board = [
        #     ["--", "--", "--", "--", "--", "--", "--", "--"], 
        #     ["--", "--", "--", "--", "--", "--", "--", "--"],  
        #     ["--", "--", "--", "--", "--", "--", "--", "--"],  
        #     ["--", "--", "--", "--", "--", "--", "--", "--"],  
        #     ["--", "--", "--", "--", "--", "--", "--", "--"],  
        #     ["--", "--", "--", "--", "--", "--", "--", "--"],  
        #     ["--", "--", "--", "--", "--", "--", "--", "--"],  
        #     ["--", "--", "--", "--", "--", "--", "--", "--"]   
        # ]

        self.moveFunctions = {"p": self.getPawnMoves, "R": self.getRookMoves, "B": self.getBishopMoves, "Q": self.getQueenMoves}
        self.white_to_move = True
        # Map each piece‐code to its own 64-bit bitboard:
        self.bitboards = {
            'wp': 0, 'wN': 0, 'wB': 0, 'wR': 0, 'wQ': 0, 'wK': 0,
            'bp': 0, 'bN': 0, 'bB': 0, 'bR': 0, 'bQ': 0, 'bK': 0,
        }
        # Occupancy bitboards:
        self.occ_white = 0
        self.occ_black = 0
        self.occ_all   = 0

        # Initialize from self.board and detect king squares:
        self.white_king_location = None
        self.black_king_location = None
        for r in range(8):
            for c in range(8):
                p = self.board[r][c]
                if p != '--':
                    sq = r*8 + c
                    self.bitboards[p] |= (1 << sq)
                    if p == 'wK':
                        self.white_king_location = (r, c)
                    elif p == 'bK':
                        self.black_king_location = (r, c)

        # Fallback to start squares if not found (e.g., custom boards still at start):
        if self.white_king_location is None:
            self.white_king_location = (7, 4)
        if self.black_king_location is None:
            self.black_king_location = (0, 4)

        self._recalc_occupancies()

        self.current_castling_rights = self._derive_castling_rights_from_board()
        self.castle_rights_log = [CastleRights(
            self.current_castling_rights.wks,
            self.current_castling_rights.wqs,
            self.current_castling_rights.bks,
            self.current_castling_rights.bqs
        )]

        self.enpassant_possible = ()  # (row, col) square where EP capture is possible; empty tuple = none
        self.enpassant_possible_log = [self.enpassant_possible]
        
        self.zobrist_key = self._compute_zobrist() # Zobrist key for the current position
        self.current_eval = self._compute_full_eval() # Current evaluation of the position
        
        self.move_log = []  # list keeping track of all the moves made in the game
        
        self.checkmate = False # No valid moves + check
        self.stalemate = False # No valid moves + no check
        self.in_check = False
        self.pins = []
        self.checks = []
        
        self.pinned_map = {}

        # Half-move clock for 50-move rule (reset on pawn move or capture)
        self.halfmove_clock = 0
        self.halfmove_clock_log = [0]

        # Position history for repetition detection: maps a simple position key → count
        self.position_history = {}
        # Record the initial position
        self._update_position_history()

    def _hydrate_move_fields(self, move):
        # Ensure piece_moved / piece_captured are populated from the current board
        if getattr(move, "piece_moved", "--") == "--":
            move.piece_moved = self.board[move.start_row][move.start_col]

        if getattr(move, "is_enpassant_move", False):
            # EP capture sits one rank behind the target
            cap_row = move.end_row + (1 if move.piece_moved[0] == "w" else -1)
            move.piece_captured = self.board[cap_row][move.end_col]
        else:
            if getattr(move, "piece_captured", "--") == "--":
                move.piece_captured = self.board[move.end_row][move.end_col]

    def _bb_args(self): # Helper
        bb = self.bitboards
        return (
            bb['wp'], bb['wN'], bb['wB'], bb['wR'], bb['wQ'], bb['wK'],
            bb['bp'], bb['bN'], bb['bB'], bb['bR'], bb['bQ'], bb['bK'],
        )

    def _derive_castling_rights_from_board(self): # Stays Python Only
        cr = CastleRights(False, False, False, False)
        b = self.board
        cr.wks = (b[7][4] == 'wK' and b[7][7] == 'wR')
        cr.wqs = (b[7][4] == 'wK' and b[7][0] == 'wR')
        cr.bks = (b[0][4] == 'bK' and b[0][7] == 'bR')
        cr.bqs = (b[0][4] == 'bK' and b[0][0] == 'bR')
        return cr

    def _python_check_pins_and_checks(self):
        """Pure-Python pin/check detector used when the native helper is unavailable."""
        pins = []
        checks = []
        in_check = False

        if self.white_to_move:
            enemy_color = 'b'
            ally_color = 'w'
            start_row, start_col = self.white_king_location
        else:
            enemy_color = 'w'
            ally_color = 'b'
            start_row, start_col = self.black_king_location

        directions = ((-1, 0), (0, -1), (1, 0), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1))
        for j, (dr, dc) in enumerate(directions):
            possible_pin = ()
            r = start_row + dr
            c = start_col + dc
            while 0 <= r < 8 and 0 <= c < 8:
                end_piece = self.board[r][c]
                if end_piece[0] == ally_color and end_piece[1] != 'K':
                    if not possible_pin:
                        possible_pin = (r, c, dr, dc)
                    else:
                        break
                elif end_piece[0] == enemy_color:
                    piece_type = end_piece[1]
                    orth = 0 <= j <= 3 and piece_type in ('R', 'Q')
                    diag = 4 <= j <= 7 and piece_type in ('B', 'Q')
                    pawn = (
                        piece_type == 'p'
                        and (
                            (enemy_color == 'w' and j in (6, 7))
                            or (enemy_color == 'b' and j in (4, 5))
                        )
                    )
                    king = piece_type == 'K' and max(abs(r - start_row), abs(c - start_col)) == 1
                    if orth or diag or pawn or king:
                        if not possible_pin:
                            in_check = True
                            checks.append((r, c, dr, dc))
                        else:
                            pins.append(possible_pin)
                        break
                    break
                r += dr
                c += dc

        knight_moves = ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1))
        for dr, dc in knight_moves:
            r = start_row + dr
            c = start_col + dc
            if 0 <= r < 8 and 0 <= c < 8:
                end_piece = self.board[r][c]
                if end_piece[0] == enemy_color and end_piece[1] == 'N':
                    in_check = True
                    checks.append((r, c, dr, dc))

        return in_check, pins, checks

    def _gen_knight_moves_py(self, moves):
        wtm = self.white_to_move
        board = self.board
        knights = self.bitboards['wN' if wtm else 'bN']
        us_occ = self.occ_white if wtm else self.occ_black
        pinned = self._pinned_knights_mask()

        while knights:
            lsb = knights & -knights
            from_sq = lsb.bit_length() - 1
            knights ^= lsb
            if (pinned >> from_sq) & 1:
                continue
            targets = KNIGHT_ATTACKS[from_sq] & ~us_occ
            while targets:
                to_lsb = targets & -targets
                to_sq = to_lsb.bit_length() - 1
                targets ^= to_lsb
                r0, c0 = divmod(from_sq, 8)
                r1, c1 = divmod(to_sq, 8)
                moves.append(Move((r0, c0), (r1, c1), board))

    def _gen_king_moves_py(self, moves, opp_attacks=None):
        wtm = self.white_to_move
        board = self.board
        king_bb = self.bitboards['wK' if wtm else 'bK']
        us_occ = self.occ_white if wtm else self.occ_black
        if not king_bb:
            return

        from_sq = (king_bb & -king_bb).bit_length() - 1
        targets = KING_ATTACKS[from_sq] & ~us_occ
        if opp_attacks is not None:
            targets &= ~int(opp_attacks)

        while targets:
            to_lsb = targets & -targets
            to_sq = to_lsb.bit_length() - 1
            targets ^= to_lsb
            r0, c0 = divmod(from_sq, 8)
            r1, c1 = divmod(to_sq, 8)
            moves.append(Move((r0, c0), (r1, c1), board))

    def _gen_pawn_moves_py(self, row, col, moves):
        board = self.board
        wtm = self.white_to_move
        move_amount = -1 if wtm else 1
        start_row = 6 if wtm else 1
        enemy_color = 'b' if wtm else 'w'
        promo_row = 0 if wtm else 7

        pin = self.pinned_map.get((row, col))
        piece_pinned = pin is not None
        pin_dr, pin_dc = pin if pin else (0, 0)

        one_step_row = row + move_amount
        if 0 <= one_step_row < 8:
            if board[one_step_row][col] == '--' and ((not piece_pinned) or (pin_dr, pin_dc) == (move_amount, 0)):
                if one_step_row == promo_row:
                    for ch in ('Q', 'R', 'B', 'N'):
                        moves.append(Move((row, col), (one_step_row, col), board, promotion_choice=ch))
                else:
                    moves.append(Move((row, col), (one_step_row, col), board))
                    two_step_row = row + 2 * move_amount
                    if row == start_row and board[two_step_row][col] == '--':
                        moves.append(Move((row, col), (two_step_row, col), board))

            for dc in (-1, 1):
                end_col = col + dc
                end_row = row + move_amount
                if not (0 <= end_col < 8 and 0 <= end_row < 8):
                    continue
                if piece_pinned and (pin_dr, pin_dc) != (move_amount, dc):
                    continue

                target = board[end_row][end_col]
                if target != '--' and target[0] == enemy_color:
                    if end_row == promo_row:
                        for ch in ('Q', 'R', 'B', 'N'):
                            moves.append(Move((row, col), (end_row, end_col), board, promotion_choice=ch))
                    else:
                        moves.append(Move((row, col), (end_row, end_col), board))

    def is_square_attacked_bb(self, sq, by_white: bool) -> bool: # C++
        """True if square index `sq` is attacked by side `by_white` on the *current* board."""
        # Try native first (cached if you've imported cengine as _ce at module top)
        if _HAVE_NATIVE_ATTACKS:
            return bool(_ce._is_square_attacked_bb(int(sq), bool(by_white), *map(int, self._bb_args())))

        # --- Python fallback (your current implementation) ---
        one = 1 << sq

        # Rebuild occupancies from piece bitboards (avoids any stale occ_* issues)
        bb = self.bitboards
        occ_w = (bb['wp'] | bb['wN'] | bb['wB'] | bb['wR'] | bb['wQ'] | bb['wK'])
        occ_b = (bb['bp'] | bb['bN'] | bb['bB'] | bb['bR'] | bb['bQ'] | bb['bK'])
        occ_all = occ_w | occ_b

        wN, bN = bb['wN'], bb['bN']
        wK, bK = bb['wK'], bb['bK']
        wR, bR = bb['wR'], bb['bR']
        wB, bB = bb['wB'], bb['bB']
        wQ, bQ = bb['wQ'], bb['bQ']
        wp, bp = bb['wp'], bb['bp']

        # Knights
        if KNIGHT_ATTACKS[sq] & (wN if by_white else bN):
            return True

        # Kings
        if KING_ATTACKS[sq] & (wK if by_white else bK):
            return True

        # Pawns (with sq = r*8+c, r=0 at top; white attacks "up" → right shifts)
        if by_white:
            wp = bb['wp']
            # White attacks: up-right (−7) and up-left (−9)
            if (((wp & NOT_FILE_H) >> 7) & one):
                return True
            if (((wp & NOT_FILE_A) >> 9) & one):
                return True
        else:
            bp = bb['bp']
            # Black attacks: down-left (+7) and down-right (+9)
            if (((bp & NOT_FILE_A) << 7) & one):
                return True
            if (((bp & NOT_FILE_H) << 9) & one):
                return True

        # Slider helpers
        rook_like   = (wR | wQ) if by_white else (bR | bQ)
        bishop_like = (wB | wQ) if by_white else (bB | bQ)

        r = sq >> 3
        c = sq & 7

        # ---- Rooks/Queens (orthogonals) ----
        # North
        rr = r - 1
        while rr >= 0:
            s = (rr << 3) | c
            bbm = 1 << s
            if occ_all & bbm:
                pc_is_white = bool(occ_w & bbm)
                if pc_is_white == by_white and (rook_like & bbm):
                    return True
                break
            rr -= 1
        # South
        rr = r + 1
        while rr < 8:
            s = (rr << 3) | c
            bbm = 1 << s
            if occ_all & bbm:
                pc_is_white = bool(occ_w & bbm)
                if pc_is_white == by_white and (rook_like & bbm):
                    return True
                break
            rr += 1
        # West
        cc = c - 1
        while cc >= 0:
            s = (r << 3) | cc
            bbm = 1 << s
            if occ_all & bbm:
                pc_is_white = bool(occ_w & bbm)
                if pc_is_white == by_white and (rook_like & bbm):
                    return True
                break
            cc -= 1
        # East
        cc = c + 1
        while cc < 8:
            s = (r << 3) | cc
            bbm = 1 << s
            if occ_all & bbm:
                pc_is_white = bool(occ_w & bbm)
                if pc_is_white == by_white and (rook_like & bbm):
                    return True
                break
            cc += 1

        # ---- Bishops/Queens (diagonals) ----
        # NW
        rr, cc = r - 1, c - 1
        while rr >= 0 and cc >= 0:
            s = (rr << 3) | cc
            bbm = 1 << s
            if occ_all & bbm:
                pc_is_white = bool(occ_w & bbm)
                if pc_is_white == by_white and (bishop_like & bbm):
                    return True
                break
            rr -= 1; cc -= 1
        # NE
        rr, cc = r - 1, c + 1
        while rr >= 0 and cc < 8:
            s = (rr << 3) | cc
            bbm = 1 << s
            if occ_all & bbm:
                pc_is_white = bool(occ_w & bbm)
                if pc_is_white == by_white and (bishop_like & bbm):
                    return True
                break
            rr -= 1; cc += 1
        # SW
        rr, cc = r + 1, c - 1
        while rr < 8 and cc >= 0:
            s = (rr << 3) | cc
            bbm = 1 << s
            if occ_all & bbm:
                pc_is_white = bool(occ_w & bbm)
                if pc_is_white == by_white and (bishop_like & bbm):
                    return True
                break
            rr += 1; cc -= 1
        # SE
        rr, cc = r + 1, c + 1
        while rr < 8 and cc < 8:
            s = (rr << 3) | cc
            bbm = 1 << s
            if occ_all & bbm:
                pc_is_white = bool(occ_w & bbm)
                if pc_is_white == by_white and (bishop_like & bbm):
                    return True
                break
            rr += 1; cc += 1

        return False

    def compute_attacked_mask(self, by_white: bool) -> int: # C++
        """
        Bitboard of all squares attacked by the given side (ignores pins & legality;
        includes blockers on slider rays). Cheap to compute and reuse.
        """
        if _HAVE_NATIVE_ATTACKS:
            return int(_ce._compute_attacked_mask(bool(by_white), *map(int, self._bb_args())))

        # --- Python fallback (your current implementation) ---
        bb = self.bitboards
        occ_w = (bb['wp'] | bb['wN'] | bb['wB'] | bb['wR'] | bb['wQ'] | bb['wK'])
        occ_b = (bb['bp'] | bb['bN'] | bb['bB'] | bb['bR'] | bb['bQ'] | bb['bK'])
        occ_all = occ_w | occ_b

        attack = 0

        # Knights
        kn = bb['wN'] if by_white else bb['bN']
        t = kn
        while t:
            lsb = t & -t
            sq = lsb.bit_length() - 1
            attack |= KNIGHT_ATTACKS[sq]
            t ^= lsb

        # King
        kbb = bb['wK'] if by_white else bb['bK']
        if kbb:
            ksq = (kbb & -kbb).bit_length() - 1
            attack |= KING_ATTACKS[ksq]

        # Pawns
        if by_white:
            wp = bb['wp']
            attack |= ((wp & NOT_FILE_H) >> 7)  # up-right
            attack |= ((wp & NOT_FILE_A) >> 9)  # up-left
        else:
            bp = bb['bp']
            attack |= ((bp & NOT_FILE_A) << 7)  # down-left
            attack |= ((bp & NOT_FILE_H) << 9)  # down-right

        # Sliders
        # Rook-like
        rook_like = (bb['wR'] | bb['wQ']) if by_white else (bb['bR'] | bb['bQ'])
        t = rook_like
        while t:
            lsb = t & -t
            sq = lsb.bit_length() - 1
            r, c = divmod(sq, 8)

            # North
            rr = r - 1
            while rr >= 0:
                s = (rr << 3) | c
                attack |= (1 << s)
                if (occ_all >> s) & 1:
                    break
                rr -= 1
            # South
            rr = r + 1
            while rr < 8:
                s = (rr << 3) | c
                attack |= (1 << s)
                if (occ_all >> s) & 1:
                    break
                rr += 1
            # West
            cc = c - 1
            while cc >= 0:
                s = (r << 3) | cc
                attack |= (1 << s)
                if (occ_all >> s) & 1:
                    break
                cc -= 1
            # East
            cc = c + 1
            while cc < 8:
                s = (r << 3) | cc
                attack |= (1 << s)
                if (occ_all >> s) & 1:
                    break
                cc += 1

            t ^= lsb

        # Bishop-like
        bishop_like = (bb['wB'] | bb['wQ']) if by_white else (bb['bB'] | bb['bQ'])
        t = bishop_like
        while t:
            lsb = t & -t
            sq = lsb.bit_length() - 1
            r, c = divmod(sq, 8)

            # NW
            rr, cc = r - 1, c - 1
            while rr >= 0 and cc >= 0:
                s = (rr << 3) | cc
                attack |= (1 << s)
                if (occ_all >> s) & 1:
                    break
                rr -= 1; cc -= 1
            # NE
            rr, cc = r - 1, c + 1
            while rr >= 0 and cc < 8:
                s = (rr << 3) | cc
                attack |= (1 << s)
                if (occ_all >> s) & 1:
                    break
                rr -= 1; cc += 1
            # SW
            rr, cc = r + 1, c - 1
            while rr < 8 and cc >= 0:
                s = (rr << 3) | cc
                attack |= (1 << s)
                if (occ_all >> s) & 1:
                    break
                rr += 1; cc -= 1
            # SE
            rr, cc = r + 1, c + 1
            while rr < 8 and cc < 8:
                s = (rr << 3) | cc
                attack |= (1 << s)
                if (occ_all >> s) & 1:
                    break
                rr += 1; cc += 1

            t ^= lsb

        return attack

    def _ep_is_legal(self, row, col, r1, c): # Stays Python Only
        """Return True if EP (row,col)->(r1,c) keeps our king safe."""
        assert self.enpassant_possible == (r1, c), "EP target mismatch"
        wtm = self.white_to_move
        mover  = 'wp' if wtm else 'bp'
        victim = 'bp' if wtm else 'wp'

        from_sq = row*8 + col
        to_sq   = r1*8 + c
        cap_sq  = row*8 + c  # victim stands on mover's start rank, target file

        # Ensure a victim pawn actually exists on the capture square
        if ((self.bitboards[victim] >> cap_sq) & 1) == 0:
            return False
        
        m_from, m_to, m_cap = (1<<from_sq), (1<<to_sq), (1<<cap_sq)

        # snapshot
        bb_mover, bb_victim = self.bitboards[mover], self.bitboards[victim]
        ow, ob, oa = self.occ_white, self.occ_black, self.occ_all

        # apply EP effect on bitboards/occupancy
        self.bitboards[mover]  ^= (m_from | m_to)
        self.bitboards[victim] ^= m_cap
        if wtm:
            self.occ_white ^= (m_from | m_to)
            self.occ_black ^= m_cap
        else:
            self.occ_black ^= (m_from | m_to)
            self.occ_white ^= m_cap
        self.occ_all = self.occ_white | self.occ_black

        # king square (unchanged)
        kr, kc = (self.white_king_location if wtm else self.black_king_location)
        illegal = self.is_square_attacked_bb(kr*8 + kc, by_white=not wtm)

        # restore
        self.bitboards[mover], self.bitboards[victim] = bb_mover, bb_victim
        self.occ_white, self.occ_black, self.occ_all = ow, ob, oa

        return not illegal

    def _ep_capturable_given_side(self, ep_square, white_to_move): # Stays Python Only
        """Return True if side-to-move (given) has a pawn that could capture on ep_square."""
        if not ep_square:
            return False
        r, c = ep_square  # target square of the EP capture
        if white_to_move:
            # White would capture from r+1,c-1 or r+1,c+1
            from_r = r + 1
            if not (0 <= from_r < 8):
                return False
            mask = 0
            if c > 0: mask |= 1 << (from_r*8 + (c-1))
            if c < 7: mask |= 1 << (from_r*8 + (c+1))
            return bool(self.bitboards['wp'] & mask)
        else:
            # Black would capture from r-1,c-1 or r-1,c+1
            from_r = r - 1
            if not (0 <= from_r < 8):
                return False
            mask = 0
            if c > 0: mask |= 1 << (from_r*8 + (c-1))
            if c < 7: mask |= 1 << (from_r*8 + (c+1))
            return bool(self.bitboards['bp'] & mask)

    def _pinned_knights_mask(self) -> int: # Helper
        """Bitboard of our KNIGHTS that are line-pinned (from self.pinned_map)."""
        wtm = self.white_to_move
        mask = 0
        for (r, c), _ray in self.pinned_map.items():
            sq = r * 8 + c
            p = self.board[r][c]
            if p != "--" and p[1] == "N" and ((p[0] == 'w') == wtm):
                mask |= (1 << sq)
        return mask

    def gen_knight_moves_bb(self, moves):
        if not _HAVE_NATIVE_KNIGHT_STEPS:
            self._gen_knight_moves_py(moves)
            return

        wtm = self.white_to_move
        us_occ = self.occ_white if wtm else self.occ_black
        knights = self.bitboards['wN' if wtm else 'bN']
        if not knights:
            return
        pinned = self._pinned_knights_mask()

        steps = _ce._gen_knight_steps(int(knights), int(us_occ), int(pinned))

        board = self.board
        append = moves.append
        for s in steps:
            fr = (s >> 6) & 63
            to = s & 63
            r0, c0 = divmod(fr, 8)
            r1, c1 = divmod(to, 8)
            append(Move((r0, c0), (r1, c1), board))

    def gen_king_moves_bb(self, moves, opp_attacks=None):
        if not _HAVE_NATIVE_KING_STEPS:
            self._gen_king_moves_py(moves, opp_attacks=opp_attacks)
            return

        wtm = self.white_to_move
        us_occ = self.occ_white if wtm else self.occ_black
        king_bb = self.bitboards['wK' if wtm else 'bK']
        if not king_bb:
            return

        use_mask = opp_attacks is not None
        mask = int(opp_attacks) if use_mask else 0
        steps = _ce._gen_king_steps(int(king_bb), int(us_occ), mask, bool(use_mask))

        board = self.board
        append = moves.append
        for s in steps:
            fr = (s >> 6) & 63
            to = s & 63
            r0, c0 = divmod(fr, 8)
            r1, c1 = divmod(to, 8)
            append(Move((r0, c0), (r1, c1), board))

    def _recalc_occupancies(self): # Stays Python Only
        self.occ_white = (
            self.bitboards['wp'] | self.bitboards['wN'] | self.bitboards['wB'] |
            self.bitboards['wR'] | self.bitboards['wQ'] | self.bitboards['wK']
        )
        self.occ_black = (
            self.bitboards['bp'] | self.bitboards['bN'] | self.bitboards['bB'] |
            self.bitboards['bR'] | self.bitboards['bQ'] | self.bitboards['bK']
        )
        self.occ_all = self.occ_white | self.occ_black

    def _compute_full_eval(self): # Stays Python Only
        """Scan board once to get material + PST total (white-positive)."""
        ps, pps = piece_score, piece_position_scores
        board = self.board
        s = 0.0
        for r in range(8):
            row = board[r]
            for c in range(8):
                sq = row[c]
                if sq != "--":
                    v = ps[sq[1]] + pps[sq][r][c]
                    s += v if sq[0] == 'w' else -v
        return s

    def _canonicalize_move_codes(self, move):
        """Ensure move.piece_moved / piece_captured are concrete like 'wN', 'bp'."""
        sr, sc, er, ec = move.start_row, move.start_col, move.end_row, move.end_col
        from_sq = sr * 8 + sc
        mask = 1 << from_sq

        # ---- piece_moved ----
        pm = getattr(move, "piece_moved", None)
        if not pm or pm == "--":
            side = (move.piece_moved[0]
                    if move.piece_moved and move.piece_moved != "--"
                    else ('w' if self.white_to_move else 'b'))
            # Prefer bitboards – reliable even if board was mutated earlier
            for code in (side + 'p', side + 'N', side + 'B', side + 'R', side + 'Q', side + 'K'):
                if self.bitboards[code] & mask:
                    pm = code
                    break
            if not pm or pm == "--":
                # Last resort: current board snapshot
                pm = self.board[sr][sc]
                # If promotion move called late, infer the pawn color
                if (not pm or pm == "--") and getattr(move, "is_pawn_promotion", False):
                    pm = side + 'p'
        move.piece_moved = pm

        # ---- piece_captured ----
        pc = getattr(move, "piece_captured", None)
        if getattr(move, "is_enpassant_move", False):
            pc = ('b' if pm[0] == 'w' else 'w') + 'p'
        else:
            if not pc or pc == "--":
                pc = self.board[er][ec] or "--"
        move.piece_captured = pc

    def _calc_move_delta(self, move):  # Stays Python only
        """
        Incremental eval change (material + PST).
        Positive = White gain; Negative = Black gain.
        Handles promotions, normal & EP captures, and rook PST during castling.
        """
        # Hydrate if needed; but we'll repair fields if board already mutated
        self._hydrate_move_fields(move)

        ps, pps = piece_score, piece_position_scores
        sr, sc, er, ec = move.start_row, move.start_col, move.end_row, move.end_col

        pm = move.piece_moved  # e.g. 'wN', 'bp'
        # If called after board mutation, start square may be empty → pm == "--".
        if pm == "--" or pm is None or pm not in pps:
            post = self.board[er][ec]
            if move.is_pawn_promotion:
                # Mover was a pawn of the color now on the end square
                color = post[0] if post != "--" else ('b' if self.white_to_move else 'w')
                pm = color + 'p'
            else:
                pm = post  # moved piece now sits on end square
        # If still unknown, give up gracefully (shouldn't happen if moves are legal)
        if not pm or pm == "--":
            return 0.0

        color_mult = 1 if pm[0] == 'w' else -1

        # 1) remove mover's old term (material+PST at the START square)
        start_key = pm if not move.is_pawn_promotion else (pm[0] + 'p')  # pawn before promotion
        delta = -color_mult * (ps[start_key[1]] + pps[start_key][sr][sc])

        # 2) add mover's new term (material+PST at the END square)
        end_key = pm if not move.is_pawn_promotion else (pm[0] + move.promotion_choice)  # e.g. 'wQ'
        delta += color_mult * (ps[end_key[1]] + pps[end_key][er][ec])

        # 3) captured piece (subtract opponent’s term once)
        cp = move.piece_captured
        if cp != "--":
            cap_mult = 1 if cp[0] == 'w' else -1
            rc, cc = er, ec
            if move.is_enpassant_move:
                rc = er + (1 if pm[0] == 'w' else -1)
                cc = ec
            delta -= cap_mult * (ps[cp[1]] + pps[cp][rc][cc])

        # 4) castling: rook PST delta (material unchanged)
        if move.is_castle_move and pm[1] == 'K':
            if pm[0] == 'w':
                delta += (pps['wR'][7][5] - pps['wR'][7][7]) if ec == 6 else (pps['wR'][7][3] - pps['wR'][7][0])
            else:
                delta += (pps['bR'][0][5] - pps['bR'][0][7]) if ec == 6 else (pps['bR'][0][3] - pps['bR'][0][0])

        return delta

    def makeMove(self, move):
        """
        Execute a Move, updating:
        - incremental evaluatio
        - board/bitboards/occupancies
        - move_logn
        - side to move
        - king locations
        - en-passant rights
        - castling rights
        - Zobrist key
        - halfmove clock & repetition history
        """

        # Save Zobrist key so undoMove can restore it directly
        move.zobrist_key_before = self.zobrist_key

        # Flags
        is_ep     = move.is_enpassant_move
        is_promo  = move.is_pawn_promotion
        is_castle = move.is_castle_move

        # Canonicalize pm/pc ONCE, before anything else uses them
        self._canonicalize_move_codes(move)

        # Hydrate masks etc.
        self._hydrate_move_fields(move)

        # ─── Incremental Eval ───
        move.eval_delta    = self._calc_move_delta(move)
        self.current_eval += move.eval_delta

        # ─── Hot locals ───
        board = self.board
        bb    = self.bitboards

        sr, sc, er, ec   = move.start_row, move.start_col, move.end_row, move.end_col
        from_mask, to_mask = move.from_mask, move.to_mask
        pm, pc           = move.piece_moved, move.piece_captured
        mover_side       = pm[0]

        # ─── Board update ───
        board[sr][sc] = "--"
        board[er][ec] = pm

        # Bitboards: mover from→to
        bb[pm] ^= (from_mask | to_mask)

        # Occupancies
        if mover_side == 'w':
            self.occ_white ^= (from_mask | to_mask)
        else:
            self.occ_black ^= (from_mask | to_mask)

        # Captures
        if is_ep:
            # captured pawn is behind the pawn’s landing square (relative to mover)
            ep_sq = (er + (1 if pm[0] == 'w' else -1)) * 8 + ec
            move.ep_captured_sq = ep_sq
            cap_mask = 1 << ep_sq
            cap_r, cap_c = divmod(ep_sq, 8)
            board[cap_r][cap_c] = "--"
            bb[pc] ^= cap_mask
            if pc[0] == 'w': self.occ_white ^= cap_mask
            else:            self.occ_black ^= cap_mask
        elif pc != "--":
            bb[pc] ^= to_mask
            if pc[0] == 'w': self.occ_white ^= to_mask
            else:            self.occ_black ^= to_mask

        # Promotion
        if is_promo:
            choice   = move.promotion_choice
            promoted = pm[0] + choice           # e.g. 'wQ'
            board[er][ec] = promoted
            bb[pm]       ^= to_mask            # remove pawn at 'to'
            bb[promoted] ^= to_mask            # add promoted at 'to' (XOR to mirror undo)

        # Castling rook move
        if is_castle:
            if ec - sc == 2:   # O-O
                rf, cf, rt, ct = er, 7, er, 5
            else:              # O-O-O
                rf, cf, rt, ct = er, 0, er, 3
            move.rook_from = (rf, cf)
            move.rook_to   = (rt, ct)
            rook_code = pm[0] + 'R'
            board[rf][cf] = "--"
            board[rt][ct] = rook_code
            m_from = 1 << (rf*8 + cf)
            m_to   = 1 << (rt*8 + ct)
            bb[rook_code] ^= (m_from | m_to)
            if mover_side == 'w': self.occ_white ^= (m_from | m_to)
            else:                 self.occ_black ^= (m_from | m_to)

        # Recompute combined
        self.occ_all = self.occ_white | self.occ_black

        # King square
        if pm == 'wK': self.white_king_location = (er, ec)
        elif pm == 'bK': self.black_king_location = (er, ec)

        # Old rights/EP snapshot (before changes)
        move.old_cr = (self.current_castling_rights.wks,
                    self.current_castling_rights.wqs,
                    self.current_castling_rights.bks,
                    self.current_castling_rights.bqs)
        move.old_ep = self.enpassant_possible
        move.old_ep_hashable = bool(move.old_ep) and self._ep_capturable_given_side(
            move.old_ep, self.white_to_move
        )

        # Update CR (pre side-flip)
        self.updateCastleRights(move)
        self.castle_rights_log.append(CastleRights(
            self.current_castling_rights.wks,
            self.current_castling_rights.wqs,
            self.current_castling_rights.bks,
            self.current_castling_rights.bqs
        ))

        # En-passant square
        if pm[1] == 'p' and abs(sr - er) == 2:
            self.enpassant_possible = ((sr + er)//2, sc)
        else:
            self.enpassant_possible = ()
        self.enpassant_possible_log.append(self.enpassant_possible)

        # New rights/EP (for Zobrist)
        move.new_cr = (self.current_castling_rights.wks,
                    self.current_castling_rights.wqs,
                    self.current_castling_rights.bks,
                    self.current_castling_rights.bqs)
        move.new_ep = self.enpassant_possible
        move.new_ep_hashable = bool(move.new_ep) and self._ep_capturable_given_side(
            move.new_ep, not self.white_to_move
        )

        # Halfmove clock
        if pm[1] == 'p' or pc != '--': self.halfmove_clock = 0
        else:                           self.halfmove_clock += 1
        self.halfmove_clock_log.append(self.halfmove_clock)

        # Flip side
        self.white_to_move = not self.white_to_move

        # Zobrist then repetition history
        self._update_zobrist(move)
        self._update_position_history()

        # Log move
        self.move_log.append(move)

    def undoMove(self):
        """
        Undo the last move, restoring:
        eval, board/bitboards/occupancies, side, king squares,
        EP & castling rights, halfmove + repetition history, and Zobrist.
        """
        if not self.move_log:
            return

        move = self.move_log.pop()
        is_ep     = move.is_enpassant_move
        is_promo  = move.is_pawn_promotion
        is_castle = move.is_castle_move

        # Revert clocks/history (current zobrist is the "after" position key)
        if self.halfmove_clock_log: self.halfmove_clock_log.pop()
        self.halfmove_clock = self.halfmove_clock_log[-1] if self.halfmove_clock_log else 0
        self._decrement_position_history()

        # EP/castling logs
        if self.enpassant_possible_log: self.enpassant_possible_log.pop()
        self.enpassant_possible = self.enpassant_possible_log[-1] if self.enpassant_possible_log else ()
        if self.castle_rights_log: self.castle_rights_log.pop()
        prev_cr = self.castle_rights_log[-1] if self.castle_rights_log else self.current_castling_rights
        self.current_castling_rights = CastleRights(prev_cr.wks, prev_cr.wqs, prev_cr.bks, prev_cr.bqs)

        # Eval
        self.current_eval -= move.eval_delta

        # Side to move flips back
        self.white_to_move = not self.white_to_move

        # Locals
        board, bb = self.board, self.bitboards
        sr, sc, er, ec = move.start_row, move.start_col, move.end_row, move.end_col
        from_mask, to_mask = move.from_mask, move.to_mask
        pm, pc = move.piece_moved, move.piece_captured
        mover_side = pm[0]

        # Restore Zobrist
        self.zobrist_key = move.zobrist_key_before

        # --- Undo promotion: replace promoted@to with pawn@to (XOR, not OR) ---
        if is_promo:
            promoted = pm[0] + move.promotion_choice
            bb[promoted] ^= to_mask      # remove promoted at 'to'
            bb[pm]       ^= to_mask      # add pawn at 'to'
            board[er][ec] = pm           # temporarily show pawn at 'to'

        # --- Undo castling rook move (mirror of makeMove) ---
        if is_castle:
            rf, cf = move.rook_from
            rt, ct = move.rook_to
            rook_code = mover_side + 'R'
            r_from_mask = 1 << (rf*8 + cf)
            r_to_mask   = 1 << (rt*8 + ct)
            bb[rook_code] ^= (r_from_mask | r_to_mask)
            board[rf][cf] = rook_code
            board[rt][ct] = "--"
            if mover_side == 'w':
                self.occ_white ^= (r_from_mask | r_to_mask)
            else:
                self.occ_black ^= (r_from_mask | r_to_mask)

        # --- Move the mover back to start ---
        board[sr][sc] = pm
        board[er][ec] = "--"
        bb[pm] ^= (from_mask | to_mask)
        if mover_side == 'w':
            self.occ_white ^= (from_mask | to_mask)
        else:
            self.occ_black ^= (from_mask | to_mask)

        # --- Restore captured piece (EP or normal) ---
        if is_ep:
            ep_sq = move.ep_captured_sq
            cap_mask = 1 << ep_sq
            cap_r, cap_c = divmod(ep_sq, 8)
            board[cap_r][cap_c] = pc
            bb[pc] ^= cap_mask                # XOR (toggle back on)
            if pc[0] == 'w':
                self.occ_white ^= cap_mask
            else:
                self.occ_black ^= cap_mask
        elif pc != "--":
            board[er][ec] = pc
            bb[pc] ^= to_mask                 # XOR (toggle back on)
            if pc[0] == 'w':
                self.occ_white ^= to_mask
            else:
                self.occ_black ^= to_mask

        # Combined occupancy
        self.occ_all = self.occ_white | self.occ_black

        # King squares
        if pm == 'wK':
            self.white_king_location = (sr, sc)
        elif pm == 'bK':
            self.black_king_location = (sr, sc)

    def makeNullMove(self):
        """
        Null move: side-to-move passes. We:
        - remove EP from zobrist if hashable,
        - flip side-to-move,
        - clear EP,
        - bump halfmove clock,
        - toggle side bit in Zobrist.
        NOTE: We do NOT touch board/bitboards/castling/logs/position_history.
        """
        # snapshot minimal state so we can restore exactly
        token = (self.white_to_move, self.enpassant_possible, self.zobrist_key)

        # If an EP file was hashable for the *current* side, remove it from hash.
        old_ep = self.enpassant_possible
        if old_ep and self._ep_capturable_given_side(old_ep, self.white_to_move):
            self.zobrist_key ^= ZOBRIST_ENPASSANT[old_ep[1]]

        # Flip side-to-move in hash
        self.white_to_move = not self.white_to_move
        self.zobrist_key ^= ZOBRIST_SIDE

        # Clear EP square (null move always cancels EP rights)
        self.enpassant_possible = ()

        return token

    def undoNullMove(self, token):
        """Restore state saved by makeNullMove()."""
        self.white_to_move, self.enpassant_possible, self.zobrist_key = token

    def updateCastleRights(self, move):
        cr = self.current_castling_rights

        # rook captured on its HOME square?
        if move.piece_captured == "wR" and move.end_row == 7:
            if move.end_col == 0: cr.wqs = False
            elif move.end_col == 7: cr.wks = False
        elif move.piece_captured == "bR" and move.end_row == 0:
            if move.end_col == 0: cr.bqs = False
            elif move.end_col == 7: cr.bks = False

        # king moved ⇒ both sides off
        if move.piece_moved == 'wK':
            cr.wqs = False
            cr.wks = False
        elif move.piece_moved == 'bK':
            cr.bqs = False
            cr.bks = False

        # rook moved from HOME square?
        elif move.piece_moved == 'wR' and move.start_row == 7:
            if move.start_col == 0: cr.wqs = False
            elif move.start_col == 7: cr.wks = False
        elif move.piece_moved == 'bR' and move.start_row == 0:
            if move.start_col == 0: cr.bqs = False
            elif move.start_col == 7: cr.bks = False

    def getValidMoves(self):
        self.in_check, pins, self.checks = self.checkForPinsAndChecks()

        if not self.in_check:
            opp_attacks = self.compute_attacked_mask(by_white=not self.white_to_move)
            legal = self.getAllPossibleMoves(opp_attacks=opp_attacks)

            kr, kc = (self.white_king_location if self.white_to_move else self.black_king_location)
            self.getCastleMoves(kr, kc, legal, opp_attacks=opp_attacks)
        else:
            legal = []
            for m in self.getAllPossibleMoves():
                self.makeMove(m)
                try:
                    if not self._own_king_in_check_after_move():
                        legal.append(m)
                finally:
                    self.undoMove()

        if not legal:
            self.checkmate = bool(self.in_check)
            self.stalemate = not self.in_check
        else:
            self.checkmate = self.stalemate = False
        return legal

    def inCheck(self):
        """True if the side to move is currently in check."""
        kr, kc = (self.white_king_location if self.white_to_move else self.black_king_location)
        return self.is_square_attacked_bb(kr * 8 + kc, by_white=not self.white_to_move)

    def _own_king_in_check_after_move(self) -> bool:
        """After makeMove(), check whether the side that just moved exposed its own king."""
        mover_is_white = not self.white_to_move
        kr, kc = (self.white_king_location if mover_is_white else self.black_king_location)
        return self.is_square_attacked_bb(kr * 8 + kc, by_white=not mover_is_white)

    def getAllPossibleMoves(self, opp_attacks=None):
        """
        Generate all pseudo-legal moves (no check filtering, no castles).
        Knights & King via bitboards; others via existing square scan.
        If opp_attacks (bitboard) is provided, king steps are filtered with it.
        """
        board = self.board
        mf = self.moveFunctions
        wtm = self.white_to_move

        buf = []

        # Square-scan only for pawns/rooks/bishops/queens (skip N and K here)
        for r in range(8):
            row = board[r]
            for c in range(8):
                sq = row[c]
                if sq != "--" and ((sq[0] == 'w') == wtm):
                    t = sq[1]
                    if t == 'N' or t == 'K':
                        continue
                    mf[t](r, c, buf)

        # Bitboard fast paths
        self.gen_knight_moves_bb(buf)
        self.gen_king_moves_bb(buf, opp_attacks=opp_attacks)  # << use precomputed mask

        if not buf:
            return []

        # Safety filter (no castling here, and never allow king captures)
        out = []
        append = out.append
        for m in buf:
            if getattr(m, 'is_castle_move', False):
                continue
            pc = m.piece_captured
            if pc != "--" and pc[1] == 'K':
                continue
            append(m)
        return out

    def checkForPinsAndChecks(self):
        """
        Return whether the current side is in check, plus pin/check ray data.
        Falls back to a pure-Python implementation when the native helper is unavailable.
        """
        if _HAVE_NATIVE_PINS:
            bb = self.bitboards
            in_check, pins, checks = _ce._check_pins_and_checks(
                bool(self.white_to_move),
                int(bb['wp']), int(bb['wN']), int(bb['wB']), int(bb['wR']), int(bb['wQ']), int(bb['wK']),
                int(bb['bp']), int(bb['bN']), int(bb['bB']), int(bb['bR']), int(bb['bQ']), int(bb['bK'])
            )
        else:
            in_check, pins, checks = self._python_check_pins_and_checks()

        self.pinned_map = {(r, c): (dr, dc) for (r, c, dr, dc) in pins}
        return bool(in_check), pins, checks

    def getPawnMoves(self, row, col, moves):
        board = self.board
        wtm = self.white_to_move
        promo_row = 0 if wtm else 7

        pin = self.pinned_map.get((row, col))
        piece_pinned = pin is not None
        pin_dr, pin_dc = (pin if pin else (0, 0))

        if _HAVE_NATIVE_PAWN_STEPS:
            steps = _ce._gen_pawn_steps_from(
                row * 8 + col, bool(wtm),
                int(self.occ_white), int(self.occ_black),
                bool(piece_pinned), int(pin_dr), int(pin_dc)
            )

            for s in steps:
                to_sq = s & 63
                from_sq = (s >> 6) & 63
                r0, c0 = divmod(from_sq, 8)
                r1, c1 = divmod(to_sq, 8)
                if r1 == promo_row:
                    for ch in ('Q', 'R', 'B', 'N'):
                        moves.append(Move((r0, c0), (r1, c1), board, promotion_choice=ch))
                else:
                    moves.append(Move((r0, c0), (r1, c1), board))
        else:
            self._gen_pawn_moves_py(row, col, moves)

        move_amount = -1 if wtm else 1
        r1 = row + move_amount
        if 0 <= r1 < 8:
            for dc in (-1, +1):
                c = col + dc
                if 0 <= c < 8:
                    if (not piece_pinned) or (pin_dr, pin_dc) == (move_amount, dc):
                        if (r1, c) == self.enpassant_possible and self._ep_is_legal(row, col, r1, c):
                            moves.append(Move((row, col), (r1, c), board, is_enpassant_move=True))

    def getKnightMoves(self, moves):
        if not _HAVE_NATIVE_KNIGHT_STEPS:
            self._gen_knight_moves_py(moves)
            return

        wtm = self.white_to_move
        board = self.board
        knights = int(self.bitboards['wN' if wtm else 'bN'])
        us_occ = int(self.occ_white if wtm else self.occ_black)

        pinned_knights = 0
        k = knights
        while k:
            lsb = k & -k
            sq = lsb.bit_length() - 1
            k ^= lsb
            r, c = divmod(sq, 8)
            if (r, c) in self.pinned_map:
                pinned_knights |= (1 << sq)

        for s in _ce._gen_knight_steps(knights, us_occ, pinned_knights):
            frm = (s >> 6) & 63
            to = s & 63
            r0, c0 = divmod(frm, 8)
            r1, c1 = divmod(to, 8)
            moves.append(Move((r0, c0), (r1, c1), board))

    def _gen_slider_from(self, r, c, dirs, moves): # Helper for rooks/bishops/queens
        them_occ = self.occ_black if self.white_to_move else self.occ_white
        pin = self.pinned_map.get((r, c))
        append = moves.append

        for dr, dc in dirs:
            # If pinned, only allow moves collinear with the pin ray
            if pin and pin != (dr, dc) and pin != (-dr, -dc):
                continue

            rr, cc = r + dr, c + dc
            while 0 <= rr < 8 and 0 <= cc < 8:
                to_sq = rr * 8 + cc
                bbm = 1 << to_sq

                if self.occ_all & bbm:           # blocked
                    if them_occ & bbm:           # enemy piece → capture then stop
                        append(Move((r, c), (rr, cc), self.board))
                    break                         # own piece or captured → stop
                else:
                    append(Move((r, c), (rr, cc), self.board))

                rr += dr; cc += dc

    def getRookMoves(self, row, col, moves): # C++
        try:
            from_sq = row*8 + col
            wtm = self.white_to_move
            us  = int(self.occ_white if wtm else self.occ_black)
            occ = int(self.occ_all)
            pin = self.pinned_map.get((row, col))
            pinned = pin is not None
            pdr, pdc = pin if pinned else (0, 0)
            for s in _ce._gen_rook_steps_from(from_sq, us, occ, pinned, pdr, pdc):
                frm = (s >> 6) & 63
                to  =  s       & 63
                r0, c0 = divmod(frm, 8); r1, c1 = divmod(to, 8)
                moves.append(Move((r0, c0), (r1, c1), self.board))
        except Exception:
            # fallback to Python version
            self._gen_slider_from(row, col, DIRS_ROOK, moves)

    def getBishopMoves(self, row, col, moves): # C++
        try:
            from_sq = row*8 + col
            wtm = self.white_to_move
            us  = int(self.occ_white if wtm else self.occ_black)
            occ = int(self.occ_all)
            pin = self.pinned_map.get((row, col))
            pinned = pin is not None
            pdr, pdc = pin if pinned else (0, 0)
            for s in _ce._gen_bishop_steps_from(from_sq, us, occ, pinned, pdr, pdc):
                frm = (s >> 6) & 63
                to  =  s       & 63
                r0, c0 = divmod(frm, 8); r1, c1 = divmod(to, 8)
                moves.append(Move((r0, c0), (r1, c1), self.board))
        except Exception:
            self._gen_slider_from(row, col, DIRS_BISHOP, moves)

    def getQueenMoves(self, row, col, moves): # C++
        try:
            from_sq = row*8 + col
            wtm = self.white_to_move
            us  = int(self.occ_white if wtm else self.occ_black)
            occ = int(self.occ_all)
            pin = self.pinned_map.get((row, col))
            pinned = pin is not None
            pdr, pdc = pin if pinned else (0, 0)
            for s in _ce._gen_queen_steps_from(from_sq, us, occ, pinned, pdr, pdc):
                frm = (s >> 6) & 63
                to  =  s       & 63
                r0, c0 = divmod(frm, 8); r1, c1 = divmod(to, 8)
                moves.append(Move((r0, c0), (r1, c1), self.board))
        except Exception:
            # Python fallback: rook-like + bishop-like
            self.getRookMoves(row, col, moves)
            self.getBishopMoves(row, col, moves)

    def getKingMoves(self, r, c, moves):
        """Generate king steps only; castling is handled separately."""
        opp_attacks = int(self.compute_attacked_mask(by_white=(not self.white_to_move)))
        if _HAVE_NATIVE_KING_STEPS:
            from_sq = (r << 3) | c
            us_occ = int(self.occ_white if self.white_to_move else self.occ_black)
            for s in _ce._gen_king_steps(1 << from_sq, us_occ, opp_attacks, True):
                frm = (s >> 6) & 63
                to = s & 63
                r0, c0 = divmod(frm, 8)
                r1, c1 = divmod(to, 8)
                moves.append(Move((r0, c0), (r1, c1), self.board))
            return

        self._gen_king_moves_py(moves, opp_attacks=opp_attacks)

    def getCastleMoves(self, row, col, moves, opp_attacks=None): # Stays Python Only
        """Append legal castling moves for side-to-move king on (row, col)."""
        ksq = (row << 3) | col
        if opp_attacks is None:
            if self.is_square_attacked_bb(ksq, by_white=(not self.white_to_move)):
                return
        else:
            if (opp_attacks >> ksq) & 1:
                return

        cr = self.current_castling_rights
        if self.white_to_move:
            if cr.wks: self.getKingsideCastleMoves(row, col, moves, opp_attacks=opp_attacks)
            if cr.wqs: self.getQueensideCastleMoves(row, col, moves, opp_attacks=opp_attacks)
        else:
            if cr.bks: self.getKingsideCastleMoves(row, col, moves, opp_attacks=opp_attacks)
            if cr.bqs: self.getQueensideCastleMoves(row, col, moves, opp_attacks=opp_attacks)

    def getKingsideCastleMoves(self, r, c, moves, opp_attacks=None): # Stays Python Only
        rook = 'wR' if self.white_to_move else 'bR'
        board = self.board
        if board[r][7] != rook:
            return
        if (self.white_to_move and not self.current_castling_rights.wks) or \
        ((not self.white_to_move) and not self.current_castling_rights.bks):
            return
        if c + 2 >= 8:
            return
        if board[r][c+1] == '--' and board[r][c+2] == '--':
            s1, s2 = (r << 3) | (c+1), (r << 3) | (c+2)
            if opp_attacks is not None:
                if ((opp_attacks >> s1) & 1) or ((opp_attacks >> s2) & 1):
                    return
            else:
                if (self.is_square_attacked_bb(s1, by_white=(not self.white_to_move)) or
                    self.is_square_attacked_bb(s2, by_white=(not self.white_to_move))):
                    return
            moves.append(Move((r, c), (r, c+2), board, is_castle_move=True))

    def getQueensideCastleMoves(self, r, c, moves, opp_attacks=None): # Stays Python Only
        rook = 'wR' if self.white_to_move else 'bR'
        board = self.board
        if board[r][0] != rook:
            return
        if (self.white_to_move and not self.current_castling_rights.wqs) or \
        ((not self.white_to_move) and not self.current_castling_rights.bqs):
            return
        if c - 2 < 0:
            return
        if board[r][c-1] == '--' and board[r][c-2] == '--' and board[r][c-3] == '--':
            s1, s2 = (r << 3) | (c-1), (r << 3) | (c-2)
            if opp_attacks is not None:
                if ((opp_attacks >> s1) & 1) or ((opp_attacks >> s2) & 1):
                    return
            else:
                if (self.is_square_attacked_bb(s1, by_white=(not self.white_to_move)) or
                    self.is_square_attacked_bb(s2, by_white=(not self.white_to_move))):
                    return
            moves.append(Move((r, c), (r, c-2), board, is_castle_move=True))

    def _compute_zobrist(self): # Stays Python Only
        """
        Compute full Zobrist key including:
        - side to move
        - piece placements
        - castling rights (order: wks, wqs, bks, bqs)
        - en-passant file (by column a–h)
        """
        key = 0

        # 1) side to move
        if not self.white_to_move:
            key ^= ZOBRIST_SIDE

        # 2) pieces
        zp = ZOBRIST_PIECE
        board = self.board
        for r in range(8):
            row = board[r]
            base = r * 8
            for c in range(8):
                p = row[c]
                if p != "--":
                    key ^= zp[p][base + c]

        # 3) castling rights (wks, wqs, bks, bqs)  ← matches global array indices [0..3]
        zc = ZOBRIST_CASTLING
        cr = self.current_castling_rights
        if cr.wks: key ^= zc[0]
        if cr.wqs: key ^= zc[1]
        if cr.bks: key ^= zc[2]
        if cr.bqs: key ^= zc[3]

        # 4) en-passant file (if any)
        ep = self.enpassant_possible
        if ep and self._ep_capturable_given_side(ep, self.white_to_move):
            key ^= ZOBRIST_ENPASSANT[ep[1]]

        return key

    def _update_zobrist(self, move): # Stays Python Only
        """
        Incrementally update Zobrist key for a single move.
        Requires:
        - move.old_cr / move.new_cr: tuples of 4 bools (wks, wqs, bks, bqs)
        - move.old_ep / move.new_ep: (row, col) or ()
        - move.old_ep_hashable / move.new_ep_hashable: booleans indicating whether
            the EP file was/is actually hashable (i.e., capturable by the side to move)
        Handles promotions, en-passant captures, and castling rook toggles.
        """
        pm, pc = move.piece_moved, move.piece_captured
        sr, sc, er, ec = move.start_row, move.start_col, move.end_row, move.end_col

        is_ep     = move.is_enpassant_move
        is_promo  = move.is_pawn_promotion
        is_castle = move.is_castle_move

        old_cr, new_cr = move.old_cr, move.new_cr
        old_ep, new_ep = move.old_ep, move.new_ep

        zp, zs, zc, ze = ZOBRIST_PIECE, ZOBRIST_SIDE, ZOBRIST_CASTLING, ZOBRIST_ENPASSANT

        # Side to move flips
        self.zobrist_key ^= zs

        # Move piece out/in (promotion-aware)
        self.zobrist_key ^= zp[pm][sr * 8 + sc]

        if is_ep:
            cap_row = er + (1 if pm[0] == "w" else -1)
            self.zobrist_key ^= zp[pc][cap_row * 8 + ec]
        elif pc != "--":
            self.zobrist_key ^= zp[pc][er * 8 + ec]

        if is_promo:
            promoted = pm[0] + move.promotion_choice
            self.zobrist_key ^= zp[promoted][er * 8 + ec]
        else:
            self.zobrist_key ^= zp[pm][er * 8 + ec]

        # Castling rook toggles
        if is_castle and move.rook_from is not None:
            rf, cf = move.rook_from
            rt, ct = move.rook_to
            rook_code = pm[0] + 'R'
            self.zobrist_key ^= zp[rook_code][rf * 8 + cf]
            self.zobrist_key ^= zp[rook_code][rt * 8 + ct]

        # Castling rights out/in
        if old_cr is not None:
            wks, wqs, bks, bqs = old_cr
            if wks: self.zobrist_key ^= zc[0]
            if wqs: self.zobrist_key ^= zc[1]
            if bks: self.zobrist_key ^= zc[2]
            if bqs: self.zobrist_key ^= zc[3]

        # EP out/in — compute *hashability* here
        if old_ep:
            # Before the move, side-to-move was the mover ⇒ that's the opposite of current self.white_to_move
            if self._ep_capturable_given_side(old_ep, not self.white_to_move):
                self.zobrist_key ^= ze[old_ep[1]]

        if new_cr is not None:
            wks, wqs, bks, bqs = new_cr
            if wks: self.zobrist_key ^= zc[0]
            if wqs: self.zobrist_key ^= zc[1]
            if bks: self.zobrist_key ^= zc[2]
            if bqs: self.zobrist_key ^= zc[3]

        if new_ep:
            # After the move, side-to-move is the opponent ⇒ exactly self.white_to_move now
            if self._ep_capturable_given_side(new_ep, self.white_to_move):
                self.zobrist_key ^= ze[new_ep[1]]

    def _update_position_history(self): # Stays Python Only
        """Increment repetition count for the current Zobrist key."""
        key = self.zobrist_key
        self.position_history[key] = self.position_history.get(key, 0) + 1

    def _decrement_position_history(self): # Stays Python Only
        """Decrement repetition count for the current Zobrist key."""
        key = self.zobrist_key
        cnt = self.position_history.get(key, 0)
        if cnt > 1:
            self.position_history[key] = cnt - 1
        elif cnt == 1:
            del self.position_history[key]

    def is_threefold_repetition(self):
        """True if this Zobrist key has appeared ≥3 times."""
        return self.position_history.get(self.zobrist_key, 0) >= 3

    def is_fifty_move_rule(self):
        """True if 50 full moves (100 half-moves) without pawn move or capture."""
        return self.halfmove_clock >= 100

    def is_insufficient_material(self):
        """
        True if checkmate is impossible by any series of legal moves.
        Covers common dead positions:
        - K vs K
        - K+B vs K, K+N vs K
        - K+NN vs K (two knights cannot force mate)
        - KB vs KB with bishops on same color squares
        Anything with pawns/rooks/queens is sufficient.
        """
        # Fast path via bitboards: any pawn/rook/queen present -> sufficient material
        bb = self.bitboards
        if (bb['wp'] | bb['bp'] | bb['wR'] | bb['bR'] | bb['wQ'] | bb['bQ']) != 0:
            return False

        # Otherwise scan minors from board to avoid square-color masks headaches
        board = self.board
        w_knights = b_knights = 0
        w_bishops = []
        b_bishops = []

        for r in range(8):
            row = board[r]
            for c in range(8):
                sq = row[c]
                if sq == '--' or sq[1] in ('K', 'Q', 'R', 'p'):
                    continue
                if sq[1] == 'N':
                    if sq[0] == 'w': w_knights += 1
                    else:            b_knights += 1
                elif sq[1] == 'B':
                    # Track bishop square color by (r+c)&1
                    if sq[0] == 'w': w_bishops.append((r + c) & 1)
                    else:            b_bishops.append((r + c) & 1)

        total_minors = w_knights + b_knights + len(w_bishops) + len(b_bishops)

        # Bare kings
        if total_minors == 0:
            return True

        # Single minor anywhere (KB vs K or KN vs K)
        if total_minors == 1:
            return True

        # Two knights vs bare king (either side)
        if (w_knights == 2 and b_knights == 0 and not b_bishops) or \
        (b_knights == 2 and w_knights == 0 and not w_bishops):
            return True

        # KB vs KB with same-colored bishops (exactly one each)
        if w_knights == b_knights == 0 and len(w_bishops) == len(b_bishops) == 1:
            return w_bishops[0] == b_bishops[0]

        # Otherwise, assume sufficient
        return False

    def debug_castling_status(self, kingside=True):
        """
        Return (ok: bool, reasons: list[str]) for current side-to-move castling.
        Non-invasive: just explains why a castle is or isn't available now.
        """
        reasons = []
        wtm = self.white_to_move
        board = self.board

        # King square + attacked
        kr, kc = (self.white_king_location if wtm else self.black_king_location)
        ksq = (kr << 3) | kc
        if self.is_square_attacked_bb(ksq, by_white=(not wtm)):
            reasons.append("king square is under attack")

        # Rights flag
        cr = self.current_castling_rights
        have_right = (cr.wks if (wtm and kingside) else
                    cr.wqs if (wtm and not kingside) else
                    cr.bks if ((not wtm) and kingside) else
                    cr.bqs)
        if not have_right:
            reasons.append("castling right flag is OFF")

        # Corner rook present
        rook_code = 'wR' if wtm else 'bR'
        r = kr
        if kingside:
            if board[r][7] != rook_code:
                reasons.append("no rook on h-file corner")
        else:
            if board[r][0] != rook_code:
                reasons.append("no rook on a-file corner")

        # Empty path & attacked intermediate squares
        if kingside:
            empties = [(r, kc+1), (r, kc+2)]
            att_sq  = [ (r << 3) | (kc+1), (r << 3) | (kc+2) ]
        else:
            empties = [(r, kc-1), (r, kc-2), (r, kc-3)]
            att_sq  = [ (r << 3) | (kc-1), (r << 3) | (kc-2) ]

        for rr, cc in empties:
            if not (0 <= rr < 8 and 0 <= cc < 8) or board[rr][cc] != "--":
                reasons.append("path square not empty")

        opp_is_white = not wtm
        for sq in att_sq:
            if self.is_square_attacked_bb(sq, by_white=opp_is_white):
                reasons.append("king passes through attacked square")

        return (len(reasons) == 0, reasons)

    def static_eval(self, fast: bool = False) -> float:
        """White-positive static eval of this position, in pawns."""
        return scoreBoard(self, fast=fast)

# --- Perft helpers (place below GameState) ---
def _uci_from_move(m) -> str:
    files = "abcdefgh"
    s = f"{files[m.start_col]}{8 - m.start_row}{files[m.end_col]}{8 - m.end_row}"
    if getattr(m, "is_pawn_promotion", False):
        # UCI wants the promotion piece as lowercase (q,r,b,n)
        s += getattr(m, "promotion_choice", "Q").lower()
    return s

def perft(gs, depth: int) -> int:
    """
    Count legal leaf nodes to `depth` plies from the current game state.
    Uses normal make/undo so it exercises your full legality stack
    (checks, pins, castling, en passant, etc.).
    """
    if depth == 0:
        return 1

    get_moves = gs.getValidMoves
    make = gs.makeMove
    undo = gs.undoMove

    if depth == 1:
        # small speed win
        return len(get_moves())

    nodes = 0
    for m in get_moves():
        make(m)
        nodes += perft(gs, depth - 1)
        undo()
    return nodes

def perft_divide(gs, depth: int) -> int:
    """
    Print a per-move breakdown at the root (useful to find where a mismatch starts).
    Returns the total node count.
    """
    total = 0
    root_moves = gs.getValidMoves()
    root_moves.sort(key=_uci_from_move)
    for m in root_moves:
        gs.makeMove(m)
        cnt = perft(gs, depth - 1)
        gs.undoMove()
        print(f"{_uci_from_move(m)}: {cnt}")
        total += cnt
    print(f"Total: {total}")
    return total

class CastleRights:
    __slots__ = ('wks', 'wqs', 'bks', 'bqs')  # keep the logical order

    def __init__(self, wks: bool, wqs: bool, bks: bool, bqs: bool):
        self.wks = wks
        self.wqs = wqs
        self.bks = bks
        self.bqs = bqs

    def to_tuple(self):
        return (self.wks, self.wqs, self.bks, self.bqs)

    def __repr__(self):
        return f"CastleRights(wks={self.wks}, wqs={self.wqs}, bks={self.bks}, bqs={self.bqs})"

# in chess, fields on the board are described by two symbols, one of them being number between 1-8 (which is corresponding to rows)
# and the second one being a letter between a-f (corresponding to columns), in order to use this notation we need to map our [row][col] coordinates
# to match the ones used in the original chess game
class Move:
    """
    Compact, fast move object.
    - Uses __slots__ to cut allocations.
    - Stable flag aliases (isCastleMove / isEnpassant) for call sites.
    - Packed integer moveID for hashing/eq.
    - Caches from/to squares + masks for hot paths.
    """
    __slots__ = (
        # coords + cached squares/masks
        'start_row','start_col','end_row','end_col',
        'from_sq','to_sq','from_mask','to_mask',
        # pieces
        'piece_moved','piece_captured',
        # flags
        'is_enpassant_move','is_enpassant','isEnpassant',
        'is_castle_move','isCastleMove',
        'is_pawn_promotion','promotion_choice',
        'is_capture',
        # identity
        'moveID',
        # engine-populated at make/undo time
        'zobrist_key_before','eval_delta','rook_from','rook_to','ep_captured_sq',
        # for zobrist incrementals
        'old_cr','new_cr','old_ep','new_ep',
        'old_ep_hashable','new_ep_hashable',
        'from_book',
    )

    # board ↔ notation maps
    ranks_to_rows = {"1": 7, "2": 6, "3": 5, "4": 4,
                     "5": 3, "6": 2, "7": 1, "8": 0}
    rows_to_ranks = {v: k for k, v in ranks_to_rows.items()}
    files_to_cols = {"a": 0, "b": 1, "c": 2, "d": 3,
                     "e": 4, "f": 5, "g": 6, "h": 7}
    cols_to_files = {v: k for k, v in files_to_cols.items()}

    def __init__(self, start_square, end_square, board,
                 is_enpassant_move=False, is_castle_move=False, promotion_choice=None):
        sr, sc = start_square
        er, ec = end_square

        # coords + caches
        self.start_row, self.start_col = sr, sc
        self.end_row,   self.end_col   = er, ec
        self.from_sq = (sr << 3) + sc
        self.to_sq   = (er << 3) + ec
        self.from_mask = 1 << self.from_sq
        self.to_mask   = 1 << self.to_sq

        self.old_ep_hashable = False
        self.new_ep_hashable = False

        # pieces
        self.piece_moved    = board[sr][sc]
        self.piece_captured = board[er][ec]

        # en-passant
        self.is_enpassant_move = bool(is_enpassant_move)
        self.is_enpassant = self.is_enpassant_move
        self.isEnpassant  = self.is_enpassant_move
        if self.is_enpassant_move:
            if self.piece_moved[1] != 'p':
                raise ValueError("en passant set but mover is not a pawn")
            self.piece_captured = "wp" if self.piece_moved == "bp" else "bp" # landing square is empty; victim pawn sits behind it

        # castling (auto-detect king two-square move on same rank)
        auto_castle = (self.piece_moved[1] == 'K' and sr == er and abs(sc - ec) == 2)
        self.is_castle_move = bool(is_castle_move or auto_castle)
        self.isCastleMove   = self.is_castle_move

        # promotion
        self.is_pawn_promotion = (
            (self.piece_moved == "wp" and er == 0) or
            (self.piece_moved == "bp" and er == 7)
        )
        self.promotion_choice = (promotion_choice if self.is_pawn_promotion else None) or 'Q'

        # capture?
        self.is_capture = self.is_enpassant_move or (self.piece_captured != "--")

        # engine-populated later
        self.zobrist_key_before = 0
        self.eval_delta = 0.0
        self.rook_from = None
        self.rook_to = None
        self.ep_captured_sq = None
        self.old_cr = None
        self.new_cr = None
        self.old_ep = None
        self.new_ep = None
        self.from_book = False

        # compute compact integer moveID (6 bits from, 6 bits to, 3 bits promo, 1 ep, 1 castle)
        self._compute_move_id()

    # --- identity / hashing ---
    def _compute_move_id(self):
        fr = self.from_sq & 0x3F
        to = self.to_sq   & 0x3F
        # promo code: 0=none, 1=Q, 2=R, 3=B, 4=N
        promo_map = {'Q': 1, 'R': 2, 'B': 3, 'N': 4}
        promo = 0
        if self.is_pawn_promotion:
            promo = promo_map.get(self.promotion_choice, 1)  # default Q
        ep = 1 if self.is_enpassant_move else 0
        cs = 1 if self.is_castle_move else 0
        self.moveID = (fr) | (to << 6) | (promo << 12) | (ep << 15) | (cs << 16)

    def recompute_id(self):
        """Call this after changing promotion_choice."""
        self._compute_move_id()

    def __hash__(self):
        return self.moveID

    def __eq__(self, other):
        return isinstance(other, Move) and self.moveID == other.moveID

    # --- notation helpers ---
    def uci(self):
        """Coordinate notation, e.g., e2e4, e7e8q."""
        s = self.getRankFile(self.start_row, self.start_col)
        e = self.getRankFile(self.end_row, self.end_col)
        if self.is_pawn_promotion:
            return (s + e + self.promotion_choice.lower())
        return s + e

    def getChessNotation(self):
        # Castling (queenside ends at col==2)
        if self.is_castle_move:
            return "O-O" if self.end_col == 6 else "O-O-O"

        # En passant (show as capture with tag)
        if self.is_enpassant_move:
            return (self.getRankFile(self.start_row, self.start_col)[0]
                    + "x" + self.getRankFile(self.end_row, self.end_col) + " e.p.")

        # Promotion (quiet or capture)
        if self.is_pawn_promotion:
            if self.is_capture and self.piece_moved[1] == "p":
                # e.g., exd8Q (simple LAN-like)
                return (self.cols_to_files[self.start_col] + "x" +
                        self.getRankFile(self.end_row, self.end_col) + self.promotion_choice)
            # quiet promotion like e8Q
            return self.getRankFile(self.end_row, self.end_col) + self.promotion_choice

        # Normal captures / quiets
        if self.is_capture:
            if self.piece_moved[1] == "p":
                return (self.cols_to_files[self.start_col] + "x" +
                        self.getRankFile(self.end_row, self.end_col))
            return self.piece_moved[1] + "x" + self.getRankFile(self.end_row, self.end_col)

        # Quiet
        if self.piece_moved[1] == "p":
            return self.getRankFile(self.end_row, self.end_col)
        return self.piece_moved[1] + self.getRankFile(self.end_row, self.end_col)

    def getRankFile(self, row, col):
        return self.cols_to_files[col] + self.rows_to_ranks[row]

    def __str__(self):
        return self.getChessNotation()

    def __repr__(self):
        return (f"Move({self.start_row},{self.start_col}->{self.end_row},{self.end_col},"
                f"{self.piece_moved}, ep={self.is_enpassant_move}, castle={self.is_castle_move}, "
                f"promo={self.promotion_choice if self.is_pawn_promotion else '-'})")