crimsonland 0.1.0.dev12__py3-none-any.whl → 0.1.0.dev13__py3-none-any.whl

crimson/assets_fetch.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
+import os
 import shutil
+import tempfile
 import urllib.request
 
 from grim.console import ConsoleState
@@ -19,17 +21,30 @@ class DownloadResult:
 
 
 def _download_file(url: str, dest: Path) -> None:
-    tmp = dest.with_suffix(dest.suffix + ".tmp")
-    if tmp.exists():
-        tmp.unlink()
+    tmp_path: Path | None = None
     try:
         req = urllib.request.Request(url, headers={"User-Agent": "crimsonland-decompile"})
-        with urllib.request.urlopen(req, timeout=30) as resp, tmp.open("wb") as handle:
-            shutil.copyfileobj(resp, handle)
-        tmp.replace(dest)
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            with tempfile.NamedTemporaryFile(
+                mode="wb",
+                delete=False,
+                dir=dest.parent,
+                prefix=dest.name + ".",
+                suffix=".tmp",
+            ) as handle:
+                tmp_path = Path(handle.name)
+                shutil.copyfileobj(resp, handle)
+                handle.flush()
+                os.fsync(handle.fileno())
+        if tmp_path is None:
+            raise RuntimeError("assets: temporary file not created")
+        tmp_path.replace(dest)
     finally:
-        if tmp.exists():
-            tmp.unlink()
+        if tmp_path is not None:
+            try:
+                tmp_path.unlink()
+            except FileNotFoundError:
+                pass
 
 
 def download_missing_paqs(

crimson/frontend/high_scores_layout.py

@@ -0,0 +1,26 @@
+"""
+Layout constants for the classic high scores screen (state_id=14).
+
+Measured from analysis/frida/ui_render_trace_oracle_1024x768.json.
+"""
+
+from __future__ import annotations
+
+# Panel positions are expressed in "panel pos" (pre-offset) space, matching other menu panels:
+#   panel_top_left = (panel_pos_x + MENU_PANEL_OFFSET_X, panel_pos_y + y_shift + MENU_PANEL_OFFSET_Y)
+
+HS_LEFT_PANEL_POS_X = -119.0
+HS_LEFT_PANEL_POS_Y = 185.0
+HS_LEFT_PANEL_HEIGHT = 378.0
+
+HS_RIGHT_PANEL_POS_X = 609.0
+HS_RIGHT_PANEL_POS_Y = 200.0
+HS_RIGHT_PANEL_HEIGHT = 254.0
+
+# Buttons inside the left panel (relative to the left panel top-left).
+HS_BUTTON_X = 234.0  # x0=136 at 1024x768
+HS_BUTTON_Y0 = 268.0  # y0=462
+HS_BUTTON_STEP_Y = 33.0
+
+HS_BACK_BUTTON_X = 400.0  # x0=302
+HS_BACK_BUTTON_Y = 301.0  # y0=495

crimson/frontend/menu.py

@@ -19,8 +19,8 @@ if TYPE_CHECKING:
     from ..game import GameState
 
 
-MENU_LABEL_WIDTH = 124.0
-MENU_LABEL_HEIGHT = 30.0
+MENU_LABEL_WIDTH = 122.0
+MENU_LABEL_HEIGHT = 28.0
 MENU_LABEL_ROW_HEIGHT = 32.0
 MENU_LABEL_ROW_PLAY_GAME = 1
 MENU_LABEL_ROW_OPTIONS = 2
@@ -31,18 +31,17 @@ MENU_LABEL_ROW_QUIT = 6
 MENU_LABEL_ROW_BACK = 7
 MENU_LABEL_BASE_X = -60.0
 MENU_LABEL_BASE_Y = 210.0
-MENU_LABEL_OFFSET_X = 270.0
-MENU_LABEL_OFFSET_Y = -38.0
+MENU_LABEL_OFFSET_X = 271.0
+MENU_LABEL_OFFSET_Y = -37.0
 MENU_LABEL_STEP = 60.0
-MENU_ITEM_OFFSET_X = -72.0
-MENU_ITEM_OFFSET_Y = -60.0
-MENU_PANEL_WIDTH = 512.0
-MENU_PANEL_HEIGHT = 256.0
-# ui_menu_assets_init:
-#   - ui_menuPanel starts with offset_x=+20 (ui_element_set_rect)
-#   - the menu-panel layout copy applies data_48fdb4 -= 116, so offset_x becomes -96
-MENU_PANEL_OFFSET_X = -96.0
-MENU_PANEL_OFFSET_Y = -82.0
+MENU_ITEM_OFFSET_X = -71.0
+MENU_ITEM_OFFSET_Y = -59.0
+MENU_PANEL_WIDTH = 510.0
+MENU_PANEL_HEIGHT = 254.0
+# Measured from ui_render_trace at 1024x768 (stable timeline):
+# panel top-left is (pos_x + 21, pos_y - 81) and size is 510x254, plus a shadow pass at +7,+7.
+MENU_PANEL_OFFSET_X = 21.0
+MENU_PANEL_OFFSET_Y = -81.0
 MENU_PANEL_BASE_X = -45.0
 MENU_PANEL_BASE_Y = 210.0
 MENU_SCALE_SMALL_THRESHOLD = 640
@@ -52,10 +51,10 @@ MENU_SCALE_SMALL = 0.8
 MENU_SCALE_LARGE = 1.2
 MENU_SCALE_SHIFT = 10.0
 
-MENU_SIGN_WIDTH = 573.44
-MENU_SIGN_HEIGHT = 143.36
-MENU_SIGN_OFFSET_X = -577.44
-MENU_SIGN_OFFSET_Y = -62.0
+MENU_SIGN_WIDTH = 571.44
+MENU_SIGN_HEIGHT = 141.36
+MENU_SIGN_OFFSET_X = -576.44
+MENU_SIGN_OFFSET_Y = -61.0
 MENU_SIGN_POS_Y = 70.0
 MENU_SIGN_POS_Y_SMALL = 60.0
 MENU_SIGN_POS_X_PAD = 4.0
@@ -584,21 +583,24 @@ class MenuView:
         start_ms: int,
         end_ms: int,
         width: float,
+        direction_flag: int = 0,
     ) -> tuple[float, float]:
         # Matches ui_element_update: angle lerps pi/2 -> 0 over [end_ms, start_ms].
-        # Direction flag (element+0x314) appears to be 0 for main menu elements.
+        # direction_flag=0 slides from left  (-width -> 0)
+        # direction_flag=1 slides from right (+width -> 0)
         if start_ms <= end_ms or width <= 0.0:
             return 0.0, 0.0
+        dir_sign = 1.0 if int(direction_flag) else -1.0
         t = self._timeline_ms
         if t < end_ms:
             angle = 1.5707964
-            offset_x = -abs(width)
+            offset_x = dir_sign * abs(width)
         elif t < start_ms:
             elapsed = t - end_ms
             span = float(start_ms - end_ms)
             p = float(elapsed) / span
             angle = 1.5707964 * (1.0 - p)
-            offset_x = -((1.0 - p) * abs(width))
+            offset_x = dir_sign * ((1.0 - p) * abs(width))
         else:
             angle = 0.0
             offset_x = 0.0

crimson/frontend/panels/base.py

@@ -8,6 +8,7 @@ from grim.assets import PaqTextureCache
 from grim.audio import play_sfx, update_audio
 from grim.terrain_render import GroundRenderer
 
+from ...ui.menu_panel import draw_classic_menu_panel
 from ..assets import MenuAssets, _ensure_texture_cache, load_menu_assets
 from ..menu import (
     MENU_ITEM_OFFSET_X,
@@ -70,6 +71,9 @@ class PanelMenuView:
         body: str | None = None,
         panel_pos_x: float = PANEL_POS_X,
         panel_pos_y: float = PANEL_POS_Y,
+        panel_offset_x: float = MENU_PANEL_OFFSET_X,
+        panel_offset_y: float = MENU_PANEL_OFFSET_Y,
+        panel_height: float = MENU_PANEL_HEIGHT,
         back_pos_x: float = PANEL_BACK_POS_X,
         back_pos_y: float = PANEL_BACK_POS_Y,
         back_action: str = "back_to_menu",
@@ -79,6 +83,9 @@ class PanelMenuView:
         self._body_lines = (body or "").splitlines()
         self._panel_pos_x = panel_pos_x
         self._panel_pos_y = panel_pos_y
+        self._panel_offset_x = panel_offset_x
+        self._panel_offset_y = panel_offset_y
+        self._panel_height = panel_height
         self._back_pos_x = back_pos_x
         self._back_pos_y = back_pos_y
         self._back_action = back_action
@@ -223,40 +230,21 @@ class PanelMenuView:
         if assets is None or assets.panel is None:
             return
         panel = assets.panel
-        panel_w = MENU_PANEL_WIDTH
-        panel_h = MENU_PANEL_HEIGHT
         _angle_rad, slide_x = MenuView._ui_element_anim(
             self,
             index=1,
             start_ms=PANEL_TIMELINE_START_MS,
             end_ms=PANEL_TIMELINE_END_MS,
-            width=panel_w * self._menu_item_scale(0)[0],
+            width=MENU_PANEL_WIDTH * self._menu_item_scale(0)[0],
         )
         item_scale, _local_y_shift = self._menu_item_scale(0)
-        dst = rl.Rectangle(
-            self._panel_pos_x + slide_x,
-            self._panel_pos_y + self._widescreen_y_shift,
-            panel_w * item_scale,
-            panel_h * item_scale,
-        )
-        origin = rl.Vector2(-(MENU_PANEL_OFFSET_X * item_scale), -(MENU_PANEL_OFFSET_Y * item_scale))
+        panel_w = MENU_PANEL_WIDTH * item_scale
+        panel_h = float(self._panel_height) * item_scale
+        top_left_x = self._panel_pos_x + slide_x + self._panel_offset_x * item_scale
+        top_left_y = self._panel_pos_y + self._widescreen_y_shift + self._panel_offset_y * item_scale
+        dst = rl.Rectangle(float(top_left_x), float(top_left_y), float(panel_w), float(panel_h))
         fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
-        if fx_detail:
-            MenuView._draw_ui_quad_shadow(
-                texture=panel,
-                src=rl.Rectangle(0.0, 0.0, float(panel.width), float(panel.height)),
-                dst=rl.Rectangle(dst.x + UI_SHADOW_OFFSET, dst.y + UI_SHADOW_OFFSET, dst.width, dst.height),
-                origin=origin,
-                rotation_deg=0.0,
-            )
-        MenuView._draw_ui_quad(
-            texture=panel,
-            src=rl.Rectangle(0.0, 0.0, float(panel.width), float(panel.height)),
-            dst=dst,
-            origin=origin,
-            rotation_deg=0.0,
-            tint=rl.WHITE,
-        )
+        draw_classic_menu_panel(panel, dst=dst, tint=rl.WHITE, shadow=fx_detail)
 
     def _draw_entry(self, entry: MenuEntry) -> None:
         assets = self._assets

crimson/frontend/panels/controls.py

@@ -9,11 +9,13 @@ from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
 from ..menu import (
     MENU_PANEL_OFFSET_X,
     MENU_PANEL_OFFSET_Y,
+    MENU_PANEL_HEIGHT,
     MENU_PANEL_WIDTH,
     MenuView,
     _draw_menu_cursor,
 )
 from ..transitions import _draw_screen_fade
+from ...ui.menu_panel import draw_classic_menu_panel
 from .base import PANEL_TIMELINE_END_MS, PANEL_TIMELINE_START_MS, PanelMenuView
 from ...input_codes import config_keybinds, input_code_name, player_move_fire_binds
 
@@ -21,15 +23,43 @@ if TYPE_CHECKING:
     from ...game import GameState
 
 
+# Measured from ui_render_trace_oracle_1024x768.json (state_3:Configure for:, timeline=300).
+CONTROLS_LEFT_PANEL_POS_X = -165.0
+CONTROLS_LEFT_PANEL_POS_Y = 200.0
+CONTROLS_RIGHT_PANEL_POS_X = 590.0
+CONTROLS_RIGHT_PANEL_POS_Y = 110.0
+CONTROLS_RIGHT_PANEL_HEIGHT = 378.0
+CONTROLS_BACK_POS_X = -155.0
+CONTROLS_BACK_POS_Y = 420.0
+
+
 class ControlsMenuView(PanelMenuView):
     def __init__(self, state: GameState) -> None:
-        super().__init__(state, title="Controls", back_action="open_options")
+        super().__init__(
+            state,
+            title="Controls",
+            back_action="open_options",
+            panel_pos_x=CONTROLS_LEFT_PANEL_POS_X,
+            panel_pos_y=CONTROLS_LEFT_PANEL_POS_Y,
+            back_pos_x=CONTROLS_BACK_POS_X,
+            back_pos_y=CONTROLS_BACK_POS_Y,
+        )
         self._small_font: SmallFontData | None = None
-        self._lines: list[str] = []
+        self._text_controls: rl.Texture2D | None = None
+        self._drop_off: rl.Texture2D | None = None
+        self._check_on: rl.Texture2D | None = None
+        self._check_off: rl.Texture2D | None = None
+
+        self._config_player = 1
 
     def open(self) -> None:
         super().open()
-        self._lines = self._build_lines()
+        cache = self._ensure_cache()
+        # UI elements used by the classic controls screen.
+        self._text_controls = cache.get_or_load("ui_textControls", "ui/ui_textControls.jaz").texture
+        self._drop_off = cache.get_or_load("ui_dropOff", "ui/ui_dropDownOff.jaz").texture
+        self._check_on = cache.get_or_load("ui_checkOn", "ui/ui_checkOn.jaz").texture
+        self._check_off = cache.get_or_load("ui_checkOff", "ui/ui_checkOff.jaz").texture
 
     def draw(self) -> None:
         self._draw_background()
@@ -51,9 +81,17 @@ class ControlsMenuView(PanelMenuView):
         self._small_font = load_small_font(self._state.assets_dir, missing_assets)
         return self._small_font
 
-    def _content_layout(self) -> dict[str, float]:
-        panel_scale, _local_shift = self._menu_item_scale(0)
+    def _draw_panel(self) -> None:
+        assets = self._assets
+        if assets is None or assets.panel is None:
+            return
+        panel = assets.panel
+
+        fx_detail = bool(self._state.config.data.get("fx_detail_0", 0))
+        panel_scale, _local_y_shift = self._menu_item_scale(0)
         panel_w = MENU_PANEL_WIDTH * panel_scale
+
+        # Left (controls options) panel: standard 254px height => a single quad.
         _angle_rad, slide_x = MenuView._ui_element_anim(
             self,
             index=1,
@@ -61,23 +99,93 @@ class ControlsMenuView(PanelMenuView):
             end_ms=PANEL_TIMELINE_END_MS,
             width=panel_w,
         )
-        panel_x = self._panel_pos_x + slide_x
-        panel_y = self._panel_pos_y + self._widescreen_y_shift
-        origin_x = -(MENU_PANEL_OFFSET_X * panel_scale)
-        origin_y = -(MENU_PANEL_OFFSET_Y * panel_scale)
-        panel_left = panel_x - origin_x
-        panel_top = panel_y - origin_y
-        base_x = panel_left + 212.0 * panel_scale
-        base_y = panel_top + 32.0 * panel_scale
-        label_x = base_x + 8.0 * panel_scale
-        return {
-            "base_x": base_x,
-            "base_y": base_y,
-            "label_x": label_x,
-            "scale": panel_scale,
-        }
-
-    def _build_lines(self) -> list[str]:
+        left_x0 = self._panel_pos_x + slide_x + MENU_PANEL_OFFSET_X * panel_scale
+        left_y0 = self._panel_pos_y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * panel_scale
+        left_h = MENU_PANEL_HEIGHT * panel_scale
+        draw_classic_menu_panel(panel, dst=rl.Rectangle(left_x0, left_y0, panel_w, left_h), tint=rl.WHITE, shadow=fx_detail)
+
+        # Right (configured bindings) panel: tall 378px panel rendered as 3 vertical slices.
+        _angle_rad, slide_x = MenuView._ui_element_anim(
+            self,
+            index=3,
+            start_ms=PANEL_TIMELINE_START_MS,
+            end_ms=PANEL_TIMELINE_END_MS,
+            width=panel_w,
+            direction_flag=1,
+        )
+        right_x0 = CONTROLS_RIGHT_PANEL_POS_X + slide_x + MENU_PANEL_OFFSET_X * panel_scale
+        right_y0 = CONTROLS_RIGHT_PANEL_POS_Y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * panel_scale
+        right_h = float(CONTROLS_RIGHT_PANEL_HEIGHT) * panel_scale
+        draw_classic_menu_panel(panel, dst=rl.Rectangle(right_x0, right_y0, panel_w, right_h), tint=rl.WHITE, shadow=fx_detail)
+
+    def _draw_contents(self) -> None:
+        # Positions are expressed relative to the panel top-left corners and scaled with the panel scale.
+        panel_scale, _local_y_shift = self._menu_item_scale(0)
+
+        left_x0 = self._panel_pos_x + MENU_PANEL_OFFSET_X * panel_scale
+        left_y0 = self._panel_pos_y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * panel_scale
+        right_x0 = CONTROLS_RIGHT_PANEL_POS_X + MENU_PANEL_OFFSET_X * panel_scale
+        right_y0 = CONTROLS_RIGHT_PANEL_POS_Y + self._widescreen_y_shift + MENU_PANEL_OFFSET_Y * panel_scale
+
+        font = self._ensure_small_font()
+        text_color = rl.Color(255, 255, 255, 255)
+
+        # --- Left panel: "Configure for" + method selectors (state_3 in trace) ---
+        if self._text_controls is not None:
+            MenuView._draw_ui_quad(
+                texture=self._text_controls,
+                src=rl.Rectangle(0.0, 0.0, float(self._text_controls.width), float(self._text_controls.height)),
+                dst=rl.Rectangle(left_x0 + 206.0 * panel_scale, left_y0 + 44.0 * panel_scale, 128.0 * panel_scale, 32.0 * panel_scale),
+                origin=rl.Vector2(0.0, 0.0),
+                rotation_deg=0.0,
+                tint=rl.WHITE,
+            )
+
+        draw_small_text(font, "Configure for:", left_x0 + 339.0 * panel_scale, left_y0 + 41.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, f"Player {int(self._config_player)}", left_x0 + 344.0 * panel_scale, left_y0 + 57.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Aiming method:", left_x0 + 213.0 * panel_scale, left_y0 + 86.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Mouse", left_x0 + 218.0 * panel_scale, left_y0 + 103.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Moving method:", left_x0 + 213.0 * panel_scale, left_y0 + 128.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Static", left_x0 + 218.0 * panel_scale, left_y0 + 145.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        check_tex = self._check_on
+        if check_tex is not None:
+            MenuView._draw_ui_quad(
+                texture=check_tex,
+                src=rl.Rectangle(0.0, 0.0, float(check_tex.width), float(check_tex.height)),
+                dst=rl.Rectangle(left_x0 + 213.0 * panel_scale, left_y0 + 174.0 * panel_scale, 16.0 * panel_scale, 16.0 * panel_scale),
+                origin=rl.Vector2(0.0, 0.0),
+                rotation_deg=0.0,
+                tint=rl.WHITE,
+            )
+        draw_small_text(
+            font,
+            "Show direction arrow",
+            left_x0 + 235.0 * panel_scale,
+            left_y0 + 175.0 * panel_scale,
+            1.0 * panel_scale,
+            text_color,
+        )
+
+        drop_tex = self._drop_off
+        if drop_tex is not None:
+            for ox, oy in (
+                (418.0, 56.0),  # player dropdown
+                (336.0, 102.0),  # aiming dropdown
+                (336.0, 144.0),  # moving dropdown
+            ):
+                MenuView._draw_ui_quad(
+                    texture=drop_tex,
+                    src=rl.Rectangle(0.0, 0.0, float(drop_tex.width), float(drop_tex.height)),
+                    dst=rl.Rectangle(left_x0 + ox * panel_scale, left_y0 + oy * panel_scale, 16.0 * panel_scale, 16.0 * panel_scale),
+                    origin=rl.Vector2(0.0, 0.0),
+                    rotation_deg=0.0,
+                    tint=rl.WHITE,
+                )
+
+        # --- Right panel: configured bindings list ---
         config = self._state.config
         pick_perk_key = int(config.data.get("keybind_pick_perk", 0x101) or 0x101)
         reload_key = int(config.data.get("keybind_reload", 0x102) or 0x102)
@@ -87,44 +195,25 @@ class ControlsMenuView(PanelMenuView):
             keybinds = (0x11, 0x1F, 0x1E, 0x20, 0x100) + (0x17E,) * 11 + (0xC8, 0xD0, 0xCB, 0xCD, 0x9D)
 
         p1_up, p1_down, p1_left, p1_right, p1_fire = player_move_fire_binds(keybinds, 0)
-        p2_up, p2_down, p2_left, p2_right, p2_fire = player_move_fire_binds(keybinds, 1)
-
-        return [
-            f"Level up: {input_code_name(pick_perk_key)} / Space / KeyPad+",
-            f"Reload: {input_code_name(reload_key)}",
-            "",
-            "Player 1:",
-            f"  Up: {input_code_name(p1_up)}",
-            f"  Down: {input_code_name(p1_down)}",
-            f"  Left: {input_code_name(p1_left)}",
-            f"  Right: {input_code_name(p1_right)}",
-            f"  Fire: {input_code_name(p1_fire)}",
-            "",
-            "Player 2:",
-            f"  Up: {input_code_name(p2_up)}",
-            f"  Down: {input_code_name(p2_down)}",
-            f"  Left: {input_code_name(p2_left)}",
-            f"  Right: {input_code_name(p2_right)}",
-            f"  Fire: {input_code_name(p2_fire)}",
-        ]
 
-    def _draw_contents(self) -> None:
-        layout = self._content_layout()
-        base_x = layout["base_x"]
-        base_y = layout["base_y"]
-        label_x = layout["label_x"]
-        scale = layout["scale"]
-
-        font = self._ensure_small_font()
-        title_scale = 1.2 * scale
-        text_scale = 1.0 * scale
-
-        title_color = rl.Color(255, 255, 255, 255)
-        text_color = rl.Color(255, 255, 255, int(255 * 0.8))
-
-        draw_small_text(font, "CONTROLS", base_x, base_y, title_scale, title_color)
-        line_y = base_y + 44.0 * scale
-        line_step = (font.cell_size + 4.0) * scale
-        for line in self._lines:
-            draw_small_text(font, line, label_x, line_y, text_scale, text_color)
-            line_y += line_step
+        draw_small_text(font, "Configured controls", right_x0 + 120.0 * panel_scale, right_y0 + 38.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Aiming", right_x0 + 44.0 * panel_scale, right_y0 + 64.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Fire:", right_x0 + 52.0 * panel_scale, right_y0 + 82.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_fire), right_x0 + 180.0 * panel_scale, right_y0 + 82.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Moving", right_x0 + 44.0 * panel_scale, right_y0 + 106.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Move Up:", right_x0 + 52.0 * panel_scale, right_y0 + 124.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_up), right_x0 + 180.0 * panel_scale, right_y0 + 124.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Move Down:", right_x0 + 52.0 * panel_scale, right_y0 + 140.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_down), right_x0 + 180.0 * panel_scale, right_y0 + 140.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Move Left:", right_x0 + 52.0 * panel_scale, right_y0 + 156.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_left), right_x0 + 180.0 * panel_scale, right_y0 + 156.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Move Right:", right_x0 + 52.0 * panel_scale, right_y0 + 172.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(p1_right), right_x0 + 180.0 * panel_scale, right_y0 + 172.0 * panel_scale, 1.0 * panel_scale, text_color)
+
+        draw_small_text(font, "Misc", right_x0 + 44.0 * panel_scale, right_y0 + 196.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Level Up:", right_x0 + 52.0 * panel_scale, right_y0 + 214.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(pick_perk_key), right_x0 + 180.0 * panel_scale, right_y0 + 214.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, "Reload:", right_x0 + 52.0 * panel_scale, right_y0 + 230.0 * panel_scale, 1.0 * panel_scale, text_color)
+        draw_small_text(font, input_code_name(reload_key), right_x0 + 180.0 * panel_scale, right_y0 + 230.0 * panel_scale, 1.0 * panel_scale, text_color)