File size: 6,762 Bytes
37d841f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ec62aa2
 
 
 
 
37d841f
ec62aa2
 
 
 
 
 
 
37d841f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ec62aa2
37d841f
 
 
 
 
 
 
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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
"""Wrapper UCI para Stockfish usando python-chess.

Singleton lazy: el motor se inicia en la primera llamada y se reutiliza
entre requests. Si el binario no existe, se lanza FileNotFoundError con
un mensaje claro para que el frontend lo reporte.
"""
import os
import threading
import chess
import chess.engine
import chess.pgn
import io

from config import STOCKFISH_PATH, STOCKFISH_DEPTH, STOCKFISH_THREADS, STOCKFISH_HASH_MB

_engine = None
_lock   = threading.Lock()


def _get_engine() -> chess.engine.SimpleEngine:
    global _engine
    if _engine is not None:
        return _engine
    with _lock:
        if _engine is not None:
            return _engine
        if not os.path.isfile(STOCKFISH_PATH):
            raise FileNotFoundError(
                f"Stockfish no encontrado en '{STOCKFISH_PATH}'. "
                f"Descargalo de https://stockfishchess.org/download/ y "
                f"coloca el binario en backend/engines/ (ver AGENTS.md)."
            )
        print(f"[Stockfish] Iniciando motor: {STOCKFISH_PATH}")
        eng = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
        eng.configure({"Threads": STOCKFISH_THREADS, "Hash": STOCKFISH_HASH_MB})
        _engine = eng
        print(f"[Stockfish] Listo (threads={STOCKFISH_THREADS}, hash={STOCKFISH_HASH_MB}MB, depth={STOCKFISH_DEPTH})")
        return _engine


def shutdown():
    """Cierra el motor (llamar al apagar el servidor; opcional)."""
    global _engine
    if _engine is not None:
        try:
            _engine.quit()
        except Exception:
            pass
        _engine = None


def _score_to_cp(score: chess.engine.PovScore) -> int:
    """Convierte un PovScore a centipawns desde el punto de vista de BLANCAS.

    Mate se mapea a ±100000 cp para que las diferencias sigan siendo comparables.
    """
    white = score.white()
    if white.is_mate():
        mate_in = white.mate()
        return 100000 if mate_in > 0 else -100000
    return white.score(mate_score=100000)


def _cp_for_terminal(board: chess.Board) -> int:
    """Eval en centipawns para una posición terminal (mate/ahogado/tablas)."""
    outcome = board.outcome()
    if outcome is None or outcome.winner is None:
        return 0  # tablas
    return 100000 if outcome.winner == chess.WHITE else -100000


def analyze_pgn(pgn_text: str, depth: int | None = None) -> dict:
    """Analiza un PGN jugada a jugada con Stockfish.

    Args:
        pgn_text: Movimientos en notación inglesa (SAN). Acepta con o sin headers.
        depth: Profundidad. Si es None usa STOCKFISH_DEPTH de config.

    Returns:
        {
          'depth': int,
          'total_moves': int,
          'moves': [
            {
              'number': int,
              'color': 'white' | 'black',
              'move': str,                # SAN jugado
              'eval_antes_cp': int,       # eval desde POV blancas, antes de jugar
              'eval_despues_cp': int,     # eval desde POV blancas, después de jugar
              'diferencia_cp': int,       # eval_despues - eval_antes (signo según color)
              'mejor_jugada': str | None, # SAN de la mejor jugada según Stockfish
              'mejor_eval_cp': int,       # eval si se hubiera jugado la mejor
            },
            ...
          ]
        }
    """
    engine = _get_engine()
    used_depth = depth if depth is not None else STOCKFISH_DEPTH
    limit = chess.engine.Limit(depth=used_depth, time=1.0)

    # Parsear el PGN. Acepta con headers o solo línea de movimientos.
    game = chess.pgn.read_game(io.StringIO(pgn_text))
    if game is None or not list(game.mainline_moves()):
        # Intentar como línea suelta de movimientos
        board = chess.Board()
        moves = []
        for token in pgn_text.split():
            if token.endswith('.') or token.replace('.', '').isdigit():
                continue
            try:
                moves.append(board.parse_san(token))
                board.push(moves[-1])
            except ValueError:
                continue
        if not moves:
            return {'depth': used_depth, 'total_moves': 0, 'moves': []}
        game = chess.pgn.Game()
        node = game
        for mv in moves:
            node = node.add_variation(mv)

    board = game.board()
    results: list[dict] = []

    for ply_idx, move in enumerate(game.mainline_moves()):
        is_white_to_move = board.turn == chess.WHITE
        move_san = board.san(move)

        # Eval ANTES de la jugada (posición actual) + mejor jugada sugerida
        info_before = engine.analyse(board, limit)
        score_before = info_before.get("score")
        eval_antes_cp = _score_to_cp(score_before) if score_before is not None else 0
        pv = info_before.get("pv") or []
        best_move_san = board.san(pv[0]) if pv else None
        # Línea principal (PV) en SAN, para el botón "Explicar" (HU-011): la
        # secuencia de mejores jugadas desde esta posición, que el frontend
        # reproduce en el tablero. Se limita para no inflar la respuesta.
        pv_san = []
        if pv:
            tmp = board.copy()
            for mv in pv[:8]:          # hasta 8 medias jugadas (4 completas)
                try:
                    pv_san.append(tmp.san(mv))
                    tmp.push(mv)
                except ValueError:
                    break
        # eval_antes_cp ya representa el valor óptimo de esta posición
        best_eval_cp = eval_antes_cp

        # Aplicar la jugada y evaluar DESPUÉS
        board.push(move)
        if board.is_game_over():
            eval_despues_cp = _cp_for_terminal(board)
        else:
            info_after = engine.analyse(board, limit)
            score_after = info_after.get("score")
            eval_despues_cp = _score_to_cp(score_after) if score_after is not None else eval_antes_cp

        # Diferencia desde la perspectiva del jugador que movió.
        # Si jugó blancas, perder centipawns es negativo. Si jugó negras, ganar
        # centipawns para negras es que white_eval bajó → invertimos signo.
        delta = eval_despues_cp - eval_antes_cp
        if not is_white_to_move:
            delta = -delta

        results.append({
            'number':          ply_idx // 2 + 1,
            'color':           'white' if is_white_to_move else 'black',
            'move':            move_san,
            'eval_antes_cp':   eval_antes_cp,
            'eval_despues_cp': eval_despues_cp,
            'diferencia_cp':   delta,
            'mejor_jugada':    best_move_san,
            'mejor_eval_cp':   best_eval_cp,
            'pv_san':          pv_san,
        })

    return {
        'depth':       used_depth,
        'total_moves': len(results),
        'moves':       results,
    }