File size: 6,079 Bytes
8ccac0b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
"""Capa de análisis del TABLERO para el modelo determinístico (TA-003).

Reconstruye las posiciones de la partida con python-chess a partir de la
secuencia de jugadas (SAN) y extrae features ajedrecísticos: desarrollo,
seguridad del rey y control del centro. Esto le da al modelo conocimiento de la
POSICIÓN —no solo de la evaluación numérica de Stockfish—, para que la
retroalimentación explique el porqué posicional de la secuencia.

Importante: python-chess solo LEE el tablero (no evalúa); la evaluación es de
Stockfish. Todo es determinista: misma secuencia de jugadas → mismos features.

Categoría académica: extracción de features de dominio (conocimiento ajedrecístico).
"""
from __future__ import annotations
import chess

# Casillas iniciales de las piezas menores (caballos y alfiles) por color.
_HOME_MINOR = {
    chess.WHITE: {chess.B1, chess.G1, chess.C1, chess.F1},
    chess.BLACK: {chess.B8, chess.G8, chess.C8, chess.F8},
}
_CENTRO = (chess.D4, chess.E4, chess.D5, chess.E5)


def _reconstruir(sans: list[str]) -> chess.Board | None:
    """Replaya la secuencia SAN desde la posición inicial; None si algo es ilegal."""
    board = chess.Board()
    for san in sans:
        if not san:
            return None
        try:
            board.push_san(san)
        except (ValueError, AssertionError):
            return None
    return board


def _desarrollo(board: chess.Board, color: bool) -> int:
    """Cantidad de piezas menores propias (caballos/alfiles) fuera de su casa."""
    home = _HOME_MINOR[color]
    n = 0
    for tipo in (chess.KNIGHT, chess.BISHOP):
        for sq in board.pieces(tipo, color):
            if sq not in home:
                n += 1
    return n


def _rey_en_centro(board: chess.Board, color: bool) -> bool:
    """True si el rey propio sigue en las columnas centrales (d/e)."""
    rey = board.king(color)
    if rey is None:
        return False
    return chess.square_file(rey) in (3, 4)   # columna d=3, e=4


def _control_centro(board: chess.Board, color: bool) -> int:
    """Casillas centrales (d4/e4/d5/e5) ocupadas o atacadas por el color."""
    score = 0
    for sq in _CENTRO:
        pieza = board.piece_at(sq)
        if pieza and pieza.color == color:
            score += 1
        if board.is_attacked_by(color, sq):
            score += 1
    return score


def _destino_file(san: str) -> int | None:
    """Columna (0-7) de la casilla de destino de una jugada SAN, o None."""
    s = san.split("=")[0].rstrip("+#")
    if len(s) >= 2 and s[-2] in "abcdefgh" and s[-1] in "12345678":
        return ord(s[-2]) - ord("a")
    return None


def _dama_fuera(board: chess.Board, color: bool) -> bool:
    """True si la dama propia ya salió de su casilla inicial (d1/d8)."""
    home = chess.D1 if color == chess.WHITE else chess.D8
    return any(sq != home for sq in board.pieces(chess.QUEEN, color))


def _caballo_en_borde(san: str) -> bool:
    """True si la jugada actual lleva un caballo a la columna del borde (a/h)."""
    if not san.startswith("N"):
        return False
    df = _destino_file(san)
    return df in (0, 7)


def _avance_peon_rey(board: chess.Board, color: bool, san: str) -> bool:
    """True si la jugada empuja un peón delante del propio rey ya enrocado.

    Debilita el refugio del rey. Solo aplica si el rey ya salió del centro
    (enrocó); empujar peones centrales en la apertura es normal y no se marca.
    """
    if not san or san[0] not in "abcdefgh":   # las jugadas de peón empiezan con columna
        return False
    df = _destino_file(san)
    rey = board.king(color)
    if df is None or rey is None:
        return False
    kf = chess.square_file(rey)
    fuera_del_centro = kf not in (3, 4)       # rey ya enrocado a un flanco
    return fuera_del_centro and abs(df - kf) <= 1


def _pieza_repetida(board: chess.Board, color: bool) -> bool:
    """True si la jugada actual vuelve a mover una pieza (no peón) ya movida antes.

    Detecta pérdida de tiempo: re-mover una pieza en vez de desarrollar nuevas.
    """
    if not board.move_stack:
        return False
    actual = board.move_stack[-1]
    pieza = board.piece_at(actual.to_square)
    if pieza is None or pieza.piece_type == chess.PAWN:
        return False
    inicio = 0 if color == chess.WHITE else 1
    previos = board.move_stack[inicio:-1:2]   # jugadas anteriores del mismo color
    return any(m.to_square == actual.from_square for m in previos)


def _tipo_jugada(san: str) -> str:
    """Clasifica la jugada por su forma SAN (para el comentario de fallback)."""
    if not san:
        return "otro"
    if san.startswith("O-O"):
        return "enroque"
    if "x" in san:
        return "captura"
    if san[0] in "NBRQK":
        return "pieza"
    if san[0] in "abcdefgh":
        return "peon"
    return "otro"


def features_tablero(sans: list[str], color_str: str, numero: int) -> dict | None:
    """Features posicionales del jugador `color_str` tras su última jugada.

    `sans`: secuencia COMPLETA de jugadas (ambos colores) en orden, incluyendo la
    actual como última. Devuelve None si la secuencia no se puede reconstruir
    (SAN inválido), para que el modelo caiga limpiamente a los patrones de cp.
    """
    board = _reconstruir(sans)
    if board is None:
        return None
    color = chess.WHITE if color_str == "white" else chess.BLACK
    sans_jugador = sans[0::2] if color == chess.WHITE else sans[1::2]
    san_actual = sans[-1] if sans else ""
    return {
        "desarrollo":     _desarrollo(board, color),
        "enrocado":       any(s.startswith("O-O") for s in sans_jugador),
        "rey_centro":     _rey_en_centro(board, color),
        "control_centro": _control_centro(board, color),
        "dama_fuera":     _dama_fuera(board, color),
        "caballo_borde":  _caballo_en_borde(san_actual),
        "avance_enroque": _avance_peon_rey(board, color, san_actual),
        "pieza_repetida": _pieza_repetida(board, color),
        "tipo_jugada":    _tipo_jugada(san_actual),
        "numero":         numero,
    }