controller.py

import os
import array
import math
import pygame
from typing import Any
from state import SimulationState
from renderer import RenderEngine
from models import SimulationLevel
from engine import SimulationEngine
from pathfinder import SpaceTimeNode
from playlist import MapPlaylist


class SimulationController:
    """The Controller: Manages events, timing, and glues MVC together."""

    def __init__(
            self, level: SimulationLevel, engine: SimulationEngine,
            filepath: str, playlist: MapPlaylist
    ) -> None:
        """Initializes the SimulationController object"""
        pygame.init()
        pygame.mixer.init(frequency=22050, size=-16, channels=1)

        info: Any = pygame.display.Info()
        width: int = int(info.current_w * 0.85)
        height: int = int(info.current_h * 0.85)
        pygame.display.set_caption(
            "Fly-in: Professional Routing Command"
        )

        self.state = SimulationState(level, engine, filepath, playlist)
        self.renderer = RenderEngine(width, height)
        self.renderer.update_scales(self.state)

        self.clock = pygame.time.Clock()
        self._start_ambient_audio()

        # Audio Mix: Blip volume heavily reduced to prevent audio stacking,
        # Zip volume slightly boosted to cut through the swarm noise.
        # (start_freq, end_freq, duration, volume)
        self.sound_blip = self._create_synth_sound(800, 800, 0.05, 0.015)
        self.sound_zip = self._create_synth_sound(400, 1600, 0.15, 0.045)

    def _create_synth_sound(
            self, start_freq: float, end_freq: float,
            duration: float, vol: float
    ) -> pygame.mixer.Sound:
        """Mathematically generates short UI sound effects."""
        sample_rate = 22050
        n_samples = int(duration * sample_rate)
        buf = array.array('h')

        for i in range(n_samples):
            t: float = float(i) / sample_rate
            freq = start_freq + (end_freq - start_freq) * (t / duration)
            envelope: float = 1.0 - (t / duration)

            val = int(32767 * vol * envelope * math.sin(
                2 * math.pi * freq * t
            ))
            buf.append(val)

        return pygame.mixer.Sound(buffer=buf.tobytes())

    def _start_ambient_audio(self) -> None:
        """Starts ambient audio"""
        audio_file = "ambient_hum.wav"
        if os.path.exists(audio_file):
            try:
                pygame.mixer.music.load(audio_file)
                pygame.mixer.music.set_volume(0.1)
                pygame.mixer.music.play(loops=-1)
            except Exception as e:
                print(f"[!] Could not load external audio: {e}")

    def run(self) -> None:
        """Manages pygame environment"""
        running = True
        while running:
            dt: float = self.clock.tick(60) / 1000.0

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                elif event.type == pygame.VIDEORESIZE:
                    self.renderer.resize(event.w, event.h)
                    self.renderer.update_scales(self.state)
                elif event.type == pygame.KEYDOWN:
                    self._handle_keydown(event)

            if self.state.is_playing and \
                    self.state.current_turn < self.state.max_turn:
                self.state.progress += self.state.speed * dt
                while self.state.progress >= 1.0:
                    self.state.progress -= 1.0
                    self.state.current_turn += 1

                    self._check_audio_triggers()

                    if self.state.current_turn >= self.state.max_turn:
                        self.state.current_turn = self.state.max_turn
                        self.state.progress = 0.0
                        self.state.is_playing = False
                        break

            self.renderer.draw_frame(self.state)

        pygame.quit()

    def _check_audio_triggers(self) -> None:
        """Triggers blip or zip sounds when drones arrive at hubs."""
        for _, path in self.state.routes.items():
            for i in range(1, len(path)):
                node: SpaceTimeNode = path[i]
                if node.t == self.state.current_turn:
                    prev_node: SpaceTimeNode = path[i-1]
                    # Check if it arrived at a new hub this exact turn
                    if prev_node.node_name != node.node_name:
                        if node.node_name == path[-1].node_name:
                            self.sound_zip.play()
                        else:
                            self.sound_blip.play()
                    break

    def _handle_keydown(self, event: pygame.event.Event) -> None:
        """Handles keydown events"""
        if event.key == pygame.K_ESCAPE:
            pygame.event.post(pygame.event.Event(pygame.QUIT))
        elif event.key == pygame.K_SPACE:
            if self.state.current_turn >= self.state.max_turn:
                self.state.current_turn = 0
                self.state.progress = 0.0
            self.state.is_playing = not self.state.is_playing
        elif event.key == pygame.K_r:
            if self.state.reload():
                self.renderer.update_scales(self.state)
            self.state.current_turn = 0
            self.state.progress = 0.0
        elif event.key == pygame.K_m:
            self.state.ground_mode = not self.state.ground_mode
        elif event.key == pygame.K_UP:
            self.state.speed = min(self.state.speed + 0.5, 5.0)
        elif event.key == pygame.K_DOWN:
            self.state.speed = max(self.state.speed - 0.5, 0.5)
        elif event.key in (pygame.K_EQUALS, pygame.K_PLUS):
            self.state.drone_override = \
                self.state.level.total_drones + 1
            if self.state.reload():
                self.renderer.update_scales(self.state)
        elif event.key == pygame.K_MINUS:
            self.state.drone_override = max(
                1, self.state.level.total_drones - 1
            )
            if self.state.reload():
                self.renderer.update_scales(self.state)
        elif event.key == pygame.K_RIGHT:
            self.state.filepath = self.state.playlist.next_map()
            self.state.drone_override = None
            if self.state.reload():
                self.renderer.update_scales(self.state)
        elif event.key == pygame.K_LEFT:
            self.state.filepath = self.state.playlist.previous_map()
            self.state.drone_override = None
            if self.state.reload():
                self.renderer.update_scales(self.state)