PST.py

import numpy as np
from numba import int32, njit

# ==========================================================
#  MIDGAME PST (INT16) — ALL NEW VALUES
# ==========================================================

pawn_mid_PST = np.array(
    [
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        60,
        60,
        60,
        60,
        60,
        60,
        60,
        60,
        15,
        15,
        25,
        35,
        35,
        25,
        15,
        15,
        5,
        5,
        15,
        30,
        30,
        15,
        5,
        5,
        0,
        0,
        5,
        25,
        25,
        5,
        0,
        0,
        5,
        -5,
        -10,
        5,
        5,
        -10,
        -5,
        5,
        5,
        15,
        15,
        -15,
        -15,
        15,
        15,
        5,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
    ],
    dtype=np.int16,
)

knight_mid_PST = np.array(
    [
        -60,
        -40,
        -30,
        -30,
        -30,
        -30,
        -40,
        -60,
        -40,
        -20,
        0,
        5,
        5,
        0,
        -20,
        -40,
        -30,
        5,
        15,
        20,
        20,
        15,
        5,
        -30,
        -30,
        10,
        20,
        25,
        25,
        20,
        10,
        -30,
        -30,
        10,
        20,
        25,
        25,
        20,
        10,
        -30,
        -30,
        5,
        15,
        20,
        20,
        15,
        5,
        -30,
        -40,
        -20,
        0,
        5,
        5,
        0,
        -20,
        -40,
        -60,
        -40,
        -30,
        -30,
        -30,
        -30,
        -40,
        -60,
    ],
    dtype=np.int16,
)

bishop_mid_PST = np.array(
    [
        -25,
        -15,
        -10,
        -10,
        -10,
        -10,
        -15,
        -25,
        -10,
        10,
        5,
        5,
        5,
        5,
        10,
        -10,
        -10,
        15,
        15,
        15,
        15,
        15,
        15,
        -10,
        -10,
        10,
        15,
        20,
        20,
        15,
        10,
        -10,
        -10,
        10,
        15,
        20,
        20,
        15,
        10,
        -10,
        -10,
        5,
        10,
        15,
        15,
        10,
        5,
        -10,
        -10,
        0,
        0,
        0,
        0,
        0,
        0,
        -10,
        -25,
        -15,
        -10,
        -10,
        -10,
        -10,
        -15,
        -25,
    ],
    dtype=np.int16,
)

rook_mid_PST = np.array(
    [
        0,
        0,
        5,
        10,
        10,
        5,
        0,
        0,
        5,
        15,
        15,
        15,
        15,
        15,
        15,
        5,
        -5,
        0,
        0,
        5,
        5,
        0,
        0,
        -5,
        -5,
        0,
        5,
        10,
        10,
        5,
        0,
        -5,
        -5,
        0,
        5,
        10,
        10,
        5,
        0,
        -5,
        -5,
        0,
        0,
        5,
        5,
        0,
        0,
        -5,
        5,
        10,
        10,
        15,
        15,
        10,
        10,
        5,
        0,
        0,
        5,
        10,
        10,
        5,
        0,
        0,
    ],
    dtype=np.int16,
)

queen_mid_PST = np.array(
    [
        -25,
        -15,
        -10,
        -5,
        -5,
        -10,
        -15,
        -25,
        -10,
        0,
        0,
        5,
        5,
        0,
        0,
        -10,
        -10,
        5,
        10,
        10,
        10,
        10,
        5,
        -10,
        -5,
        5,
        10,
        15,
        15,
        10,
        5,
        -5,
        0,
        5,
        10,
        15,
        15,
        10,
        5,
        -5,
        -10,
        5,
        10,
        10,
        10,
        10,
        5,
        -10,
        -10,
        0,
        5,
        0,
        0,
        5,
        0,
        -10,
        -25,
        -15,
        -10,
        -5,
        -5,
        -10,
        -15,
        -25,
    ],
    dtype=np.int16,
)

king_mid_PST = np.array(
    [
        -40,
        -50,
        -50,
        -60,
        -60,
        -50,
        -50,
        -40,
        -40,
        -50,
        -50,
        -60,
        -60,
        -50,
        -50,
        -40,
        -40,
        -50,
        -50,
        -60,
        -60,
        -50,
        -50,
        -40,
        -40,
        -50,
        -50,
        -60,
        -60,
        -50,
        -50,
        -40,
        -30,
        -40,
        -40,
        -50,
        -50,
        -40,
        -40,
        -30,
        -20,
        -30,
        -30,
        -30,
        -30,
        -30,
        -30,
        -20,
        20,
        20,
        5,
        0,
        0,
        5,
        20,
        20,
        25,
        35,
        15,
        0,
        0,
        15,
        35,
        25,
    ],
    dtype=np.int16,
)


# ==========================================================
#  ENDGAME PST — ALL SEPARATELY DECLARED
# ==========================================================

pawn_end_PST = np.array(
    [
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        90,
        90,
        90,
        90,
        90,
        90,
        90,
        90,
        60,
        60,
        60,
        60,
        60,
        60,
        60,
        60,
        40,
        40,
        40,
        40,
        40,
        40,
        40,
        40,
        30,
        30,
        30,
        30,
        30,
        30,
        30,
        30,
        20,
        20,
        20,
        20,
        20,
        20,
        20,
        20,
        10,
        10,
        10,
        -10,
        -10,
        10,
        10,
        10,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
    ],
    dtype=np.int16,
)

knight_end_PST = np.array(
    [
        -50,
        -30,
        -20,
        -20,
        -20,
        -20,
        -30,
        -50,
        -30,
        -10,
        5,
        5,
        5,
        5,
        -10,
        -30,
        -20,
        5,
        15,
        20,
        20,
        15,
        5,
        -20,
        -20,
        5,
        20,
        25,
        25,
        20,
        5,
        -20,
        -20,
        5,
        20,
        25,
        25,
        20,
        5,
        -20,
        -20,
        5,
        15,
        20,
        20,
        15,
        5,
        -20,
        -30,
        -10,
        5,
        5,
        5,
        5,
        -10,
        -30,
        -50,
        -30,
        -20,
        -20,
        -20,
        -20,
        -30,
        -50,
    ],
    dtype=np.int16,
)

bishop_end_PST = np.array(
    [
        -30,
        -20,
        -15,
        -15,
        -15,
        -15,
        -20,
        -30,
        -15,
        5,
        10,
        10,
        10,
        10,
        5,
        -15,
        -15,
        10,
        15,
        20,
        20,
        15,
        10,
        -15,
        -15,
        10,
        20,
        25,
        25,
        20,
        10,
        -15,
        -15,
        10,
        20,
        25,
        25,
        20,
        10,
        -15,
        -15,
        10,
        15,
        20,
        20,
        15,
        10,
        -15,
        -15,
        5,
        10,
        10,
        10,
        10,
        5,
        -15,
        -30,
        -20,
        -15,
        -15,
        -15,
        -15,
        -20,
        -30,
    ],
    dtype=np.int16,
)

rook_end_PST = np.array(
    [
        0,
        5,
        10,
        15,
        15,
        10,
        5,
        0,
        0,
        5,
        10,
        15,
        15,
        10,
        5,
        0,
        -5,
        0,
        5,
        10,
        10,
        5,
        0,
        -5,
        -5,
        0,
        5,
        10,
        10,
        5,
        0,
        -5,
        -5,
        0,
        5,
        10,
        10,
        5,
        0,
        -5,
        -5,
        0,
        0,
        5,
        5,
        0,
        0,
        -5,
        5,
        10,
        10,
        15,
        15,
        10,
        10,
        5,
        0,
        5,
        10,
        15,
        15,
        10,
        5,
        0,
    ],
    dtype=np.int16,
)

queen_end_PST = np.array(
    [
        -20,
        -10,
        -5,
        0,
        0,
        -5,
        -10,
        -20,
        -10,
        5,
        10,
        10,
        10,
        10,
        5,
        -10,
        -5,
        10,
        15,
        15,
        15,
        15,
        10,
        -5,
        0,
        10,
        15,
        20,
        20,
        15,
        10,
        0,
        0,
        10,
        15,
        20,
        20,
        15,
        10,
        0,
        -5,
        10,
        15,
        15,
        15,
        15,
        10,
        -5,
        -10,
        5,
        10,
        10,
        10,
        10,
        5,
        -10,
        -20,
        -10,
        -5,
        0,
        0,
        -5,
        -10,
        -20,
    ],
    dtype=np.int16,
)

king_end_PST = np.array(
    [
        -60,
        -40,
        -20,
        -10,
        -10,
        -20,
        -40,
        -60,
        -40,
        -20,
        0,
        10,
        10,
        0,
        -20,
        -40,
        -20,
        0,
        20,
        30,
        30,
        20,
        0,
        -20,
        -10,
        10,
        30,
        40,
        40,
        30,
        10,
        -10,
        -10,
        10,
        30,
        40,
        40,
        30,
        10,
        -10,
        -20,
        0,
        20,
        30,
        30,
        20,
        0,
        -20,
        -40,
        -20,
        0,
        0,
        0,
        0,
        -20,
        -40,
        -60,
        -40,
        -20,
        -10,
        -10,
        -20,
        -40,
        -60,
    ],
    dtype=np.int16,
)


# ==========================================================
#  STACKED PST TABLES (DECLARED)
# ==========================================================

PST_MID = np.stack(
    [
        pawn_mid_PST,
        knight_mid_PST,
        bishop_mid_PST,
        rook_mid_PST,
        queen_mid_PST,
        king_mid_PST,
    ],
    axis=0,
)

PST_END = np.stack(
    [
        pawn_end_PST,
        knight_end_PST,
        bishop_end_PST,
        rook_end_PST,
        queen_end_PST,
        king_end_PST,
    ],
    axis=0,
)


#  BLACK MIRRORED TABLES (DECLARED)
PST_MID_BLACK = PST_MID[:, ::-1]
PST_END_BLACK = PST_END[:, ::-1]


# ==========================================================
#  FINAL ULTRA-FAST PST ACCESSOR
# ==========================================================


@njit(int32(int32, int32, int32), fastmath=True)
def pst_eval(piece, square, endgame):
    # 0–5 = white, 6–11 = black
    is_black = piece >= 6
    p = piece - 6 if is_black else piece

    if endgame:
        return -PST_END_BLACK[p, square] if is_black else PST_END[p, square]
    else:
        return -PST_MID_BLACK[p, square] if is_black else PST_MID[p, square]