crimsonland 0.1.0.dev1__py3-none-any.whl

crimson/views/projectile_render_debug.py

@@ -0,0 +1,407 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+import random
+
+import pyray as rl
+
+from grim.audio import AudioState, init_audio_state, shutdown_audio
+from grim.config import ensure_crimson_cfg
+from grim.console import ConsoleLog, ConsoleState
+from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.view import View, ViewContext
+
+from ..game_world import GameWorld
+from ..gameplay import PlayerInput, player_update, weapon_assign_player
+from ..paths import default_runtime_dir
+from ..ui.cursor import draw_aim_cursor
+from ..weapons import WEAPON_TABLE
+from .registry import register_view
+
+
+WORLD_SIZE = 1024.0
+
+BG = rl.Color(10, 10, 12, 255)
+GRID_COLOR = rl.Color(255, 255, 255, 14)
+
+UI_TEXT = rl.Color(235, 235, 235, 255)
+UI_HINT = rl.Color(180, 180, 180, 255)
+UI_ERROR = rl.Color(240, 80, 80, 255)
+
+TARGET_FILL = rl.Color(220, 80, 80, 220)
+TARGET_OUTLINE = rl.Color(140, 40, 40, 255)
+
+
+@dataclass(slots=True)
+class TargetDummy:
+    x: float
+    y: float
+    hp: float
+    size: float = 56.0
+
+
+def _clamp(value: float, lo: float, hi: float) -> float:
+    if value < lo:
+        return lo
+    if value > hi:
+        return hi
+    return value
+
+
+class ProjectileRenderDebugView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._small: SmallFontData | None = None
+
+        self._world = GameWorld(
+            assets_dir=ctx.assets_dir,
+            world_size=WORLD_SIZE,
+            demo_mode_active=False,
+            difficulty_level=0,
+            hardcore=False,
+        )
+        self._player = self._world.players[0] if self._world.players else None
+        self._aim_texture: rl.Texture | None = None
+        self._audio: AudioState | None = None
+        self._audio_rng: random.Random | None = None
+        self._console: ConsoleState | None = None
+
+        self._weapon_ids = [entry.weapon_id for entry in WEAPON_TABLE if entry.name is not None]
+        self._weapon_index = 0
+
+        self._targets: list[TargetDummy] = []
+
+        self.close_requested = False
+        self._paused = False
+        self._screenshot_requested = False
+
+    def _ui_line_height(self, scale: float = 1.0) -> int:
+        if self._small is not None:
+            return int(self._small.cell_size * scale)
+        return int(20 * scale)
+
+    def _draw_ui_text(self, text: str, x: float, y: float, color: rl.Color, scale: float = 1.0) -> None:
+        if self._small is not None:
+            draw_small_text(self._small, text, x, y, scale, color)
+        else:
+            rl.draw_text(text, int(x), int(y), int(20 * scale), color)
+
+    def _selected_weapon_id(self) -> int:
+        if not self._weapon_ids:
+            return 0
+        return int(self._weapon_ids[self._weapon_index % len(self._weapon_ids)])
+
+    def _apply_weapon(self) -> None:
+        if self._player is None:
+            return
+        weapon_assign_player(self._player, self._selected_weapon_id())
+
+    def _reset_targets(self) -> None:
+        self._targets.clear()
+        base_x = WORLD_SIZE * 0.5
+        base_y = WORLD_SIZE * 0.5
+        ring = 260.0
+        for idx in range(10):
+            angle = float(idx) / 10.0 * math.tau
+            x = _clamp(base_x + math.cos(angle) * ring, 40.0, WORLD_SIZE - 40.0)
+            y = _clamp(base_y + math.sin(angle) * ring, 40.0, WORLD_SIZE - 40.0)
+            self._targets.append(TargetDummy(x=x, y=y, hp=260.0, size=64.0))
+
+    def _reset_scene(self) -> None:
+        self._world.reset(seed=0xBEEF, player_count=1, spawn_x=WORLD_SIZE * 0.5, spawn_y=WORLD_SIZE * 0.5)
+        self._player = self._world.players[0] if self._world.players else None
+        self._weapon_index = 0
+        self._apply_weapon()
+        self._reset_targets()
+        self._world.update_camera(0.0)
+
+    def _world_scale(self) -> float:
+        _cam_x, _cam_y, scale_x, scale_y = self._world._world_params()
+        return (scale_x + scale_y) * 0.5
+
+    def _draw_grid(self) -> None:
+        step = 64.0
+        out_w = float(rl.get_screen_width())
+        out_h = float(rl.get_screen_height())
+        screen_w, screen_h = self._world._camera_screen_size()
+        cam_x, cam_y, scale_x, scale_y = self._world._world_params()
+
+        start_x = math.floor((-cam_x) / step) * step
+        end_x = (-cam_x) + screen_w
+        x = start_x
+        while x <= end_x:
+            sx = int((x + cam_x) * scale_x)
+            rl.draw_line(sx, 0, sx, int(out_h), GRID_COLOR)
+            x += step
+
+        start_y = math.floor((-cam_y) / step) * step
+        end_y = (-cam_y) + screen_h
+        y = start_y
+        while y <= end_y:
+            sy = int((y + cam_y) * scale_y)
+            rl.draw_line(0, sy, int(out_w), sy, GRID_COLOR)
+            y += step
+
+    def _handle_debug_input(self) -> None:
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+            self.close_requested = True
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_SPACE):
+            self._paused = not self._paused
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_LEFT_BRACKET):
+            self._weapon_index = (self._weapon_index - 1) % max(1, len(self._weapon_ids))
+            self._apply_weapon()
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_RIGHT_BRACKET):
+            self._weapon_index = (self._weapon_index + 1) % max(1, len(self._weapon_ids))
+            self._apply_weapon()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_T):
+            self._reset_targets()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_BACKSPACE):
+            self._reset_scene()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_P):
+            self._screenshot_requested = True
+
+    def _build_input(self) -> PlayerInput:
+        move_x = 0.0
+        move_y = 0.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_A):
+            move_x -= 1.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_D):
+            move_x += 1.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_W):
+            move_y -= 1.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_S):
+            move_y += 1.0
+
+        mouse = rl.get_mouse_position()
+        aim_x, aim_y = self._world.screen_to_world(float(mouse.x), float(mouse.y))
+
+        fire_down = rl.is_mouse_button_down(rl.MouseButton.MOUSE_BUTTON_LEFT)
+        fire_pressed = rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT)
+        reload_pressed = rl.is_key_pressed(rl.KeyboardKey.KEY_R)
+
+        return PlayerInput(
+            move_x=move_x,
+            move_y=move_y,
+            aim_x=float(aim_x),
+            aim_y=float(aim_y),
+            fire_down=fire_down,
+            fire_pressed=fire_pressed,
+            reload_pressed=reload_pressed,
+        )
+
+    def open(self) -> None:
+        self._missing_assets.clear()
+        try:
+            self._small = load_small_font(self._assets_root, self._missing_assets)
+        except Exception:
+            self._small = None
+
+        runtime_dir = default_runtime_dir()
+        if runtime_dir.is_dir():
+            try:
+                self._world.config = ensure_crimson_cfg(runtime_dir)
+            except Exception:
+                self._world.config = None
+        else:
+            self._world.config = None
+
+        if self._world.config is not None:
+            try:
+                self._console = ConsoleState(
+                    base_dir=runtime_dir,
+                    log=ConsoleLog(base_dir=runtime_dir),
+                    assets_dir=self._assets_root,
+                )
+                self._audio = init_audio_state(self._world.config, self._assets_root, self._console)
+                self._audio_rng = random.Random(0xBEEF)
+                self._world.audio = self._audio
+                self._world.audio_rng = self._audio_rng
+            except Exception:
+                self._audio = None
+                self._audio_rng = None
+                self._console = None
+                self._world.audio = None
+                self._world.audio_rng = None
+
+        self._world.open()
+        self._aim_texture = self._world._load_texture(
+            "ui_aim",
+            cache_path="ui/ui_aim.jaz",
+            file_path="ui/ui_aim.png",
+        )
+        self._reset_scene()
+        rl.hide_cursor()
+
+    def close(self) -> None:
+        rl.show_cursor()
+        if self._small is not None:
+            rl.unload_texture(self._small.texture)
+            self._small = None
+        if self._audio is not None:
+            shutdown_audio(self._audio)
+            self._audio = None
+            self._audio_rng = None
+            self._console = None
+        self._world.audio = None
+        self._world.audio_rng = None
+        self._world.close()
+        self._aim_texture = None
+
+    def consume_screenshot_request(self) -> bool:
+        requested = self._screenshot_requested
+        self._screenshot_requested = False
+        return requested
+
+    def update(self, dt: float) -> None:
+        self._handle_debug_input()
+
+        if self._paused:
+            dt = 0.0
+
+        if self._world.ground is not None:
+            self._world._sync_ground_settings()
+            self._world.ground.process_pending()
+
+        if self._player is None:
+            return
+
+        prev_audio = None
+        if self._world.audio is not None:
+            prev_audio = (int(self._player.shot_seq), bool(self._player.reload_active), float(self._player.reload_timer))
+
+        # Keep the scene stable: targets are static, only projectiles + player advance.
+        hits = self._world.state.projectiles.update(
+            float(dt),
+            self._targets,
+            world_size=WORLD_SIZE,
+            damage_scale_by_type=self._world._damage_scale_by_type,
+            rng=self._world.state.rng.rand,
+            runtime_state=self._world.state,
+        )
+        self._world.state.secondary_projectiles.update_pulse_gun(float(dt), self._targets)
+        if hits:
+            self._world._queue_projectile_decals(hits)
+            self._world._play_hit_sfx(hits, game_mode=1)
+        self._targets = [target for target in self._targets if target.hp > 0.0]
+
+        input_state = self._build_input()
+        player_update(self._player, input_state, float(dt), self._world.state, world_size=WORLD_SIZE)
+
+        if prev_audio is not None:
+            prev_shot_seq, prev_reload_active, prev_reload_timer = prev_audio
+            self._world._handle_player_audio(
+                self._player,
+                prev_shot_seq=prev_shot_seq,
+                prev_reload_active=prev_reload_active,
+                prev_reload_timer=prev_reload_timer,
+            )
+
+        self._world._bake_fx_queues()
+        self._world.update_camera(float(dt))
+
+    def draw(self) -> None:
+        rl.clear_background(BG)
+
+        cam_x, cam_y, scale_x, scale_y = self._world._world_params()
+        screen_w, screen_h = self._world._camera_screen_size()
+
+        if self._world.ground is not None:
+            self._world.ground.draw(cam_x, cam_y, screen_w=screen_w, screen_h=screen_h)
+
+        warn_x = 24.0
+        warn_y = 24.0
+        warn_line = float(self._ui_line_height())
+        if self._missing_assets:
+            self._draw_ui_text("Missing assets (ui): " + ", ".join(self._missing_assets), warn_x, warn_y, UI_ERROR)
+            warn_y += warn_line
+        if self._world.missing_assets:
+            self._draw_ui_text(
+                "Missing assets (world): " + ", ".join(self._world.missing_assets),
+                warn_x,
+                warn_y,
+                UI_ERROR,
+            )
+            warn_y += warn_line
+
+        scale = self._world_scale()
+
+        self._draw_grid()
+
+        # Targets.
+        for target in self._targets:
+            sx, sy = self._world.world_to_screen(float(target.x), float(target.y))
+            radius = max(2.0, float(target.size) * 0.5 * scale)
+            rl.draw_circle(int(sx), int(sy), radius, TARGET_FILL)
+            rl.draw_circle_lines(int(sx), int(sy), int(max(1.0, radius)), TARGET_OUTLINE)
+
+        # Projectiles.
+        for proj in self._world.state.projectiles.iter_active():
+            self._world._draw_projectile(proj, scale=scale)
+        for proj in self._world.state.secondary_projectiles.iter_active():
+            self._world._draw_secondary_projectile(proj, scale=scale)
+
+        # Player.
+        player = self._player
+        if player is not None:
+            texture = self._world.creature_textures.get("trooper")
+            if texture is not None:
+                self._world._draw_player_trooper_sprite(
+                    texture,
+                    player,
+                    cam_x=cam_x,
+                    cam_y=cam_y,
+                    scale_x=scale_x,
+                    scale_y=scale_y,
+                    scale=scale,
+                )
+            else:
+                px, py = self._world.world_to_screen(float(player.pos_x), float(player.pos_y))
+                rl.draw_circle(int(px), int(py), max(1.0, 14.0 * scale), rl.Color(90, 190, 120, 255))
+
+        if player is not None and player.health > 0.0:
+            aim_x = float(getattr(player, "aim_x", player.pos_x))
+            aim_y = float(getattr(player, "aim_y", player.pos_y))
+            dist = math.hypot(aim_x - float(player.pos_x), aim_y - float(player.pos_y))
+            radius = max(6.0, dist * float(getattr(player, "spread_heat", 0.0)) * 0.5)
+            screen_radius = max(1.0, radius * scale)
+            aim_screen_x, aim_screen_y = self._world.world_to_screen(aim_x, aim_y)
+            self._world._draw_aim_circle(x=aim_screen_x, y=aim_screen_y, radius=screen_radius)
+
+        # UI.
+        x = 16.0
+        y = 12.0
+        line = float(self._ui_line_height())
+
+        weapon_id = int(player.weapon_id) if player is not None else 0
+        weapon_name = next((w.name for w in WEAPON_TABLE if w.weapon_id == weapon_id), None) or f"weapon_{weapon_id}"
+        self._draw_ui_text("Projectile render debug", x, y, UI_TEXT)
+        y += line
+        self._draw_ui_text(f"{weapon_name} (weapon_id={weapon_id})", x, y, UI_TEXT)
+        y += line
+        if player is not None:
+            self._draw_ui_text(
+                f"ammo {player.ammo}/{player.clip_size}  reload {player.reload_timer:.2f}/{player.reload_timer_max:.2f}",
+                x,
+                y,
+                UI_TEXT,
+            )
+            y += line
+        y += 6.0
+        self._draw_ui_text("WASD move  LMB fire  R reload  [/] cycle weapons  Space pause  P screenshot", x, y, UI_HINT)
+        y += line
+        self._draw_ui_text("T reset targets  Backspace reset scene  Esc quit", x, y, UI_HINT)
+
+        mouse = rl.get_mouse_position()
+        draw_aim_cursor(self._world.particles_texture, self._aim_texture, x=float(mouse.x), y=float(mouse.y))
+
+
+@register_view("projectile-render-debug", "Projectile render debug")
+def build_projectile_render_debug_view(ctx: ViewContext) -> View:
+    return ProjectileRenderDebugView(ctx)

crimson/views/projectiles.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pyray as rl
+
+from .registry import register_view
+from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.view import View, ViewContext
+
+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)
+UI_KNOWN_COLOR = rl.Color(80, 160, 240, 255)
+UI_HOVER_COLOR = rl.Color(240, 200, 80, 255)
+
+
+@dataclass(frozen=True, slots=True)
+class KnownProjectile:
+    type_id: int
+    grid: int
+    frame: int
+    label: str
+
+
+KNOWN_PROJECTILES = [
+    KnownProjectile(type_id=0x13, grid=2, frame=0, label="Pulse Gun"),
+    KnownProjectile(type_id=0x1D, grid=4, frame=3, label="Splitter Gun"),
+    KnownProjectile(type_id=0x19, grid=4, frame=6, label="Blade Gun"),
+    KnownProjectile(type_id=0x15, grid=4, frame=2, label="Ion Rifle"),
+    KnownProjectile(type_id=0x16, grid=4, frame=2, label="Ion Minigun"),
+    KnownProjectile(type_id=0x17, grid=4, frame=2, label="Ion Cannon"),
+    KnownProjectile(type_id=0x18, grid=4, frame=2, label="Shrinkifier 5k"),
+    KnownProjectile(type_id=0x2D, grid=4, frame=2, label="Fire Bullets"),
+]
+
+
+def _build_known_map() -> dict[int, dict[int, list[KnownProjectile]]]:
+    known: dict[int, dict[int, list[KnownProjectile]]] = {}
+    for entry in KNOWN_PROJECTILES:
+        grid_map = known.setdefault(entry.grid, {})
+        grid_map.setdefault(entry.frame, []).append(entry)
+    return known
+
+
+KNOWN_BY_GRID = _build_known_map()
+
+
+class ProjectileView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._texture: rl.Texture | None = None
+        self._small: SmallFontData | None = None
+        self._grid = 4
+
+    def _ui_line_height(self, scale: float = UI_TEXT_SCALE) -> int:
+        if self._small is not None:
+            return int(self._small.cell_size * scale)
+        return int(20 * scale)
+
+    def _draw_ui_text(
+        self,
+        text: str,
+        x: float,
+        y: float,
+        color: rl.Color,
+        scale: float = UI_TEXT_SCALE,
+    ) -> None:
+        if self._small is not None:
+            draw_small_text(self._small, text, x, y, scale, color)
+        else:
+            rl.draw_text(text, int(x), int(y), int(20 * scale), color)
+
+    def open(self) -> None:
+        self._missing_assets.clear()
+        self._small = load_small_font(self._assets_root, self._missing_assets)
+        path = self._assets_root / "crimson" / "game" / "projs.png"
+        if not path.is_file():
+            self._missing_assets.append("game/projs.png")
+            raise FileNotFoundError(f"Missing asset: {path}")
+        self._texture = rl.load_texture(str(path))
+
+    def close(self) -> None:
+        if self._texture is not None:
+            rl.unload_texture(self._texture)
+            self._texture = None
+        if self._small is not None:
+            rl.unload_texture(self._small.texture)
+            self._small = None
+
+    def update(self, dt: float) -> None:
+        del dt
+
+    def _handle_input(self) -> None:
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_TWO):
+            self._grid = 2
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_FOUR):
+            self._grid = 4
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_G):
+            self._grid = 2 if self._grid == 4 else 4
+
+    def draw(self) -> None:
+        rl.clear_background(rl.Color(12, 12, 14, 255))
+        if self._missing_assets:
+            message = "Missing assets: " + ", ".join(self._missing_assets)
+            self._draw_ui_text(message, 24, 24, UI_ERROR_COLOR)
+            return
+        if self._texture is None:
+            self._draw_ui_text("No projectile texture loaded.", 24, 24, UI_TEXT_COLOR)
+            return
+
+        self._handle_input()
+
+        margin = 24
+        panel_gap = 32
+        panel_width = min(360, int(rl.get_screen_width() * 0.35))
+        available_width = rl.get_screen_width() - margin * 2 - panel_gap - panel_width
+        available_height = rl.get_screen_height() - margin * 2 - 60
+        scale = min(
+            2.0,
+            available_width / self._texture.width,
+            available_height / self._texture.height,
+        )
+        draw_w = self._texture.width * scale
+        draw_h = self._texture.height * scale
+        x = margin
+        y = margin + 60
+
+        src = rl.Rectangle(0.0, 0.0, float(self._texture.width), float(self._texture.height))
+        dst = rl.Rectangle(float(x), float(y), float(draw_w), float(draw_h))
+        rl.draw_texture_pro(self._texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+
+        cell_w = draw_w / self._grid
+        cell_h = draw_h / self._grid
+        for i in range(1, self._grid):
+            rl.draw_line(
+                int(x + i * cell_w),
+                int(y),
+                int(x + i * cell_w),
+                int(y + draw_h),
+                rl.Color(60, 60, 70, 255),
+            )
+            rl.draw_line(
+                int(x),
+                int(y + i * cell_h),
+                int(x + draw_w),
+                int(y + i * cell_h),
+                rl.Color(60, 60, 70, 255),
+            )
+
+        known_frames = KNOWN_BY_GRID.get(self._grid, {})
+        for frame_index in known_frames:
+            row = frame_index // self._grid
+            col = frame_index % self._grid
+            hl = rl.Rectangle(
+                float(x + col * cell_w),
+                float(y + row * cell_h),
+                float(cell_w),
+                float(cell_h),
+            )
+            rl.draw_rectangle_lines_ex(hl, 2, UI_KNOWN_COLOR)
+
+        hovered_index = None
+        mouse = rl.get_mouse_position()
+        if x <= mouse.x <= x + draw_w and y <= mouse.y <= y + draw_h:
+            col = int((mouse.x - x) // cell_w)
+            row = int((mouse.y - y) // cell_h)
+            if 0 <= col < self._grid and 0 <= row < self._grid:
+                hovered_index = row * self._grid + col
+                hl = rl.Rectangle(
+                    float(x + col * cell_w),
+                    float(y + row * cell_h),
+                    float(cell_w),
+                    float(cell_h),
+                )
+                rl.draw_rectangle_lines_ex(hl, 3, UI_HOVER_COLOR)
+
+        info_x = x + draw_w + panel_gap
+        info_y = margin
+        self._draw_ui_text(
+            f"projs.png (grid {self._grid}x{self._grid})",
+            info_x,
+            info_y,
+            UI_TEXT_COLOR,
+        )
+        info_y += self._ui_line_height() + 6
+        self._draw_ui_text("2/4: grid  G: toggle", info_x, info_y, UI_HINT_COLOR)
+        info_y += self._ui_line_height() + 12
+
+        if hovered_index is not None:
+            self._draw_ui_text(f"frame {hovered_index:02d}", info_x, info_y, UI_TEXT_COLOR)
+            info_y += self._ui_line_height() + 6
+            entries = known_frames.get(hovered_index, [])
+            if entries:
+                for entry in entries:
+                    self._draw_ui_text(
+                        f"0x{entry.type_id:02x} {entry.label}",
+                        info_x,
+                        info_y,
+                        UI_TEXT_COLOR,
+                    )
+                    info_y += self._ui_line_height() + 4
+            else:
+                self._draw_ui_text("no known mapping", info_x, info_y, UI_HINT_COLOR)
+                info_y += self._ui_line_height() + 4
+            info_y += 8
+
+        self._draw_ui_text("Known frames", info_x, info_y, UI_TEXT_COLOR)
+        info_y += self._ui_line_height() + 6
+        for frame_index in sorted(known_frames.keys()):
+            entries = known_frames[frame_index]
+            labels = ", ".join(f"0x{entry.type_id:02x} {entry.label}" for entry in entries)
+            self._draw_ui_text(f"{frame_index:02d}: {labels}", info_x, info_y, UI_HINT_COLOR)
+            info_y += self._ui_line_height() + 4
+
+
+@register_view("projectiles", "Projectile atlas preview")
+def build_projectile_view(ctx: ViewContext) -> View:
+    return ProjectileView(ctx)