bunker.py

# ============================================
# bunker.py - Fase del bunker (6 dias de supervivencia)
# ============================================

import pygame
from config import (
    SCREEN_WIDTH, SCREEN_HEIGHT,
    BUNKER_WALL, BUNKER_FLOOR, BUNKER_CEILING,
    METAL_DOOR, METAL_DOOR_DARK, SHELF_COLOR, SHELF_DARK,
    BOOK_COLORS, WHITE, BLACK, DARK_GRAY, LIGHT_GRAY,
    MODAL_BG, MODAL_BORDER, MODAL_HEADER,
    BUTTON_GREEN, BUTTON_GREEN_HOVER,
    BUTTON_RED, BUTTON_RED_HOVER,
    BUTTON_BLUE, BUTTON_BLUE_HOVER,
    BUTTON_GRAY, BUTTON_GRAY_HOVER,
    INPUT_BG, INPUT_BORDER, INPUT_ACTIVE, INPUT_TEXT,
    ENDING_PERFECT, ENDING_PARTIAL, ENDING_FAILURE,
)
from entities import TextInput, draw_worker_sprite, PLAYER_WORKER_BUNKER_SIZE
from problems import get_bunker_problems, check_all_fields


# =========================================================================
#  CONTENIDO EXTENSO DETALLADO EXTRAIDO DE LOS ARCHIVOS PDF RECOPILADOS
# =========================================================================
PDF_BOOK_DATA = {
    "green": [
        "--- LIBRO VERDE: INTERPOLACION ---",
        "",
        "1. POLINOMIOS DE LAGRANGE:",
        "Formula: g(x) = S [ yi * Li(x) ]",
        "Donde L0 = [(x - x1)(x - x2)] / [(x0 - x1)(x0 - x2)]",
        "Se calcula cada coeficiente Li en el punto deseado y se",
        "multiplica por su Yi. Ideal para intervalos no uniformes.",
        "",
        "2. NEWTON CON DIFERENCIAS DIVIDIDAS:",
        "Formula: g(x) = D0 + D1*(x - x0) + D2*(x - x0)*(x - x1) + ...",
        "Reglas para obtener D:",
        " - D0 = y0",
        " - D1 = (y1 - y0) / (x1 - x0)",
        " - D2 = (D1_2 - D1_1) / (x2 - x0)",
        "El numerador es la resta de dos diferencias de nivel anterior.",
        "El denominador es la resta de los valores de X de los extremos.",
        "",
        "3. NEWTON HACIA ATRAS (Intervalos Uniformes):",
        "Requiere 'h' constante (h = Xi+1 - Xi).",
        "s = (x - Xn) / h  <-- Xn representa el ULTIMO valor de la tabla.",
        "¡'s' siempre resulta NEGATIVO!",
        "Formula: g(x) = Yn + V1*s + V2*[s(s+1)/2!] + V3*[s(s+1)(s+2)/3!]",
        "Las diferencias (V) se calculan de abajo hacia arriba (yi - yi-1).",
        "",
        "4. NEWTON HACIA ADELANTE (Intervalos Uniformes):",
        "s = (x - X0) / h  <-- X0 representa el PRIMER valor de la tabla.",
        "¡'s' siempre resulta POSITIVO!",
        "Formula: g(x) = Y0 + D1*s + D2*[s(s-1)/2!] + D3*[s(s-1)(s-2)/3!]",
        "Las diferencias (D) se calculan de arriba hacia abajo."
    ],
    "red": [
        "--- LIBRO ROJO: ECUACIONES NO LINEALES ---",
        "",
        "1. METODO GRAFICO Y BISECTRIZ:",
        "Grafico: Observar el cruce en el eje X.",
        "Bisectriz: x = (a+b)/2. Raiz presente si f(a)*f(b) < 0.",
        "",
        "2. PUNTO FIJO (Sustituciones Sucesivas):",
        "Despejar x de la ecuacion f(x)=0 para obtener x = g(x).",
        "Formula iterativa: Xi+1 = g(Xi).",
        "Ejemplo: f(x) = e^(-x) - x = 0  =>  x = e^(-x).",
        "El metodo converge si la derivada |g'(x)| < 1.",
        "",
        "3. NEWTON RAPHSON:",
        "Utiliza iterativamente las rectas tangentes.",
        "Formula: Xi+1 = Xi - [ f(Xi) / f'(Xi) ]",
        "Requiere calcular la derivada f'(x). Muy rapido si converge.",
        "",
        "4. FALSA POSICION (Regula-Falsi):",
        "Une f(a) y f(b) con una linea recta.",
        "Formula: Xr = b - [ f(b)*(b - a) ] / [ f(b) - f(a) ]",
        "Criterio de busqueda:",
        " - Si f(a)*f(Xr) < 0, la raiz esta en [a, Xr] => Hacer b = Xr.",
        " - Si f(a)*f(Xr) > 0, la raiz esta en [Xr, b] => Hacer a = Xr.",
        "",
        "5. SECANTE:",
        "Formula: Xi+1 = Xi - [ f(Xi)*(Xi - Xi-1) ] / [ f(Xi) - f(Xi-1) ]",
        "Predice extrapolando una tangente. No requiere derivada pero usa 2 valores iniciales."
    ],
    "blue": [
        "--- LIBRO AZUL: ECUACIONES LINEALES ---",
        "",
        "REQUISITO: Matriz Diagonal Dominante.",
        "El coeficiente en la diagonal principal debe ser mayor a la",
        "suma de los demas coeficientes en su misma fila.",
        "",
        "1. METODO DE GAUSS-SEIDEL:",
        "Formula: X_i^(k+1) = (B_i - S [A_ij * X_j]) / A_ii",
        "Pasos:",
        "1) Despejar la variable de la diagonal principal.",
        "2) Evaluar con valores iniciales (ej. 0, 0, 0).",
        "3) ¡REGLA CRITICA!: Al obtener una variable, usar ese NUEVO",
        "   valor INMEDIATAMENTE para calcular las demas variables",
        "   dentro de esa misma iteracion.",
        "Errores: Ea = |a_actual - a_anterior|",
        "",
        "2. METODO DE JACOBI:",
        "Formula identica a Gauss-Seidel pero DIFIERE en la regla de uso.",
        "¡REGLA CRITICA!: NO usar valores nuevos inmediatamente.",
        "Todas las variables de la nueva iteracion se calculan usando",
        "ESTRICTAMENTE los valores de la iteracion anterior completa."
    ],
    "purple": [
        "--- LIBRO MORADO: MINIMOS CUADRADOS ---",
        "",
        "Se usa cuando los datos tienen errores/dispersion sustancial.",
        "",
        "1. LINEA RECTA: g(x) = a0 + a1*x",
        "Sistema de Ecuaciones (2x2):",
        " n*a0 + (Sx)*a1 = Sy",
        " (Sx)*a0 + (Sx^2)*a1 = Sxy",
        "",
        "2. CUADRATICA: g(x) = a0 + a1*x + a2*x^2",
        "Sistema extendido (3x3):",
        " n*a0 + (Sx)*a1 + (Sx^2)*a2 = Sy",
        " (Sx)*a0 + (Sx^2)*a1 + (Sx^3)*a2 = Sxy",
        " (Sx^2)*a0 + (Sx^3)*a1 + (Sx^4)*a2 = Sx^2y",
        "",
        "3. CUBICA: g(x) = a0 + a1*x + a2*x^2 + a3*x^3",
        "Sistema 4x4, requiriendo columnas de sumatorias hasta Sx^6.",
        "",
        "4. LINEAL Y CUADRATICA CON FUNCION:",
        "Incorpora funciones base como e^x, sen(x), cos(x), ln(x).",
        "Lineal: g(x) = a0 + a1*x + a2*f(x)",
        "Cuadratica: g(x) = a0 + a1*x + a2*x^2 + a3*f(x)",
        "Se arman las matrices usando Sf(x), Sx*f(x), Sf(x)^2, etc."
    ],
    "yellow": [
        "--- LIBRO AMARILLO: INTEGRACION Y E.D.O ---",
        "",
        "INTEGRACION NUMERICA:",
        "Permite calcular el area bajo la curva (suma de cambios puntuales).",
        "",
        "1. REGLA TRAPEZOIDAL:",
        "I = (b - a) * [ f(a) + f(b) ] / 2",
        "",
        "2. REGLA 1/3 DE SIMPSON:",
        "I = (b - a) * [ f(x0) + 4*f(x1) + f(x2) ] / 6",
        "",
        "3. REGLA 3/8 DE SIMPSON:",
        "I = (b - a) * [ f(x0) + 3*f(x1) + 3*f(x2) + f(x3) ] / 8",
        "",
        "ECUACIONES DIFERENCIALES ORDINARIAS (EDO):",
        "Resolucion de problemas de valor inicial calculados en",
        "intervalos paso a paso."
    ],
    "darkbrown": [
        "--- LIBRO CAFE: RUNGE-KUTTA ---",
        "",
        "METODOS DE RUNGE-KUTTA (RK):",
        "Calculan E.D.O aproximando derivadas (pendientes) promediadas,",
        "sin necesidad de derivacion analitica de orden superior.",
        "",
        "1. RK1 (Euler):",
        "y_i+1 = y_i + f(x_i, y_i)*h",
        "",
        "2. RK2 (Heun):",
        "Promedia dos pendientes (al inicio y final del intervalo).",
        "",
        "3. RK4 (Clasico):",
        "Promedia cuatro pendientes ponderadas (k1, k2, k3, k4).",
        " k1 = f(x_i, y_i)",
        " k2 = f(x_i + h/2, y_i + k1*h/2)",
        " k3 = f(x_i + h/2, y_i + k2*h/2)",
        " k4 = f(x_i + h, y_i + k3*h)",
        " y_i+1 = y_i + (1/6) * (k1 + 2k2 + 2k3 + k4) * h"
    ]
}


# ============================================
#  MODAL DE PROBLEMA
# ============================================
class ProblemModal:
    """
    Ventana emergente para resolver un problema matematico.
    Incluye: enunciado, campo de texto, timer, botones, pistas de libros.
    """

    def __init__(self, problem, time_seconds, books_collected, sound_manager):
        self.problem = problem
        self.time_remaining = time_seconds
        self.time_total = time_seconds
        self.books = books_collected
        self.sound_manager = sound_manager

        # Estado
        self.paused = False
        self.finished = False
        self.result = None
        self.show_hint = None
        self.ready_to_exit = False

        # Configuracion de Ventana Deslizable para PDFs
        self.scroll_y = 0
        self.max_scroll = 0
        self.scroll_x = 0
        self.max_scroll_x = 0
        self.problem_scroll_y = 0
        self.max_problem_scroll = 0
        self.problem_view_rect = None

        # Multiples campos de respuesta
        self.fields = problem.get("fields", [])
        self.text_inputs = []
        self.active_field = 0
        for i, field in enumerate(self.fields):
            ti = TextInput(0, 0, 200, 30, font_size=18)
            ti.active = (i == 0)
            self.text_inputs.append(ti)
        if not self.text_inputs:
            self.text_inputs = [TextInput(0, 0, 280, 40)]

        # Fuentes
        self.font_title = pygame.font.SysFont("Arial", 20, bold=True)
        self.font_text = pygame.font.SysFont("Arial", 16)
        self.font_label = pygame.font.SysFont("Arial", 14, bold=True)
        self.font_timer = pygame.font.SysFont("Consolas", 28, bold=True)
        self.font_button = pygame.font.SysFont("Arial", 16, bold=True)
        self.font_small = pygame.font.SysFont("Arial", 13)

        # Geometria del modal
        self.modal_rect = pygame.Rect(40, 30, SCREEN_WIDTH - 80, SCREEN_HEIGHT - 60)

        # La ventana de PDF cubre casi toda la pantalla central-derecha para mejor lectura
        self.reader_rect = pygame.Rect(
            self.modal_rect.left + 120,
            self.modal_rect.top + 45,
            self.modal_rect.width - 135,
            self.modal_rect.height - 60,
        )

        # Mensaje de resultado
        self.result_message = ""
        self.result_timer = 0
        self.show_result = False
        self.force_next_day = False

    def update(self, events, dt):
        if self.force_next_day:
            self.force_next_day = False
            return "correct"

        if self.show_result:
            if self.result == "correct":
                if self.ready_to_exit:
                    return self.result
            else:
                self.result_timer -= dt
                if self.result_timer <= 0:
                    return self.result
                return None

        if not self.paused and not self.show_result:
            self.time_remaining -= dt
            if self.time_remaining <= 0:
                self.time_remaining = 0
                self._set_result("timeout", "Se acabo el tiempo")
                return None

        if not self.show_result and not self.show_hint and self.active_field < len(self.text_inputs):
            self.text_inputs[self.active_field].update(dt)

        for event in events:
            if event.type == pygame.MOUSEWHEEL and self.show_hint:
                mouse = pygame.mouse.get_pos()
                if self.reader_rect.collidepoint(mouse):
                    mods = pygame.key.get_mods()
                    if mods & pygame.KMOD_SHIFT:
                        self.scroll_x = max(0, min(self.max_scroll_x, self.scroll_x - event.y * 35))
                    else:
                        self.scroll_y = max(0, min(self.max_scroll, self.scroll_y - event.y * 25))

            if event.type == pygame.MOUSEBUTTONDOWN:
                mouse = pygame.mouse.get_pos()
                self._handle_click(mouse)

                # Soporte de Scrolling con la rueda del mouse
                if self.show_hint and self.reader_rect.collidepoint(mouse):
                    if event.button == 4:  # Rueda Arriba
                        mods = pygame.key.get_mods()
                        if mods & pygame.KMOD_SHIFT:
                            self.scroll_x = max(0, self.scroll_x - 35)
                        else:
                            self.scroll_y = max(0, self.scroll_y - 25)
                    elif event.button == 5:  # Rueda Abajo
                        mods = pygame.key.get_mods()
                        if mods & pygame.KMOD_SHIFT:
                            self.scroll_x = min(self.max_scroll_x, self.scroll_x + 35)
                        else:
                            self.scroll_y = min(self.max_scroll, self.scroll_y + 25)
                elif self.problem_view_rect and self.problem_view_rect.collidepoint(mouse):
                    if event.button == 4:  # Rueda Arriba
                        self.problem_scroll_y = max(0, self.problem_scroll_y - 25)
                    elif event.button == 5:
                        self.problem_scroll_y = min(self.max_problem_scroll, self.problem_scroll_y + 25)

            if event.type == pygame.KEYDOWN:
                if self.show_hint:
                    if event.key == pygame.K_UP:
                        self.scroll_y = max(0, self.scroll_y - 30)
                    elif event.key == pygame.K_DOWN:
                        self.scroll_y = min(self.max_scroll, self.scroll_y + 25)
                    elif event.key == pygame.K_LEFT:
                        self.scroll_x = max(0, self.scroll_x - 35)
                    elif event.key == pygame.K_RIGHT:
                        self.scroll_x = min(self.max_scroll_x, self.scroll_x + 35)

                if not self.show_result and not self.show_hint:
                    if event.key == pygame.K_TAB:
                        self._switch_field((self.active_field + 1) % len(self.text_inputs))
                    elif event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
                        self._submit_answer()
                    else:
                        if self.active_field < len(self.text_inputs):
                            self.text_inputs[self.active_field].handle_event(event)

        return None

    def _switch_field(self, idx):
        for i, ti in enumerate(self.text_inputs):
            ti.active = (i == idx)
        self.active_field = idx

    def _handle_click(self, mouse):
        if self.show_result:
            if self.result == "correct":
                btn_continue = pygame.Rect(self.modal_rect.centerx - 70, self.modal_rect.bottom - 55, 140, 38)
                if btn_continue.collidepoint(mouse) and not self.show_hint:
                    self.sound_manager.play("select")
                    self.ready_to_exit = True
            self._handle_book_clicks(mouse)
            return

        # Boton Entregar
        btn_submit = pygame.Rect(self.modal_rect.centerx - 70, self.modal_rect.bottom - 55, 140, 38)
        if btn_submit.collidepoint(mouse):
            self.sound_manager.play("select")
            self._submit_answer()
            return

        # Boton temporal: pasar dia sin responder (revision)
        btn_skip_day = pygame.Rect(self.modal_rect.centerx + 90, self.modal_rect.bottom - 55, 170, 38)
        if btn_skip_day.collidepoint(mouse):
            self.sound_manager.play("select")
            self.force_next_day = True
            return

        # Clic en campos de texto de respuestas
        for i, ti in enumerate(self.text_inputs):
            if ti.rect.collidepoint(mouse):
                self._switch_field(i)
                return

        self._handle_book_clicks(mouse)

    def _handle_book_clicks(self, mouse):
        """Abre o cierra los libros recolectados en el panel izquierdo."""
        book_y = self.modal_rect.top + 90
        color_order = ["green", "red", "blue", "purple", "yellow", "darkbrown"]
        book_idx = 0
        for color in color_order:
            if self.books.get(color, 0) > 0:
                book_rect = pygame.Rect(self.modal_rect.left + 15, book_y + book_idx * 55, 95, 45)
                if book_rect.collidepoint(mouse):
                    self.sound_manager.play("select")
                    if self.show_hint == color:
                        self.show_hint = None
                    else:
                        self.show_hint = color
                        self.scroll_y = 0  # Reiniciar scroll al cambiar de libro
                        self.scroll_x = 0
                    return
                book_idx += 1

    def _submit_answer(self):
        if self.show_result:
            return
        user_answers = [ti.get_value() for ti in self.text_inputs]
        if all(a == "" for a in user_answers):
            self._set_result("wrong", "No ingresaste una respuesta")
            return
        if check_all_fields(self.problem, user_answers):
            self._set_result("correct", "Respuesta correcta")
        else:
            self._set_result("wrong", "Incorrecto")

    def _set_result(self, result, message):
        self.result = result
        self.result_message = message
        self.show_result = True
        self.result_timer = 2.5
        if result == "correct":
            self.sound_manager.play("victoria")
        else:
            self.sound_manager.play("error")

    def _get_correct_answers_lines(self):
        """Devuelve las respuestas correctas del problema actual para mostrarlas al calificar."""
        lines = []
        for field in self.fields:
            label = self._safe_text(field.get("label", "")).strip()
            answer = self._safe_text(field.get("answer", "")).strip()
            if not label:
                continue
            lines.append(f"{label} {answer}" if answer else label)
        return lines

    def _safe_text(self, text):
        """Corrige mojibake frecuente en textos del problema/libros para mostrarlos limpios."""
        if text is None:
            return ""
        fixed = str(text)
        for _ in range(2):
            try:
                decoded = fixed.encode("latin1").decode("utf-8")
            except (UnicodeEncodeError, UnicodeDecodeError):
                break
            if decoded == fixed:
                break
            fixed = decoded

        replacements = {
            "Є": "E",
            "Є": "E",
            "∑": "∑",
            "∑": "∑",
            "²": "²",
            "≠": "!=",
            "≠": "!=",
            "Δ": "Δ",
            "∆": "Δ",
            "×": "x",
            "—": "-",
            "–": "-",
            "raíz": "raiz",
            "Método": "Metodo",
            "método": "metodo",
            "Posición": "Posicion",
            "Interpolación": "Interpolacion",
            "Atrás": "Atras",
            "Día": "Dia",
            "á": "a",
            "é": "e",
            "í": "i",
            "ó": "o",
            "ú": "u",
            "ñ": "n",
            "Á": "A",
            "É": "E",
            "Í": "I",
            "Ó": "O",
            "Ú": "U",
            "Ñ": "N",
            "Â": "",
        }
        replacements.update({
            "Є": "E",
            "Є": "E",
            "∑": "∑",
            "∑": "∑",
            "∑": "∑",
            "²": "²",
            "²": "²",
            "²": "²",
            "≠": "!=",
            "≠": "!=",
            "≠": "!=",
            "Δ": "Δ",
            "Δ": "Δ",
            "∆": "Δ",
            "∆": "Δ",
            "Δ": "Δ",
            "×": "x",
            "×": "x",
            "—": "-",
            "–": "-",
            "—": "-",
            "–": "-",
            "¡": "¡",
            "raíz": "raiz",
            "Método": "Metodo",
            "método": "metodo",
            "Posición": "Posicion",
            "Interpolación": "Interpolacion",
            "Atrás": "Atras",
            "Día": "Dia",
            "á": "a",
            "é": "e",
            "í": "i",
            "ó": "o",
            "ú": "u",
            "ñ": "n",
            "Á": "A",
            "É": "E",
            "Í": "I",
            "Ó": "O",
            "Ú": "U",
            "Ñ": "N",
            "Â": "",
        })
        for bad, good in replacements.items():
            fixed = fixed.replace(bad, good)
        return fixed

    def draw(self, surface):
        overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT), pygame.SRCALPHA)
        overlay.fill((0, 0, 0, 150))
        surface.blit(overlay, (0, 0))

        mr = self.modal_rect
        mouse = pygame.mouse.get_pos()

        pygame.draw.rect(surface, MODAL_BG, mr, border_radius=10)
        pygame.draw.rect(surface, MODAL_BORDER, mr, 2, border_radius=10)

        header = pygame.Rect(mr.left, mr.top, mr.width, 40)
        pygame.draw.rect(surface, MODAL_HEADER, header, border_top_left_radius=10, border_top_right_radius=10)
        topic = self._safe_text(self.problem.get("topic", "Problema"))
        title = self.font_title.render(f"Metodo: {topic}", True, WHITE)
        title_center_x = mr.left + (mr.width - 130) // 2
        surface.blit(title, title.get_rect(center=(title_center_x, mr.top + 20)))

        mins = int(self.time_remaining // 60)
        secs = int(self.time_remaining % 60)
        timer_color = (255, 80, 80) if self.time_remaining < 60 else WHITE
        timer_text = self.font_timer.render(f"{mins:02d}:{secs:02d}", True, timer_color)
        surface.blit(timer_text, (mr.right - 120, mr.top + 5))

        # Libros
        books_x = mr.left + 10
        books_y = mr.top + 85
        books_title = self.font_small.render("Libros:", True, LIGHT_GRAY)
        surface.blit(books_title, (books_x, books_y - 15))

        color_order = ["green", "red", "blue", "purple", "yellow", "darkbrown"]
        color_names = {
            "green": "Verde",
            "red": "Rojo",
            "blue": "Azul",
            "purple": "Morado",
            "yellow": "Amarillo",
            "darkbrown": "Cafe",
        }
        book_idx = 0
        for color in color_order:
            count = self.books.get(color, 0)
            if count > 0:
                by = books_y + book_idx * 55
                book_rect = pygame.Rect(books_x + 5, by, 95, 45)
                is_selected = self.show_hint == color
                bg_color = (70, 70, 85) if is_selected else (50, 50, 65)
                pygame.draw.rect(surface, bg_color, book_rect, border_radius=5)
                pygame.draw.rect(surface, BOOK_COLORS[color], book_rect, 2, border_radius=5)
                icon = pygame.Rect(books_x + 10, by + 8, 18, 25)
                pygame.draw.rect(surface, BOOK_COLORS[color], icon, border_radius=2)
                name = self.font_small.render(self._safe_text(color_names[color]), True, WHITE)
                surface.blit(name, (books_x + 33, by + 14))
                book_idx += 1

        # --- Contenido de la pregunta / Inputs (Centro) ---
        content_x = mr.left + 130
        content_w = mr.width - 170
        content_y = mr.top + 52
        content_h = mr.height - 140
        if self.show_hint:
            gap = 10
            left_w = int(content_w * 0.58)
            right_w = content_w - left_w - gap
            self.problem_view_rect = pygame.Rect(content_x + 8, content_y, left_w - 16, content_h)
            self.reader_rect = pygame.Rect(self.problem_view_rect.right + gap, content_y, right_w - 8, content_h)
        else:
            self.problem_view_rect = pygame.Rect(content_x + 8, content_y, content_w - 16, content_h)

        problem_top = mr.top + 55
        problem_text = self._safe_text(self.problem["text"])
        raw_lines = problem_text.split("\n")
        text_left = content_x + 20
        wrap_w = self.problem_view_rect.width - 44

        logical_y = problem_top
        surface.set_clip(self.problem_view_rect)

        # --- Contenido del enunciado dentro del recuadro principal ---
        for raw_line in raw_lines:
            if raw_line.strip() == "":
                logical_y += 15
                continue

            draw_y = logical_y - self.problem_scroll_y

            # Tablas estilo | x | y |
            if "|" in raw_line:
                cells = [self._safe_text(c.strip()) for c in raw_line.split("|") if c.strip() != ""]
                available_w = max(220, wrap_w - 10)
                cols = max(1, len(cells))
                # Ancho uniforme por fila para que no "salte" entre renglones.
                cell_w = max(95, int(available_w / cols))
                cell_h = 30
                for col_idx, cell_text in enumerate(cells):
                    cx = text_left + col_idx * cell_w
                    pygame.draw.rect(surface, (70, 70, 85), (cx, draw_y, cell_w, cell_h), 1)
                    lt = self.font_text.render(cell_text, True, (220, 255, 255))
                    surface.blit(lt, (cx + 8, draw_y + 5))
                logical_y += cell_h
                continue

            words = raw_line.split()
            current_l = ""
            for word in words:
                test = current_l + " " + word if current_l else word
                if self.font_text.size(test)[0] < wrap_w:
                    current_l = test
                else:
                    lt = self.font_text.render(self._safe_text(current_l), True, WHITE)
                    surface.blit(lt, (text_left, logical_y - self.problem_scroll_y))
                    logical_y += 20
                    current_l = word
            if current_l:
                lt = self.font_text.render(self._safe_text(current_l), True, WHITE)
                surface.blit(lt, (text_left, logical_y - self.problem_scroll_y))
                logical_y += 20

        logical_y += 12

        # --- Campos de respuesta dentro del mismo recuadro ---
        if self.show_result and self.result == "correct":
            proc_text = self._safe_text(self.problem.get("procedimiento", "Procedimiento no disponible."))
            proc_lines = proc_text.split('\n')
            for line in proc_lines:
                lt = self.font_text.render(self._safe_text(line), True, (150, 255, 150))
                surface.blit(lt, (text_left, logical_y - self.problem_scroll_y))
                logical_y += 22
        else:
            fields_count = len(self.fields)
            if fields_count > 0:
                if fields_count <= 4:
                    cols = 2
                else:
                    cols = 3

                gap_x = 10
                panel_inner_w = self.problem_view_rect.width - 34
                col_w = max(130, (panel_inner_w - (cols - 1) * gap_x) // cols)
                row_h = 44

                for i, field in enumerate(self.fields):
                    row = i // cols
                    col = i % cols
                    base_x = text_left + col * (col_w + gap_x)
                    base_y = logical_y + row * row_h - self.problem_scroll_y

                    clean_label = self._safe_text(field["label"])
                    lbl = self.font_label.render(clean_label, True, (255, 215, 0))
                    surface.blit(lbl, (base_x, base_y + 6))
                    lbl_w = lbl.get_width() + 6

                    self.text_inputs[i].rect.x = base_x + lbl_w
                    self.text_inputs[i].rect.y = base_y + 2
                    self.text_inputs[i].rect.width = max(90, min(150, col_w - lbl_w - 6))
                    self.text_inputs[i].rect.height = 30
                    self.text_inputs[i].draw(surface)

                rows = (fields_count + cols - 1) // cols
                logical_y += rows * row_h + 4

        surface.set_clip(None)

        total_problem_height = max(0, (logical_y - problem_top) + 12)
        self.max_problem_scroll = max(0, total_problem_height - self.problem_view_rect.height)
        self.problem_scroll_y = min(self.problem_scroll_y, self.max_problem_scroll)

        pygame.draw.rect(surface, (70, 70, 95), self.problem_view_rect, 1, border_radius=4)
        if self.max_problem_scroll > 0:
            pb_y = self.problem_view_rect.top + 8
            pb_h = self.problem_view_rect.height - 16
            pb_x_r = self.problem_view_rect.right - 6
            p_ratio = self.problem_scroll_y / self.max_problem_scroll
            p_thumb_h = max(20, int(pb_h * (self.problem_view_rect.height / max(total_problem_height, 1))))
            p_thumb_y = pb_y + int((pb_h - p_thumb_h) * p_ratio)
            pygame.draw.rect(surface, (130, 160, 210), (pb_x_r, p_thumb_y, 4, p_thumb_h), border_radius=2)

        # --- Logica de Visualizacion: Campos de Entrada o Procedimiento Resuelto ---
        if self.show_result and self.result == "correct":
            rt = self.font_title.render("Respuesta correcta", True, (100, 255, 100))
            surface.blit(rt, rt.get_rect(center=(content_x + content_w // 2, self.problem_view_rect.bottom + 28)))

            answer_lines = self._get_correct_answers_lines()
            if answer_lines:
                ans_title = self.font_small.render("Respuestas correctas:", True, (170, 240, 170))
                surface.blit(ans_title, (content_x + 12, self.problem_view_rect.bottom + 42))
                ans_y = self.problem_view_rect.bottom + 60
                for line in answer_lines[:6]:
                    ans_text = self.font_small.render(self._safe_text(line), True, (190, 255, 190))
                    surface.blit(ans_text, (content_x + 12, ans_y))
                    ans_y += 18

            btn_continue = pygame.Rect(mr.centerx - 70, mr.bottom - 55, 140, 38)
            c_hover = btn_continue.collidepoint(mouse)
            c_color = BUTTON_GREEN_HOVER if c_hover else BUTTON_GREEN
            pygame.draw.rect(surface, c_color, btn_continue, border_radius=8)
            pygame.draw.rect(surface, WHITE, btn_continue, 2, border_radius=8)
            c_text = self.font_button.render("Continuar", True, WHITE)
            surface.blit(c_text, c_text.get_rect(center=btn_continue.center))
        else:
            # Boton Entregar
            btn_submit = pygame.Rect(mr.centerx - 70, mr.bottom - 55, 140, 38)
            s_hover = btn_submit.collidepoint(mouse)
            s_color = BUTTON_GREEN_HOVER if s_hover else BUTTON_GREEN
            pygame.draw.rect(surface, s_color, btn_submit, border_radius=8)
            pygame.draw.rect(surface, WHITE, btn_submit, 2, border_radius=8)
            s_text = self.font_button.render("Entregar", True, WHITE)
            surface.blit(s_text, s_text.get_rect(center=btn_submit.center))

            # Boton temporal para revision de dias
            btn_skip_day = pygame.Rect(mr.centerx + 90, mr.bottom - 55, 170, 38)
            skip_hover = btn_skip_day.collidepoint(mouse)
            skip_color = BUTTON_BLUE_HOVER if skip_hover else BUTTON_BLUE
            pygame.draw.rect(surface, skip_color, btn_skip_day, border_radius=8)
            pygame.draw.rect(surface, WHITE, btn_skip_day, 2, border_radius=8)
            skip_text = self.font_small.render("Pasar dia (temporal)", True, WHITE)
            surface.blit(skip_text, skip_text.get_rect(center=btn_skip_day.center))

        # --- VENTANA DESLIZANTE: LECTOR DE PDF (Derecha) ---
        if self.show_hint and self.show_hint in PDF_BOOK_DATA:
            pygame.draw.rect(surface, (28, 28, 38), self.reader_rect, border_radius=6)
            pygame.draw.rect(surface, BOOK_COLORS[self.show_hint], self.reader_rect, 2, border_radius=6)
            surface.set_clip(self.reader_rect.inflate(-10, -10))

            lines = [self._safe_text(line) for line in PDF_BOOK_DATA[self.show_hint]]
            start_idx = 0
            for idx, line in enumerate(lines):
                upper = line.upper()
                if upper.startswith("2.") and "POLINOMIOS" in upper:
                    start_idx = idx
                    break
            lines = lines[start_idx:]
            text_y = self.reader_rect.top + 15 - self.scroll_y

            for line in lines:
                if line.startswith("---") or line.endswith("---"):
                    color = (255, 215, 0)  # Oro para titulos de archivos
                elif "Formula" in line or "g(x)" in line or "Ecuacion" in line or "k1 =" in line:
                    color = (120, 255, 255)  # Cian para expresiones matematicas
                else:
                    color = WHITE
                lt = self.font_text.render(line, True, color)
                surface.blit(lt, (self.reader_rect.left + 15 - self.scroll_x, text_y))
                text_y += 22

            # Calcular limites maximos de scroll dinamicamente
            total_content_height = len(lines) * 24
            self.max_scroll = max(0, total_content_height - self.reader_rect.height + 30)
            max_line_width = 0
            for line in lines:
                line_w = self.font_text.size(line)[0]
                if line_w > max_line_width:
                    max_line_width = line_w
            visible_w = self.reader_rect.width - 34
            self.max_scroll_x = max(0, max_line_width - visible_w)
            self.scroll_x = min(self.scroll_x, self.max_scroll_x)

            # Desactivar el recorte de pantalla
            surface.set_clip(None)

            if self.max_scroll > 0:
                sb_x = self.reader_rect.right - 10
                sb_y = self.reader_rect.top + 10
                sb_h = self.reader_rect.height - 20
                pygame.draw.rect(surface, (50, 50, 60), (sb_x, sb_y, 6, sb_h), border_radius=3)
                scroll_ratio = self.scroll_y / self.max_scroll
                thumb_h = max(30, int(sb_h * (self.reader_rect.height / total_content_height)))
                thumb_y = sb_y + int((sb_h - thumb_h) * scroll_ratio)
                pygame.draw.rect(surface, BOOK_COLORS[self.show_hint], (sb_x, thumb_y, 6, thumb_h), border_radius=3)

            # Barra horizontal (arriba y abajo) para desplazamiento lateral
            if self.max_scroll_x > 0:
                hb_x = self.reader_rect.left + 10
                hb_w = self.reader_rect.width - 20
                hb_y_top = self.reader_rect.top + 4
                hb_y_bottom = self.reader_rect.bottom - 8
                pygame.draw.rect(surface, (50, 50, 60), (hb_x, hb_y_top, hb_w, 3), border_radius=1)
                pygame.draw.rect(surface, (50, 50, 60), (hb_x, hb_y_bottom, hb_w, 3), border_radius=1)
                x_ratio = self.scroll_x / self.max_scroll_x
                thumb_w = max(22, int(hb_w * (visible_w / max(max_line_width, 1))))
                thumb_x = hb_x + int((hb_w - thumb_w) * x_ratio)
                pygame.draw.rect(surface, BOOK_COLORS[self.show_hint], (thumb_x, hb_y_top, thumb_w, 3), border_radius=1)
                pygame.draw.rect(surface, BOOK_COLORS[self.show_hint], (thumb_x, hb_y_bottom, thumb_w, 3), border_radius=1)

        # Indicador de pausa
        if self.paused:
            pause_overlay = pygame.Surface((mr.width - 4, 40), pygame.SRCALPHA)
            pause_overlay.fill((0, 0, 0, 180))
            surface.blit(pause_overlay, (mr.left + 2, mr.centery - 20))
            pt = self.font_title.render("JUEGO EN PAUSA", True, (255, 215, 0))
            surface.blit(pt, pt.get_rect(center=(mr.centerx, mr.centery)))

        # Mostrar bloque de error
        if self.show_result and self.result != "correct" and not self.show_hint:
            answer_lines = self._get_correct_answers_lines()
            overlay_h = 60 + (22 if answer_lines else 0) + (18 * min(len(answer_lines), 6))
            result_overlay = pygame.Surface((mr.width - 4, overlay_h), pygame.SRCALPHA)
            result_overlay.fill((80, 20, 20, 235))
            surface.blit(result_overlay, (mr.left + 2, mr.centery + 40))
            rt = self.font_title.render(self.result_message, True, (255, 100, 100))
            surface.blit(rt, rt.get_rect(center=(mr.centerx, mr.centery + 70)))
            if answer_lines:
                y0 = mr.centery + 96
                at = self.font_small.render("Respuestas correctas:", True, (255, 200, 200))
                surface.blit(at, (mr.left + 20, y0))
                y0 += 18
                for line in answer_lines[:6]:
                    ans = self.font_small.render(self._safe_text(line), True, (255, 220, 220))
                    surface.blit(ans, (mr.left + 20, y0))
                    y0 += 18


# ============================================
#  FASE DEL BUNKER (PANTALLA 3)
# ============================================
class BunkerPhase:
    """
    Fase del bunker: 6 dias de supervivencia.
    """
    def __init__(self, sound_manager):
        self.sound_manager = sound_manager
        self.reset({})

    def reset(self, books_collected):
        self.books = books_collected
        self.current_day = 1
        self.errors = 0
        self.fail_streak = 0
        self.days_completed = 0
        self.total_days = 6
        self.base_day_time = 20 * 60
        self.day_bonus_increments = [5 * 60, 5 * 60, 10 * 60, 5 * 60, 5 * 60, 0]
        self.time_bonus_pool = 0
        self.max_failures_total = 3
        self.max_failures_streak = 3

        self.problems = get_bunker_problems()
        self.water = 10
        self.food = 10

        self.show_arrow = True
        self.arrow_timer = 0
        self.modal = None
        self.transitioning = False
        self.transition_timer = 0
        self.day_start_shown = False

        self.message = ""
        self.message_timer = 0
        self.failure_pending = False
        self.failure_timer = 0

        self.font_title = pygame.font.SysFont("Arial", 28, bold=True)
        self.font_subtitle = pygame.font.SysFont("Arial", 20)
        self.font_text = pygame.font.SysFont("Arial", 16)
        self.font_small = pygame.font.SysFont("Arial", 13)
        self.font_day = pygame.font.SysFont("Arial", 36, bold=True)
        self.font_day_top = pygame.font.SysFont("Arial", 28, bold=True)
        self.font_message = pygame.font.SysFont("Arial", 22, bold=True)

        self.sound_manager.play("hoja")

    def init_with_books(self, books_collected):
        self.reset(books_collected)

    def _get_day_time(self, day_index):
        return max(60, self.base_day_time + self.time_bonus_pool)

    def update(self, events, dt):
        if self.failure_pending:
            self.failure_timer -= dt
            self.message_timer -= dt
            if self.failure_timer <= 0:
                return ENDING_FAILURE
            return None

        if self.transitioning:
            self.transition_timer -= dt
            if self.message_timer > 0:
                self.message_timer -= dt
            if self.transition_timer <= 0:
                self.transitioning = False
                self.day_start_shown = False
                self.arrow_timer = 0
                self.water = max(0, self.water - 2)
                self.food = max(0, self.food - 2)
                self.sound_manager.play("hoja")
            return None

        if self.message_timer > 0:
            self.message_timer -= dt

        if self.modal:
            result = self.modal.update(events, dt)
            if result:
                return self._handle_problem_result(result)
            return None

        if self.current_day > self.total_days:
            if self.errors == 0:
                return ENDING_PERFECT
            else:
                return ENDING_PARTIAL

        self.arrow_timer += dt

        for event in events:
            if event.type == pygame.MOUSEBUTTONDOWN:
                mouse = pygame.mouse.get_pos()
                door_rect = self._get_door_rect()
                if door_rect.collidepoint(mouse) and self.modal is None:
                    self._open_problem()

        return None

    def _get_door_rect(self):
        return pygame.Rect(SCREEN_WIDTH - 185, SCREEN_HEIGHT - 170, 120, 95)

    def _open_problem(self):
        day_index = min(self.current_day - 1, len(self.problems) - 1)
        problem = self.problems[day_index]
        time_sec = self._get_day_time(day_index)
        self.modal = ProblemModal(problem, time_sec, self.books, self.sound_manager)

    def _handle_problem_result(self, result):
        self.modal = None
        if result == "correct":
            self.days_completed += 1
            self.fail_streak = 0
            day_idx = self.current_day - 1
            if 0 <= day_idx < len(self.day_bonus_increments):
                bonus_gain = self.day_bonus_increments[day_idx]
                if self.current_day < self.total_days and bonus_gain > 0:
                    self.time_bonus_pool += bonus_gain

            if self.current_day < self.total_days:
                self.message = f"Correcto. Pasas al dia {self.current_day + 1}."
            else:
                self.message = "Correcto. Has completado el ultimo dia."
            self.message_timer = 3.0
            self.current_day += 1
            self.transitioning = True
            self.transition_timer = 2.0
        else:
            self.errors += 1
            self.fail_streak += 1
            if self.errors >= self.max_failures_total or self.fail_streak >= self.max_failures_streak:
                if self.fail_streak >= self.max_failures_streak:
                    self.message = "Has fallado 3 dias seguidos. El juego termina."
                else:
                    self.message = "Has fallado 3 veces. El juego termina."
                self.message_timer = 4.0
                self.failure_pending = True
                self.failure_timer = 4.0
                self.sound_manager.play("error")
                return None

            self.message = f"Error. Pasas al dia {self.current_day + 1} sin bonificacion."
            self.message_timer = 4.0
            self.current_day += 1
            self.transitioning = True
            self.transition_timer = 3.0

        if self.current_day > self.total_days:
            self.transitioning = True
            self.transition_timer = 2.0

        return None

    def draw(self, surface):
        self._draw_bunker_bg(surface)
        self._draw_bunker_set_dressing(surface)
        self._draw_character(surface)
        self._draw_bookshelf(surface)
        self._draw_door(surface)
        self._draw_supplies(surface)
        self._draw_day_hud(surface)

        if self.modal is None and self.current_day <= self.total_days and not self.transitioning:
            self._draw_arrow(surface)

        if self.transitioning:
            self._draw_transition(surface)

        if self.message_timer > 0 and self.message:
            self._draw_message(surface)

        if self.failure_pending:
            fail_overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT), pygame.SRCALPHA)
            fail_overlay.fill((0, 0, 0, 180))
            surface.blit(fail_overlay, (0, 0))
            self._draw_message(surface)

        if self.modal:
            self.modal.draw(surface)

    def _draw_bunker_bg(self, surface):
        surface.fill((66, 67, 80))
        pygame.draw.rect(surface, (86, 88, 101), (0, 0, SCREEN_WIDTH, 120))
        pygame.draw.rect(surface, (54, 55, 66), (0, 0, SCREEN_WIDTH, 42))
        pygame.draw.rect(surface, (45, 46, 57), (0, 120, SCREEN_WIDTH, 6))

        pygame.draw.rect(surface, (60, 61, 74), (0, SCREEN_HEIGHT - 180, SCREEN_WIDTH, 180))
        center_zone = pygame.Rect(SCREEN_WIDTH // 2 - 300, SCREEN_HEIGHT // 2 - 85, 600, 250)
        pygame.draw.rect(surface, (70, 72, 86), center_zone, border_radius=8)
        pygame.draw.rect(surface, (88, 90, 104), center_zone, 2, border_radius=8)

        for y in range(150, SCREEN_HEIGHT - 170, 82):
            pygame.draw.line(surface, (57, 58, 70), (0, y), (SCREEN_WIDTH, y), 2)

        for x in range(30, SCREEN_WIDTH, 120):
            for y in [74, 112]:
                pygame.draw.circle(surface, (123, 126, 140), (x, y), 2)
                pygame.draw.circle(surface, (94, 97, 110), (x, y), 2, 1)

    def _draw_bunker_set_dressing(self, surface):
        cx = SCREEN_WIDTH // 2
        cy = SCREEN_HEIGHT // 2 + 28
        shelf_left = pygame.Rect(cx - 320, cy - 144, 190, 16)
        pygame.draw.rect(surface, (92, 70, 45), shelf_left, border_radius=3)
        pygame.draw.rect(surface, (63, 47, 31), shelf_left, 2, border_radius=3)

        table = pygame.Rect(cx - 105, cy + 46, 240, 74)
        pygame.draw.rect(surface, (104, 73, 48), table, border_radius=6)
        pygame.draw.rect(surface, (74, 52, 35), table, 2, border_radius=6)
        pygame.draw.rect(surface, (65, 46, 30), (table.x + 16, table.bottom - 10, 18, 24), border_radius=2)
        pygame.draw.rect(surface, (65, 46, 30), (table.right - 34, table.bottom - 10, 18, 24), border_radius=2)
        chair = pygame.Rect(cx + 128, cy + 60, 58, 60)
        pygame.draw.rect(surface, (88, 92, 108), chair, border_radius=4)
        pygame.draw.rect(surface, (58, 61, 75), chair, 2, border_radius=4)
        pygame.draw.rect(surface, (88, 92, 108), (chair.x + 6, chair.y - 22, 46, 24), border_radius=4)
        pygame.draw.rect(surface, (58, 61, 75), (chair.x + 6, chair.y - 22, 46, 24), 2, border_radius=4)

        pygame.draw.rect(surface, (67, 135, 210), (table.x + 18, table.y + 18, 42, 30), border_radius=4)
        pygame.draw.rect(surface, (48, 96, 156), (table.x + 18, table.y + 18, 42, 30), 2, border_radius=4)
        pygame.draw.rect(surface, (118, 122, 136), (table.x + 96, table.y + 16, 50, 22), border_radius=3)
        pygame.draw.circle(surface, (66, 66, 76), (table.x + 110, table.y + 27), 4)
        pygame.draw.circle(surface, (66, 66, 76), (table.x + 132, table.y + 27), 4)
        pygame.draw.rect(surface, (145, 116, 82), (table.x + 164, table.y + 21, 26, 14), border_radius=2)
        pygame.draw.rect(surface, (110, 155, 96), (table.x + 196, table.y + 20, 22, 18), border_radius=2)

        crates = [
            pygame.Rect(cx + 225, cy + 12, 70, 46),
            pygame.Rect(cx + 240, cy + 58, 86, 54),
            pygame.Rect(cx + 200, cy + 80, 56, 40),
        ]
        for crate in crates:
            pygame.draw.rect(surface, (120, 88, 58), crate, border_radius=3)
            pygame.draw.rect(surface, (86, 63, 43), crate, 2, border_radius=3)
            pygame.draw.line(surface, (98, 72, 49), (crate.x + 6, crate.centery), (crate.right - 6, crate.centery), 2)

    def _draw_character(self, surface):
        cx = SCREEN_WIDTH // 2
        cy = SCREEN_HEIGHT // 2 + 24
        draw_worker_sprite(surface, cx, cy, "down", 0, render_size=PLAYER_WORKER_BUNKER_SIZE)

    def _draw_bookshelf(self, surface):
        cx = SCREEN_WIDTH // 2
        cy = SCREEN_HEIGHT // 2 + 24
        shelf_x = cx - 328
        shelf_y = cy - 112
        shelf_rect = pygame.Rect(shelf_x, shelf_y, 160, 282)
        pygame.draw.rect(surface, (126, 90, 55), shelf_rect, border_radius=4)
        pygame.draw.rect(surface, (82, 58, 36), shelf_rect, 3, border_radius=4)
        for i in range(6):
            ry = shelf_y + 16 + i * 42
            pygame.draw.rect(surface, (86, 60, 38), (shelf_x + 8, ry, 146, 30), border_radius=2)
            pygame.draw.rect(surface, (60, 43, 28), (shelf_x + 8, ry, 146, 30), 2, border_radius=2)

        color_order = ["green", "red", "blue", "purple", "yellow", "darkbrown"]
        for i, color in enumerate(color_order):
            count = self.books.get(color, 0)
            if count > 0 and i < 6:
                for j in range(min(count, 2)):
                    bx = shelf_x + 18 + j * 18
                    by = shelf_y + 21 + i * 42
                    book_rect = pygame.Rect(bx, by, 14, 22)
                    pygame.draw.rect(surface, BOOK_COLORS[color], book_rect, border_radius=2)
                    c = BOOK_COLORS[color]
                    darker = (max(0, c[0] - 45), max(0, c[1] - 45), max(0, c[2] - 45))
                    pygame.draw.rect(surface, darker, book_rect, 1, border_radius=2)
                    pygame.draw.line(surface, (225, 225, 225), (bx + 3, by + 8), (bx + 11, by + 8), 1)

    def _draw_door(self, surface):
        note_rect = self._get_door_rect()
        paper = pygame.Surface((note_rect.width, note_rect.height), pygame.SRCALPHA)
        paper.fill((234, 226, 202))
        pygame.draw.rect(paper, (196, 184, 156), paper.get_rect(), 2, border_radius=4)
        pygame.draw.line(paper, (198, 189, 163), (12, 22), (note_rect.width - 12, 22), 1)
        pygame.draw.line(paper, (198, 189, 163), (12, 36), (note_rect.width - 12, 36), 1)
        pygame.draw.line(paper, (198, 189, 163), (12, 50), (note_rect.width - 12, 50), 1)
        pygame.draw.line(paper, (84, 84, 96), (18, note_rect.height - 16), (note_rect.width - 18, 16), 2)
        surface.blit(paper, note_rect.topleft)

    def _draw_supplies(self, surface):
        sx = 220
        sy = SCREEN_HEIGHT - 118
        panel = pygame.Rect(sx - 22, sy - 28, 440, 92)
        pygame.draw.rect(surface, (46, 47, 59), panel, border_radius=8)
        pygame.draw.rect(surface, (76, 78, 92), panel, 2, border_radius=8)
        title = self.font_small.render("Suministros:", True, LIGHT_GRAY)
        surface.blit(title, (sx, sy - 18))

        for i in range(self.water + 2):
            bx = sx + i * 18
            by = sy
            pygame.draw.rect(surface, (50, 130, 220), (bx, by, 12, 25), border_radius=3)
            pygame.draw.rect(surface, (40, 100, 180), (bx, by, 12, 25), 1, border_radius=3)
            pygame.draw.rect(surface, (70, 150, 240), (bx + 3, by - 3, 6, 5), border_radius=1)

        for i in range(self.food + 2):
            bx = sx + i * 18
            by = sy + 35
            pygame.draw.rect(surface, (200, 60, 60), (bx, by, 14, 18), border_radius=2)
            pygame.draw.rect(surface, (160, 40, 40), (bx, by, 14, 18), 1, border_radius=2)
            pygame.draw.rect(surface, (230, 230, 210), (bx + 2, by + 5, 10, 6))

        water_label = self.font_small.render("Agua", True, (100, 180, 255))
        food_label = self.font_small.render("Comida", True, (255, 120, 120))
        surface.blit(water_label, (sx + 236, sy + 7))
        surface.blit(food_label, (sx + 236, sy + 40))

    def _draw_day_hud(self, surface):
        display_day = min(self.current_day, self.total_days)
        label = self.font_day_top.render(f"Dia {display_day}", True, WHITE)
        shadow = self.font_day_top.render(f"Dia {display_day}", True, (35, 35, 45))
        x = SCREEN_WIDTH // 2
        y = 30
        surface.blit(shadow, shadow.get_rect(center=(x + 2, y + 2)))
        surface.blit(label, label.get_rect(center=(x, y)))

        result_text = self.font_small.render(f"Resueltos: {self.days_completed}/6", True, (100, 255, 150))
        surface.blit(result_text, result_text.get_rect(topright=(SCREEN_WIDTH - 20, 12)))
        fails_text = self.font_small.render(f"Fallos: {self.errors}/{self.max_failures_total}", True, (255, 120, 120))
        surface.blit(fails_text, fails_text.get_rect(topright=(SCREEN_WIDTH - 20, 32)))

    def _draw_arrow(self, surface):
        note_rect = self._get_door_rect()
        if int(self.arrow_timer * 3) % 2 == 0:
            ax = note_rect.centerx
            ay = note_rect.top - 42
            points = [(ax, ay + 20), (ax - 12, ay), (ax - 5, ay), (ax - 5, ay - 10), (ax + 5, ay - 10), (ax + 5, ay), (ax + 12, ay)]
            pygame.draw.polygon(surface, (255, 215, 0), points)
            pygame.draw.polygon(surface, (200, 170, 0), points, 2)
            click_text = self.font_small.render("Clic aqui", True, (255, 215, 0))
            surface.blit(click_text, click_text.get_rect(center=(ax, ay - 20)))

    def _draw_message(self, surface):
        msg_rect = pygame.Rect(SCREEN_WIDTH // 2 - 250, SCREEN_HEIGHT // 2 - 25, 500, 50)
        msg_surface = pygame.Surface((500, 50), pygame.SRCALPHA)
        if "Error" in self.message:
            msg_surface.fill((80, 20, 20, 220))
        else:
            msg_surface.fill((20, 80, 20, 220))
        surface.blit(msg_surface, msg_rect.topleft)
        pygame.draw.rect(surface, WHITE, msg_rect, 2, border_radius=5)
        msg_text = self.font_message.render(self.message, True, WHITE)
        surface.blit(msg_text, msg_text.get_rect(center=msg_rect.center))

    def _draw_transition(self, surface):
        overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT), pygame.SRCALPHA)
        alpha = max(0, min(255, int(200 * (1 - self.transition_timer / 3.0))))
        overlay.fill((0, 0, 0, alpha))
        surface.blit(overlay, (0, 0))

        if self.transition_timer < 1.5 and self.current_day <= self.total_days:
            display_day = min(self.current_day, self.total_days)
            day_label = self.font_day.render(f"Dia {display_day}", True, WHITE)
            surface.blit(day_label, day_label.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)))