ui.screens

  1"""
  2ui/screens.py
  3
  4Interfaz visual del juego.
  5
  6Incluye:
  7- Mapa interactivo de cámaras.
  8- Visualización de habitaciones y linterna.
  9- Pantallas de Game Over, historia, introducción e instrucciones.
 10- Selección de dificultad.
 11"""
 12
 13
 14import os
 15import time
 16import msvcrt
 17import warnings
 18from threading import Thread
 19
 20from colorama import Fore, init, Style
 21
 22from utils.utils import limpiar_pantalla, reproducir_sonido, cargar_plantilla_archivo
 23from core.energy import barra_energia
 24import core.config as estado
 25from core.animatronics import animatronics
 26from core.movement import mover_animatronico, detener_todos_los_canales
 27
 28init(autoreset=True)
 29
 30# Ignorar warnings de Pygame
 31os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
 32warnings.filterwarnings("ignore", category=UserWarning)
 33
 34import pygame
 35pygame.init()
 36
 37
 38# -------------------------- MAPA Y CÁMARAS -------------------------- #
 39def mostrar_mapa(camara_seleccionada):
 40    """
 41    Muestra en pantalla el mapa de cámaras interactivo, resaltando la cámara seleccionada.
 42    
 43    Args:
 44        camara_seleccionada (int): Número de cámara actualmente seleccionada.
 45    """
 46    limpiar_pantalla()
 47    def cam_texto(numero):
 48        texto = f"CAM 0{numero}"
 49        return Fore.RED + texto + Style.RESET_ALL if camara_seleccionada == numero else texto
 50
 51    print("\r" + barra_energia(), end="", flush=True)
 52    print(Fore.LIGHTYELLOW_EX + f"\nHora: {estado.horas[estado.hora_actual]}\n")    
 53    print(Fore.LIGHTWHITE_EX + f"""
 54                      ╔══════════╗
 55               ╔══════╣  {cam_texto(2)}  ╠════════════╗
 56               ║      ╚══════════╝            ║
 57             ╔═╩══════╗                 ╔═════╩══╗
 58      ╔══════╣        ║  ╔════════════╗ ║        ║
 59   ╔══╩═════╗║ {cam_texto(6)} ╠══╣   {cam_texto(1)}   ╠═╣ {cam_texto(3)} ╠══╗
 60   ║        ║║        ║  ╚════════╦═══╝ ║        ║  ║
 61   ║ {cam_texto(7)} ║╚══╦═════╝           ║     ╚═╦═══╦══╝  ║
 62   ║        ║   ║     ╔════════╗  ║       ║   ║     ║
 63   ╚══╦═════╝   ╚═════╣ {cam_texto(5)} ╠══╩═══════╝   ║     ║
 64      ║               ╚════════╝              ╠═════╝
 65      ║           ╔═════════════════╗         ║  
 66      ╚═══════════╣	 {cam_texto(4)}     ╠═════════╝   
 67                  ╚════╦══════╦═════╝        
 68                    ╔══╝      ╚══╗
 69                    ║   ╔════╗   ║        
 70                    ╚═══╣ CG ╠═══╝
 71                        ╚════╝
 72    """)
 73    print("Presiona 'Q' para salir")
 74
 75
 76def mapa_interactivo():
 77    """
 78    Muestra el mapa interactivo de cámaras y permite navegación.
 79    Controla refresco de pantalla, batería y sincronización con stop_event.
 80    """
 81    camaras_disponibles = [1, 2, 3, 4, 5, 6, 7]
 82    indice = 0
 83    camara_seleccionada = camaras_disponibles[indice]
 84    ultimo_refresco = time.time()
 85
 86    mostrar_mapa(camara_seleccionada)
 87
 88    while not estado.stop_event.is_set():
 89        # Refresco automático
 90        if time.time() - ultimo_refresco >= estado.config["tiempo_avanzar_hora"]:
 91            mostrar_mapa(camara_seleccionada)
 92            ultimo_refresco = time.time()
 93
 94        # Entrada de usuario
 95        if msvcrt.kbhit():
 96            if estado.stop_event.is_set():
 97                break 
 98            tecla = msvcrt.getch()
 99            
100            if tecla == b'\xe0':
101                flecha = msvcrt.getch()
102                if flecha in [b'H', b'M']:  # Arriba/derecha
103                    indice = (indice + 1) % len(camaras_disponibles)
104                elif flecha in [b'P', b'K']:  # Abajo/izquierda
105                    indice = (indice - 1) % len(camaras_disponibles)
106                camara_seleccionada = camaras_disponibles[indice]
107                mostrar_mapa(camara_seleccionada)
108
109            elif tecla == b'\r':  # Enter
110                if estado.energia_actual <= 0:
111                    print(Fore.RED + "\n¡Sin batería! No podés usar cámaras.")
112                    estado.energia_actual = 0
113                    time.sleep(1.5)
114                else:
115                    mostrar_habitacion(camara_seleccionada)
116                    mostrar_mapa(camara_seleccionada)
117
118            elif tecla in [b'q', b'Q']:
119                estado.stop_event.set()
120                print("Saliendo del juego...")
121                time.sleep(2)
122                detener_todos_los_canales()
123                limpiar_pantalla()
124                break
125
126
127def mostrar_habitacion(numero: int):
128    """
129    Muestra la cámara seleccionada y permite interacción con linterna.
130
131    Args:
132        numero (int): Número de la cámara.
133    """
134    if estado.energia_actual <= 0:
135        print(Fore.RED + "¡Sin batería! No podés usar cámaras.")
136        time.sleep(2)
137        return
138
139    estado.energia_actual -= estado.config["energia_uso_camara"]
140    estado.energia_actual = max(0, estado.energia_actual)
141
142    reproducir_sonido(estado.config["sonido_camara"], canal=estado.canal_interface)
143    limpiar_pantalla()
144    print(Fore.CYAN + f"[ Cámara {numero:02d} - {estado.habitaciones[numero]} ]\n")
145
146    anim_presentes = [n for n, a in animatronics.items() if a.posicion == numero]
147    plantilla = cargar_plantilla_archivo(numero, anim_presentes)
148    for linea in plantilla:
149        print(Fore.WHITE + linea.rstrip("\n"))
150
151    spawn_owners = [n for n, a in animatronics.items() if a.spawn == numero]
152    anim_own = any(owner in anim_presentes for owner in spawn_owners)
153    todos_son_duenios = all(anim in spawn_owners for anim in anim_presentes)
154
155    if not todos_son_duenios and anim_own:
156        print(Fore.YELLOW + "\n¡Animatrónico detectado! Presiona 'F' para usar la linterna.")
157        if input("\n> ").strip().upper() == 'F':
158            usar_linterna(anim_presentes, spawn_owners[0])
159    elif todos_son_duenios and anim_presentes:
160        print(Fore.RED + "\n¡Linterna Desactivada!")
161        input("\nPresiona Enter para volver.")
162    elif not anim_own and anim_presentes:
163        print(Fore.YELLOW + "\n¡Animatrónico detectado! Presiona 'F' para usar la linterna.")
164        if input("\n> ").strip().upper() == 'F':
165            usar_linterna(anim_presentes, None)
166    else:
167        if estado.energia_actual <= 0:
168            print(Fore.RED + "\nSin batería. No podés usar cámaras.")
169            time.sleep(2)
170        else:
171            print(Fore.CYAN + "\nPresiona Enter para volver.")
172            input()
173
174
175def usar_linterna(anim_presentes: list, spawn_owner=None):
176    """
177    Simula el uso de la linterna para retroceder animatrónicos no dueños del spawn.
178
179    Args:
180        anim_presentes (list): Animatrónicos presentes.
181        spawn_owner (str, optional): Animatrónico dueño del spawn.
182    """
183    if estado.energia_actual <= 0:
184        print(Fore.RED + "¡Sin batería! La linterna no funciona.")
185        time.sleep(1)
186        return
187
188    estado.energia_actual -= estado.config["energia_uso_linterna"]
189    estado.energia_actual = max(0, estado.energia_actual)
190
191    print(Fore.GREEN + "¡Usaste la linterna!")
192    for nombre in anim_presentes:
193        if nombre != spawn_owner:
194            animatronics[nombre].regresar_spawn()
195            print(Fore.GREEN + f"{animatronics[nombre].cara} {nombre} regresó a su posición inicial.")
196    time.sleep(1)
197
198
199# -------------------------- GAME OVER -------------------------- #
200def pantalla_game_over(nombre: str):
201    """
202    Muestra la pantalla de Game Over, reproduciendo sonidos y ASCII art.
203
204    Args:
205        nombre (str): Animatrónico responsable del Game Over.
206    """
207    anim = animatronics[nombre]
208    detener_todos_los_canales()
209
210    reproducir_sonido(estado.config["sonido_powerdown"])
211    while pygame.mixer.music.get_busy():
212        time.sleep(0.1)
213
214    reproducir_sonido(anim.cancion_muerte)
215    while pygame.mixer.music.get_busy():
216        time.sleep(0.1)
217
218    reproducir_sonido(estado.config["sonido_jumpscare"])
219    time.sleep(1.5)
220
221    estado.stop_event.set()
222    estado.juego_activo = False
223    limpiar_pantalla()
224    ancho = 80
225
226    mensaje = [
227        Fore.RED + Style.BRIGHT + f"¡{nombre.upper()} ENTRÓ A LA OFICINA!".center(ancho),
228        "",
229        Fore.MAGENTA + Style.BRIGHT + "  ██████╗   █████╗  ███╗   ███╗ ███████╗     ██████╗  ██╗   ██╗ ███████╗ ██████╗ ",
230        Fore.MAGENTA + Style.BRIGHT + " ██╔════╝  ██╔══██╗ ████╗ ████║ ██╔════╝    ██╔═══██╗ ██║   ██║ ██╔════╝ ██╔══██╗",
231        Fore.MAGENTA + Style.BRIGHT + " ██║  ███╗ ███████║ ██╔████╔██║ █████╗      ██║   ██║ ██║   ██║ █████╗   ██████╔╝",
232        Fore.MAGENTA + Style.BRIGHT + " ██║   ██║ ██╔══██║ ██║╚██╔╝██║ ██╔══╝      ██║   ██║ ███╗ ███║ ██╔══╝   ██╔══██╗",
233        Fore.MAGENTA + Style.BRIGHT + " ╚██████╔╝ ██║  ██║ ██║ ╚═╝ ██║ ███████╗    ╚██████╔╝ ╚═████╔═╝ ███████╗ ██║  ██║",
234        Fore.MAGENTA + Style.BRIGHT + "  ╚═════╝  ╚═╝  ╚═╝ ╚═╝     ╚═╝ ╚══════╝     ╚═════╝    ╚═══╝   ╚══════╝ ╚═╝  ╚═╝"
235    ]
236
237    for linea in mensaje:
238        print(linea)
239        time.sleep(0.3)
240
241    time.sleep(2)
242    print(Fore.YELLOW + "Volviendo al menú principal...".center(ancho))
243    time.sleep(1)
244    from ui.menu import menu_principal
245    menu_principal()
246
247
248# ------------------------------ INTRO ------------------------------ #
249def intro():
250    """Reproduce la introducción de audio y luego inicia el movimiento de los animatrónicos."""
251    reproducir_sonido(estado.config["intro"])
252    while pygame.mixer.music.get_busy():
253        time.sleep(0.1)
254
255    for nombre in animatronics:
256        Thread(target=mover_animatronico, args=(nombre,), daemon=True).start()
257
258
259# -------------------------- INSTRUCCIONES -------------------------- #
260def mostrar_instrucciones():
261    """Muestra las instrucciones del juego en consola."""
262    limpiar_pantalla()
263    print("\n════════════════════════════════════════")
264    print(Style.BRIGHT + Fore.MAGENTA + "📜 INSTRUCCIONES 📜".center(38))
265    print("════════════════════════════════════════\n")
266
267    print(Style.BRIGHT + Fore.WHITE + "- Usa las flechas " + Fore.CYAN + "↑ ↓ ← →" + Fore.WHITE + " para moverte por el mapa.\n")
268    print(Fore.WHITE + "- Tu objetivo es " + Fore.RED + "sobrevivir la noche" + Fore.WHITE + " vigilando las cámaras.\n")
269    print(Fore.WHITE + "- Observa los movimientos de los animatrónicos.\n")
270    print(Fore.WHITE + "- Usa la " + Fore.LIGHTYELLOW_EX + "linterna" + Fore.WHITE + " para espantarlos.\n")
271    print(Fore.WHITE + "- Si un animatrónico entra en la oficina... " + Fore.RED + Style.BRIGHT + "GAME OVER!\n")
272    input(Fore.GREEN + "\nPresiona Enter para volver al menú.")
273
274
275# -------------------------- DIFICULTAD -------------------------- #
276def seleccionar_dificultad():
277    """
278    Muestra un menú interactivo para seleccionar la dificultad del juego.
279
280    Permite elegir entre NORMAL, DIFÍCIL, PESADILLA o VOLVER al menú principal.
281    Cada dificultad modifica:
282        - Velocidad de avance de las horas.
283        - Consumo de energía por linterna.
284        - Consumo de energía por uso de cámara.
285
286    Controles:
287        - Flechas arriba/abajo: navegan entre las opciones.
288        - Enter: confirma la selección.
289
290    Variables globales:
291        estado.config (dict): Diccionario con los parámetros de configuración.
292    """
293    opciones = ["NORMAL", "DIFÍCIL", "PESADILLA", "VOLVER"]
294    colores = [Fore.GREEN, Fore.YELLOW, Fore.MAGENTA, Fore.WHITE]
295    ancho_pantalla = 60
296    seleccion = 0
297
298    while True:
299        limpiar_pantalla()
300
301        # Título del menú
302        print(Style.BRIGHT + Fore.WHITE + """
303                    
304        ███╗   ███╗  ██████╗  ██████╗   ██████╗  ███████╗
305        ████╗ ████║ ██╔═══██╗ ██╔══██╗ ██╔═══██╗ ██╔════╝
306        ██╔████╔██║ ██║   ██║ ██║  ██║ ██║   ██║ ███████╗
307        ██║╚██╔╝██║ ██║   ██║ ██║  ██║ ██║   ██║ ╚════██║
308        ██║ ╚═╝ ██║ ╚██████╔╝ ██████╔╝ ╚██████╔╝ ███████║
309        ╚═╝     ╚═╝  ╚═════╝  ╚═════╝   ╚═════╝  ╚══════╝
310        """)
311
312        # Mostrar opciones con la selección actual
313        for i, opcion in enumerate(opciones):
314            flecha = ">> " if i == seleccion else "   "
315            linea = flecha + opcion
316            print("\n" + colores[i] + linea.center(ancho_pantalla))
317
318        # Lectura de teclas
319        tecla = msvcrt.getch()
320
321        if tecla == b'\xe0':  # Flechas
322            flecha = msvcrt.getch()
323            if flecha == b'H':  # Arriba
324                seleccion = (seleccion - 1) % len(opciones)
325            elif flecha == b'P':  # Abajo
326                seleccion = (seleccion + 1) % len(opciones)
327        elif tecla == b'\r':  # Enter
328            if seleccion == 0:  # NORMAL
329                estado.config.update({
330                    "tiempo_avanzar_hora": 60,
331                    "energia_uso_linterna": 5,
332                    "energia_uso_camara": 2,
333                    "dificultad": "NORMAL"
334                })
335            elif seleccion == 1:  # DIFÍCIL
336                estado.config.update({
337                    "tiempo_avanzar_hora": 120,
338                    "energia_uso_linterna": 3,
339                    "energia_uso_camara": 1.5,
340                    "dificultad": "DIFICIL"
341                })
342            elif seleccion == 2:  # PESADILLA
343                estado.config.update({
344                    "tiempo_avanzar_hora": 225,
345                    "energia_uso_linterna": 2,
346                    "energia_uso_camara": 1,
347                    "dificultad": "PESADILLA"
348                })
349            elif seleccion == 3:  # VOLVER
350                from ui.menu import menu_principal
351                menu_principal()
352                return
353            time.sleep(1)
354            return