crimsonland 0.1.0.dev5__py3-none-any.whl

crimson/modes/rush_mode.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import random
+
+import pyray as rl
+
+from grim.assets import PaqTextureCache
+from grim.audio import AudioState
+from grim.config import CrimsonConfig
+from grim.view import ViewContext
+
+from ..creatures.spawn import tick_rush_mode_spawns
+from ..game_modes import GameMode
+from ..gameplay import PlayerInput, most_used_weapon_id_for_player, weapon_assign_player
+from ..input_codes import config_keybinds, input_code_is_down, input_code_is_pressed, player_move_fire_binds
+from ..persistence.highscores import HighScoreRecord
+from ..ui.cursor import draw_aim_cursor, draw_menu_cursor
+from ..ui.hud import draw_hud_overlay
+from ..ui.perk_menu import load_perk_menu_assets
+from .base_gameplay_mode import BaseGameplayMode
+
+WORLD_SIZE = 1024.0
+RUSH_WEAPON_ID = 2
+
+UI_TEXT_SCALE = 1.0
+UI_TEXT_COLOR = rl.Color(220, 220, 220, 255)
+UI_HINT_COLOR = rl.Color(140, 140, 140, 255)
+UI_ERROR_COLOR = rl.Color(240, 80, 80, 255)
+
+
+@dataclass(slots=True)
+class _RushState:
+    elapsed_ms: float = 0.0
+    spawn_cooldown_ms: float = 0.0
+
+
+class RushMode(BaseGameplayMode):
+    def __init__(
+        self,
+        ctx: ViewContext,
+        *,
+        texture_cache: PaqTextureCache | None = None,
+        config: CrimsonConfig | None = None,
+        audio: AudioState | None = None,
+        audio_rng: random.Random | None = None,
+    ) -> None:
+        super().__init__(
+            ctx,
+            world_size=WORLD_SIZE,
+            default_game_mode_id=int(GameMode.RUSH),
+            demo_mode_active=False,
+            difficulty_level=0,
+            hardcore=False,
+            texture_cache=texture_cache,
+            config=config,
+            audio=audio,
+            audio_rng=audio_rng,
+        )
+        self._rush = _RushState()
+
+        self._ui_assets = None
+
+    def _enforce_rush_loadout(self) -> None:
+        for player in self._world.players:
+            if int(player.weapon_id) != RUSH_WEAPON_ID:
+                weapon_assign_player(player, RUSH_WEAPON_ID)
+            # `rush_mode_update` forces weapon+ammo every frame; keep ammo topped up.
+            player.ammo = float(max(0, int(player.clip_size)))
+
+    def open(self) -> None:
+        super().open()
+        self._ui_assets = load_perk_menu_assets(self._assets_root)
+        if self._ui_assets.missing:
+            self._missing_assets.extend(self._ui_assets.missing)
+        self._rush = _RushState()
+        self._enforce_rush_loadout()
+
+    def close(self) -> None:
+        if self._ui_assets is not None:
+            self._ui_assets = None
+        super().close()
+
+    def _handle_input(self) -> None:
+        if self._game_over_active:
+            if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+                self._action = "back_to_menu"
+                self.close_requested = True
+            return
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_TAB):
+            self._paused = not self._paused
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+            self.close_requested = True
+
+    def _build_input(self) -> PlayerInput:
+        keybinds = config_keybinds(self._config)
+        if not keybinds:
+            keybinds = (0x11, 0x1F, 0x1E, 0x20, 0x100)
+        up_key, down_key, left_key, right_key, fire_key = player_move_fire_binds(keybinds, 0)
+
+        move_x = 0.0
+        move_y = 0.0
+        if input_code_is_down(left_key):
+            move_x -= 1.0
+        if input_code_is_down(right_key):
+            move_x += 1.0
+        if input_code_is_down(up_key):
+            move_y -= 1.0
+        if input_code_is_down(down_key):
+            move_y += 1.0
+
+        mouse = self._ui_mouse_pos()
+        aim_x, aim_y = self._world.screen_to_world(float(mouse.x), float(mouse.y))
+
+        fire_down = input_code_is_down(fire_key)
+        fire_pressed = input_code_is_pressed(fire_key)
+
+        return PlayerInput(
+            move_x=move_x,
+            move_y=move_y,
+            aim_x=float(aim_x),
+            aim_y=float(aim_y),
+            fire_down=bool(fire_down),
+            fire_pressed=bool(fire_pressed),
+            reload_pressed=False,
+        )
+
+    def _player_name_default(self) -> str:
+        config = self._config
+        if config is None:
+            return ""
+        raw = config.data.get("player_name")
+        if isinstance(raw, (bytes, bytearray)):
+            return bytes(raw).split(b"\x00", 1)[0].decode("latin-1", errors="ignore")
+        if isinstance(raw, str):
+            return raw
+        return ""
+
+    def _enter_game_over(self) -> None:
+        if self._game_over_active:
+            return
+
+        record = HighScoreRecord.blank()
+        record.score_xp = int(self._player.experience)
+        record.survival_elapsed_ms = int(self._rush.elapsed_ms)
+        record.creature_kill_count = int(self._creatures.kill_count)
+        weapon_id = most_used_weapon_id_for_player(self._state, player_index=int(self._player.index), fallback_weapon_id=int(self._player.weapon_id))
+        record.most_used_weapon_id = int(weapon_id)
+        fired = 0
+        hit = 0
+        try:
+            fired = int(self._state.shots_fired[int(self._player.index)])
+            hit = int(self._state.shots_hit[int(self._player.index)])
+        except Exception:
+            fired = 0
+            hit = 0
+        fired = max(0, int(fired))
+        hit = max(0, min(int(hit), fired))
+        record.shots_fired = fired
+        record.shots_hit = hit
+        record.game_mode_id = int(self._config.data.get("game_mode", int(GameMode.RUSH))) if self._config is not None else int(GameMode.RUSH)
+
+        self._game_over_record = record
+        self._game_over_ui.open()
+        self._game_over_active = True
+
+    def update(self, dt: float) -> None:
+        self._update_audio(dt)
+
+        dt_frame = self._tick_frame(dt)[0]
+        self._handle_input()
+
+        if self._game_over_active:
+            record = self._game_over_record
+            if record is None:
+                self._enter_game_over()
+                record = self._game_over_record
+            if record is not None:
+                action = self._game_over_ui.update(
+                    dt,
+                    record=record,
+                    player_name_default=self._player_name_default(),
+                    play_sfx=self._world.audio_router.play_sfx,
+                    rand=self._state.rng.rand,
+                    mouse=self._ui_mouse_pos(),
+                )
+                if action == "play_again":
+                    self.open()
+                    return
+                if action == "high_scores":
+                    self._action = "open_high_scores"
+                    return
+                if action == "main_menu":
+                    self._action = "back_to_menu"
+                    self.close_requested = True
+            return
+
+        any_alive = any(player.health > 0.0 for player in self._world.players)
+        dt_world = 0.0 if self._paused or (not any_alive) else dt_frame
+
+        self._rush.elapsed_ms += dt_world * 1000.0
+        if dt_world <= 0.0:
+            if not any_alive:
+                self._enter_game_over()
+            return
+
+        self._enforce_rush_loadout()
+        input_state = self._build_input()
+        self._world.update(
+            dt_world,
+            inputs=[input_state for _ in self._world.players],
+            auto_pick_perks=False,
+            game_mode=int(GameMode.RUSH),
+            perk_progression_enabled=False,
+        )
+
+        cooldown, spawns = tick_rush_mode_spawns(
+            self._rush.spawn_cooldown_ms,
+            dt_world * 1000.0,
+            self._state.rng,
+            player_count=len(self._world.players),
+            survival_elapsed_ms=int(self._rush.elapsed_ms),
+            terrain_width=float(self._world.world_size),
+            terrain_height=float(self._world.world_size),
+        )
+        self._rush.spawn_cooldown_ms = cooldown
+        self._creatures.spawn_inits(spawns)
+
+        if not any(player.health > 0.0 for player in self._world.players):
+            self._enter_game_over()
+
+    def _draw_game_cursor(self) -> None:
+        mouse_x = float(self._ui_mouse_x)
+        mouse_y = float(self._ui_mouse_y)
+        cursor_tex = self._ui_assets.cursor if self._ui_assets is not None else None
+        draw_menu_cursor(
+            self._world.particles_texture,
+            cursor_tex,
+            x=mouse_x,
+            y=mouse_y,
+            pulse_time=float(self._cursor_pulse_time),
+        )
+
+    def _draw_aim_cursor(self) -> None:
+        mouse_x = float(self._ui_mouse_x)
+        mouse_y = float(self._ui_mouse_y)
+        aim_tex = self._ui_assets.aim if self._ui_assets is not None else None
+        draw_aim_cursor(self._world.particles_texture, aim_tex, x=mouse_x, y=mouse_y)
+
+    def draw(self) -> None:
+        self._world.draw(draw_aim_indicators=(not self._game_over_active))
+        self._draw_screen_fade()
+
+        hud_bottom = 0.0
+        if (not self._game_over_active) and self._hud_assets is not None:
+            hud_bottom = draw_hud_overlay(
+                self._hud_assets,
+                player=self._player,
+                players=self._world.players,
+                bonus_hud=self._state.bonus_hud,
+                elapsed_ms=self._rush.elapsed_ms,
+                font=self._small,
+                frame_dt_ms=self._last_dt_ms,
+                show_xp=False,
+                show_time=True,
+            )
+
+        if not self._game_over_active:
+            x = 18.0
+            y = max(18.0, hud_bottom + 10.0)
+            line = float(self._ui_line_height())
+            self._draw_ui_text(f"rush: t={self._rush.elapsed_ms/1000.0:6.1f}s", x, y, UI_TEXT_COLOR)
+            self._draw_ui_text(f"kills={self._creatures.kill_count}", x, y + line, UI_HINT_COLOR)
+            if self._paused:
+                self._draw_ui_text("paused (TAB)", x, y + line * 2.0, UI_HINT_COLOR)
+            if self._player.health <= 0.0:
+                self._draw_ui_text("game over", x, y + line * 2.0, UI_ERROR_COLOR)
+
+        warn_y = float(rl.get_screen_height()) - 28.0
+        if self._world.missing_assets:
+            warn = "Missing world assets: " + ", ".join(self._world.missing_assets)
+            self._draw_ui_text(warn, 24.0, warn_y, UI_ERROR_COLOR, scale=0.8)
+            warn_y -= float(self._ui_line_height(scale=0.8)) + 2.0
+        if self._hud_missing:
+            warn = "Missing HUD assets: " + ", ".join(self._hud_missing)
+            self._draw_ui_text(warn, 24.0, warn_y, UI_ERROR_COLOR, scale=0.8)
+
+        if not self._game_over_active:
+            self._draw_aim_cursor()
+        else:
+            self._draw_game_cursor()
+            if self._game_over_record is not None:
+                self._game_over_ui.draw(
+                    record=self._game_over_record,
+                    banner_kind=self._game_over_banner,
+                    hud_assets=self._hud_assets,
+                    mouse=self._ui_mouse_pos(),
+                )