crimsonland 0.1.0.dev5__py3-none-any.whl

crimson/views/camera_shake.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+
+import pyray as rl
+
+from grim.config import ensure_crimson_cfg
+from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.view import View, ViewContext
+
+from ..bonuses import BonusId
+from ..creatures.spawn import CreatureInit, CreatureTypeId
+from ..game_world import GameWorld
+from ..gameplay import PlayerInput, bonus_apply
+from ..paths import default_runtime_dir
+from .registry import register_view
+
+
+WORLD_SIZE = 1024.0
+
+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)
+
+
+def _clamp(value: float, lo: float, hi: float) -> float:
+    if value < lo:
+        return lo
+    if value > hi:
+        return hi
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class _SpawnSpec:
+    r: float
+    angle_rad: float
+    type_id: CreatureTypeId
+    hp: float
+
+
+class CameraShakeView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._small: SmallFontData | None = None
+
+        runtime_dir = default_runtime_dir()
+        config = None
+        if runtime_dir.is_dir():
+            try:
+                config = ensure_crimson_cfg(runtime_dir)
+            except Exception:
+                config = None
+
+        self.close_requested = False
+        self._world = GameWorld(
+            assets_dir=self._assets_root,
+            world_size=WORLD_SIZE,
+            demo_mode_active=False,
+            difficulty_level=0,
+            hardcore=False,
+            texture_cache=None,
+            config=config,
+            audio=None,
+            audio_rng=None,
+        )
+        self._reflex_boost_locked = False
+        self._reset_scene()
+
+    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 _spawn_creature(self, *, world_x: float, world_y: float, type_id: CreatureTypeId, hp: float) -> None:
+        init = CreatureInit(
+            origin_template_id=0,
+            pos_x=_clamp(world_x, 64.0, WORLD_SIZE - 64.0),
+            pos_y=_clamp(world_y, 64.0, WORLD_SIZE - 64.0),
+            heading=math.pi,
+            phase_seed=0.0,
+            type_id=type_id,
+            health=float(hp),
+            max_health=float(hp),
+            move_speed=0.0,
+            reward_value=0.0,
+            size=50.0,
+            contact_damage=0.0,
+        )
+        self._world.creatures.spawn_init(init, rand=self._world.state.rng.rand)
+
+    def _reset_scene(self) -> None:
+        self._world.reset(seed=0xBEEF, player_count=1)
+        self._world.state.camera_shake_offset_x = 0.0
+        self._world.state.camera_shake_offset_y = 0.0
+        self._world.state.camera_shake_timer = 0.0
+        self._world.state.camera_shake_pulses = 0
+
+        player = self._world.players[0]
+        player.pos_x = WORLD_SIZE * 0.5
+        player.pos_y = WORLD_SIZE * 0.5
+
+        spawn = [
+            _SpawnSpec(r=140.0, angle_rad=0.0, type_id=CreatureTypeId.ZOMBIE, hp=50.0),
+            _SpawnSpec(r=160.0, angle_rad=math.pi * 0.5, type_id=CreatureTypeId.LIZARD, hp=60.0),
+            _SpawnSpec(r=180.0, angle_rad=math.pi, type_id=CreatureTypeId.ALIEN, hp=70.0),
+            _SpawnSpec(r=200.0, angle_rad=math.pi * 1.5, type_id=CreatureTypeId.SPIDER_SP1, hp=80.0),
+            _SpawnSpec(r=320.0, angle_rad=math.pi * 0.25, type_id=CreatureTypeId.SPIDER_SP2, hp=90.0),
+            _SpawnSpec(r=460.0, angle_rad=math.pi * 1.25, type_id=CreatureTypeId.ZOMBIE, hp=100.0),
+        ]
+        for entry in spawn:
+            x = player.pos_x + math.cos(entry.angle_rad) * entry.r
+            y = player.pos_y + math.sin(entry.angle_rad) * entry.r
+            self._spawn_creature(world_x=x, world_y=y, type_id=entry.type_id, hp=entry.hp)
+
+    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
+        self._world.open()
+
+    def close(self) -> None:
+        self._world.close()
+        if self._small is not None:
+            rl.unload_texture(self._small.texture)
+            self._small = None
+
+    def _handle_input(self) -> None:
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+            self.close_requested = True
+            return
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_R):
+            self._reset_scene()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_N):
+            player = self._world.players[0]
+            bonus_apply(
+                self._world.state,
+                player,
+                BonusId.NUKE,
+                origin=player,
+                creatures=self._world.creatures.entries,
+            )
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_T):
+            self._reflex_boost_locked = not self._reflex_boost_locked
+            self._world.state.bonuses.reflex_boost = 9999.0 if self._reflex_boost_locked else 0.0
+
+    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=bool(fire_down),
+            fire_pressed=bool(fire_pressed),
+            reload_pressed=bool(reload_pressed),
+        )
+
+    def update(self, dt: float) -> None:
+        self._handle_input()
+        if self._reflex_boost_locked:
+            self._world.state.bonuses.reflex_boost = 9999.0
+        self._world.update(dt, inputs=[self._build_input()], auto_pick_perks=True, perk_progression_enabled=False)
+
+    def draw(self) -> None:
+        self._world.draw()
+
+        if self._missing_assets:
+            message = "Missing assets: " + ", ".join(self._missing_assets)
+            self._draw_ui_text(message, 24, 24, UI_ERROR_COLOR)
+
+        state = self._world.state
+        cam_x, cam_y, _sx, _sy = self._world._world_params()
+        lines = [
+            "WASD move  N: nuke shake  T: toggle reflex-boost shake-rate  R: reset  Esc: exit",
+            f"camera_offset=({cam_x:.1f},{cam_y:.1f})  camera_raw=({self._world.camera_x:.1f},{self._world.camera_y:.1f})",
+            f"shake_offset=({state.camera_shake_offset_x:.1f},{state.camera_shake_offset_y:.1f})  "
+            f"shake_timer={state.camera_shake_timer:.3f}  pulses={state.camera_shake_pulses}",
+            f"reflex_boost={state.bonuses.reflex_boost:.2f}  creatures_alive={len(self._world.creatures.iter_active())}",
+        ]
+        x = 24.0
+        y = 24.0 + float(self._ui_line_height()) + 12.0
+        for idx, line in enumerate(lines):
+            color = UI_HINT_COLOR if idx == 0 else UI_TEXT_COLOR
+            self._draw_ui_text(line, x, y, color)
+            y += float(self._ui_line_height())
+
+
+@register_view("camera-shake", "Camera shake")
+def build_camera_shake_view(*, ctx: ViewContext) -> View:
+    return CameraShakeView(ctx)

crimson/views/corpse_stamp_debug.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import pyray as rl
+
+from crimson.creatures.anim import creature_corpse_frame_for_type
+from crimson.creatures.spawn import CreatureTypeId
+from grim.assets import resolve_asset_path
+from grim.config import ensure_crimson_cfg
+from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.terrain_render import GroundCorpseDecal, GroundRenderer, _maybe_alpha_test
+from grim.view import View, ViewContext
+
+from ..paths import default_runtime_dir
+from .registry import register_view
+
+
+WORLD_SIZE = 1024.0
+WINDOW_W = 1024
+WINDOW_H = 768
+
+BG = rl.Color(235, 235, 235, 255)
+UI_TEXT = rl.Color(20, 20, 20, 255)
+UI_HINT = rl.Color(70, 70, 70, 255)
+UI_ERROR = rl.Color(240, 80, 80, 255)
+
+
+@dataclass(frozen=True, slots=True)
+class _Step:
+    name: str
+    description: str
+
+
+_STEPS: tuple[_Step, ...] = (
+    _Step(name="clear", description="Clear the ground render target"),
+    _Step(name="shadow", description="Bake shadow pass only (correct order)"),
+    _Step(name="color", description="Bake color pass only (correct order)"),
+    _Step(name="clear", description="Clear the ground render target"),
+    _Step(name="color", description="Bake color pass only (wrong order)"),
+    _Step(name="shadow", description="Bake shadow pass only (wrong order)"),
+)
+
+
+class CorpseStampDebugView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._small: SmallFontData | None = None
+
+        self._owned_textures: list[rl.Texture] = []
+        self._ground: GroundRenderer | None = None
+        self._bodyset: rl.Texture | None = None
+
+        self.close_requested = False
+        self._step_index = 0
+        self._corpse_size = 256.0
+        self._corpse_rotation = 0.0
+        self._screenshot_requested = False
+        self._dump_requested = False
+        self._dump_index = 0
+
+    def _ui_line_height(self) -> int:
+        if self._small is not None:
+            return int(self._small.cell_size)
+        return 20
+
+    def _draw_ui_text(self, text: str, x: float, y: float, color: rl.Color) -> None:
+        if self._small is not None:
+            draw_small_text(self._small, text, x, y, 1.0, color)
+        else:
+            rl.draw_text(text, int(x), int(y), 20, color)
+
+    def _load_runtime_config(self) -> tuple[float, float | None, float | None]:
+        runtime_dir = default_runtime_dir()
+        if runtime_dir.is_dir():
+            try:
+                cfg = ensure_crimson_cfg(runtime_dir)
+                return float(cfg.texture_scale), float(cfg.screen_width), float(cfg.screen_height)
+            except Exception:
+                return 1.0, None, None
+        return 1.0, None, None
+
+    def _dump_render_target(self) -> Path | None:
+        ground = self._ground
+        if ground is None or ground.render_target is None:
+            return None
+
+        log_dir = Path("artifacts") / "debug"
+        try:
+            log_dir.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            log_dir = Path("artifacts")
+
+        step = _STEPS[self._step_index]
+        alpha_test = "a1" if bool(getattr(ground, "alpha_test", True)) else "a0"
+        filename = f"corpse_stamp_rt_{self._dump_index:03d}_step{self._step_index + 1:02d}_{step.name}_{alpha_test}.png"
+        out_path = log_dir / filename
+
+        image = rl.load_image_from_texture(ground.render_target.texture)
+        # Render textures are vertically flipped in raylib.
+        rl.image_flip_vertical(image)
+        try:
+            rl.export_image(image, str(out_path))
+        finally:
+            rl.unload_image(image)
+        self._dump_index += 1
+        return out_path
+
+    def _corpse_decal(self) -> GroundCorpseDecal:
+        size = float(self._corpse_size)
+        frame = creature_corpse_frame_for_type(int(CreatureTypeId.SPIDER_SP1))
+        cx = WORLD_SIZE * 0.5
+        cy = WORLD_SIZE * 0.5
+        return GroundCorpseDecal(
+            bodyset_frame=int(frame),
+            top_left_x=cx - size * 0.5,
+            top_left_y=cy - size * 0.5,
+            size=size,
+            rotation_rad=float(self._corpse_rotation),
+            tint=rl.Color(255, 255, 255, 255),
+        )
+
+    def _clear_ground(self) -> None:
+        ground = self._ground
+        if ground is None:
+            return
+        ground.create_render_target()
+        if ground.render_target is None:
+            return
+        rl.begin_texture_mode(ground.render_target)
+        rl.clear_background(BG)
+        rl.end_texture_mode()
+        # GroundRenderer treats this as an internal invariant; set it for debug fills.
+        ground._render_target_ready = True  # type: ignore[attr-defined]
+
+    def _bake_shadow_only(self) -> None:
+        ground = self._ground
+        bodyset = self._bodyset
+        if ground is None or bodyset is None:
+            return
+        ground.create_render_target()
+        if ground.render_target is None:
+            return
+
+        scale = ground._normalized_texture_scale()
+        inv_scale = 1.0 / scale
+        offset = 2.0 * scale / float(ground.width)
+        ground._set_texture_filters((bodyset,), point=True)
+
+        rl.begin_texture_mode(ground.render_target)
+        with _maybe_alpha_test(ground.alpha_test):
+            ground._draw_corpse_shadow_pass(bodyset, [self._corpse_decal()], inv_scale, offset)
+        rl.end_texture_mode()
+
+        ground._set_texture_filters((bodyset,), point=False)
+        ground._render_target_ready = True  # type: ignore[attr-defined]
+
+    def _bake_color_only(self) -> None:
+        ground = self._ground
+        bodyset = self._bodyset
+        if ground is None or bodyset is None:
+            return
+        ground.bake_corpse_decals(bodyset, [self._corpse_decal()], shadow=False)
+
+    def _apply_step(self) -> None:
+        step = _STEPS[self._step_index]
+        if step.name == "clear":
+            self._clear_ground()
+        elif step.name == "shadow":
+            self._bake_shadow_only()
+        elif step.name == "color":
+            self._bake_color_only()
+
+    def open(self) -> None:
+        rl.set_window_size(WINDOW_W, WINDOW_H)
+        self._missing_assets.clear()
+        self._owned_textures.clear()
+        self._ground = None
+        self._bodyset = None
+        self.close_requested = False
+        self._step_index = 0
+
+        try:
+            self._small = load_small_font(self._assets_root, self._missing_assets)
+        except Exception:
+            self._small = None
+
+        base_path = resolve_asset_path(self._assets_root, "ter/ter_q1_base.png")
+        bodyset_path = resolve_asset_path(self._assets_root, "game/bodyset.png")
+        if base_path is None:
+            self._missing_assets.append("ter/ter_q1_base.png")
+        if bodyset_path is None:
+            self._missing_assets.append("game/bodyset.png")
+        if self._missing_assets:
+            raise FileNotFoundError("Missing assets: " + ", ".join(self._missing_assets))
+
+        base = rl.load_texture(str(base_path))
+        bodyset = rl.load_texture(str(bodyset_path))
+        self._owned_textures.extend([base, bodyset])
+        self._bodyset = bodyset
+
+        texture_scale, screen_w, screen_h = self._load_runtime_config()
+        self._ground = GroundRenderer(
+            texture=base,
+            width=int(WORLD_SIZE),
+            height=int(WORLD_SIZE),
+            texture_scale=float(texture_scale),
+            screen_width=screen_w,
+            screen_height=screen_h,
+        )
+        self._ground.alpha_test = True
+        self._clear_ground()
+
+    def close(self) -> None:
+        if self._ground is not None and self._ground.render_target is not None:
+            rl.unload_render_texture(self._ground.render_target)
+            self._ground.render_target = None
+        self._ground = None
+        self._bodyset = None
+
+        for texture in self._owned_textures:
+            rl.unload_texture(texture)
+        self._owned_textures.clear()
+
+        if self._small is not None:
+            rl.unload_texture(self._small.texture)
+            self._small = None
+
+    def update(self, dt: float) -> None:
+        del dt
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+            self.close_requested = True
+            return
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_R):
+            self._step_index = 0
+            self._clear_ground()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_A):
+            if self._ground is not None:
+                self._ground.alpha_test = not bool(self._ground.alpha_test)
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_N) or rl.is_key_pressed(rl.KeyboardKey.KEY_SPACE):
+            self._step_index = (self._step_index + 1) % len(_STEPS)
+            self._apply_step()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_P):
+            self._screenshot_requested = True
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_D):
+            self._dump_requested = True
+
+        if rl.is_key_down(rl.KeyboardKey.KEY_Q):
+            self._corpse_rotation -= 0.04
+        if rl.is_key_down(rl.KeyboardKey.KEY_E):
+            self._corpse_rotation += 0.04
+
+    def consume_screenshot_request(self) -> bool:
+        requested = self._screenshot_requested
+        self._screenshot_requested = False
+        return requested
+
+    def draw(self) -> None:
+        rl.clear_background(BG)
+
+        if self._missing_assets:
+            self._draw_ui_text("Missing assets: " + ", ".join(self._missing_assets), 24, 24, UI_ERROR)
+            return
+
+        ground = self._ground
+        if ground is None:
+            self._draw_ui_text("Ground renderer not initialized.", 24, 24, UI_ERROR)
+            return
+
+        if self._dump_requested:
+            self._dump_requested = False
+            self._dump_render_target()
+
+        screen_w = float(rl.get_screen_width())
+        screen_h = float(rl.get_screen_height())
+        cam_x = screen_w * 0.5 - WORLD_SIZE * 0.5
+        cam_y = screen_h * 0.5 - WORLD_SIZE * 0.5
+        ground.draw(cam_x, cam_y, screen_w=screen_w, screen_h=screen_h)
+
+        # UI
+        x = 24.0
+        y = 20.0
+        line = float(self._ui_line_height())
+        step = _STEPS[self._step_index]
+        alpha_test = bool(getattr(ground, "alpha_test", True))
+        self._draw_ui_text("Corpse stamp debug (SPIDER)", x, y, UI_TEXT)
+        y += line
+        self._draw_ui_text(
+            "N/Space: next step   R: reset   A: toggle alpha test   Q/E: rotate   P: screenshot   D: dump RT",
+            x,
+            y,
+            UI_HINT,
+        )
+        y += line
+        self._draw_ui_text(f"step {self._step_index + 1}/{len(_STEPS)}: {step.description}", x, y, UI_HINT)
+        y += line
+        self._draw_ui_text(
+            f"alpha_test={'on' if alpha_test else 'off'}  size={self._corpse_size:.1f}  dump_index={self._dump_index}",
+            x,
+            y,
+            UI_HINT,
+        )
+
+        # Source preview (bodyset frame) in the corner for inspection.
+        if self._bodyset is not None:
+            frame = creature_corpse_frame_for_type(int(CreatureTypeId.SPIDER_SP1))
+            src = ground._corpse_src(self._bodyset, int(frame))
+            preview = 256.0
+            pad = 18.0
+            dst = rl.Rectangle(screen_w - preview - pad, pad, preview, preview)
+            rl.draw_rectangle(int(dst.x) - 2, int(dst.y) - 2, int(preview) + 4, int(preview) + 4, rl.Color(0, 0, 0, 30))
+            rl.draw_texture_pro(self._bodyset, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+
+
+@register_view("corpse-stamp-debug", "Corpse stamp debug")
+def build_corpse_stamp_debug_view(ctx: ViewContext) -> View:
+    return CorpseStampDebugView(ctx)