crimsonland 0.1.0.dev14__py3-none-any.whl → 0.1.0.dev16__py3-none-any.whl

crimson/game.py

@@ -38,7 +38,7 @@ from grim.terrain_render import GroundRenderer
 from grim.view import View, ViewContext
 from grim.fonts.small import SmallFontData, draw_small_text, load_small_font, measure_small_text_width
 
-from .debug import debug_enabled
+from .debug import debug_enabled, set_debug_enabled
 from grim import music
 
 from .demo import DemoView
@@ -57,12 +57,78 @@ from .frontend.high_scores_layout import (
     HS_BUTTON_STEP_Y,
     HS_BUTTON_X,
     HS_BUTTON_Y0,
+    HS_LOCAL_DATE_X,
+    HS_LOCAL_DATE_Y,
+    HS_LOCAL_FRAGS_X,
+    HS_LOCAL_FRAGS_Y,
+    HS_LOCAL_HIT_X,
+    HS_LOCAL_HIT_Y,
+    HS_LOCAL_LABEL_X,
+    HS_LOCAL_LABEL_Y,
+    HS_LOCAL_NAME_X,
+    HS_LOCAL_NAME_Y,
+    HS_LOCAL_RANK_X,
+    HS_LOCAL_RANK_Y,
+    HS_LOCAL_SCORE_LABEL_X,
+    HS_LOCAL_SCORE_LABEL_Y,
+    HS_LOCAL_SCORE_VALUE_X,
+    HS_LOCAL_SCORE_VALUE_Y,
+    HS_LOCAL_TIME_LABEL_X,
+    HS_LOCAL_TIME_LABEL_Y,
+    HS_LOCAL_TIME_VALUE_X,
+    HS_LOCAL_TIME_VALUE_Y,
+    HS_LOCAL_WEAPON_X,
+    HS_LOCAL_WEAPON_Y,
+    HS_LOCAL_WICON_X,
+    HS_LOCAL_WICON_Y,
     HS_LEFT_PANEL_HEIGHT,
     HS_LEFT_PANEL_POS_X,
     HS_LEFT_PANEL_POS_Y,
+    HS_QUEST_ARROW_X,
+    HS_QUEST_ARROW_Y,
+    HS_RIGHT_CHECK_X,
+    HS_RIGHT_CHECK_Y,
     HS_RIGHT_PANEL_HEIGHT,
     HS_RIGHT_PANEL_POS_X,
     HS_RIGHT_PANEL_POS_Y,
+    HS_RIGHT_GAME_MODE_DROP_X,
+    HS_RIGHT_GAME_MODE_DROP_Y,
+    HS_RIGHT_GAME_MODE_VALUE_X,
+    HS_RIGHT_GAME_MODE_VALUE_Y,
+    HS_RIGHT_GAME_MODE_WIDGET_W,
+    HS_RIGHT_GAME_MODE_WIDGET_X,
+    HS_RIGHT_GAME_MODE_WIDGET_Y,
+    HS_RIGHT_GAME_MODE_X,
+    HS_RIGHT_GAME_MODE_Y,
+    HS_RIGHT_NUMBER_PLAYERS_X,
+    HS_RIGHT_NUMBER_PLAYERS_Y,
+    HS_RIGHT_PLAYER_COUNT_DROP_X,
+    HS_RIGHT_PLAYER_COUNT_DROP_Y,
+    HS_RIGHT_PLAYER_COUNT_VALUE_X,
+    HS_RIGHT_PLAYER_COUNT_VALUE_Y,
+    HS_RIGHT_PLAYER_COUNT_WIDGET_W,
+    HS_RIGHT_PLAYER_COUNT_WIDGET_X,
+    HS_RIGHT_PLAYER_COUNT_WIDGET_Y,
+    HS_RIGHT_SCORE_LIST_DROP_X,
+    HS_RIGHT_SCORE_LIST_DROP_Y,
+    HS_RIGHT_SCORE_LIST_VALUE_X,
+    HS_RIGHT_SCORE_LIST_VALUE_Y,
+    HS_RIGHT_SCORE_LIST_WIDGET_W,
+    HS_RIGHT_SCORE_LIST_WIDGET_X,
+    HS_RIGHT_SCORE_LIST_WIDGET_Y,
+    HS_RIGHT_SCORE_LIST_X,
+    HS_RIGHT_SCORE_LIST_Y,
+    HS_RIGHT_SHOW_INTERNET_X,
+    HS_RIGHT_SHOW_INTERNET_Y,
+    HS_RIGHT_SHOW_SCORES_DROP_X,
+    HS_RIGHT_SHOW_SCORES_DROP_Y,
+    HS_RIGHT_SHOW_SCORES_VALUE_X,
+    HS_RIGHT_SHOW_SCORES_VALUE_Y,
+    HS_RIGHT_SHOW_SCORES_WIDGET_W,
+    HS_RIGHT_SHOW_SCORES_WIDGET_X,
+    HS_RIGHT_SHOW_SCORES_WIDGET_Y,
+    HS_RIGHT_SHOW_SCORES_X,
+    HS_RIGHT_SHOW_SCORES_Y,
 )
 from .frontend.menu import (
     MENU_PANEL_HEIGHT,
@@ -113,6 +179,7 @@ class GameConfig:
     seed: int | None = None
     demo_enabled: bool = False
     no_intro: bool = False
+    debug: bool = False
 
 
 @dataclass(slots=True)
@@ -190,6 +257,25 @@ QUEST_BACK_BUTTON_X_OFFSET = 138.0
 QUEST_BACK_BUTTON_Y_OFFSET = 212.0
 QUEST_PANEL_HEIGHT = 378.0
 
+# game_update_victory_screen (0x00406350): used as the "end note" screen after the final quest.
+END_NOTE_PANEL_POS_X = -45.0
+END_NOTE_PANEL_POS_Y = 110.0
+END_NOTE_PANEL_GEOM_X0 = -63.0
+END_NOTE_PANEL_GEOM_Y0 = -81.0
+END_NOTE_PANEL_W = 510.0
+END_NOTE_PANEL_H = 378.0
+
+END_NOTE_HEADER_X_OFFSET = 214.0  # v11 + 44 - 10 in the decompile, relative to panel-left
+END_NOTE_HEADER_Y_OFFSET = 46.0  # (base_y + 40) + 6 in the decompile, relative to panel-top
+END_NOTE_BODY_X_OFFSET = END_NOTE_HEADER_X_OFFSET - 8.0
+END_NOTE_BODY_Y_GAP = 32.0
+END_NOTE_LINE_STEP_Y = 14.0
+END_NOTE_AFTER_BODY_Y_GAP = 22.0  # 14 + 8 in the decompile
+
+END_NOTE_BUTTON_X_OFFSET = 266.0  # (v11 + 44 + 20) - 4 + 26, relative to panel-left
+END_NOTE_BUTTON_Y_OFFSET = 210.0  # (base_y + 40) + 170 in the decompile, relative to panel-top
+END_NOTE_BUTTON_STEP_Y = 32.0
+
 
 class QuestsMenuView:
     """Quest selection menu.
@@ -282,6 +368,7 @@ class QuestsMenuView:
         self._cursor_pulse_time += min(dt, 0.1) * 1.1
 
         config = self._state.config
+        status = self._state.status
 
         # The original forcibly clears hardcore in the demo build.
         if self._state.demo_enabled:
@@ -289,6 +376,14 @@ class QuestsMenuView:
                 config.data["hardcore_flag"] = 0
                 self._dirty = True
 
+        if debug_enabled() and rl.is_key_pressed(rl.KeyboardKey.KEY_F5):
+            unlock = 49
+            if int(status.quest_unlock_index) < unlock:
+                status.quest_unlock_index = unlock
+            if int(status.quest_unlock_index_full) < unlock:
+                status.quest_unlock_index_full = unlock
+            self._state.console.log.log("debug: unlocked all quests")
+
         if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
             self._action = "open_play_game"
             return
@@ -374,7 +469,7 @@ class QuestsMenuView:
         # `sub_447d40` base sums:
         #   x_sum = <ui_element_x> + <ui_element_offset_x>  (x=-5)
         #   y_sum = <ui_element_y> + <ui_element_offset_y>  (y=185 + widescreen shift via ui_menu_layout_init)
-        x_sum = QUEST_MENU_BASE_X + MENU_PANEL_OFFSET_X
+        x_sum = QUEST_MENU_BASE_X + QUEST_MENU_PANEL_OFFSET_X
         y_sum = QUEST_MENU_BASE_Y + MENU_PANEL_OFFSET_Y + self._widescreen_y_shift
 
         title_x = x_sum + QUEST_TITLE_X_OFFSET
@@ -1288,6 +1383,9 @@ class QuestResultsView:
             self._action = "start_quest"
             return
         if action == "play_next":
+            if int(self._quest_stage_major) == 5 and int(self._quest_stage_minor) == 10:
+                self._action = "end_note"
+                return
             next_level = _next_quest_level(self._quest_level)
             if next_level is not None:
                 self._state.pending_quest_level = next_level
@@ -1336,6 +1434,217 @@ class QuestResultsView:
         self._action = "open_high_scores"
 
 
+class EndNoteView:
+    """Final quest "Show End Note" flow.
+
+    Classic:
+      - quest_results_screen_update uses "Show End Note" instead of "Play Next" for quest 5.10
+      - clicking it transitions to state 0x15 (game_update_victory_screen @ 0x00406350)
+    """
+
+    def __init__(self, state: GameState) -> None:
+        self._state = state
+        self._ground: GroundRenderer | None = None
+        self._small_font: SmallFontData | None = None
+        self._panel_tex: rl.Texture2D | None = None
+        self._button_textures: UiButtonTextureSet | None = None
+        self._action: str | None = None
+        self._cursor_pulse_time = 0.0
+
+        self._survival_button = UiButtonState("Survival", force_wide=True)
+        self._rush_button = UiButtonState("  Rush  ", force_wide=True)
+        self._typo_button = UiButtonState("Typ'o'Shooter", force_wide=True)
+        self._main_menu_button = UiButtonState("Main Menu", force_wide=True)
+
+    def open(self) -> None:
+        self._action = None
+        self._cursor_pulse_time = 0.0
+        self._ground = None if self._state.pause_background is not None else ensure_menu_ground(self._state)
+
+        cache = _ensure_texture_cache(self._state)
+        self._panel_tex = cache.get_or_load("ui_menuPanel", "ui/ui_menuPanel.jaz").texture
+        button_md = cache.get_or_load("ui_buttonMd", "ui/ui_button_128x32.jaz").texture
+        button_sm = cache.get_or_load("ui_buttonSm", "ui/ui_button_64x32.jaz").texture
+        self._button_textures = UiButtonTextureSet(button_sm=button_sm, button_md=button_md)
+        self._small_font = None
+
+    def close(self) -> None:
+        self._ground = None
+        self._small_font = None
+        self._panel_tex = None
+        self._button_textures = None
+
+    def update(self, dt: float) -> None:
+        if self._state.audio is not None:
+            update_audio(self._state.audio, dt)
+        if self._ground is not None:
+            self._ground.process_pending()
+        self._cursor_pulse_time += min(float(dt), 0.1) * 1.1
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+            if self._state.audio is not None:
+                play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
+            self._action = "back_to_menu"
+            return
+
+        textures = self._button_textures
+        if textures is None or (textures.button_sm is None and textures.button_md is None):
+            return
+
+        screen_w = float(rl.get_screen_width())
+        scale = 1.0
+
+        layout_w = screen_w / scale if scale else screen_w
+        widescreen_shift_y = MenuView._menu_widescreen_y_shift(layout_w)
+
+        panel_left = (END_NOTE_PANEL_GEOM_X0 + END_NOTE_PANEL_POS_X) * scale
+        panel_top = (END_NOTE_PANEL_GEOM_Y0 + END_NOTE_PANEL_POS_Y + widescreen_shift_y) * scale
+
+        button_x = panel_left + END_NOTE_BUTTON_X_OFFSET * scale
+        button_y = panel_top + END_NOTE_BUTTON_Y_OFFSET * scale
+
+        font = self._ensure_small_font()
+        mouse = rl.get_mouse_position()
+        click = rl.is_mouse_button_pressed(rl.MOUSE_BUTTON_LEFT)
+        dt_ms = min(float(dt), 0.1) * 1000.0
+
+        survival_w = button_width(font, self._survival_button.label, scale=scale, force_wide=self._survival_button.force_wide)
+        if button_update(self._survival_button, x=button_x, y=button_y, width=survival_w, dt_ms=dt_ms, mouse=mouse, click=click):
+            self._state.config.data["game_mode"] = 1
+            if self._state.audio is not None:
+                play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
+            self._action = "start_survival"
+            return
+
+        button_y += END_NOTE_BUTTON_STEP_Y * scale
+        rush_w = button_width(font, self._rush_button.label, scale=scale, force_wide=self._rush_button.force_wide)
+        if button_update(self._rush_button, x=button_x, y=button_y, width=rush_w, dt_ms=dt_ms, mouse=mouse, click=click):
+            self._state.config.data["game_mode"] = 2
+            if self._state.audio is not None:
+                play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
+            self._action = "start_rush"
+            return
+
+        button_y += END_NOTE_BUTTON_STEP_Y * scale
+        typo_w = button_width(font, self._typo_button.label, scale=scale, force_wide=self._typo_button.force_wide)
+        if button_update(self._typo_button, x=button_x, y=button_y, width=typo_w, dt_ms=dt_ms, mouse=mouse, click=click):
+            self._state.config.data["game_mode"] = 4
+            self._state.screen_fade_alpha = 0.0
+            self._state.screen_fade_ramp = True
+            if self._state.audio is not None:
+                play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
+            self._action = "start_typo"
+            return
+
+        button_y += END_NOTE_BUTTON_STEP_Y * scale
+        main_w = button_width(font, self._main_menu_button.label, scale=scale, force_wide=self._main_menu_button.force_wide)
+        if button_update(self._main_menu_button, x=button_x, y=button_y, width=main_w, dt_ms=dt_ms, mouse=mouse, click=click):
+            if self._state.audio is not None:
+                play_sfx(self._state.audio, "sfx_ui_buttonclick", rng=self._state.rng)
+            self._action = "back_to_menu"
+            return
+
+    def draw(self) -> None:
+        rl.clear_background(rl.BLACK)
+        pause_background = self._state.pause_background
+        if pause_background is not None:
+            pause_background.draw_pause_background()
+        elif self._ground is not None:
+            self._ground.draw(0.0, 0.0)
+        _draw_screen_fade(self._state)
+
+        panel_tex = self._panel_tex
+        if panel_tex is None:
+            return
+
+        screen_w = float(rl.get_screen_width())
+        scale = 1.0
+        layout_w = screen_w / scale if scale else screen_w
+        widescreen_shift_y = MenuView._menu_widescreen_y_shift(layout_w)
+
+        panel_left = (END_NOTE_PANEL_GEOM_X0 + END_NOTE_PANEL_POS_X) * scale
+        panel_top = (END_NOTE_PANEL_GEOM_Y0 + END_NOTE_PANEL_POS_Y + widescreen_shift_y) * scale
+        panel = rl.Rectangle(
+            float(panel_left),
+            float(panel_top),
+            float(END_NOTE_PANEL_W * scale),
+            float(END_NOTE_PANEL_H * scale),
+        )
+
+        fx_detail = bool(int(self._state.config.data.get("fx_detail_0", 0) or 0))
+        draw_classic_menu_panel(panel_tex, dst=panel, tint=rl.WHITE, shadow=fx_detail)
+
+        font = self._ensure_small_font()
+        hardcore = bool(int(self._state.config.data.get("hardcore_flag", 0) or 0))
+        header = "   Incredible!" if hardcore else "Congratulations!"
+        body_lines = (
+            [
+                "You've done the thing we all thought was",
+                "virtually impossible. To reward your",
+                "efforts a new weapon has been unlocked ",
+                "for you: Splitter Gun.",
+                "",
+                "",
+            ]
+            if hardcore
+            else [
+                "You've completed all the levels but the battle",
+                "isn't over yet! With all of the unlocked perks",
+                "and weapons your Survival is just a bit easier.",
+                "You can also replay the quests in Hardcore.",
+                "As an additional reward for your victorious",
+                "playing, a completely new and different game",
+                "mode is unlocked for you: Typ'o'Shooter.",
+            ]
+        )
+
+        header_x = panel_left + END_NOTE_HEADER_X_OFFSET * scale
+        header_y = panel_top + END_NOTE_HEADER_Y_OFFSET * scale
+        header_color = rl.Color(255, 255, 255, int(255 * 0.8))
+        body_color = rl.Color(255, 255, 255, int(255 * 0.5))
+
+        draw_small_text(font, header, header_x, header_y, 1.5 * scale, header_color)
+
+        body_x = panel_left + END_NOTE_BODY_X_OFFSET * scale
+        body_y = header_y + END_NOTE_BODY_Y_GAP * scale
+        for idx, line in enumerate(body_lines):
+            draw_small_text(font, line, body_x, body_y, 1.0 * scale, body_color)
+            if idx != len(body_lines) - 1:
+                body_y += END_NOTE_LINE_STEP_Y * scale
+        body_y += END_NOTE_AFTER_BODY_Y_GAP * scale
+        draw_small_text(font, "Good luck with your battles, trooper!", body_x, body_y, 1.0 * scale, body_color)
+
+        textures = self._button_textures
+        if textures is not None and (textures.button_sm is not None or textures.button_md is not None):
+            button_x = panel_left + END_NOTE_BUTTON_X_OFFSET * scale
+            button_y = panel_top + END_NOTE_BUTTON_Y_OFFSET * scale
+            survival_w = button_width(font, self._survival_button.label, scale=scale, force_wide=self._survival_button.force_wide)
+            button_draw(textures, font, self._survival_button, x=button_x, y=button_y, width=survival_w, scale=scale)
+            button_y += END_NOTE_BUTTON_STEP_Y * scale
+            rush_w = button_width(font, self._rush_button.label, scale=scale, force_wide=self._rush_button.force_wide)
+            button_draw(textures, font, self._rush_button, x=button_x, y=button_y, width=rush_w, scale=scale)
+            button_y += END_NOTE_BUTTON_STEP_Y * scale
+            typo_w = button_width(font, self._typo_button.label, scale=scale, force_wide=self._typo_button.force_wide)
+            button_draw(textures, font, self._typo_button, x=button_x, y=button_y, width=typo_w, scale=scale)
+            button_y += END_NOTE_BUTTON_STEP_Y * scale
+            main_w = button_width(font, self._main_menu_button.label, scale=scale, force_wide=self._main_menu_button.force_wide)
+            button_draw(textures, font, self._main_menu_button, x=button_x, y=button_y, width=main_w, scale=scale)
+
+        _draw_menu_cursor(self._state, pulse_time=self._cursor_pulse_time)
+
+    def take_action(self) -> str | None:
+        action = self._action
+        self._action = None
+        return action
+
+    def _ensure_small_font(self) -> SmallFontData:
+        if self._small_font is not None:
+            return self._small_font
+        missing_assets: list[str] = []
+        self._small_font = load_small_font(self._state.assets_dir, missing_assets)
+        return self._small_font
+
+
 class QuestFailedView:
     def __init__(self, state: GameState) -> None:
         self._state = state
@@ -1558,6 +1867,10 @@ class HighScoresView:
         self._small_font: SmallFontData | None = None
         self._button_tex: rl.Texture2D | None = None
         self._button_textures: UiButtonTextureSet | None = None
+        self._check_on: rl.Texture2D | None = None
+        self._drop_off: rl.Texture2D | None = None
+        self._arrow_tex: rl.Texture2D | None = None
+        self._wicons_tex: rl.Texture2D | None = None
         self._update_button = UiButtonState("Update scores", force_wide=True)
         self._play_button = UiButtonState("Play a game", force_wide=True)
         self._back_button = UiButtonState("Back", force_wide=False)
@@ -1588,6 +1901,16 @@ class HighScoresView:
         self._button_tex = cache.get_or_load("ui_buttonMd", "ui/ui_button_128x32.jaz").texture
         button_sm = cache.get_or_load("ui_buttonSm", "ui/ui_button_64x32.jaz").texture
         self._button_textures = UiButtonTextureSet(button_sm=button_sm, button_md=self._button_tex)
+        self._check_on = cache.get_or_load("ui_checkOn", "ui/ui_checkOn.jaz").texture
+        self._drop_off = cache.get_or_load("ui_dropOff", "ui/ui_dropDownOff.jaz").texture
+        self._arrow_tex = cache.get_or_load("ui_arrow", "ui/ui_arrow.jaz").texture
+
+        if self._wicons_tex is not None:
+            rl.unload_texture(self._wicons_tex)
+            self._wicons_tex = None
+        wicons_path = self._state.assets_dir / "crimson" / "ui" / "ui_wicons.png"
+        if wicons_path.is_file():
+            self._wicons_tex = rl.load_texture(str(wicons_path))
 
         request = self._state.pending_high_scores
         self._state.pending_high_scores = None
@@ -1623,9 +1946,15 @@ class HighScoresView:
         if self._small_font is not None:
             rl.unload_texture(self._small_font.texture)
             self._small_font = None
+        if self._wicons_tex is not None:
+            rl.unload_texture(self._wicons_tex)
+            self._wicons_tex = None
         self._assets = None
         self._button_tex = None
         self._button_textures = None
+        self._check_on = None
+        self._drop_off = None
+        self._arrow_tex = None
         self._request = None
         self._records = []
         self._scroll_index = 0
@@ -1779,10 +2108,22 @@ class HighScoresView:
         )
 
         title = "High scores - Quests" if int(mode_id) == 3 else f"High scores - {self._mode_label(mode_id, quest_major, quest_minor)}"
-        draw_small_text(font, title, left_x0 + 269.0 * scale, left_y0 + 41.0 * scale, 1.0 * scale, rl.Color(255, 255, 255, 255))
+        title_x = 269.0
+        if int(mode_id) == 1:
+            # state_14:High scores - Survival title at x=168 (panel left_x0 is -98).
+            title_x = 266.0
+        draw_small_text(font, title, left_x0 + title_x * scale, left_y0 + 41.0 * scale, 1.0 * scale, rl.Color(255, 255, 255, 255))
         if int(mode_id) == 3:
             quest_label = f"{int(quest_major)}.{int(quest_minor)}: {self._quest_title(quest_major, quest_minor)}"
             draw_small_text(font, quest_label, left_x0 + 236.0 * scale, left_y0 + 63.0 * scale, 1.0 * scale, rl.Color(255, 255, 255, 255))
+            arrow = self._arrow_tex
+            if arrow is not None:
+                dst_w = float(arrow.width) * scale
+                dst_h = float(arrow.height) * scale
+                # state_14 draws ui_arrow.jaz flipped (uv 1..0) to point left.
+                src = rl.Rectangle(float(arrow.width), 0.0, -float(arrow.width), float(arrow.height))
+                dst = rl.Rectangle(left_x0 + HS_QUEST_ARROW_X * scale, left_y0 + HS_QUEST_ARROW_Y * scale, dst_w, dst_h)
+                rl.draw_texture_pro(arrow, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
 
         header_color = rl.Color(255, 255, 255, int(255 * 0.85))
         row_y0 = left_y0 + 84.0 * scale
@@ -1841,9 +2182,351 @@ class HighScoresView:
                 scale=scale,
             )
 
+        self._draw_right_panel(font=font, right_x0=right_x0, right_y0=right_y0, scale=scale, mode_id=mode_id, highlight_rank=highlight_rank)
         self._draw_sign(assets)
         _draw_menu_cursor(self._state, pulse_time=self._cursor_pulse_time)
 
+    def _draw_right_panel(
+        self,
+        *,
+        font: SmallFontData,
+        right_x0: float,
+        right_y0: float,
+        scale: float,
+        mode_id: int,
+        highlight_rank: int | None,
+    ) -> None:
+        if int(mode_id) == 3:
+            self._draw_right_panel_quest_options(font=font, right_x0=right_x0, right_y0=right_y0, scale=scale)
+            return
+        self._draw_right_panel_local_score(
+            font=font,
+            right_x0=right_x0,
+            right_y0=right_y0,
+            scale=scale,
+            highlight_rank=highlight_rank,
+        )
+
+    def _draw_right_panel_quest_options(self, *, font: SmallFontData, right_x0: float, right_y0: float, scale: float) -> None:
+        text_scale = 1.0 * scale
+        text_color = rl.Color(255, 255, 255, int(255 * 0.8))
+
+        check_on = self._check_on
+        if check_on is not None:
+            check_w = float(check_on.width) * scale
+            check_h = float(check_on.height) * scale
+            rl.draw_texture_pro(
+                check_on,
+                rl.Rectangle(0.0, 0.0, float(check_on.width), float(check_on.height)),
+                rl.Rectangle(right_x0 + HS_RIGHT_CHECK_X * scale, right_y0 + HS_RIGHT_CHECK_Y * scale, check_w, check_h),
+                rl.Vector2(0.0, 0.0),
+                0.0,
+                rl.WHITE,
+            )
+        draw_small_text(
+            font,
+            "Show internet scores",
+            right_x0 + HS_RIGHT_SHOW_INTERNET_X * scale,
+            right_y0 + HS_RIGHT_SHOW_INTERNET_Y * scale,
+            text_scale,
+            text_color,
+        )
+        draw_small_text(
+            font,
+            "Number of players",
+            right_x0 + HS_RIGHT_NUMBER_PLAYERS_X * scale,
+            right_y0 + HS_RIGHT_NUMBER_PLAYERS_Y * scale,
+            text_scale,
+            text_color,
+        )
+        draw_small_text(
+            font,
+            "Game mode",
+            right_x0 + HS_RIGHT_GAME_MODE_X * scale,
+            right_y0 + HS_RIGHT_GAME_MODE_Y * scale,
+            text_scale,
+            text_color,
+        )
+        draw_small_text(
+            font,
+            "Show scores:",
+            right_x0 + HS_RIGHT_SHOW_SCORES_X * scale,
+            right_y0 + HS_RIGHT_SHOW_SCORES_Y * scale,
+            text_scale,
+            text_color,
+        )
+        draw_small_text(
+            font,
+            "Selected score list:",
+            right_x0 + HS_RIGHT_SCORE_LIST_X * scale,
+            right_y0 + HS_RIGHT_SCORE_LIST_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        # Closed list widgets (state_14 quest variant): white border + black fill.
+        widget_h = 16.0 * scale
+        for wx, wy, ww in (
+            (HS_RIGHT_PLAYER_COUNT_WIDGET_X, HS_RIGHT_PLAYER_COUNT_WIDGET_Y, HS_RIGHT_PLAYER_COUNT_WIDGET_W),
+            (HS_RIGHT_GAME_MODE_WIDGET_X, HS_RIGHT_GAME_MODE_WIDGET_Y, HS_RIGHT_GAME_MODE_WIDGET_W),
+            (HS_RIGHT_SHOW_SCORES_WIDGET_X, HS_RIGHT_SHOW_SCORES_WIDGET_Y, HS_RIGHT_SHOW_SCORES_WIDGET_W),
+            (HS_RIGHT_SCORE_LIST_WIDGET_X, HS_RIGHT_SCORE_LIST_WIDGET_Y, HS_RIGHT_SCORE_LIST_WIDGET_W),
+        ):
+            x = right_x0 + float(wx) * scale
+            y = right_y0 + float(wy) * scale
+            w = float(ww) * scale
+            rl.draw_rectangle(int(x), int(y), int(w), int(widget_h), rl.WHITE)
+            rl.draw_rectangle(int(x) + 1, int(y) + 1, max(0, int(w) - 2), max(0, int(widget_h) - 2), rl.BLACK)
+
+        # Values (static in the oracle).
+        draw_small_text(
+            font,
+            "1 player",
+            right_x0 + HS_RIGHT_PLAYER_COUNT_VALUE_X * scale,
+            right_y0 + HS_RIGHT_PLAYER_COUNT_VALUE_Y * scale,
+            text_scale,
+            text_color,
+        )
+        draw_small_text(
+            font,
+            "Quests",
+            right_x0 + HS_RIGHT_GAME_MODE_VALUE_X * scale,
+            right_y0 + HS_RIGHT_GAME_MODE_VALUE_Y * scale,
+            text_scale,
+            text_color,
+        )
+        draw_small_text(
+            font,
+            "Best of all time",
+            right_x0 + HS_RIGHT_SHOW_SCORES_VALUE_X * scale,
+            right_y0 + HS_RIGHT_SHOW_SCORES_VALUE_Y * scale,
+            text_scale,
+            text_color,
+        )
+        draw_small_text(
+            font,
+            "default",
+            right_x0 + HS_RIGHT_SCORE_LIST_VALUE_X * scale,
+            right_y0 + HS_RIGHT_SCORE_LIST_VALUE_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        drop_off = self._drop_off
+        if drop_off is None:
+            return
+        drop_w = float(drop_off.width) * scale
+        drop_h = float(drop_off.height) * scale
+        for dx, dy in (
+            (HS_RIGHT_PLAYER_COUNT_DROP_X, HS_RIGHT_PLAYER_COUNT_DROP_Y),
+            (HS_RIGHT_GAME_MODE_DROP_X, HS_RIGHT_GAME_MODE_DROP_Y),
+            (HS_RIGHT_SHOW_SCORES_DROP_X, HS_RIGHT_SHOW_SCORES_DROP_Y),
+            (HS_RIGHT_SCORE_LIST_DROP_X, HS_RIGHT_SCORE_LIST_DROP_Y),
+        ):
+            rl.draw_texture_pro(
+                drop_off,
+                rl.Rectangle(0.0, 0.0, float(drop_off.width), float(drop_off.height)),
+                rl.Rectangle(right_x0 + float(dx) * scale, right_y0 + float(dy) * scale, drop_w, drop_h),
+                rl.Vector2(0.0, 0.0),
+                0.0,
+                rl.WHITE,
+            )
+
+    def _draw_right_panel_local_score(
+        self,
+        *,
+        font: SmallFontData,
+        right_x0: float,
+        right_y0: float,
+        scale: float,
+        highlight_rank: int | None,
+    ) -> None:
+        if not self._records:
+            return
+        idx = int(highlight_rank) if highlight_rank is not None else int(self._scroll_index)
+        if idx < 0:
+            idx = 0
+        if idx >= len(self._records):
+            idx = len(self._records) - 1
+        entry = self._records[idx]
+
+        text_scale = 1.0 * scale
+        text_color = rl.Color(255, 255, 255, int(255 * 0.8))
+
+        name = ""
+        try:
+            name = str(entry.name())
+        except Exception:
+            name = ""
+        if not name:
+            name = "???"
+        draw_small_text(font, name, right_x0 + HS_LOCAL_NAME_X * scale, right_y0 + HS_LOCAL_NAME_Y * scale, text_scale, text_color)
+        draw_small_text(
+            font,
+            "Local score",
+            right_x0 + HS_LOCAL_LABEL_X * scale,
+            right_y0 + HS_LOCAL_LABEL_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        date_text = self._format_score_date(entry)
+        if date_text:
+            draw_small_text(
+                font,
+                date_text,
+                right_x0 + HS_LOCAL_DATE_X * scale,
+                right_y0 + HS_LOCAL_DATE_Y * scale,
+                text_scale,
+                text_color,
+            )
+
+        draw_small_text(
+            font,
+            "Score",
+            right_x0 + HS_LOCAL_SCORE_LABEL_X * scale,
+            right_y0 + HS_LOCAL_SCORE_LABEL_Y * scale,
+            text_scale,
+            text_color,
+        )
+        draw_small_text(
+            font,
+            "Game time",
+            right_x0 + HS_LOCAL_TIME_LABEL_X * scale,
+            right_y0 + HS_LOCAL_TIME_LABEL_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        score_value = f"{int(getattr(entry, 'score_xp', 0))}"
+        draw_small_text(
+            font,
+            score_value,
+            right_x0 + HS_LOCAL_SCORE_VALUE_X * scale,
+            right_y0 + HS_LOCAL_SCORE_VALUE_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        elapsed_ms = int(getattr(entry, "survival_elapsed_ms", 0) or 0)
+        draw_small_text(
+            font,
+            self._format_elapsed_mm_ss(elapsed_ms),
+            right_x0 + HS_LOCAL_TIME_VALUE_X * scale,
+            right_y0 + HS_LOCAL_TIME_VALUE_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        draw_small_text(
+            font,
+            f"Rank: {self._ordinal(idx + 1)}",
+            right_x0 + HS_LOCAL_RANK_X * scale,
+            right_y0 + HS_LOCAL_RANK_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        frags = int(getattr(entry, "creature_kill_count", 0) or 0)
+        draw_small_text(
+            font,
+            f"Frags: {frags}",
+            right_x0 + HS_LOCAL_FRAGS_X * scale,
+            right_y0 + HS_LOCAL_FRAGS_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        shots_fired = int(getattr(entry, "shots_fired", 0) or 0)
+        shots_hit = int(getattr(entry, "shots_hit", 0) or 0)
+        hit_pct = 0
+        if shots_fired > 0:
+            hit_pct = int((shots_hit * 100) // shots_fired)
+        draw_small_text(
+            font,
+            f"Hit %: {hit_pct}%",
+            right_x0 + HS_LOCAL_HIT_X * scale,
+            right_y0 + HS_LOCAL_HIT_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+        weapon_id = int(getattr(entry, "most_used_weapon_id", 0) or 0)
+        weapon_name, icon_index = self._weapon_label_and_icon(weapon_id)
+        if icon_index is not None:
+            self._draw_wicon(icon_index, x=right_x0 + HS_LOCAL_WICON_X * scale, y=right_y0 + HS_LOCAL_WICON_Y * scale, scale=scale)
+        draw_small_text(
+            font,
+            weapon_name,
+            right_x0 + HS_LOCAL_WEAPON_X * scale,
+            right_y0 + HS_LOCAL_WEAPON_Y * scale,
+            text_scale,
+            text_color,
+        )
+
+    def _draw_wicon(self, icon_index: int, *, x: float, y: float, scale: float) -> None:
+        tex = self._wicons_tex
+        if tex is None:
+            return
+        idx = int(icon_index)
+        if idx < 0 or idx > 31:
+            return
+        cols = 4
+        rows = 8
+        icon_w = float(tex.width) / float(cols)
+        icon_h = float(tex.height) / float(rows)
+        src_x = float(idx % cols) * icon_w
+        src_y = float(idx // cols) * icon_h
+        rl.draw_texture_pro(
+            tex,
+            rl.Rectangle(src_x, src_y, icon_w, icon_h),
+            rl.Rectangle(float(x), float(y), icon_w * scale, icon_h * scale),
+            rl.Vector2(0.0, 0.0),
+            0.0,
+            rl.WHITE,
+        )
+
+    @staticmethod
+    def _ordinal(value: int) -> str:
+        n = int(value)
+        if 10 <= (n % 100) <= 20:
+            return f"{n}th"
+        suffix = {1: "st", 2: "nd", 3: "rd"}.get(n % 10, "th")
+        return f"{n}{suffix}"
+
+    @staticmethod
+    def _format_elapsed_mm_ss(value_ms: int) -> str:
+        total = max(0, int(value_ms)) // 1000
+        minutes, seconds = divmod(total, 60)
+        return f"{minutes}:{seconds:02d}"
+
+    @staticmethod
+    def _format_score_date(entry: object) -> str:
+        try:
+            day = int(getattr(entry, "day", 0) or 0)
+            month = int(getattr(entry, "month", 0) or 0)
+            year_off = int(getattr(entry, "year_offset", 0) or 0)
+        except Exception:
+            return ""
+        if day <= 0 or month <= 0:
+            return ""
+        months = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+        month_name = months[month - 1] if 1 <= month <= 12 else f"{month}"
+        year = 2000 + year_off if year_off >= 0 else 2000
+        return f"{day}. {month_name} {year}"
+
+    @staticmethod
+    def _weapon_label_and_icon(weapon_id: int) -> tuple[str, int | None]:
+        try:
+            from .weapons import WEAPON_BY_ID
+        except Exception:
+            WEAPON_BY_ID = {}
+        weapon = WEAPON_BY_ID.get(int(weapon_id))
+        if weapon is None:
+            return f"Weapon {int(weapon_id)}", None
+        name = weapon.name or f"weapon_{int(weapon.weapon_id)}"
+        return name, weapon.icon_index
+
     def _draw_sign(self, assets: MenuAssets) -> None:
         if assets.sign is None:
             return
@@ -1944,6 +2627,7 @@ class GameLoopView:
             "start_quest": QuestGameView(state),
             "quest_results": QuestResultsView(state),
             "quest_failed": QuestFailedView(state),
+            "end_note": EndNoteView(state),
             "open_high_scores": HighScoresView(state),
             "start_survival": SurvivalGameView(state),
             "start_rush": RushGameView(state),
@@ -2474,6 +3158,8 @@ def _resolve_assets_dir(config: GameConfig) -> Path:
 
 
 def run_game(config: GameConfig) -> None:
+    if config.debug:
+        set_debug_enabled(True)
     base_dir = config.base_dir
     base_dir.mkdir(parents=True, exist_ok=True)
     crash_path = base_dir / "crash.log"