main.py

# ============================================
# main.py - Punto de entrada del juego
# ============================================

import pygame
import sys
import ctypes
from config import (
    SCREEN_WIDTH,
    SCREEN_HEIGHT,
    FPS,
    BLACK,
    STATE_MENU,
    STATE_HOUSE,
    STATE_BUNKER,
    STATE_ENDING,
)
from sounds import SoundManager
from menu import MainMenu, EndScreen
from house import HousePhase
from bunker import BunkerPhase


class Game:
    """Clase principal del juego y manejo de estados."""

    def __init__(self):
        pygame.init()
        try:
            pygame.mixer.init(frequency=22050, size=-16, channels=1, buffer=512)
        except Exception:
            pass

        self.windowed_flags = self._compose_flags("RESIZABLE")
        self.fullscreen_flags = self._compose_flags("FULLSCREEN_DESKTOP", "FULLSCREEN")
        self.fullscreen = False
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT), self.windowed_flags)
        pygame.display.set_caption("30 Segundos Antes de la Tragedia")
        self.clock = pygame.time.Clock()
        self.canvas = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT)).convert()
        self.display_size = self.screen.get_size()
        self._logical_mouse_pos = (0, 0)
        self._raw_mouse_get_pos = pygame.mouse.get_pos
        pygame.mouse.get_pos = self._get_logical_mouse_pos
        self._maximize_window()

        self.sound_manager = SoundManager()

        self.menu = MainMenu(self.sound_manager)
        self.house_phase = HousePhase(self.sound_manager)
        self.bunker_phase = BunkerPhase(self.sound_manager)
        self.end_screen = EndScreen(self.sound_manager)

        self.state = STATE_MENU
        self.running = True

        self.pause_active = False
        self.pause_screen = "main"  # main | controls | options
        self.pause_button_rect = pygame.Rect(12, 10, 42, 36)
        self.font_pause = pygame.font.SysFont("Arial", 18, bold=True)
        self.font_pause_title = pygame.font.SysFont("Arial", 28, bold=True)
        self.font_pause_text = pygame.font.SysFont("Arial", 18)
        self.font_pause_small = pygame.font.SysFont("Arial", 15)

    def _maximize_window(self):
        """Maximiza la ventana en modo ventana normal."""
        try:
            hwnd = pygame.display.get_wm_info().get("window")
            if hwnd:
                ctypes.windll.user32.ShowWindow(hwnd, 3)
        except Exception:
            pass

    def _get_logical_mouse_pos(self):
        return self._logical_mouse_pos

    def _compose_flags(self, *flag_names):
        """Construye un OR de flags disponibles en esta version de pygame."""
        flags = 0
        for name in flag_names:
            value = getattr(pygame, name, 0)
            flags |= value
        return flags

    def _set_display_mode(self, fullscreen):
        """Cambia entre ventana maximizada y pantalla completa."""
        self.fullscreen = fullscreen
        flags = self.fullscreen_flags if fullscreen else self.windowed_flags
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT), flags)
        self._sync_display_size()
        if not fullscreen:
            self._maximize_window()

    def _toggle_fullscreen(self):
        """Alterna con F11 entre ventana y pantalla completa."""
        self._set_display_mode(not self.fullscreen)

    def run(self):
        """Bucle principal."""
        while self.running:
            dt = self.clock.tick(FPS) / 1000.0

            events = []
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                    break
                if event.type == pygame.KEYDOWN and event.key == pygame.K_F11:
                    self._toggle_fullscreen()
                    continue
                if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                    if self.state in (STATE_HOUSE, STATE_BUNKER):
                        if self.pause_active:
                            if self.pause_screen == "main":
                                self.pause_active = False
                            else:
                                self.pause_screen = "main"
                        else:
                            self.pause_active = True
                            self.pause_screen = "main"
                        continue
                events.append(self._map_input_event(event))

            if not self.running:
                break

            self._sync_mouse_position()

            if self.state in (STATE_HOUSE, STATE_BUNKER):
                if self._update_pause(events):
                    self._draw_current_state()
                    self._draw_pause_button()
                    if self.pause_active:
                        self._draw_pause_overlay()
                    self._present_frame()
                    continue

            if self.pause_active:
                self._draw_current_state()
                self._draw_pause_button()
                self._draw_pause_overlay()
                self._present_frame()
                continue

            if self.state == STATE_MENU:
                result = self.menu.update(events, dt)
                if result == "new_game":
                    self._start_new_game()
                elif result == "quit":
                    self.running = False

            elif self.state == STATE_HOUSE:
                result = self.house_phase.update(events, dt)
                if result:
                    next_state, data = result
                    if next_state == STATE_BUNKER:
                        self._enter_bunker(data)
                    elif next_state == STATE_ENDING:
                        self._show_ending(data, 0)

            elif self.state == STATE_BUNKER:
                result = self.bunker_phase.update(events, dt)
                if result:
                    days = self.bunker_phase.days_completed
                    self._show_ending(result, days)

            elif self.state == STATE_ENDING:
                result = self.end_screen.update(events, dt)
                if result == "menu":
                    self._return_to_menu()

            self._draw_current_state()
            if self.state in (STATE_HOUSE, STATE_BUNKER):
                self._draw_pause_button()
            self._present_frame()

        pygame.quit()
        sys.exit()

    def _update_pause(self, events):
        """Procesa clics del boton de pausa y del menu de pausa."""
        for event in events:
            if event.type != pygame.MOUSEBUTTONDOWN:
                continue
            mouse = event.pos

            if not self.pause_active:
                if self.pause_button_rect.collidepoint(mouse):
                    self.pause_active = True
                    self.pause_screen = "main"
                    self.sound_manager.play("select")
                    return True
                continue

            panel = pygame.Rect(SCREEN_WIDTH // 2 - 220, SCREEN_HEIGHT // 2 - 190, 440, 380)
            if self.pause_screen == "main":
                btns = self._get_pause_main_buttons(panel)
                # Priorizar "Salir al Menu" en caso de borde/solape visual.
                if btns["menu"].collidepoint(mouse):
                    self.sound_manager.play("select")
                    self._return_to_menu()
                    self.pause_active = False
                    return True
                if btns["resume"].collidepoint(mouse):
                    self.pause_active = False
                    self.sound_manager.play("select")
                    return True
                if btns["controls"].collidepoint(mouse):
                    self.pause_screen = "controls"
                    self.sound_manager.play("select")
                    return True
                if btns["options"].collidepoint(mouse):
                    self.pause_screen = "options"
                    self.sound_manager.play("select")
                    return True

            elif self.pause_screen == "controls":
                back_btn = pygame.Rect(panel.left + 120, panel.bottom - 60, 200, 38)
                if back_btn.collidepoint(mouse):
                    self.pause_screen = "main"
                    self.sound_manager.play("select")
                    return True

            elif self.pause_screen == "options":
                sound_btn = pygame.Rect(panel.left + 100, panel.top + 150, 240, 48)
                back_btn = pygame.Rect(panel.left + 120, panel.bottom - 60, 200, 38)
                if sound_btn.collidepoint(mouse):
                    self.sound_manager.toggle()
                    self.sound_manager.play("select")
                    return True
                if back_btn.collidepoint(mouse):
                    self.pause_screen = "main"
                    self.sound_manager.play("select")
                    return True

        return self.pause_active

    def _sync_mouse_position(self):
        """Actualiza la posicion del mouse en coordenadas logicas."""
        self._sync_display_size()
        self._logical_mouse_pos = self._to_logical_pos(self._raw_mouse_get_pos())

    def _sync_display_size(self):
        """Lee el tamaño real de salida de la ventana o pantalla completa."""
        try:
            self.display_size = pygame.display.get_window_size()
        except Exception:
            self.display_size = self.screen.get_size()

    def _to_logical_pos(self, pos):
        """Convierte coordenadas de pantalla a coordenadas logicas."""
        dw, dh = self.display_size
        if dw <= 0 or dh <= 0:
            return pos
        x = int(pos[0] * SCREEN_WIDTH / dw)
        y = int(pos[1] * SCREEN_HEIGHT / dh)
        x = max(0, min(SCREEN_WIDTH - 1, x))
        y = max(0, min(SCREEN_HEIGHT - 1, y))
        return (x, y)

    def _map_input_event(self, event):
        """Reescribe eventos de mouse a coordenadas logicas."""
        if event.type in (pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP, pygame.MOUSEMOTION):
            data = event.dict.copy()
            if "pos" in data:
                data["pos"] = self._to_logical_pos(data["pos"])
            if "rel" in data and self.display_size[0] and self.display_size[1]:
                data["rel"] = (
                    int(data["rel"][0] * SCREEN_WIDTH / self.display_size[0]),
                    int(data["rel"][1] * SCREEN_HEIGHT / self.display_size[1]),
                )
            return pygame.event.Event(event.type, data)
        return event

    def _present_frame(self):
        """Escala la superficie logica a la resolucion real de salida."""
        if self.display_size == (SCREEN_WIDTH, SCREEN_HEIGHT):
            self.screen.blit(self.canvas, (0, 0))
        else:
            scaled = pygame.transform.smoothscale(self.canvas, self.display_size)
            self.screen.blit(scaled, (0, 0))
        pygame.display.flip()

    def _draw_current_state(self):
        self.canvas.fill(BLACK)
        if self.state == STATE_MENU:
            self.menu.draw(self.canvas)
        elif self.state == STATE_HOUSE:
            self.house_phase.draw(self.canvas)
        elif self.state == STATE_BUNKER:
            self.bunker_phase.draw(self.canvas)
        elif self.state == STATE_ENDING:
            self.end_screen.draw(self.canvas)

    def _draw_pause_button(self):
        mouse = pygame.mouse.get_pos()
        hover = self.pause_button_rect.collidepoint(mouse)
        bg = (100, 100, 120) if hover else (75, 75, 95)
        pygame.draw.rect(self.canvas, bg, self.pause_button_rect, border_radius=6)
        pygame.draw.rect(self.canvas, (230, 230, 240), self.pause_button_rect, 2, border_radius=6)
        bar_y = self.pause_button_rect.y + 9
        pygame.draw.rect(self.canvas, (240, 240, 240), (self.pause_button_rect.x + 12, bar_y, 6, 18))
        pygame.draw.rect(self.canvas, (240, 240, 240), (self.pause_button_rect.x + 24, bar_y, 6, 18))

    def _draw_pause_overlay(self):
        overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT), pygame.SRCALPHA)
        overlay.fill((0, 0, 0, 160))
        self.canvas.blit(overlay, (0, 0))

        panel = pygame.Rect(SCREEN_WIDTH // 2 - 220, SCREEN_HEIGHT // 2 - 190, 440, 380)
        pygame.draw.rect(self.canvas, (40, 40, 55), panel, border_radius=10)
        pygame.draw.rect(self.canvas, (130, 130, 155), panel, 2, border_radius=10)

        if self.pause_screen == "main":
            title = self.font_pause_title.render("Pausa", True, (245, 245, 245))
            self.canvas.blit(title, title.get_rect(center=(panel.centerx, panel.top + 45)))
            btns = self._get_pause_main_buttons(panel)
            self._draw_pause_menu_button(btns["resume"], "Reanudar")
            self._draw_pause_menu_button(btns["controls"], "Controles")
            self._draw_pause_menu_button(btns["options"], "Opciones")
            self._draw_pause_menu_button(btns["menu"], "Salir al Menu")

        elif self.pause_screen == "controls":
            title = self.font_pause_title.render("Controles", True, (245, 245, 245))
            self.canvas.blit(title, title.get_rect(center=(panel.centerx, panel.top + 38)))
            controls = [
                "Movimiento: W A S D o Flechas",
                "Recoger libro / Entrar bunker: E",
                "Entregar respuesta: Enter",
                "Interaccion en bunker: Clic",
            ]
            y = panel.top + 90
            for line in controls:
                t = self.font_pause_text.render(line, True, (220, 220, 235))
                self.canvas.blit(t, (panel.left + 35, y))
                y += 38
            self._draw_back_button(panel)

        elif self.pause_screen == "options":
            title = self.font_pause_title.render("Opciones", True, (245, 245, 245))
            self.canvas.blit(title, title.get_rect(center=(panel.centerx, panel.top + 38)))
            status = "Sonido: Activado" if self.sound_manager.is_enabled() else "Sonido: Desactivado"
            sound_btn = pygame.Rect(panel.left + 100, panel.top + 150, 240, 48)
            hover = sound_btn.collidepoint(pygame.mouse.get_pos())
            color = (75, 130, 75) if hover else (60, 105, 60)
            pygame.draw.rect(self.canvas, color, sound_btn, border_radius=7)
            pygame.draw.rect(self.canvas, (240, 240, 240), sound_btn, 2, border_radius=7)
            label = self.font_pause_text.render(status, True, (245, 245, 245))
            self.canvas.blit(label, label.get_rect(center=sound_btn.center))
            hint = self.font_pause_small.render("Clic para cambiar", True, (200, 200, 220))
            self.canvas.blit(hint, hint.get_rect(center=(panel.centerx, sound_btn.bottom + 24)))
            self._draw_back_button(panel)

    def _get_pause_main_buttons(self, panel):
        """Rectangulos unificados para dibujar y detectar clic en pausa."""
        return {
            "resume": pygame.Rect(panel.left + 80, panel.top + 90, 280, 44),
            "controls": pygame.Rect(panel.left + 80, panel.top + 145, 280, 44),
            "options": pygame.Rect(panel.left + 80, panel.top + 200, 280, 44),
            "menu": pygame.Rect(panel.left + 80, panel.top + 255, 280, 44),
        }

    def _draw_pause_menu_button(self, rect, text):
        hover = rect.collidepoint(pygame.mouse.get_pos())
        color = (90, 90, 115) if hover else (70, 70, 95)
        pygame.draw.rect(self.canvas, color, rect, border_radius=8)
        pygame.draw.rect(self.canvas, (240, 240, 240), rect, 2, border_radius=8)
        label = self.font_pause_text.render(text, True, (245, 245, 245))
        self.canvas.blit(label, label.get_rect(center=rect.center))

    def _draw_back_button(self, panel):
        rect = pygame.Rect(panel.left + 120, panel.bottom - 60, 200, 38)
        hover = rect.collidepoint(pygame.mouse.get_pos())
        color = (90, 90, 115) if hover else (70, 70, 95)
        pygame.draw.rect(self.canvas, color, rect, border_radius=8)
        pygame.draw.rect(self.canvas, (240, 240, 240), rect, 2, border_radius=8)
        label = self.font_pause_text.render("Volver", True, (245, 245, 245))
        self.canvas.blit(label, label.get_rect(center=rect.center))

    def _start_new_game(self):
        self.house_phase.reset()
        self.pause_active = False
        self.pause_screen = "main"
        self.state = STATE_HOUSE

    def _enter_bunker(self, books_collected):
        self.bunker_phase.init_with_books(books_collected)
        self.state = STATE_BUNKER

    def _show_ending(self, ending_type, days_completed):
        self.end_screen.init(ending_type, days_completed)
        self.pause_active = False
        self.state = STATE_ENDING

    def _return_to_menu(self):
        self.menu.selected = 0
        self.pause_active = False
        self.pause_screen = "main"
        self.state = STATE_MENU


if __name__ == "__main__":
    game = Game()
    game.run()