Spaces:
Paused
Paused
Download modules/deterministic/tablero.py from SamilG2/BACKEND-CheckScan: direct link, hf CLI and curl.
- Browser
- Download file 6.08 kB
-
https://huggingface.co/spaces/SamilG2/BACKEND-CheckScan/resolve/main/modules/deterministic/tablero.py
- Command line
-
hf download hf://spaces/SamilG2/BACKEND-CheckScan/modules/deterministic/tablero.py
-
curl -L -o tablero.py https://huggingface.co/spaces/SamilG2/BACKEND-CheckScan/resolve/main/modules/deterministic/tablero.py
6.08 kB
| """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, | |
| } | |