doom 0.6.0 → 0.11.0

data/lib/doom/platform/gosu_window.rb

@@ -1,75 +1,62 @@
 # frozen_string_literal: true
 
 require 'gosu'
+require_relative 'sdl'
+require_relative 'window_logic'
 
 module Doom
   module Platform
     class GosuWindow < Gosu::Window
       SCALE = 3
 
-      # Movement constants (matching Chocolate Doom P_Thrust / P_XYMovement)
-      # DOOM: terminal walk speed = 7.55 units/tic = 264 units/sec
-      # Continuous-time: v_terminal = thrust_rate / decay_rate
-      # decay_rate = -ln(0.90625) * 35 = 3.44/sec
-      # thrust_rate = 264 * 3.44 = 908 units/sec^2
-      MOVE_THRUST_RATE = 264.0 * 3.44     # Thrust rate (units/sec^2)
-      FRICTION_DECAY_RATE = 3.44           # Friction decay (1/sec)
-      STOPSPEED = 0.5                      # Snap-to-zero threshold (units/sec)
-      TURN_SPEED = 3.0       # Degrees per frame
-      MOUSE_SENSITIVITY = 0.15  # Mouse look sensitivity
-      PLAYER_RADIUS = 16.0   # Collision radius
-
-      USE_DISTANCE = 64.0  # Max distance to use a linedef
-
-      # Solid thing types with their collision radii (from mobjinfo[] MF_SOLID)
-      # Monsters, barrels, pillars, lamps, torches, trees block player movement
-      SOLID_THING_RADIUS = {
-        9 => 20, 65 => 20, 66 => 20, 67 => 20, 68 => 20, # Shotgun Guy variants
-        3004 => 20, 84 => 20,                               # Zombieman
-        3001 => 20,                                          # Imp
-        3002 => 30, 58 => 30,                                # Demon, Spectre
-        3003 => 24, 69 => 24,                                # Baron, Hell Knight
-        3006 => 16,                                          # Lost Soul
-        3005 => 31,                                          # Cacodemon
-        16 => 40,                                            # Cyberdemon
-        7 => 128,                                            # Spider Mastermind
-        64 => 20,                                            # Archvile
-        71 => 31,                                            # Pain Elemental
-        2035 => 10,                                          # Barrel
-        2028 => 16,                                          # Tall lamp
-        48 => 16, 30 => 16, 32 => 16,                       # Tech column, green/red pillars
-        31 => 16, 33 => 16, 36 => 16,                       # Short pillars
-        41 => 16, 43 => 16,                                  # Evil eye, burnt tree
-        54 => 32,                                            # Brown tree
-        44 => 16, 45 => 16, 46 => 16,                       # Tall torches
-        55 => 16, 56 => 16, 57 => 16,                       # Short torches
-        47 => 16, 70 => 16,                                  # Stubs
-        85 => 16, 86 => 16,                                  # Tall tech lamps
-        2046 => 16,                                          # Burning barrel
-      }.freeze
-
-      def initialize(renderer, palette, map, player_state = nil, status_bar = nil, weapon_renderer = nil, sector_actions = nil, animations = nil, sector_effects = nil, item_pickup = nil, combat = nil, monster_ai = nil)
+      # Movement now lives in Game::PlayerPhysics and runs per tic, so the old
+      # continuous-time thrust/friction constants moved there with it.
+      TURN_SPEED = 3.0 # Degrees per tic
+
+      # Frame generation is decoupled from presentation. Gosu's main loop is
+      # limited by the buffer swap, which blocks on vblank -- so drawing every
+      # iteration pins the whole engine to the monitor's refresh rate. Instead
+      # we render every iteration (in update) but only ask Gosu to present when
+      # a refresh interval has elapsed; needs_redraw? => false skips both the
+      # blit and the swap, letting the loop spin freely in between.
+      #
+      # Gosu 1.4 exposes no refresh-rate API, so we ask SDL (see
+      # SDLDisplayMode) and fall back to 60 Hz if it will not say.
+      DEFAULT_REFRESH_HZ = 60.0
+      PRESENT_INTERVAL_SLACK = 0.85 # Aim slightly early so we don't miss a vblank
+      MOUSE_SENSITIVITY = 0.15 # Mouse look sensitivity
+
+      # The simulation now lives in Game::World; this class is input and
+      # output only. The world's subsystems are cached in ivars because the
+      # automap, debug overlay and HUD read them constantly -- bind_world keeps
+      # those caches honest whenever the world is rebuilt.
+      def initialize(renderer, palette, world, status_bar = nil, weapon_renderer = nil,
+                     animations = nil, menu = nil, sound_engine = nil, session: nil, client: nil)
         fullscreen = ARGV.include?('--fullscreen') || ARGV.include?('-f')
         super(Render::SCREEN_WIDTH * SCALE, Render::SCREEN_HEIGHT * SCALE, fullscreen)
         self.caption = 'Doom Ruby'
-        self.update_interval = 0  # Uncap framerate (default 16.67ms = 60 FPS cap)
+        self.update_interval = 0 # Uncap framerate (default 16.67ms = 60 FPS cap)
+        SDLKeyboardGrab.setup
 
         @renderer = renderer
         @palette = palette
-        @map = map
-        @player_state = player_state
         @status_bar = status_bar
         @weapon_renderer = weapon_renderer
-        @sector_actions = sector_actions
         @animations = animations
-        @sector_effects = sector_effects
-        @item_pickup = item_pickup
-        @combat = combat
-        @monster_ai = monster_ai
-        @last_floor_height = nil
-        @move_momx = 0.0
-        @move_momy = 0.0
-        @leveltime = 0
+        @menu = menu
+        @doom_font = menu&.font
+        @sound = sound_engine
+        @skill = Game::Menu::SKILL_MEDIUM
+        @session = session
+        @client = client # authoritative-server client, if we joined one
+        @local_player_id = session&.local_id || client&.local_id || 0
+        @last_tic_at = Time.now  # for interpolating between server frames
+        @last_net_send_at = nil  # throttles outbound packets to the tic rate
+        @client_input_window = [] # recent [tic, ticcmd] resent against loss
+        menu.netgame = true if menu && (session || client)
+
+        bind_world(world)
+        @pending_turn = 0.0 # Mouse turn accumulated between tics
         @tic_accumulator = 0.0
         @screen_image = nil
         @mouse_captured = false
@@ -78,17 +65,30 @@ module Doom
         @use_pressed = false
         @show_debug = false
         @show_map = false
-        @debug_font = Gosu::Font.new(16)
+        @screen_melt = nil
+        @intermission = nil
+        @current_map = 'E1M1'
+        @debug_font = Gosu::Font.new(24)
         @fps_frames = 0
         @fps_time = Time.now
         @fps_display = 0.0
 
+        # Uncapped frame generation. Presented frames are counted separately so
+        # the overlay can show both the render rate and what the display got.
+        @uncapped_fps = !ARGV.include?('--vsync')
+        menu.options[:uncapped_fps] = @uncapped_fps if menu
+        @present_frames = 0
+        @present_fps_display = 0.0
+        @last_present_ms = 0
+        @refresh_hz = (SDLDisplayMode.refresh_rate || DEFAULT_REFRESH_HZ).to_f
+        @present_interval_ms = 1000.0 / @refresh_hz
+
         # Precompute sector colors for automap
         @sector_colors = build_sector_colors
 
         # Pre-build palette RGBA lookups for all 14 palettes (0=normal, 1-8=pain red)
         @all_palette_rgba = []
-        wad = renderer.instance_variable_get(:@wad)
+        wad = renderer.wad
         14.times do |pal_idx|
           pal = Wad::Palette.load(wad, pal_idx)
           @all_palette_rgba << pal.colors.map { |r, g, b| [r, g, b, 255].pack('CCCC') }
@@ -96,277 +96,257 @@ module Doom
         @palette_rgba = @all_palette_rgba[0]
       end
 
-      def update
-        # Calculate delta time for smooth animations
-        now = Time.now
-        delta_time = now - @last_update_time
-        @last_update_time = now
-
-        handle_input(delta_time)
-
-        # Update player state (per-frame for smooth bob)
-        if @player_state
-          @player_state.update_bob(delta_time)
-          @player_state.update_view_bob(delta_time)
-        end
-
-        # Advance game tics at 35/sec (DOOM's tic rate)
-        @tic_accumulator += delta_time * 35.0
+      def advance_local
         while @tic_accumulator >= 1.0
-          @leveltime += 1
           @tic_accumulator -= 1.0
-          @sector_effects&.update
-          @player_state&.update_viewheight
-          @player_state&.update_attack  # Attack timing at 35fps like DOOM
-          @combat&.update
-          @monster_ai&.update(@renderer.player_x, @renderer.player_y)
-
-          @player_state&.update_damage_count
-
-          # Sector damage (nukage, lava, etc.) every 32 tics
-          if @player_state && !@player_state.dead && (@leveltime % 32 == 0)
-            check_sector_damage
-          end
-
-          # Track death tic for death animation
-          if @player_state&.dead
-            @player_state.death_tic += 1
-          end
-        end
-        @animations&.update(@leveltime)
-
-        # Update HUD animations
-        @status_bar&.update
-
-        # Update sector actions (doors, lifts, etc.)
-        if @sector_actions
-          @sector_actions.update_player_position(@renderer.player_x, @renderer.player_y)
-          @sector_actions.update
+          @leveltime = @world.run_tic(@player.id => build_ticcmd)
+          @item_pickup.update_flash
         end
+      end
 
-        # Check item pickups
-        if @item_pickup
-          @item_pickup.update(@renderer.player_x, @renderer.player_y)
-          @renderer.hidden_things = @item_pickup.picked_up
+      # Networked: input is sampled on the local clock but tics only run once
+      # every player's command for them has arrived. A stall is normal -- it
+      # means someone else's packet is late -- so we keep drawing and say who
+      # we are waiting for rather than freezing silently.
+      # Authoritative-server client: no local simulation at all. Poll the
+      # server's frame stream (Net::Client applies it), send this frame's input
+      # tagged a few tics ahead so it lands before that tic is finalized, and
+      # follow the world the client holds -- which it rebuilds from a fresh
+      # snapshot on a resync, so re-point at it when the object changes.
+      CLIENT_INPUT_LEAD = 3
+      # Outbound packets are paced to the tic rate, not the uncapped render loop:
+      # drawing runs at hundreds of FPS, and sending one packet per frame would
+      # flood the server (and, in P2P, every peer) from every phone in the room.
+      NET_SEND_INTERVAL = 1.0 / 35.0
+      # Each input packet repeats the last few tics of commands, so pacing the
+      # send rate down does not make a single dropped packet lose that input.
+      CLIENT_INPUT_REDUNDANCY = 4
+
+      def advance_server_client
+        @client.poll
+        bind_world(@client.world) unless @world.equal?(@client.world)
+
+        send_client_input
+
+        if @client.synced_tic != @leveltime
+          @leveltime = @client.synced_tic
+          @last_tic_at = Time.now
+          @item_pickup.update_flash
         end
+        # Fraction into the current tic, so rendering stays smooth above the
+        # server's 35 Hz frame rate.
+        @tic_accumulator = [(Time.now - @last_tic_at) * 35.0, 1.0].min
+      end
 
-        # Pass combat state to renderer for death frame rendering
-        @renderer.combat = @combat
-        @renderer.monster_ai = @monster_ai
-        @renderer.leveltime = @leveltime
-
-        # Render the 3D world
-        @renderer.render_frame
+      def advance_networked
+        @session.poll
 
-        # Render HUD on top
-        if @weapon_renderer && !@player_state&.dead
-          @weapon_renderer.render(@renderer.framebuffer)
-        end
-        if @status_bar
-          @status_bar.render(@renderer.framebuffer)
+        while @tic_accumulator >= 1.0
+          @tic_accumulator -= 1.0
+          @session.submit(build_ticcmd)
         end
+        # Lockstep already resends a redundancy window from each peer's ack, so
+        # pacing transmit to the tic rate loses nothing but the flood.
+        @session.transmit if net_send_due?
 
-        # Red tint when dead
-        if @player_state&.dead
-          apply_death_tint(@renderer.framebuffer)
-        end
+        ran = @session.run(@world, limit: 10)
+        ran.times { @item_pickup.update_flash }
+        @leveltime = @world.leveltime
       end
 
-      def handle_input(delta_time)
-        # Handle respawn when dead
-        if @player_state&.dead
-          if @player_state.death_tic > 35  # 1 second delay before respawn allowed
-            if Gosu.button_down?(Gosu::KB_SPACE) || Gosu.button_down?(Gosu::KB_X) ||
-               Gosu.button_down?(Gosu::MS_LEFT) || Gosu.button_down?(Gosu::KB_LEFT_SHIFT)
-              respawn_player
-            end
-          end
-          return  # No other input while dead
-        end
-
-        # Mouse look
-        handle_mouse_look
+      # Sample this frame's input for a near-future tic and send it, paced to the
+      # tic rate, with a short redundancy window against packet loss. Only the
+      # newest sample for a given target tic is kept.
+      def send_client_input
+        return unless net_send_due?
 
-        # Keyboard turning
-        if Gosu.button_down?(Gosu::KB_LEFT)
-          @renderer.turn(TURN_SPEED)
-        end
-        if Gosu.button_down?(Gosu::KB_RIGHT)
-          @renderer.turn(-TURN_SPEED)
+        tic = @client.synced_tic + CLIENT_INPUT_LEAD
+        if @client_input_window.last&.first == tic
+          @client_input_window[-1] = [tic, build_ticcmd]
+        else
+          @client_input_window << [tic, build_ticcmd]
         end
+        @client_input_window = @client_input_window.last(CLIENT_INPUT_REDUNDANCY)
+        @client.send_input(@client_input_window)
+      end
 
-        # Apply thrust from input (P_Thrust: additive, scaled by delta_time)
-        thrust = MOVE_THRUST_RATE * delta_time
-        has_input = false
+      # True at most once per tic interval, so outbound packets track the 35 Hz
+      # simulation rather than the uncapped frame rate. Advances the clock as a
+      # side effect when it fires.
+      def net_send_due?
+        now = Time.now
+        return false if @last_net_send_at && (now - @last_net_send_at) < NET_SEND_INTERVAL
 
-        if Gosu.button_down?(Gosu::KB_UP) || Gosu.button_down?(Gosu::KB_W)
-          @move_momx += @renderer.cos_angle * thrust
-          @move_momy += @renderer.sin_angle * thrust
-          has_input = true
-        end
-        if Gosu.button_down?(Gosu::KB_DOWN) || Gosu.button_down?(Gosu::KB_S)
-          @move_momx -= @renderer.cos_angle * thrust
-          @move_momy -= @renderer.sin_angle * thrust
-          has_input = true
-        end
-        if Gosu.button_down?(Gosu::KB_A)
-          @move_momx -= @renderer.sin_angle * thrust
-          @move_momy += @renderer.cos_angle * thrust
-          has_input = true
-        end
-        if Gosu.button_down?(Gosu::KB_D)
-          @move_momx += @renderer.sin_angle * thrust
-          @move_momy -= @renderer.cos_angle * thrust
-          has_input = true
-        end
+        @last_net_send_at = now
+        true
+      end
 
-        # Apply friction (continuous-time equivalent of *= 0.90625 per tic)
-        decay = Math.exp(-FRICTION_DECAY_RATE * delta_time)
-        if !has_input && @move_momx.abs < STOPSPEED && @move_momy.abs < STOPSPEED
-          @move_momx = 0.0
-          @move_momy = 0.0
-        else
-          @move_momx *= decay
-          @move_momy *= decay
-        end
+      # Point this window at a world, refreshing every cached reference. Called
+      # on construction and whenever the world is rebuilt (new map, respawn).
+      def bind_world(world)
+        @world = world
+        @map = world.map
+        @random = world.random
+        @player = world.player(@local_player_id) || world.add_player(id: @local_player_id)
+        apply_debug_pose if ENV['DOOM_DEBUG_POSE'] && !@debug_pose_applied
+        @player_state = @player.state
+        # The HUD holds the player state directly; re-point it, or a map change
+        # or a netgame resync (which builds a fresh world) leaves it on a stale
+        # player showing frozen health and ammo.
+        @status_bar.player = @player_state if @status_bar
+        @weapon_renderer.player = @player_state if @weapon_renderer
+        @physics = world.physics_for(@player)
+        @combat = world.combat
+        @monster_ai = world.monster_ai
+        @item_pickup = world.item_pickup
+        @sector_actions = world.sector_actions
+        @damage_multiplier = world.damage_multiplier
+        @leveltime = world.leveltime
+      end
 
-        # Track movement state for weapon/view bob
-        if @player_state
-          @player_state.is_moving = has_input
-          @player_state.set_movement_momentum(@move_momx, @move_momy)
-        end
+      def apply_debug_pose
+        x, y, angle = ENV.fetch('DOOM_DEBUG_POSE').split(',').map { |value| Float(value) }
+        sector = @map.sector_at(x, y)
+        @player.place(x, y, (sector&.floor_height || 0) + Game::PlayerState::VIEWHEIGHT, angle)
+        @debug_pose_applied = true
+      rescue ArgumentError
+        warn 'DOOM_DEBUG_POSE must be x,y,angle_degrees'
+      end
 
-        # Apply momentum with collision detection (scale by delta_time for frame-rate independence)
-        if @move_momx.abs > STOPSPEED || @move_momy.abs > STOPSPEED
-          try_move(@move_momx * delta_time, @move_momy * delta_time)
-        end
+      def update
+        # Calculate delta time for smooth animations
+        now = Time.now
+        delta_time = now - @last_update_time
+        @last_update_time = now
 
-        # Handle firing (left click, Z, or Shift - Ctrl conflicts with macOS spaces)
-        if @player_state && ((@mouse_captured && Gosu.button_down?(Gosu::MS_LEFT)) ||
-            Gosu.button_down?(Gosu::KB_X) || Gosu.button_down?(Gosu::KB_LEFT_SHIFT) ||
-            Gosu.button_down?(Gosu::KB_RIGHT_SHIFT))
-          was_attacking = @player_state.attacking
-          @player_state.start_attack
-          # Fire hitscan on the first frame of the attack
-          if @player_state.attacking && !was_attacking && @combat
-            @combat.fire(@renderer.player_x, @renderer.player_y, @renderer.player_z,
-                         @renderer.cos_angle, @renderer.sin_angle, @player_state.weapon)
+        # Menu is active -- only update menu animation, skip game logic.
+        #
+        # Except in a networked game, which must never stop simulating. Peers
+        # are waiting on our ticcmds and lockstep cannot skip a tic, so a
+        # paused peer stops the whole session; if the pause outlasts the
+        # commands the others still hold, it wedges permanently. DOOM does not
+        # pause netgames either. Input is neutral while the menu has focus, so
+        # navigating it does not also drive the player.
+        if @menu&.active?
+          @menu.update
+
+          if @session
+            @tic_accumulator += delta_time * 35.0
+            advance_networked
+          elsif @client
+            advance_server_client
           end
+          return
         end
 
-        # Handle weapon switching with number keys
-        handle_weapon_switch if @player_state
-
-        # Handle use key (spacebar or E)
-        handle_use_key if @sector_actions
-      end
-
-      def handle_use_key
-        use_down = Gosu.button_down?(Gosu::KB_SPACE) || Gosu.button_down?(Gosu::KB_E)
-
-        if use_down && !@use_pressed
-          @use_pressed = true
-          try_use_linedef
-        elsif !use_down
-          @use_pressed = false
+        # Intermission screen active
+        if @intermission
+          @intermission.update
+          return
         end
-      end
 
-      def try_use_linedef
-        # Cast a ray forward to find a usable linedef
-        player_x = @renderer.player_x
-        player_y = @renderer.player_y
-        cos_angle = @renderer.cos_angle
-        sin_angle = @renderer.sin_angle
+        handle_input(delta_time)
 
-        # Check point in front of player
-        use_x = player_x + cos_angle * USE_DISTANCE
-        use_y = player_y + sin_angle * USE_DISTANCE
+        # Advance the simulation at 35/sec (DOOM's tic rate). Everything that
+        # decides what happens now lives in Game::World; this loop only decides
+        # how many tics are owed and hands over the input for each.
+        @tic_accumulator += delta_time * 35.0
+        if @session
+          advance_networked
+        elsif @client
+          advance_server_client
+        else
+          advance_local
+        end
 
-        # Find the closest linedef the player is facing
-        best_linedef = nil
-        best_idx = nil
-        best_dist = Float::INFINITY
+        @animations&.update(@leveltime)
+        @status_bar&.update
+        @renderer.hidden_things = @world.hidden_things
 
-        @map.linedefs.each_with_index do |linedef, idx|
-          next if linedef.special == 0  # Skip non-special linedefs
+        trigger_level_exit(@world.exit_triggered) if @world.exit_triggered && !@intermission
 
-          v1 = @map.vertices[linedef.v1]
-          v2 = @map.vertices[linedef.v2]
+        # Other players are drawn as sprites; the local one never is.
+        @renderer.players = @world.players
+        @renderer.view_player = @player
 
-          # Check if player is close enough to the linedef
-          dist = point_to_line_distance(player_x, player_y, v1.x, v1.y, v2.x, v2.y)
-          next if dist > USE_DISTANCE
-          next if dist >= best_dist
+        # Pass combat state to renderer for death frame rendering
+        @renderer.combat = @combat
+        @renderer.monster_ai = @monster_ai
+        @renderer.leveltime = @leveltime
 
-          # Check if player is facing the linedef (on the front side)
-          next unless facing_linedef?(player_x, player_y, cos_angle, sin_angle, v1, v2)
+        # Render the 3D world. This is the generated-frame rate: it runs every
+        # loop iteration, whether or not the result gets presented.
+        @renderer.render_frame
+        track_frame_rates
 
-          best_linedef = linedef
-          best_idx = idx
-          best_dist = dist
-        end
+        # Render HUD on top
+        @weapon_renderer.render(@renderer.framebuffer) if @weapon_renderer && !@player_state&.dead
+        @status_bar.render(@renderer.framebuffer) if @status_bar
 
-        if best_linedef
-          @sector_actions.use_linedef(best_linedef, best_idx)
+        # Pickup message (drawn into framebuffer with DOOM font, 4 seconds like Chocolate Doom)
+        if @doom_font && @item_pickup&.pickup_message && @item_pickup.message_tics > 0
+          @doom_font.draw_text(@renderer.framebuffer, @item_pickup.pickup_message, 2, 2)
         end
-      end
-
-      def point_to_line_distance(px, py, x1, y1, x2, y2)
-        # Vector from line start to point
-        dx = px - x1
-        dy = py - y1
-
-        # Line direction vector
-        line_dx = x2 - x1
-        line_dy = y2 - y1
-        line_len_sq = line_dx * line_dx + line_dy * line_dy
-
-        return Math.sqrt(dx * dx + dy * dy) if line_len_sq == 0
-
-        # Project point onto line, clamped to segment
-        t = ((dx * line_dx) + (dy * line_dy)) / line_len_sq
-        t = [[t, 0.0].max, 1.0].min
 
-        # Closest point on line segment
-        closest_x = x1 + t * line_dx
-        closest_y = y1 + t * line_dy
+        # Red tint when dead
+        return unless @player_state&.dead
 
-        # Distance from point to closest point on segment
-        dist_x = px - closest_x
-        dist_y = py - closest_y
-        Math.sqrt(dist_x * dist_x + dist_y * dist_y)
+        hold_pain_palette
       end
 
-      def facing_linedef?(px, py, cos_angle, sin_angle, v1, v2)
-        # Calculate linedef normal (perpendicular to line, pointing to front side)
-        line_dx = v2.x - v1.x
-        line_dy = v2.y - v1.y
-
-        # Normal points to the right of the line direction
-        normal_x = -line_dy
-        normal_y = line_dx
-
-        # Normalize
-        len = Math.sqrt(normal_x * normal_x + normal_y * normal_y)
-        return false if len == 0
-
-        normal_x /= len
-        normal_y /= len
+      # Per-frame input sampling. Produces nothing but intent: the simulation
+      # itself runs per-tic in Game::World (fed the ticcmd from build_ticcmd).
+      # Mouse motion is accumulated here because frames are more frequent than
+      # tics and dropping the surplus would lose part of every flick.
+      def handle_input(_delta_time)
+        # Handle respawn when dead. Local play only: respawn rebuilds the level,
+        # which in a networked game would desync us from everyone else, so there
+        # it is the server's job (not yet wired -- dead players stay down).
+        if @player_state&.dead
+          if !@session && !@client && @player_state.death_tic > 35 && (Gosu.button_down?(Gosu::KB_SPACE) || Gosu.button_down?(Gosu::KB_X) ||
+               Gosu.button_down?(Gosu::MS_LEFT) || Gosu.button_down?(Gosu::KB_LEFT_SHIFT))
+            respawn_player
+          end
+          return # No other input while dead
+        end
 
-        # Check if player is on the front side (normal side) of the line
-        to_player_x = px - v1.x
-        to_player_y = py - v1.y
-        dot_player = to_player_x * normal_x + to_player_y * normal_y
+        handle_mouse_look # accumulates into @pending_turn
+        handle_weapon_switch if @player_state
+      end
 
-        # Player must be on front side
-        return false if dot_player < 0
+      # Collect this tic's intent. Everything that moves the player must come
+      # through here, so that replacing it with a ticcmd off the network is the
+      # only change multiplayer needs.
+      def build_ticcmd
+        return Game::Ticcmd.none if @menu&.active?
+        return Game::Ticcmd.none if @player_state&.dead
+
+        forward = 0.0
+        side = 0.0
+        forward += 1.0 if Gosu.button_down?(Gosu::KB_UP) || Gosu.button_down?(Gosu::KB_W)
+        forward -= 1.0 if Gosu.button_down?(Gosu::KB_DOWN) || Gosu.button_down?(Gosu::KB_S)
+        side += 1.0 if Gosu.button_down?(Gosu::KB_D)
+        side -= 1.0 if Gosu.button_down?(Gosu::KB_A)
+
+        turn = @pending_turn
+        @pending_turn = 0.0
+        turn += TURN_SPEED if Gosu.button_down?(Gosu::KB_LEFT)
+        turn -= TURN_SPEED if Gosu.button_down?(Gosu::KB_RIGHT)
+
+        buttons = 0
+        if (@mouse_captured && Gosu.button_down?(Gosu::MS_LEFT)) ||
+           Gosu.button_down?(Gosu::KB_LEFT_CONTROL) || Gosu.button_down?(Gosu::KB_RIGHT_CONTROL) ||
+           Gosu.button_down?(Gosu::KB_X) || Gosu.button_down?(Gosu::KB_LEFT_SHIFT) ||
+           Gosu.button_down?(Gosu::KB_RIGHT_SHIFT)
+          buttons |= Game::Ticcmd::BTN_FIRE
+        end
+        buttons |= Game::Ticcmd::BTN_USE if Gosu.button_down?(Gosu::KB_SPACE) || Gosu.button_down?(Gosu::KB_E)
 
-        # Check if player is facing toward the line
-        dot_facing = cos_angle * (-normal_x) + sin_angle * (-normal_y)
-        dot_facing > 0.5  # Must be roughly facing the line
+        Game::Ticcmd.new(forward, side, turn, buttons)
       end
 
+      # Weapon selection from the number keys. Read per-frame like the rest of
+      # input; the switch itself only changes which weapon the HUD/firing use.
       def handle_weapon_switch
         if Gosu.button_down?(Gosu::KB_1)
           @player_state.switch_weapon(Game::PlayerState::WEAPON_FIST)
@@ -385,361 +365,412 @@ module Doom
         end
       end
 
-      def try_move(dx, dy)
-        old_x = @renderer.player_x
-        old_y = @renderer.player_y
-        new_x = old_x + dx
-        new_y = old_y + dy
+      # Lazily computed and cached on first access; cleared by load_next_map.
+      def map_bounds
+        return @map_bounds if defined?(@map_bounds) && @map_bounds
 
-        # Check if new position is valid and path doesn't cross blocking linedefs
-        if valid_move?(old_x, old_y, new_x, new_y)
-          @renderer.move_to(new_x, new_y)
-          update_player_height(new_x, new_y)
-        else
-          # Wall sliding: project movement along the blocking wall
-          slide_x, slide_y = compute_slide(old_x, old_y, dx, dy)
-          if slide_x && (slide_x != 0.0 || slide_y != 0.0)
-            sx = old_x + slide_x
-            sy = old_y + slide_y
-            if valid_move?(old_x, old_y, sx, sy)
-              @renderer.move_to(sx, sy)
-              update_player_height(sx, sy)
-              # Redirect momentum along the wall
-              @move_momx = slide_x / ([dx.abs, dy.abs].max.nonzero? || 1) * @move_momx.abs
-              @move_momy = slide_y / ([dx.abs, dy.abs].max.nonzero? || 1) * @move_momy.abs
-              return
-            end
-          end
-
-          # Fallback: try axis-aligned sliding
-          if dx != 0.0 && valid_move?(old_x, old_y, new_x, old_y)
-            @renderer.move_to(new_x, old_y)
-            update_player_height(new_x, old_y)
-            @move_momy *= 0.0
-          elsif dy != 0.0 && valid_move?(old_x, old_y, old_x, new_y)
-            @renderer.move_to(old_x, new_y)
-            update_player_height(old_x, new_y)
-            @move_momx *= 0.0
-          else
-            # Fully blocked - kill momentum
-            @move_momx = 0.0
-            @move_momy = 0.0
-          end
-        end
-      end
-
-      # Find the blocking linedef and project movement along it
-      def compute_slide(px, py, dx, dy)
-        best_wall = nil
-        best_dist = Float::INFINITY
-
-        @map.linedefs.each do |linedef|
-          v1 = @map.vertices[linedef.v1]
-          v2 = @map.vertices[linedef.v2]
-
-          # Only check linedefs near the player
-          next unless line_circle_intersect?(v1.x, v1.y, v2.x, v2.y, px + dx, py + dy, PLAYER_RADIUS)
-
-          # Check if this linedef actually blocks
-          next unless linedef_blocks?(linedef, px + dx, py + dy) ||
-                      crosses_blocking_linedef?(px, py, px + dx, py + dy, linedef)
-
-          # Distance from player to this linedef
-          dist = point_to_line_distance(px, py, v1.x, v1.y, v2.x, v2.y)
-          if dist < best_dist
-            best_dist = dist
-            best_wall = linedef
-          end
+        min_x = min_y = Float::INFINITY
+        max_x = max_y = -Float::INFINITY
+        @map.vertices.each do |v|
+          min_x = v.x if v.x < min_x
+          max_x = v.x if v.x > max_x
+          min_y = v.y if v.y < min_y
+          max_y = v.y if v.y > max_y
         end
+        return nil if max_x == min_x || max_y == min_y
 
-        return nil unless best_wall
-
-        # Get wall direction vector
-        v1 = @map.vertices[best_wall.v1]
-        v2 = @map.vertices[best_wall.v2]
-        wall_dx = (v2.x - v1.x).to_f
-        wall_dy = (v2.y - v1.y).to_f
-        wall_len = Math.sqrt(wall_dx * wall_dx + wall_dy * wall_dy)
-        return nil if wall_len == 0
-
-        wall_dx /= wall_len
-        wall_dy /= wall_len
-
-        # Project movement onto wall direction
-        dot = dx * wall_dx + dy * wall_dy
-        [dot * wall_dx, dot * wall_dy]
+        @map_bounds = { min_x: min_x, max_x: max_x, min_y: min_y, max_y: max_y }
       end
 
-      def update_player_height(x, y)
-        sector = @map.sector_at(x, y)
-        return unless sector
-
-        new_floor = sector.floor_height
+      def handle_mouse_look
+        return unless @mouse_captured
 
-        if @player_state
-          # Detect step: floor height changed since last move
-          if @last_floor_height && @last_floor_height != new_floor
-            step = new_floor - @last_floor_height
-            @player_state.notify_step(step) if step.abs <= 24
-          end
-          @last_floor_height = new_floor
+        current_x = mouse_x
+        if @last_mouse_x
+          delta_x = current_x - @last_mouse_x
+          # Accumulate rather than turn: the turn is applied by the next ticcmd,
+          # so fast mouse motion between tics is summed instead of dropped.
+          @pending_turn -= delta_x * MOUSE_SENSITIVITY if delta_x != 0
+        end
 
-          view_bob = @player_state.view_bob_offset
-          @renderer.set_z(new_floor + @player_state.viewheight + view_bob)
+        # Keep mouse centered
+        center_x = width / 2
+        if (current_x - center_x).abs > 50
+          self.mouse_x = center_x
+          @last_mouse_x = center_x
         else
-          @renderer.set_z(new_floor + 41)
+          @last_mouse_x = current_x
         end
       end
 
-      def valid_move?(old_x, old_y, new_x, new_y)
-        # Check if destination is inside a valid sector
-        sector = @map.sector_at(new_x, new_y)
-        return false unless sector
+      # Gosu calls this before draw; false skips both the blit and the buffer
+      # swap, so the main loop keeps generating frames without waiting on the
+      # display. Returning true unconditionally restores plain vsync behaviour.
+      def needs_redraw?
+        return true unless @uncapped_fps
 
-        # Check floor height - can't step up too high
-        floor_height = sector.floor_height
-        return false if floor_height > @renderer.player_z + 24  # Max step height
+        WindowLogic.present_due?(Gosu.milliseconds, @last_present_ms,
+                                 @present_interval_ms, PRESENT_INTERVAL_SLACK)
+      end
 
-        # Check against blocking linedefs: both circle intersection and path crossing
-        @map.linedefs.each do |linedef|
-          if linedef_blocks?(linedef, new_x, new_y)
-            return false
-          end
-          if crosses_blocking_linedef?(old_x, old_y, new_x, new_y, linedef)
-            return false
-          end
-        end
+      attr_reader :refresh_hz
 
-        # Check against solid things (monsters, barrels, pillars, etc.)
-        combined_radius = PLAYER_RADIUS
-        picked = @item_pickup&.picked_up
-        @map.things.each_with_index do |thing, idx|
-          next if picked && picked[idx]
-          next if @combat && @combat.dead?(idx)
-          thing_radius = SOLID_THING_RADIUS[thing.type]
-          next unless thing_radius
-
-          dx = new_x - thing.x
-          dy = new_y - thing.y
-          min_dist = combined_radius + thing_radius
-          if dx * dx + dy * dy < min_dist * min_dist
-            return false
-          end
-        end
+      # Frames generated vs frames actually shown. With uncapped rendering the
+      # first number can run well above the second, which is the whole point.
+      def track_frame_rates
+        @fps_frames += 1
+        now = Time.now
+        elapsed = now - @fps_time
+        return if elapsed < 0.5
 
-        true
+        @fps_display = (@fps_frames / elapsed).round(1)
+        @present_fps_display = (@present_frames / elapsed).round(1)
+        @fps_frames = 0
+        @present_frames = 0
+        @fps_time = now
       end
 
-      # Check if movement from (x1,y1) to (x2,y2) crosses a blocking linedef
-      def crosses_blocking_linedef?(x1, y1, x2, y2, linedef)
-        v1 = @map.vertices[linedef.v1]
-        v2 = @map.vertices[linedef.v2]
-
-        # One-sided linedef always blocks crossing
-        if linedef.sidedef_left == 0xFFFF
-          return segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
+      def draw
+        @present_frames += 1
+        @last_present_ms = Gosu.milliseconds
+
+        # Aim the camera at the local player. The simulation runs at 35 Hz but
+        # we draw as fast as we can, so interpolate between the previous tic's
+        # pose and the current one by however far into the tic we are.
+        @renderer.apply_view(*@player.view_pose(@tic_accumulator))
+
+        # Intermission screen
+        if @intermission
+          fb = Array.new(Render::SCREEN_WIDTH * Render::SCREEN_HEIGHT, 0)
+          @intermission.render(fb)
+          present(fb)
+          return
         end
 
-        # BLOCKING flag blocks crossing even on two-sided linedefs
-        if (linedef.flags & 0x0001) != 0
-          return segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
+        # Screen melt effect in progress
+        if @screen_melt && !@screen_melt.done?
+          fb = Array.new(Render::SCREEN_WIDTH * Render::SCREEN_HEIGHT, 0)
+          @screen_melt.update(fb)
+          present(fb)
+          @screen_melt = nil if @screen_melt.done?
+          return
         end
 
-        # Two-sided: check if impassable (high step OR low ceiling)
-        front_side = @map.sidedefs[linedef.sidedef_right]
-        back_side = @map.sidedefs[linedef.sidedef_left]
-        front_sector = @map.sectors[front_side.sector]
-        back_sector = @map.sectors[back_side.sector]
+        if @menu&.active?
+          hardware = @renderer.respond_to?(:hardware?) && @renderer.hardware?
+          if hardware && @menu.needs_background?
+            sync_renderer_visual_options
+            @renderer.draw_hardware(width, height)
+            draw_hardware_hud(menu: true)
+            return
+          elsif @menu.needs_background?
+            # Render game view + HUD as background, then overlay menu on top
+            @renderer.render_frame
+            @weapon_renderer&.render(@renderer.framebuffer) unless @player_state&.dead
+            @status_bar&.render(@renderer.framebuffer)
+            fb = @renderer.framebuffer.dup
+          else
+            # Title screen: black background
+            fb = Array.new(Render::SCREEN_WIDTH * Render::SCREEN_HEIGHT, 0)
+          end
+          @menu.render(fb, nil)
 
-        step = (back_sector.floor_height - front_sector.floor_height).abs
-        min_ceiling = [front_sector.ceiling_height, back_sector.ceiling_height].min
-        max_floor = [front_sector.floor_height, back_sector.floor_height].max
+          # Capture current menu frame for melt transitions
+          @last_menu_fb = fb.dup
 
-        # Passable if step is small AND enough headroom
-        return false if step <= 24 && (min_ceiling - max_floor) >= 56
+          present(fb)
+        elsif @show_map
+          draw_automap
+        else
+          if @renderer.respond_to?(:hardware?) && @renderer.hardware?
+            sync_renderer_visual_options
+            @renderer.draw_hardware(width, height)
+            draw_hardware_hud
+          else
+            present(@renderer.framebuffer, active_palette_index)
+          end
 
-        segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
+          draw_debug_overlay if @show_debug
+          draw_net_status if @session
+          draw_match_status if @world.deathmatch?
+        end
       end
 
-      # Test if line segment (ax1,ay1)-(ax2,ay2) intersects (bx1,by1)-(bx2,by2)
-      def segments_intersect?(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2)
-        d1x = ax2 - ax1
-        d1y = ay2 - ay1
-        d2x = bx2 - bx1
-        d2y = by2 - by1
-
-        denom = d1x * d2y - d1y * d2x
-        return false if denom.abs < 0.001  # Parallel
-
-        dx = bx1 - ax1
-        dy = by1 - ay1
-
-        t = (dx * d2y - dy * d2x).to_f / denom
-        u = (dx * d1y - dy * d1x).to_f / denom
-
-        t > 0.0 && t < 1.0 && u >= 0.0 && u <= 1.0
+      # Blit one palette-indexed framebuffer to the window. pal_idx selects one
+      # of the 14 prebuilt RGBA palettes (0 = normal, 1-8 = pain red, 9 = pickup
+      # yellow). All four draw paths funnel through here so the blob->image->draw
+      # sequence lives in exactly one place.
+      def present(framebuffer, pal_idx = 0)
+        active_pal = @all_palette_rgba[pal_idx]
+        rgba = framebuffer.map { |idx| active_pal[idx] }.join
+        @screen_image = Gosu::Image.from_blob(
+          Render::SCREEN_WIDTH, Render::SCREEN_HEIGHT, rgba
+        )
+        @screen_image.draw(0, 0, 0, SCALE, SCALE)
       end
 
-      def linedef_blocks?(linedef, x, y)
-        v1 = @map.vertices[linedef.v1]
-        v2 = @map.vertices[linedef.v2]
-
-        # Check if player circle intersects this line
-        return false unless line_circle_intersect?(v1.x, v1.y, v2.x, v2.y, x, y, PLAYER_RADIUS)
-
-        # One-sided linedef (wall) always blocks
-        return true if linedef.sidedef_left == 0xFFFF
-
-        # BLOCKING flag (0x0001) blocks even on two-sided linedefs (e.g., windows)
-        return true if (linedef.flags & 0x0001) != 0
-
-        # Two-sided: check if impassable (high step OR low ceiling)
-        front_side = @map.sidedefs[linedef.sidedef_right]
-        back_side = @map.sidedefs[linedef.sidedef_left]
-
-        front_sector = @map.sectors[front_side.sector]
-        back_sector = @map.sectors[back_side.sector]
-
-        step = (back_sector.floor_height - front_sector.floor_height).abs
-        min_ceiling = [front_sector.ceiling_height, back_sector.ceiling_height].min
-        max_floor = [front_sector.floor_height, back_sector.floor_height].max
+      # Hardware world rendering bypasses the indexed framebuffer. Build a
+      # transparent indexed overlay for the existing weapon/status renderers,
+      # preserving the gameplay UI while the world is drawn by OpenGL.
+      def draw_hardware_hud(menu: false)
+        # The weapon hand is a held object, so the world's light colours it: tint
+        # it by the light where the player stands (lamps, the flashlight). Drawn
+        # on its own so only it is lit -- never while a menu is up or the player
+        # is dead.
+        unless menu || @player_state&.dead
+          weapon = new_hud_overlay
+          @weapon_renderer&.render(weapon)
+          blit_hud_overlay(weapon, active_palette_index, weapon_light_tint)
+        end
 
-        # Block if step too high OR not enough headroom
-        step > 24 || (min_ceiling - max_floor) < 56
+        # HUD, pickup message and menu: readable UI, never lit by the world. The
+        # menu also drops the pain/pickup tint (normal palette), as the classic
+        # present(fb) path does.
+        hud = new_hud_overlay
+        @status_bar&.render(hud)
+        if @doom_font && @item_pickup&.pickup_message && @item_pickup.message_tics.positive?
+          @doom_font.draw_text(hud, @item_pickup.pickup_message, 2, 2)
+        end
+        @menu.render(hud, nil) if menu
+        blit_hud_overlay(hud, menu ? 0 : active_palette_index, nil)
       end
 
-      def line_circle_intersect?(x1, y1, x2, y2, cx, cy, radius)
-        # Vector from line start to circle center
-        dx = cx - x1
-        dy = cy - y1
-
-        # Line direction vector
-        line_dx = x2 - x1
-        line_dy = y2 - y1
-        line_len_sq = line_dx * line_dx + line_dy * line_dy
-
-        return false if line_len_sq == 0
+      def new_hud_overlay
+        Array.new(Render::SCREEN_WIDTH * Render::SCREEN_HEIGHT, -1)
+      end
 
-        # Project circle center onto line, clamped to segment
-        t = ((dx * line_dx) + (dy * line_dy)) / line_len_sq
-        t = [[t, 0.0].max, 1.0].min
+      # Blit an indexed overlay (transparent = -1) over the GL world, coloured by
+      # palette `pal_idx`; `tint` multiplies the whole image (nil = untinted).
+      def blit_hud_overlay(overlay, pal_idx, tint)
+        palette = @all_palette_rgba[pal_idx]
+        rgba = overlay.map { |index| index == -1 ? "\0\0\0\0" : palette[index] }.join
+        image = Gosu::Image.from_blob(Render::SCREEN_WIDTH, Render::SCREEN_HEIGHT, rgba)
+        if tint
+          image.draw(0, 0, 10, SCALE, SCALE, tint)
+        else
+          image.draw(0, 0, 10, SCALE, SCALE)
+        end
+      end
 
-        # Closest point on line segment
-        closest_x = x1 + t * line_dx
-        closest_y = y1 + t * line_dy
+      # The world light reaching the player, as a Gosu colour to multiply the
+      # weapon by. Only the hardware/ray-traced renderer computes this; the
+      # rasterizer leaves the weapon at full brightness.
+      def weapon_light_tint
+        return nil unless @renderer.respond_to?(:light_color_at)
 
-        # Distance from circle center to closest point
-        dist_x = cx - closest_x
-        dist_y = cy - closest_y
-        dist_sq = dist_x * dist_x + dist_y * dist_y
+        r, g, b = @renderer.light_color_at(@player.x, @player.y, @player.z)
+        Gosu::Color.rgba(hud_tint_byte(r), hud_tint_byte(g), hud_tint_byte(b), 255)
+      end
 
-        dist_sq < radius * radius
+      def hud_tint_byte(value)
+        (value * 255.0).clamp(0.0, 255.0).to_i
       end
 
-      def handle_mouse_look
-        return unless @mouse_captured
+      def sync_renderer_visual_options
+        return unless @menu
 
-        current_x = mouse_x
-        if @last_mouse_x
-          delta_x = current_x - @last_mouse_x
-          @renderer.turn(-delta_x * MOUSE_SENSITIVITY) if delta_x != 0
-        end
+        @renderer.fog_enabled = @menu.options[:fog] if @renderer.respond_to?(:fog_enabled=)
+        @renderer.flashlight_enabled = @menu.options[:flashlight] if @renderer.respond_to?(:flashlight_enabled=)
+        @renderer.bounces_enabled = @menu.options[:rt_bounces] if @renderer.respond_to?(:bounces_enabled=)
+      end
 
-        # Keep mouse centered
-        center_x = width / 2
-        if (current_x - center_x).abs > 50
-          self.mouse_x = center_x
-          @last_mouse_x = center_x
+      # Palette for the live game view: red pain flash while taking damage
+      # (1-8), yellow flash on item pickup (9), otherwise the normal palette.
+      def active_palette_index
+        if @item_pickup && @item_pickup.pickup_flash > 0
+          9
+        elsif @player_state
+          @player_state.damage_count.clamp(0, 8)
         else
-          @last_mouse_x = current_x
+          0
         end
       end
 
-      def draw
-        if @show_map
-          draw_automap
-        else
-          # Select palette: red tint when taking damage (palettes 1-8)
-          pal_idx = @player_state ? @player_state.damage_count.clamp(0, 8) : 0
-          active_pal = @all_palette_rgba[pal_idx]
-          rgba = @renderer.framebuffer.map { |idx| active_pal[idx] }.join
+      # Deathmatch scoreboard. One line of frags, and the result once someone
+      # has hit the limit -- the world decides who won, this only reports it.
+      def draw_match_status
+        score = @world.frags.map { |id, frags| "P#{id + 1} #{frags}" }.join('  ')
+        @debug_font.draw_text(score, 20, 20, 2, 1, 1, Gosu::Color::YELLOW)
 
-          @screen_image = Gosu::Image.from_blob(
-            Render::SCREEN_WIDTH,
-            Render::SCREEN_HEIGHT,
-            rgba
-          )
+        winner = @world.match_winner
+        return unless winner
 
-          @screen_image.draw(0, 0, 0, SCALE, SCALE)
+        line = "PLAYER #{winner.id + 1} WINS -- #{winner.frags} FRAGS"
+        @debug_font.draw_text(line, 22, (height / 3) + 2, 2, 1, 1, Gosu::Color::BLACK)
+        @debug_font.draw_text(line, 20, height / 3, 2, 1, 1, Gosu::Color::YELLOW)
+      end
 
-          draw_debug_overlay if @show_debug
+      # A lockstep stall looks exactly like a freeze unless we say otherwise,
+      # and a desync means everything on screen is already wrong -- both are
+      # worth interrupting the player for.
+      def draw_net_status
+        lines = WindowLogic.net_status_lines(
+          started: @session.started?,
+          host: @session.host?,
+          waiting: @session.waiting_on,
+          stalled_seconds: @session.stalled_seconds,
+          stall_threshold: Net::Session::STALL_WARNING_SECONDS,
+          desync: @session.desyncs.first
+        )
+
+        return if lines.empty?
+
+        y = height / 3
+        lines.each do |line|
+          @debug_font.draw_text(line, 22, y + 2, 2, 1, 1, Gosu::Color::BLACK)
+          @debug_font.draw_text(line, 20, y, 2, 1, 1, Gosu::Color::YELLOW)
+          y += 30
         end
       end
 
       def draw_debug_overlay
-        # Update FPS counter (refresh every 0.5 seconds)
-        @fps_frames += 1
-        now = Time.now
-        elapsed = now - @fps_time
-        if elapsed >= 0.5
-          @fps_display = (@fps_frames / elapsed).round(1)
-          @fps_frames = 0
-          @fps_time = now
-        end
-
-        sector = @map.sector_at(@renderer.player_x, @renderer.player_y)
-        return unless sector
-
-        # Find sector index
-        sector_idx = @map.sectors.index(sector)
-
-        lines = [
-          "FPS: #{@fps_display}",
-          "Sector #{sector_idx}",
-          "Floor: #{sector.floor_height} (#{sector.floor_texture})",
-          "Ceil:  #{sector.ceiling_height} (#{sector.ceiling_texture})",
-          "Light: #{sector.light_level}",
-          "Pos: #{@renderer.player_x.round}, #{@renderer.player_y.round}",
-          "Heading: #{(Math.atan2(@renderer.sin_angle, @renderer.cos_angle) * 180.0 / Math::PI).round(1)}",
-          "YJIT: #{defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled? ? 'ON' : 'OFF'} (Y to toggle)",
-        ]
+        yjit_status = defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled? ? 'ON' : 'OFF'
+        renderer_name = Render::RendererFactory.type_of(@renderer).to_s
+        ang = (Math.atan2(@player.sin_angle, @player.cos_angle) * 180.0 / Math::PI).round(1)
+
+        # Shown vs generated: only worth spelling out when they differ.
+        shown = if @uncapped_fps
+                  "shown #{@present_fps_display} / #{@refresh_hz.round} Hz"
+                else
+                  'vsync'
+                end
+
+        lines = if @menu&.options&.[](:rubykaigi_mode)
+                  [
+                    "#{@fps_display} FPS  (#{shown})",
+                    "YJIT: #{yjit_status}  (Y to toggle)",
+                    "Ruby #{RUBY_VERSION}",
+                    "Renderer: #{renderer_name}",
+                    "Map: #{@current_map}",
+                    "Pos: #{@player.x.round}, #{@player.y.round}",
+                    "Ang: #{ang}"
+                  ]
+                else
+                  [
+                    "FPS: #{@fps_display}  (#{shown})",
+                    "YJIT: #{yjit_status}",
+                    "Renderer: #{renderer_name}",
+                    "Pos: #{@player.x.round}, #{@player.y.round}",
+                    "Ang: #{ang}"
+                  ]
+                end
 
         y = 4
         lines.each do |line|
-          @debug_font.draw_text(line, 6, y + 1, 1, 1, 1, Gosu::Color::BLACK)
-          @debug_font.draw_text(line, 5, y, 1, 1, 1, Gosu::Color::WHITE)
-          y += 18
+          @debug_font.draw_text(line, 8, y + 2, 1, 1, 1, Gosu::Color::BLACK)
+          @debug_font.draw_text(line, 6, y, 1, 1, 1, Gosu::Color::WHITE)
+          y += 26
         end
       end
 
       def button_down(id)
+        # Intermission handles input
+        if @intermission
+          @intermission.handle_key
+          if @intermission.finished
+            next_map = @intermission.next_map
+            @intermission = nil
+            if next_map
+              load_next_map(next_map)
+            else
+              # Episode complete - return to menu
+              @menu&.show
+            end
+          end
+          return
+        end
+
+        # Menu handles input when active
+        if @menu&.active?
+          key = case id
+                when Gosu::KB_UP then :up
+                when Gosu::KB_DOWN then :down
+                when Gosu::KB_RETURN, Gosu::KB_SPACE then :enter
+                when Gosu::KB_ESCAPE then :escape
+                end
+          if key
+            # Play menu navigation sounds
+            case key
+            when :up, :down
+              @sound&.menu_move
+            when :escape
+              @sound&.menu_back
+            end
+
+            # Capture old screen before menu state change (for melt effect)
+            old_state = @menu.state
+            result = @menu.handle_key(key)
+            new_state = @menu.state
+
+            # Trigger melt when transitioning from title to main menu
+            if old_state == Game::Menu::STATE_TITLE && new_state == Game::Menu::STATE_MAIN && @last_menu_fb
+              if @renderer.respond_to?(:hardware?) && @renderer.hardware?
+                # The OpenGL scene has no palette-indexed snapshot for
+                # ScreenMelt. Draw it live on the next frame instead of
+                # melting toward HardwareRenderer's intentionally black
+                # compatibility framebuffer.
+                @screen_melt = nil
+              else
+                # Build the new screen (main menu with game background)
+                @renderer.render_frame
+                @weapon_renderer&.render(@renderer.framebuffer) unless @player_state&.dead
+                @status_bar&.render(@renderer.framebuffer)
+                new_fb = @renderer.framebuffer.dup
+                @menu.render(new_fb, nil)
+                @screen_melt = Render::ScreenMelt.new(@last_menu_fb, new_fb)
+              end
+            end
+
+            # Play confirmation sound on select
+            @sound&.menu_select if key == :enter
+
+            case result
+            when :start_game
+              # Restarting the level is local, so it would desync a netgame --
+              # for a lockstep peer or an authoritative-server client alike.
+              apply_difficulty(@menu.selected_skill) unless @session || @client
+            when :resume
+              @mouse_captured = true
+              SDLKeyboardGrab.grab!
+            when :quit
+              close
+            when Hash
+              handle_option_toggle(result[:option], result[:value]) if result[:action] == :toggle_option
+            end
+          end
+          return
+        end
+
         case id
         when Gosu::KB_ESCAPE
-          if @mouse_captured
-            @mouse_captured = false
-            self.mouse_x = width / 2
-            self.mouse_y = height / 2
-          else
-            close
-          end
+          SDLKeyboardGrab.release!
+          @mouse_captured = false
+          self.mouse_x = width / 2
+          self.mouse_y = height / 2
+          @menu&.show
         when Gosu::MS_LEFT, Gosu::KB_TAB
           unless @mouse_captured
             @mouse_captured = true
             @last_mouse_x = mouse_x
+            SDLKeyboardGrab.grab!
           end
         when Gosu::KB_Z
           @show_debug = !@show_debug
+        when Gosu::KB_R
+          switch_renderer
+        when Gosu::KB_B
+          @renderer.skip_background_fill = !@renderer.skip_background_fill
         when Gosu::KB_Y
           if defined?(RubyVM::YJIT)
             setup_yjit_toggle
             if RubyVM::YJIT.enabled?
               RubyVM::YJIT.disable
-              puts "YJIT disabled!"
             else
               RubyVM::YJIT.enable
-              puts "YJIT enabled!"
             end
           end
+        when Gosu::KB_C
+          @monster_ai.aggression = !@monster_ai.aggression if @monster_ai
         when Gosu::KB_M
           @show_map = !@show_map
         when Gosu::KB_F12
@@ -747,68 +778,223 @@ module Doom
         end
       end
 
-      # Sector damage types from DOOM (p_spec.c)
-      # Type 5: 10 damage, Type 7: 5 damage, Type 4/16: 20 damage
-      SECTOR_DAMAGE = { 5 => 10, 7 => 5, 4 => 20, 16 => 20, 11 => 20 }.freeze
-
-      def check_sector_damage
-        sector = @map.sector_at(@renderer.player_x, @renderer.player_y)
-        return unless sector
-
-        damage = SECTOR_DAMAGE[sector.special]
-        @player_state.take_damage(damage) if damage
+      def switch_renderer
+        Render::RendererFactory.type_of(@renderer)
+        target = Render::RendererFactory.next_type(@renderer)
+        replacement = Render::RendererFactory.build_like(@renderer, target)
+        replacement.apply_view(@renderer.player_x, @renderer.player_y,
+                               @renderer.player_z, @renderer.player_angle)
+        replacement.skip_background_fill = @renderer.skip_background_fill
+        @renderer = replacement
+        puts "Renderer: #{target}"
       end
 
-      def apply_death_tint(framebuffer)
-        # Death keeps damage_count at max so the pain palette stays red
+      # Death keeps damage_count pinned at max so the draw loop selects the red
+      # pain palette every frame while dead. The tint itself is applied by
+      # palette selection in #draw, not here.
+      def hold_pain_palette
         @player_state.damage_count = 8 if @player_state&.dead
       end
 
       def respawn_player
-        @player_state.reset
-        @last_floor_height = nil
-        @move_momx = 0.0
-        @move_momy = 0.0
+        if @world.deathmatch?
+          # Deathmatch death is personal: everyone else is still playing, so
+          # only this player comes back. restart_level would revive the monsters
+          # and restore the items under them.
+          @world.respawn(@player)
+        else
+          # Single player: death restarts the level, so the world rebuilds its
+          # actor subsystems and the cached references must be refreshed.
+          @world.restart_level(@player)
+        end
+        bind_world(@world)
+
+        # Re-apply active cheats from menu options
+        return unless @menu
+
+        opts = @menu.options
+        @player_state.god_mode = opts[:god_mode]
+        @player_state.infinite_ammo = opts[:infinite_ammo]
+        handle_option_toggle(:all_weapons, true) if opts[:all_weapons]
+        apply_rubykaigi_mode if opts[:rubykaigi_mode]
+      end
+
+      def handle_option_toggle(option, value)
+        # Belt and braces: the menu already hides these in a netgame, but a
+        # cheat applied on one machine only is a real desync, so refuse it
+        # here as well rather than trusting the menu to have filtered.
+        return if (@session || @client) && Game::Menu::NETGAME_UNSAFE_OPTIONS.include?(option)
+
+        case option
+        when :god_mode
+          @player_state.god_mode = value
+          @player_state.health = 100 if value
+        when :infinite_ammo
+          @player_state.infinite_ammo = value
+        when :all_weapons
+          if value
+            # Give all weapons that have sprites loaded
+            @gfx_weapons ||= @weapon_renderer&.gfx&.weapons || {}
+            (0..7).each do |w|
+              name = Game::PlayerState::WEAPON_NAMES[w]
+              @player_state.has_weapons[w] = true if @gfx_weapons[name]&.dig(:idle)
+            end
+            @player_state.ammo_bullets = @player_state.max_bullets
+            @player_state.ammo_shells = @player_state.max_shells
+            @player_state.ammo_rockets = @player_state.max_rockets
+            @player_state.ammo_cells = @player_state.max_cells
+          end
+        when :uncapped_fps
+          @uncapped_fps = value
+          # Re-read on re-enable: the window may have moved to a display with a
+          # different refresh rate.
+          if value
+            @refresh_hz = (SDLDisplayMode.refresh_rate || DEFAULT_REFRESH_HZ).to_f
+            @present_interval_ms = 1000.0 / @refresh_hz
+          end
+        when :fullscreen
+          self.fullscreen = value if respond_to?(:fullscreen=)
+        when :rubykaigi_mode
+          apply_rubykaigi_mode if value
+        end
+      end
+
+      def apply_rubykaigi_mode
+        return unless @menu&.options&.[](:rubykaigi_mode)
 
-        # Reset item pickup, combat, and monster AI state
-        sprites = @combat&.instance_variable_get(:@sprites)
-        @item_pickup = Game::ItemPickup.new(@map, @player_state) if @item_pickup
-        @combat = Game::Combat.new(@map, @player_state, sprites) if @combat && sprites
-        @monster_ai = Game::MonsterAI.new(@map, @combat) if @monster_ai && @combat
+        # God mode: invincible for stress-free demos
+        @player_state.god_mode = true
+        @player_state.health = 100
 
-        # Move player to start position
-        ps = @map.player_start
-        if ps
-          @renderer.set_player(ps.x, ps.y, 41, ps.angle)
-          update_player_height(ps.x, ps.y)
+        # All weapons + full ammo
+        handle_option_toggle(:all_weapons, true)
+        @player_state.infinite_ammo = true
+
+        # Monsters don't attack (peaceful exploration)
+        @monster_ai.aggression = false if @monster_ai
+
+        # Force debug overlay on (shows FPS + YJIT status)
+        @show_debug = true
+      end
+
+      def compute_skill_hidden(skill)
+        WindowLogic.skill_hidden(skill, @map.things)
+      end
+
+      def trigger_level_exit(exit_type)
+        # Gather stats
+        total_monsters = @monster_ai ? @monster_ai.monsters.size : 0
+        killed = @combat ? @combat.dead_things.size : 0
+
+        total_items = Game::ItemPickup::ITEMS.keys.count do |t|
+          @map.things.any? { |th| th.type == t }
         end
+        picked = @item_pickup ? @item_pickup.picked_up.size : 0
+
+        # Secret sectors (type 9) tracked by SectorActions
+        total_secrets = @map.sectors.count { |s| s.special == 9 }
+        found_secrets = @sector_actions ? @sector_actions.secrets_found.size : 0
+
+        stats = {
+          map: @current_map,
+          kills: killed, total_kills: total_monsters,
+          items: picked, total_items: total_items,
+          secrets: found_secrets, total_secrets: total_secrets,
+          time_tics: @leveltime,
+          exit_type: exit_type
+        }
+
+        @intermission = Game::Intermission.new(@renderer.wad, @status_bar.gfx, stats)
+      end
+
+      def load_next_map(map_name)
+        return unless map_name
+
+        wad = @renderer.wad
+        @current_map = map_name
+
+        # Load new map data
+        map = Map::MapData.load(wad, map_name)
+        @map = map
+        @map_bounds = nil # Recompute on next automap draw
+        @sector_colors = build_sector_colors
+
+        # Rebuild all systems for new map
+        @renderer = Render::RendererFactory.build(
+          Render::RendererFactory.type_of(@renderer), wad, map, @renderer.textures,
+          @palette, @renderer.colormap, @renderer.flats.values, @renderer.sprites, @animations
+        )
+        # A new map means a new world; the RNG carries over so the run stays
+        # one continuous deterministic sequence across level changes.
+        skill_hidden = compute_skill_hidden(@skill || Game::Menu::SKILL_MEDIUM)
+        world = Game::World.new(map, sprites: @renderer.sprites, sound: @sound,
+                                     random: @random, skill_hidden: skill_hidden)
+        world.damage_multiplier = @damage_multiplier
+        world.item_pickup.ammo_multiplier = @skill == Game::Menu::SKILL_BABY ? 2 : 1
+        world.monster_ai.aggression = true
+        world.monster_ai.damage_multiplier = @damage_multiplier
+        world.add_player
+
+        bind_world(world)
+      end
+
+      def apply_difficulty(skill)
+        @skill = skill
+        @damage_multiplier = case skill
+                             when Game::Menu::SKILL_BABY then 0.5
+                             when Game::Menu::SKILL_EASY then 0.75
+                             when Game::Menu::SKILL_MEDIUM then 1.0
+                             when Game::Menu::SKILL_HARD then 1.0
+                             when Game::Menu::SKILL_NIGHTMARE then 1.5
+                             else 1.0
+                             end
+
+        # Push difficulty into the world before respawning: respawn rebuilds the
+        # actor subsystems from the world's settings, so setting them here only
+        # would be discarded.
+        @world.skill_hidden = compute_skill_hidden(skill)
+        @world.damage_multiplier = @damage_multiplier
+        @physics.skill_hidden = @world.skill_hidden
+
+        # Baby mode: start with some armor
+        @player_state.armor = 50 if skill == Game::Menu::SKILL_BABY
+
+        respawn_player
+
+        @monster_ai.aggression = true
+        @monster_ai.damage_multiplier = @damage_multiplier
+        # Baby: double ammo from pickups (matching DOOM skill 1)
+        @item_pickup.ammo_multiplier = skill == Game::Menu::SKILL_BABY ? 2 : 1
       end
 
       def setup_yjit_toggle
         return if @yjit_toggle_ready || !defined?(RubyVM::YJIT)
-        require "fiddle"
 
-        address = Fiddle::Handle::DEFAULT["rb_yjit_enabled_p"]
+        require 'fiddle'
+
+        address = Fiddle::Handle::DEFAULT['rb_yjit_enabled_p']
         enabled_ptr = Fiddle::Pointer.new(address, Fiddle::SIZEOF_CHAR)
 
         RubyVM::YJIT.singleton_class.prepend(Module.new do
           define_method(:enable) do |**kwargs|
             return false if enabled?
-            return super(**kwargs) unless RUBY_DESCRIPTION.include?("+YJIT")
+            return super(**kwargs) unless RUBY_DESCRIPTION.include?('+YJIT')
+
             enabled_ptr[0] = 1
             true
           end
 
           define_method(:disable) do
             return false unless enabled?
+
             enabled_ptr[0] = 0
             true
           end
         end)
 
         @yjit_toggle_ready = true
-      rescue => e
-        puts "YJIT toggle setup failed: #{e.message}"
+      rescue StandardError => e
+        warn "YJIT toggle setup failed: #{e.class}: #{e.message}"
       end
 
       def needs_cursor?
@@ -841,9 +1027,9 @@ module Doom
         img.save("#{prefix}.png")
 
         # Save player state and sector info
-        sector = @map.sector_at(@renderer.player_x, @renderer.player_y)
+        sector = @map.sector_at(@player.x, @player.y)
         sector_idx = sector ? @map.sectors.index(sector) : nil
-        angle_deg = Math.atan2(@renderer.sin_angle, @renderer.cos_angle) * 180.0 / Math::PI
+        angle_deg = Math.atan2(@player.sin_angle, @player.cos_angle) * 180.0 / Math::PI
 
         # Sprite diagnostics
         sprites_info = @renderer.sprite_diagnostics
@@ -852,14 +1038,18 @@ module Doom
 
         sprite_lines = nearby.map do |s|
           "  #{s[:prefix]} type=#{s[:type]} pos=(#{s[:x]},#{s[:y]}) dist=#{s[:dist]} " \
-          "screen_x=#{s[:screen_x]} scale=#{s[:sprite_scale]} " \
+            "screen_x=#{s[:screen_x]} scale=#{s[:sprite_scale]} " \
           "range=#{s[:screen_range]} status=#{s[:status]} " \
           "clip_segs=#{s[:clipping_segs]}" \
-          "#{s[:clipping_detail]&.any? ? "\n    clips: #{s[:clipping_detail].map { |c| "ds[#{c[:x1]}..#{c[:x2]}] scale=#{c[:scale]} sil=#{c[:sil]}" }.join(', ')}" : ''}"
+          "#{if s[:clipping_detail]&.any?
+               "\n    clips: #{s[:clipping_detail].map do |c|
+                 "ds[#{c[:x1]}..#{c[:x2]}] scale=#{c[:scale]} sil=#{c[:sil]}"
+               end.join(', ')}"
+             end}"
         end
 
         File.write("#{prefix}.txt", <<~INFO)
-          pos: #{@renderer.player_x.round(1)}, #{@renderer.player_y.round(1)}, #{@renderer.player_z.round(1)}
+          pos: #{@player.x.round(1)}, #{@player.y.round(1)}, #{@player.z.round(1)}
           angle: #{angle_deg.round(1)}
           sector: #{sector_idx}
           floor: #{sector&.floor_height} (#{sector&.floor_texture})
@@ -869,8 +1059,6 @@ module Doom
           nearby sprites (#{nearby.size}):
           #{sprite_lines.join("\n")}
         INFO
-
-        puts "Snapshot saved: #{prefix}.png + .txt"
       end
 
       # --- Automap ---
@@ -892,7 +1080,7 @@ module Doom
 
       def hsv_to_gosu(h, s, v)
         c = v * s
-        x = c * (1 - ((h / 60.0) % 2 - 1).abs)
+        x = c * (1 - (((h / 60.0) % 2) - 1).abs)
         m = v - c
 
         r, g, b = case (h / 60).to_i % 6
@@ -911,36 +1099,32 @@ module Doom
         # Black background
         Gosu.draw_rect(0, 0, width, height, Gosu::Color::BLACK, 0)
 
-        # Compute map bounds
-        verts = @map.vertices
-        min_x = min_y = Float::INFINITY
-        max_x = max_y = -Float::INFINITY
-        verts.each do |v|
-          min_x = v.x if v.x < min_x
-          max_x = v.x if v.x > max_x
-          min_y = v.y if v.y < min_y
-          max_y = v.y if v.y > max_y
-        end
+        bounds = map_bounds
+        return unless bounds
 
+        verts = @map.vertices
+        min_x = bounds[:min_x]
+        max_x = bounds[:max_x]
+        min_y = bounds[:min_y]
+        max_y = bounds[:max_y]
         map_w = max_x - min_x
         map_h = max_y - min_y
-        return if map_w == 0 || map_h == 0
 
         # Scale to fit screen with margin
-        draw_w = width - MAP_MARGIN * 2
-        draw_h = height - MAP_MARGIN * 2
+        draw_w = width - (MAP_MARGIN * 2)
+        draw_h = height - (MAP_MARGIN * 2)
         scale = [draw_w.to_f / map_w, draw_h.to_f / map_h].min
 
         # Center the map
-        offset_x = MAP_MARGIN + (draw_w - map_w * scale) / 2.0
-        offset_y = MAP_MARGIN + (draw_h - map_h * scale) / 2.0
+        offset_x = MAP_MARGIN + ((draw_w - (map_w * scale)) / 2.0)
+        offset_y = MAP_MARGIN + ((draw_h - (map_h * scale)) / 2.0)
 
         # World to screen coordinate transform (Y flipped: world Y+ is up, screen Y+ is down)
-        to_sx = ->(wx) { offset_x + (wx - min_x) * scale }
-        to_sy = ->(wy) { offset_y + (max_y - wy) * scale }
+        to_sx = ->(wx) { offset_x + ((wx - min_x) * scale) }
+        to_sy = ->(wy) { offset_y + ((max_y - wy) * scale) }
 
         # Draw linedefs colored by front sector
-        two_sided_color = Gosu::Color.new(100, 80, 80, 80)
+        Gosu::Color.new(100, 80, 80, 80)
 
         @map.linedefs.each do |linedef|
           v1 = verts[linedef.v1]
@@ -965,27 +1149,27 @@ module Doom
         end
 
         # Draw player
-        px = to_sx.call(@renderer.player_x)
-        py = to_sy.call(@renderer.player_y)
+        px = to_sx.call(@player.x)
+        py = to_sy.call(@player.y)
 
-        cos_a = @renderer.cos_angle
-        sin_a = @renderer.sin_angle
+        cos_a = @player.cos_angle
+        sin_a = @player.sin_angle
 
         # FOV cone
         fov_len = 40.0
         half_fov = Math::PI / 4.0 # 45 deg half = 90 deg total
 
         # Cone edges (in world space, Y+ is up; on screen Y is flipped via to_sy)
-        left_dx = Math.cos(half_fov) * cos_a - Math.sin(half_fov) * sin_a
-        left_dy = Math.cos(half_fov) * sin_a + Math.sin(half_fov) * cos_a
-        right_dx = Math.cos(-half_fov) * cos_a - Math.sin(-half_fov) * sin_a
-        right_dy = Math.cos(-half_fov) * sin_a + Math.sin(-half_fov) * cos_a
+        left_dx = (Math.cos(half_fov) * cos_a) - (Math.sin(half_fov) * sin_a)
+        left_dy = (Math.cos(half_fov) * sin_a) + (Math.sin(half_fov) * cos_a)
+        right_dx = (Math.cos(-half_fov) * cos_a) - (Math.sin(-half_fov) * sin_a)
+        right_dy = (Math.cos(-half_fov) * sin_a) + (Math.sin(-half_fov) * cos_a)
 
         # Screen positions for cone tips
-        lx = px + left_dx * fov_len
-        ly = py - left_dy * fov_len  # negate because screen Y is flipped
-        rx = px + right_dx * fov_len
-        ry = py - right_dy * fov_len
+        lx = px + (left_dx * fov_len)
+        ly = py - (left_dy * fov_len) # negate because screen Y is flipped
+        rx = px + (right_dx * fov_len)
+        ry = py - (right_dy * fov_len)
 
         cone_color = Gosu::Color.new(60, 0, 255, 0)
         Gosu.draw_triangle(px, py, cone_color, lx, ly, cone_color, rx, ry, cone_color, 2)
@@ -1001,16 +1185,12 @@ module Doom
 
         # Direction line
         dir_len = 12.0
-        dx = px + cos_a * dir_len
-        dy = py - sin_a * dir_len
+        dx = px + (cos_a * dir_len)
+        dy = py - (sin_a * dir_len)
         Gosu.draw_line(px, py, Gosu::Color::WHITE, dx, dy, Gosu::Color::WHITE, 3)
       end
 
       # --- End Automap ---
-
-      def needs_cursor?
-        !@mouse_captured
-      end
     end
   end
 end