"""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, }