#!/usr/bin/python3 import argparse import random import os import json import time from engine import maze, sdl2 as engine, controls, graphics, unit_manager, scoring, state_machine, config from engine.state_machine import GameState from engine.collision_system import CollisionSystem from units import points from units.unit import UnitType from engine.user_profile_integration import UserProfileIntegration from runtime_paths import bundle_path class MiceMaze: # ==================== INITIALIZATION ==================== def _update_startup_loading(self, message, detail=None, progress=None): if getattr(self, "startup_loading_active", False): self.render_engine.show_loading_screen(message, detail=detail, progress=progress) def __init__(self, maze_file, level_index=0): self._setup_initial_state(maze_file, level_index) self._setup_engine() self._setup_components() self._setup_game_assets() self._setup_initial_units() def _setup_initial_state(self, maze_file, level_index): # Initialize user profile integration self.profile_integration = UserProfileIntegration() self.map_source = maze_file self.map = maze.Map(maze_file, level_index=level_index) self.current_level = self.map.level_index self.total_levels = self.map.level_count # Load profile-specific settings self.audio = self.profile_integration.get_setting('sound_enabled', True) self.sound_volume = self.profile_integration.get_setting('sound_volume', 50) self.music_volume = self.profile_integration.get_setting('music_volume', self.sound_volume) self.difficulty = config.DEFAULT_DIFFICULTY self.initial_rat_count = config.BASE_INITIAL_RATS self.rat_speed_multiplier = 1.0 self._apply_difficulty(self.profile_integration.get_setting('difficulty', config.DEFAULT_DIFFICULTY), persist=False) self.cell_size = 40 self.full_screen = False self.start_menu_selection = 0 self.points = 0 self.units = {} self.unit_positions = {} self.unit_positions_before = {} self.scrolling_direction = None self.game_status = "start_menu" self.menu_screen = "start" self.game_end = (False, None) self.run_recorded = False self.scrolling = False self.sounds = {} self.background_texture = None self.tunnel_cover_texture = None self.combined_scores = None def _setup_engine(self): player_name = self.profile_integration.get_profile_name() window_title = f"Mice! - {player_name}" self.render_engine = engine.GameWindow(self.map.width, self.map.height, self.cell_size, window_title, key_callback=lambda action: self.controls.trigger(action)) self.render_engine.audio = self.audio self.startup_loading_active = True # Apply profile volumes if hasattr(self.render_engine, 'set_sound_volume'): self.render_engine.set_sound_volume(self.sound_volume) if hasattr(self.render_engine, 'set_music_volume'): self.render_engine.set_music_volume(self.music_volume) def _setup_components(self): self.scoring = scoring.Scoring(self) self.unit_manager = unit_manager.UnitManager(self) self.graphics = graphics.Graphics(self) self.controls = controls.KeyBindings(self) self.state_machine = state_machine.StateMachine(self) self.collision_system = CollisionSystem(self.cell_size, self.map.width, self.map.height) def _setup_game_assets(self): self._update_startup_loading("Loading Mice!", detail="Applying player settings", progress=0.08) self.controls.initialize_keybindings() self._update_startup_loading("Loading configuration", detail="Reading bundled settings", progress=0.14) self.configs = self.get_config() self._update_startup_loading("Scanning music", detail="Building soundtrack list", progress=0.2) self.available_music_tracks = self._load_available_music_tracks() self.current_level_music = None self._update_startup_loading("Loading graphics", detail="Preparing common assets", progress=0.26) self.graphics.load_assets() self._update_startup_loading("Loading start menu", detail="Preparing menu animation", progress=0.9) self.start_menu_animation = self.render_engine.load_animation(config.START_MENU_ANIMATION) self.start_menu_animation_started_at = time.monotonic() def _setup_initial_units(self): self._update_startup_loading("Starting", detail="Opening intro screen", progress=0.98) self.render_engine.show_intro(bundle_path("assets", "Rat", "intro.png")) self.startup_loading_active = False self.pointer = (random.randint(1, self.map.width-2), random.randint(1, self.map.height-2)) self.graphics.scroll_cursor() self.start_game() def get_config(self): configs = {} conf_dir = bundle_path("conf") for file in sorted(os.listdir(conf_dir)): if file.endswith(".json"): with open(os.path.join(conf_dir, file), encoding="utf-8") as f: configs[file[:-5]] = json.load(f) return configs def _load_available_music_tracks(self): music_dir = bundle_path("assets", "music") tracks = [] for file_name in sorted(os.listdir(music_dir)): _, extension = os.path.splitext(file_name) if extension.lower() not in config.SUPPORTED_MUSIC_EXTENSIONS: continue if os.path.isfile(os.path.join(music_dir, file_name)): tracks.append(file_name) return tracks def _resolve_level_music(self, level_index): level_number = level_index + 1 level_music_config = self.configs.get(config.LEVEL_MUSIC_CONFIG, {}) configured_tracks = level_music_config.get("levels", {}) configured_track = configured_tracks.get(str(level_number)) if configured_track in self.available_music_tracks: print(f"[audio] level {level_number} music={configured_track} source=config") return configured_track if configured_track: print(f"[audio] level {level_number} configured music missing: {configured_track}") if not self.available_music_tracks: print(f"[audio] no music tracks available for level {level_number}") return None fallback_track = random.choice(self.available_music_tracks) print(f"[audio] level {level_number} music={fallback_track} source=random") return fallback_track def _normalize_difficulty(self, difficulty_key): difficulty_key = config.DIFFICULTY_ALIASES.get(difficulty_key, difficulty_key) if difficulty_key in config.DIFFICULTY_OPTIONS_BY_KEY: return difficulty_key return config.DEFAULT_DIFFICULTY def _difficulty_config(self): return config.DIFFICULTY_OPTIONS_BY_KEY[self.difficulty] def _apply_difficulty(self, difficulty_key, persist=True): normalized_difficulty = self._normalize_difficulty(difficulty_key) difficulty_config = config.DIFFICULTY_OPTIONS_BY_KEY[normalized_difficulty] self.difficulty = normalized_difficulty self.initial_rat_count = max( 1, int(round(config.BASE_INITIAL_RATS * difficulty_config["starting_rats_multiplier"])), ) self.rat_speed_multiplier = difficulty_config["speed_multiplier"] if persist: self.profile_integration.set_setting("difficulty", normalized_difficulty) def _can_adjust_start_difficulty(self): if self.game_end[0]: return False return self.state_machine.current_state == GameState.START_MENU def _cycle_difficulty(self, delta): if not self._can_adjust_start_difficulty(): return current_index = 0 for index, option in enumerate(config.DIFFICULTY_OPTIONS): if option["key"] == self.difficulty: current_index = index break next_index = (current_index + delta) % len(config.DIFFICULTY_OPTIONS) self._apply_difficulty(config.DIFFICULTY_OPTIONS[next_index]["key"]) def _is_dat_campaign(self): return self.map.source_path.suffix.lower() == ".dat" def _is_last_dat_level(self): return self._is_dat_campaign() and self.current_level >= self.total_levels - 1 def _normalize_target_level(self, level_index): if self._is_dat_campaign(): return maze.normalize_level_index(level_index, self.total_levels) return 0 def _record_run_result(self, completed): if not self.run_recorded: self.scoring.save_score() self.profile_integration.update_game_stats(self.points, completed=completed) self.run_recorded = True self.combined_scores = self.profile_integration.get_device_leaderboard(5) def activate_debug_run_complete_dialog(self, score=None): if score is not None: self.points = max(0, int(score)) self.current_level = max(0, self.total_levels - 1) self.state_machine.transition_to(GameState.PAUSED) self.game_end = (True, config.GAME_END_RUN_COMPLETE) self.run_recorded = True self.combined_scores = self.profile_integration.get_device_leaderboard(5) print( f"[debug] showing run-complete dialog: level={self.current_level + 1}/{self.total_levels} " f"points={self.points}" ) def start_game(self): print( f"[flow] start_game: level={self.current_level + 1} " f"difficulty={self.difficulty} starting_rats={self.initial_rat_count} " f"rat_speed={int(self.rat_speed_multiplier * 100)}%" ) self.start_menu_animation_started_at = time.monotonic() self.current_level_music = self._resolve_level_music(self.current_level) self._valid_positions = None self.combined_scores = None self.run_recorded = False self.ammo = { "bomb": { "count": 2, "max": 8 }, "nuclear": { "count": 1, "max": 1 }, "mine": { "count": 2, "max": 4 }, "gas": { "count": 2, "max": 4 } } self.blood_stains = {} self.background_texture = None # Clear blood layer on game start/restart self.graphics.blood_layer_sprites.clear() self.graphics.cave_foreground_tiles.clear() self.game_end = (False, None) self.game_status = "start_menu" self.menu_screen = "start" self.units.clear() self.unit_positions.clear() self.unit_positions_before.clear() self.points = 0 self.pointer = (random.randint(1, self.map.width-2), random.randint(1, self.map.height-2)) self.graphics.scroll_cursor() for _ in range(self.initial_rat_count): self.unit_manager.spawn_rat() def load_level(self, level_index, preserve_points=True, show_menu=False, menu_screen=None): target_level_index = self._normalize_target_level(level_index) next_theme_index = target_level_index // 8 + 1 print( f"[flow] load_level requested: target_level={target_level_index + 1} " f"preserve_points={preserve_points} show_menu={show_menu} menu_screen={menu_screen} " f"current_points={self.points} next_theme={next_theme_index}" ) self.map = maze.Map(self.map_source, level_index=target_level_index) self.current_level = self.map.level_index self.total_levels = self.map.level_count self.current_level_music = self._resolve_level_music(self.current_level) self._valid_positions = None self.collision_system = CollisionSystem( self.cell_size, self.map.width, self.map.height ) if self.graphics.loaded_theme_index != next_theme_index: print( f"[flow] theme switch needed: loaded_theme={self.graphics.loaded_theme_index} " f"-> next_theme={next_theme_index}" ) self.graphics.load_assets() else: print(f"[flow] theme unchanged: reusing theme {next_theme_index}") self.units.clear() self.unit_positions.clear() self.unit_positions_before.clear() self.blood_stains = {} self.graphics.blood_layer_sprites.clear() self.graphics.cave_foreground_tiles.clear() self.background_texture = None self.ammo = { "bomb": {"count": 2, "max": 8}, "nuclear": {"count": 1, "max": 1}, "mine": {"count": 2, "max": 4}, "gas": {"count": 2, "max": 4}, } self.combined_scores = None self.game_end = (False, None) self.pointer = (random.randint(1, self.map.width-2), random.randint(1, self.map.height-2)) self.graphics.scroll_cursor() if not preserve_points: self.points = 0 self.run_recorded = False print("[flow] points reset for new run") print( f"[flow] spawning {self.initial_rat_count} rats for level={self.current_level + 1} " f"difficulty={self.difficulty}", flush=True, ) for _ in range(self.initial_rat_count): self.unit_manager.spawn_rat() if show_menu: if menu_screen == "start": self.state_machine.transition_to(GameState.START_MENU) else: self.state_machine.transition_to(GameState.PLAYING) print(f"[flow] level loaded into state: {self.state_machine.current_state} points={self.points}") else: self.state_machine.transition_to(GameState.PLAYING) print(f"[flow] level loaded directly into PLAYING: points={self.points}") def advance_level(self): print(f"[flow] advance_level called from level={self.current_level + 1} points={self.points}") if not self._is_dat_campaign(): self.load_level(self.current_level, preserve_points=True, show_menu=False) return if self._is_last_dat_level(): print("[flow] advance_level -> reached end of DAT campaign") self.game_end = (True, config.GAME_END_RUN_COMPLETE) self.state_machine.transition_to(GameState.VICTORY) self._record_run_result(completed=True) return next_level = self.current_level + 1 print(f"[flow] advancing to level={next_level + 1}") self.load_level(next_level, preserve_points=True, show_menu=False) def reset_game(self): print( f"[flow] reset_game called: game_end={self.game_end} state={self.state_machine.current_state} " f"menu_screen={self.menu_screen} points={self.points} level={self.current_level + 1}" ) if self.game_end[0]: if self.game_end[1] == config.GAME_END_LEVEL_CLEAR: print("[flow] reset_game -> post-victory path") self.advance_level() elif self.game_end[1] == config.GAME_END_RUN_COMPLETE: print("[flow] reset_game -> DAT run complete, returning to start menu") self.start_menu_animation_started_at = time.monotonic() self.load_level(0, preserve_points=False, show_menu=True, menu_screen="start") else: print("[flow] reset_game -> defeat, returning to start menu") self.start_menu_animation_started_at = time.monotonic() self.load_level(0, preserve_points=False, show_menu=True, menu_screen="start") return if self.state_machine.current_state == GameState.PAUSED: print("[flow] reset_game -> unpausing current level") self.state_machine.transition_to(GameState.PLAYING) return if self.state_machine.current_state == GameState.START_MENU: print(f"[flow] reset_game -> entering gameplay") self.state_machine.transition_to(GameState.PLAYING) return print("[flow] reset_game -> hard reload current level") self.load_level(self.current_level, preserve_points=False, show_menu=False) # ==================== GAME LOGIC ==================== def _can_adjust_audio_menu(self): if self.game_end[0]: return False return self.state_machine.current_state == GameState.PAUSED def _apply_volume_setting(self, setting_name, value): clamped = max(0, min(100, int(value))) setattr(self, setting_name, clamped) if setting_name == "sound_volume": self.render_engine.set_sound_volume(clamped) else: self.render_engine.set_music_volume(clamped) self.profile_integration.set_setting(setting_name, clamped) def menu_up(self): if self._can_adjust_start_difficulty(): self._cycle_difficulty(-1) return if not self._can_adjust_audio_menu(): return self.start_menu_selection = (self.start_menu_selection - 1) % len(config.START_MENU_AUDIO_OPTIONS) def menu_down(self): if self._can_adjust_start_difficulty(): self._cycle_difficulty(1) return if not self._can_adjust_audio_menu(): return self.start_menu_selection = (self.start_menu_selection + 1) % len(config.START_MENU_AUDIO_OPTIONS) def _adjust_selected_volume(self, delta): if not self._can_adjust_audio_menu(): return setting_name, _ = config.START_MENU_AUDIO_OPTIONS[self.start_menu_selection] current_value = getattr(self, setting_name) self._apply_volume_setting(setting_name, current_value + delta) def menu_left(self): if self._can_adjust_start_difficulty(): self._cycle_difficulty(-1) return self._adjust_selected_volume(-config.VOLUME_STEP) def menu_right(self): if self._can_adjust_start_difficulty(): self._cycle_difficulty(1) return self._adjust_selected_volume(config.VOLUME_STEP) def update_background_music(self): if self.game_end[0] and self.game_end[1] == config.GAME_END_RUN_COMPLETE: self.render_engine.play_music(config.RUN_COMPLETE_MUSIC, loop=True) return if self.state_machine.current_state == GameState.PLAYING and not self.game_end[0]: if self.current_level_music: self.render_engine.play_music(self.current_level_music, loop=True) return if self.state_machine.current_state == GameState.START_MENU and not self.game_end[0]: self.render_engine.play_music(config.START_MENU_MUSIC, loop=True) return self.render_engine.pause_music() def update_maze(self): self.update_background_music() # Handle non-playing states via state machine if self.state_machine.current_state != GameState.PLAYING: self.state_machine.update() return # Actual active gameplay logic if self.game_end[0]: if self.game_end[1] == config.GAME_END_DEFEAT: self.state_machine.transition_to(GameState.GAME_OVER) else: self.state_machine.transition_to(GameState.VICTORY) return if self.game_over(): return self.render_engine.delete_tag("unit") self.render_engine.delete_tag("effect") self.render_engine.delete_tag("cave") # Clear collision system and legacy dictionaries self.collision_system.clear() self.unit_positions.clear() self.unit_positions_before.clear() # Sort units by ID for deterministic execution sorted_units = sorted(self.units.values(), key=lambda u: int(u.id)) # Pass 1: MOVE and REGISTER for unit in sorted_units: # 1a. Move unit (logic) unit.move() # 1b. Register final position in collision system if unit.bbox == (0.0, 0.0, 0.0, 0.0): x_pos = unit.position[0] * self.cell_size y_pos = unit.position[1] * self.cell_size unit.bbox = (float(x_pos), float(y_pos), float(x_pos + self.cell_size), float(y_pos + self.cell_size)) self.collision_system.register_unit( unit.id, unit.bbox, unit.position, unit.position_before, unit.collision_layer ) # Maintain backward compatibility dictionaries self.unit_positions.setdefault(unit.position, []).append(unit) self.unit_positions_before.setdefault(unit.position_before, []).append(unit) # Pass 2: RESOLVE and DRAW for unit in sorted_units: unit.collisions() # Draw mobile units first so ground effects appear on top for unit in sorted_units: if not getattr(unit, "draw_on_top", False): unit.draw() # Draw top-layer effects on top of mobile units for unit in sorted_units: if getattr(unit, "draw_on_top", False) and not getattr(unit, "draw_last", False): unit.draw() # Draw tunnel cover overlay above units/effects but below cave foreground and points self.render_engine.draw_overlay_texture(self.graphics.tunnel_cover_texture, alpha=191) # Draw cave foreground (tunnel entrances) above the tunnel cover self.graphics.draw_cave_foreground() # Draw foreground/last-layer units (points) on top of everything for unit in sorted_units: if getattr(unit, "draw_last", False): unit.draw() self.render_engine.draw_pointer(self.pointer[0] * self.cell_size, self.pointer[1] * self.cell_size) self.render_engine.update_status(f"Mice: {self.unit_manager.count_rats()} - Points: {self.points}") self.unit_manager.refill_ammo() self.render_engine.update_ammo(self.ammo, self.graphics.assets) self.controls.scroll() self.render_engine.new_cycle(50, self.update_maze) def run(self): self.render_engine.mainloop(update=self.update_maze, bg_update=self.graphics.draw_maze) # ==================== GAME OVER LOGIC ==================== def game_over(self): if self.game_end[0]: if self.combined_scores is None: self.combined_scores = self.profile_integration.get_device_leaderboard(5) if self.game_end[1] == config.GAME_END_DEFEAT: self.render_engine.dialog( "Game Over: Mice are too many!", image=self.graphics.assets.get("lose", self.graphics.assets["BMP_WEWIN"]), subtitle=f"Reached level: {self.current_level + 1}\nPress Return to go back to the start menu", scores=self.combined_scores, ) elif self.game_end[1] == config.GAME_END_RUN_COMPLETE: self.render_engine.dialog( "THE END", image=self.graphics.assets.get("end", self.graphics.assets["BMP_WEWIN"]), current_score=self.points, style="run_complete", ) else: self.render_engine.dialog( f"Level {self.current_level + 1} Clear! Points: {self.points}", image=self.graphics.assets.get("clear", self.graphics.assets["BMP_WEWIN"]), subtitle="Press Return for the next level", scores=self.combined_scores ) return True count_rats = self.unit_manager.count_rats() if count_rats > 200: self.render_engine.stop_sound() self.render_engine.play_sound("WEWIN.WAV") self.game_end = (True, config.GAME_END_DEFEAT) self.state_machine.transition_to(GameState.GAME_OVER) print(f"[flow] defeat reached: rats={count_rats} points={self.points} level={self.current_level + 1}") self._record_run_result(completed=False) return True if not count_rats and not any(unit.type == UnitType.POINT for unit in self.units.values()): self.render_engine.stop_sound() self.render_engine.play_sound("VICTORY.WAV") if self._is_last_dat_level(): self.render_engine.play_sound("WELLDONE.WAV", tag="effects") self.game_end = (True, config.GAME_END_RUN_COMPLETE) self.state_machine.transition_to(GameState.VICTORY) self._record_run_result(completed=True) print(f"[flow] final DAT victory reached: points={self.points} level={self.current_level + 1}") else: self.game_end = (True, config.GAME_END_LEVEL_CLEAR) self.state_machine.transition_to(GameState.VICTORY) self.combined_scores = self.profile_integration.get_device_leaderboard(5) print(f"[flow] victory reached: points={self.points} level={self.current_level + 1}") return True def parse_args(): def parse_debug_score(value): try: parsed = float(str(value).strip()) except ValueError as exc: raise argparse.ArgumentTypeError(f"invalid int value: {value!r}") from exc if not parsed.is_integer(): raise argparse.ArgumentTypeError(f"invalid int value: {value!r}") return int(parsed) parser = argparse.ArgumentParser(description="Run Mice! with DAT or JSON map loading") parser.add_argument("--level", type=int, default=0, help="Level index to load from level.dat (default: 0)") parser.add_argument("--map", dest="map_path", default=None, help="Optional map path override (.dat or .json)") parser.add_argument( "--debug-run-complete-dialog", action="store_true", help="Start directly on the final run-complete dialog without saving a fake high score", ) parser.add_argument( "--debug-final-score", type=parse_debug_score, default=1125, help="Score shown by --debug-run-complete-dialog (default: 1125)", ) return parser.parse_args() if __name__ == "__main__": args = parse_args() print("Game starting...") map_source = args.map_path or maze.get_default_map_source() print(f"Loading map from {map_source} (level {args.level})") solver = MiceMaze(map_source, level_index=args.level) if args.debug_run_complete_dialog: solver.activate_debug_run_complete_dialog(score=args.debug_final_score) solver.run()