File size: 4,248 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
"""Motor de inferencia: del estado/features al patrón estratégico dominante.

REGLA DE ORO del experimento: las condiciones operan sobre FEATURES derivados de
la secuencia (pendiente, racha, cambio de régimen, fase), NUNCA sobre el valor
puntual de `diferencia_cp`. Por eso el comentario emerge del análisis de la
trayectoria y no es una traducción directa cp→texto.

Categoría académica: sistema basado en reglas (inferencia simbólica).
"""
from .estado import EstadoEstrategico

# Umbrales sobre FEATURES (no sobre cp crudo de la jugada actual).
UMBRAL_PENDIENTE = -8.0   # cp/jugada: pendiente que indica caída sostenida
UMBRAL_RACHA = 2          # jugadas seguidas por debajo de la media propia
UMBRAL_CAMBIO = 35.0      # cp: salto entre ventanas que indica cambio de régimen

_MALAS = {"Imprecisión", "Error"}


def _patron_posicional(t: dict) -> str | None:
    """Patrón ajedrecístico a partir de los features del tablero (python-chess).

    Explica el PORQUÉ posicional de un error mirando lo que vienen mostrando las
    jugadas previas. Reglas de más a menos específicas; la primera que matchea
    gana. Devuelve None si no hay un problema posicional claro.
    """
    if t.get("avance_enroque"):
        return "avance_enroque"
    if not t["enrocado"] and t["rey_centro"] and t["numero"] >= 8:
        return "rey_sin_enrocar"
    if t["desarrollo"] <= 1 and t["numero"] >= 6:
        return "sin_desarrollo"
    if t.get("pieza_repetida") and t["numero"] <= 12:
        return "pieza_repetida"
    if t.get("dama_fuera") and t["numero"] <= 7:
        return "dama_temprano"
    if t.get("caballo_borde"):
        return "caballo_borde"
    if t["control_centro"] <= 1 and t["numero"] >= 5:
        return "cede_centro"
    return None


def _fallback_por_jugada(t: dict | None) -> str:
    """Fallback cuando no hay patrón claro: varía según el tipo de jugada (SAN).

    Evita el comentario genérico idéntico: aunque no se detecte un patrón fuerte,
    el texto menciona qué clase de jugada fue (captura, peón, pieza...).
    """
    if not t:
        return "desviacion_leve"
    return "leve_" + t.get("tipo_jugada", "otro")


def detectar_patron(estado: EstadoEstrategico, clasificacion: str,
                    tablero: dict | None = None) -> str:
    """Devuelve la clave del patrón dominante.

    Las reglas están ordenadas de más a menos específicas: la primera que se
    cumple gana. Así un mismo conjunto de features produce siempre el mismo
    patrón (determinismo). `tablero` aporta el contexto posicional (python-chess);
    si es None, se decide solo con los features de cp.
    """
    mala = clasificacion in _MALAS

    # 1. Caída brusca: el régimen reciente cae con fuerza (suele ser un error
    #    táctico puntual; narrativa fuerte y específica).
    if mala and estado.cambio <= -UMBRAL_CAMBIO:
        return "caida_brusca"

    # 2. Explicación posicional del error (apertura/medio juego, con tablero).
    #    Tiene prioridad sobre la tendencia de cp porque dice el PORQUÉ ajedrecístico
    #    (rey expuesto, sin desarrollo, centro cedido), no solo que "viene cayendo".
    if mala and tablero and estado.fase != "final":
        posicional = _patron_posicional(tablero)
        if posicional:
            return posicional

    # 3. Deterioro sostenido: racha bajo la media propia + pendiente negativa.
    if mala and estado.racha >= UMBRAL_RACHA and estado.pendiente <= UMBRAL_PENDIENTE:
        return "deterioro_sostenido"

    # 4. Error en el final: la fase amplifica el costo del descuido.
    if mala and estado.fase == "final":
        return "error_en_final"

    # 5. Hallazgo táctico.
    if clasificacion == "Brillante":
        return "hallazgo"

    # 6. Recuperación: salto de mejora de régimen tras un tramo flojo.
    if not mala and estado.cambio >= UMBRAL_CAMBIO:
        return "recuperacion"

    # 7. Solidez: sin racha sostenida bajo la media propia, juego parejo.
    if not mala and estado.racha < UMBRAL_RACHA:
        return "solidez"

    # 8. Sin patrón fuerte: fallback que varía según el tipo de jugada (mala) /
    #    neutro (buena sin patrón marcado).
    return _fallback_por_jugada(tablero) if mala else "neutro"