doom 0.8.0 → 0.11.0

data/lib/doom/platform/gosu_window.rb

@@ -1,113 +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
 
-      # SDL2 keyboard grab via Gosu's bundled SDL -- prevents OS key interception
-      module SDLKeyboardGrab
-        def self.setup
-          require "fiddle"
-          gosu_spec = Gem.loaded_specs["gosu"]
-          lib_ext = RbConfig::CONFIG["DLEXT"] || "so"
-          bundle = File.join(gosu_spec.full_gem_path, "lib", "gosu.#{lib_ext}")
-          @lib = Fiddle.dlopen(bundle)
-          @shared_window = Fiddle::Function.new(
-            @lib["_ZN4Gosu13shared_windowEv"], [], Fiddle::TYPE_VOIDP
-          )
-          @set_kb_grab = Fiddle::Function.new(
-            @lib["SDL_SetWindowKeyboardGrab"],
-            [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT], Fiddle::TYPE_VOID
-          )
-          @ready = true
-        rescue
-          @ready = false
-        end
-
-        def self.grab!
-          return unless @ready
-          @set_kb_grab.call(@shared_window.call, 1)
-        end
-
-        def self.release!
-          return unless @ready
-          @set_kb_grab.call(@shared_window.call, 0)
-        end
-      end
-
-      # 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, menu = nil, sound_engine = 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
         @menu = menu
         @doom_font = menu&.font
         @sound = sound_engine
-        @damage_multiplier = 1.0
         @skill = Game::Menu::SKILL_MEDIUM
-        @skill_hidden = {}  # Thing indices hidden by difficulty
-        @last_floor_height = nil
-        @move_momx = 0.0
-        @move_momy = 0.0
-        @leveltime = 0
+        @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
@@ -124,12 +73,22 @@ module Doom
         @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') }
@@ -137,15 +96,146 @@ module Doom
         @palette_rgba = @all_palette_rgba[0]
       end
 
+      def advance_local
+        while @tic_accumulator >= 1.0
+          @tic_accumulator -= 1.0
+          @leveltime = @world.run_tic(@player.id => build_ticcmd)
+          @item_pickup.update_flash
+        end
+      end
+
+      # 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
+
+      def advance_networked
+        @session.poll
+
+        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?
+
+        ran = @session.run(@world, limit: 10)
+        ran.times { @item_pickup.update_flash }
+        @leveltime = @world.leveltime
+      end
+
+      # 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?
+
+        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
+
+      # 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
+
+        @last_net_send_at = now
+        true
+      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
+
+      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
+
       def update
         # Calculate delta time for smooth animations
         now = Time.now
         delta_time = now - @last_update_time
         @last_update_time = now
 
-        # Menu is active -- only update menu animation, skip game logic
+        # 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
 
@@ -157,104 +247,41 @@ module Doom
 
         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)
+        # 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
-        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
-          health_before = @player_state&.health || 100
-
-          @combat&.update_player_pos(@renderer.player_x, @renderer.player_y, @renderer.player_z)
-          @combat&.update
-          @monster_ai&.update(@renderer.player_x, @renderer.player_y)
-
-          # Sound effects for player damage/death
-          if @sound && @player_state
-            health_now = @player_state.health
-            if health_now < health_before
-              if @player_state.dead
-                @sound.player_death
-              else
-                @sound.player_pain
-              end
-            end
-          end
-
-          @player_state&.update_damage_count
-          @item_pickup&.update_flash
-
-          # 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
+        if @session
+          advance_networked
+        elsif @client
+          advance_server_client
+        else
+          advance_local
         end
-        @animations&.update(@leveltime)
 
-        # Update HUD animations
+        @animations&.update(@leveltime)
         @status_bar&.update
+        @renderer.hidden_things = @world.hidden_things
 
-        # Update sector actions (doors, lifts, etc.)
-        if @sector_actions
-          @sector_actions.update_player_position(@renderer.player_x, @renderer.player_y)
-          @sector_actions.update
+        trigger_level_exit(@world.exit_triggered) if @world.exit_triggered && !@intermission
 
-          # Check for level exit
-          if @sector_actions.exit_triggered && !@intermission
-            trigger_level_exit(@sector_actions.exit_triggered)
-          end
-
-          # Check for teleport
-          if (dest = @sector_actions.pop_teleport)
-            @renderer.set_player(dest[:x], dest[:y], @renderer.player_z, dest[:angle])
-            update_player_height(dest[:x], dest[:y])
-          end
-        end
-
-        # Check item pickups
-        if @item_pickup
-          picked_before = @item_pickup.picked_up.size
-          @item_pickup.update(@renderer.player_x, @renderer.player_y)
-          @renderer.hidden_things = @skill_hidden.merge(@item_pickup.picked_up)
-          if @sound && @item_pickup.picked_up.size > picked_before
-            # Check if it was a weapon pickup (has :weapon key in ITEMS)
-            msg = @item_pickup.pickup_message
-            if msg && msg.include?('!')  # Weapon pickups end with !
-              @sound.weapon_pickup
-            else
-              @sound.item_pickup
-            end
-          end
-        end
+        # Other players are drawn as sprites; the local one never is.
+        @renderer.players = @world.players
+        @renderer.view_player = @player
 
         # Pass combat state to renderer for death frame rendering
         @renderer.combat = @combat
         @renderer.monster_ai = @monster_ai
         @renderer.leveltime = @leveltime
 
-        # Render the 3D world
+        # 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
 
         # Render HUD on top
-        if @weapon_renderer && !@player_state&.dead
-          @weapon_renderer.render(@renderer.framebuffer)
-        end
-        if @status_bar
-          @status_bar.render(@renderer.framebuffer)
-        end
+        @weapon_renderer.render(@renderer.framebuffer) if @weapon_renderer && !@player_state&.dead
+        @status_bar.render(@renderer.framebuffer) if @status_bar
 
         # 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
@@ -262,210 +289,64 @@ module Doom
         end
 
         # Red tint when dead
-        if @player_state&.dead
-          apply_death_tint(@renderer.framebuffer)
-        end
+        return unless @player_state&.dead
+
+        hold_pain_palette
       end
 
-      def handle_input(delta_time)
-        # Handle respawn when dead
+      # 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 @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
+          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
-
-        # Mouse look
-        handle_mouse_look
-
-        # 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)
+          return # No other input while dead
         end
 
-        # Apply thrust from input (P_Thrust: additive, scaled by delta_time)
-        thrust = MOVE_THRUST_RATE * delta_time
-        has_input = false
-
-        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
-
-        # 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
-
-        # 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
-
-        # 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
-
-        # Handle firing (left click, Ctrl, X, or Shift)
-        if @player_state && ((@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))
-          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)
-            @sound&.weapon_fire(@player_state.weapon)
-          end
-        end
-
-        # Handle weapon switching with number keys
+        handle_mouse_look # accumulates into @pending_turn
         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
-        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
-
-        # Check point in front of player
-        use_x = player_x + cos_angle * USE_DISTANCE
-        use_y = player_y + sin_angle * USE_DISTANCE
-
-        # Find the closest linedef the player is facing
-        best_linedef = nil
-        best_idx = nil
-        best_dist = Float::INFINITY
-
-        @map.linedefs.each_with_index do |linedef, idx|
-          next if linedef.special == 0  # Skip non-special linedefs
-
-          v1 = @map.vertices[linedef.v1]
-          v2 = @map.vertices[linedef.v2]
-
-          # 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
-
-          # 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)
-
-          best_linedef = linedef
-          best_idx = idx
-          best_dist = dist
+      # 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)
 
-        if best_linedef
-          @sector_actions.use_linedef(best_linedef, best_idx)
-        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
-
-        # 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)
-      end
-
-      def facing_linedef?(px, py, cos_angle, sin_angle, v1, v2)
-        # Calculate linedef normal (perpendicular to line)
-        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
-
-        len = Math.sqrt(normal_x * normal_x + normal_y * normal_y)
-        return false if len == 0
-
-        normal_x /= len
-        normal_y /= len
-
-        # Determine which side the player is on
-        to_player_x = px - v1.x
-        to_player_y = py - v1.y
-        side = to_player_x * normal_x + to_player_y * normal_y
-
-        # Flip normal if player is on the back side (so we check facing toward the line)
-        if side < 0
-          normal_x = -normal_x
-          normal_y = -normal_y
-        end
-
-        # Check if player is facing toward the line (relaxed angle check)
-        dot_facing = cos_angle * (-normal_x) + sin_angle * (-normal_y)
-        dot_facing > 0.2  # ~78 degree cone, matching DOOM's generous use check
+        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)
@@ -484,257 +365,21 @@ 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
-
-        # 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]
+      # Lazily computed and cached on first access; cleared by load_next_map.
+      def map_bounds
+        return @map_bounds if defined?(@map_bounds) && @map_bounds
 
-          # 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
-        end
-
-        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]
-      end
-
-      def update_player_height(x, y)
-        sector = @map.sector_at(x, y)
-        return unless sector
-
-        new_floor = sector.floor_height
-
-        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
-
-          view_bob = @player_state.view_bob_offset
-          @renderer.set_z(new_floor + @player_state.viewheight + view_bob)
-        else
-          @renderer.set_z(new_floor + 41)
-        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
-
-        # 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
-
-        # 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
-
-        # 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 @skill_hidden[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
-
-        true
-      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)
-        end
-
-        # ML_BLOCKING (0x0001) blocks crossing for everything including player
-        if (linedef.flags & 0x0001) != 0
-          return segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
+        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
 
-        # 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
-
-        # Passable if step is small AND enough headroom
-        return false if step <= 24 && (min_ceiling - max_floor) >= 56
-
-        segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
-      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
-      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
-
-        # ML_BLOCKING on two-sided: handled by crosses_blocking_linedef? (crossing check)
-        # Don't check here -- linedef_blocks? is a proximity check and would
-        # block the player when standing near the line, not just crossing it
-
-        # 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
-
-        # Block if step too high OR not enough headroom
-        step > 24 || (min_ceiling - max_floor) < 56
-      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
-
-        # 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
-
-        # Closest point on line segment
-        closest_x = x1 + t * line_dx
-        closest_y = y1 + t * line_dy
-
-        # 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
-
-        dist_sq < radius * radius
+        @map_bounds = { min_x: min_x, max_x: max_x, min_y: min_y, max_y: max_y }
       end
 
       def handle_mouse_look
@@ -743,7 +388,9 @@ module Doom
         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
+          # 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
 
         # Keep mouse centered
@@ -756,17 +403,47 @@ module Doom
         end
       end
 
+      # 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
+
+        WindowLogic.present_due?(Gosu.milliseconds, @last_present_ms,
+                                 @present_interval_ms, PRESENT_INTERVAL_SLACK)
+      end
+
+      attr_reader :refresh_hz
+
+      # 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
+
+        @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
+
       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)
-          active_pal = @all_palette_rgba[0]
-          rgba = fb.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)
+          present(fb)
           return
         end
 
@@ -774,18 +451,19 @@ module Doom
         if @screen_melt && !@screen_melt.done?
           fb = Array.new(Render::SCREEN_WIDTH * Render::SCREEN_HEIGHT, 0)
           @screen_melt.update(fb)
-          active_pal = @all_palette_rgba[0]
-          rgba = fb.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)
+          present(fb)
           @screen_melt = nil if @screen_melt.done?
           return
         end
 
         if @menu&.active?
-          if @menu.needs_background?
+          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
@@ -800,64 +478,180 @@ module Doom
           # Capture current menu frame for melt transitions
           @last_menu_fb = fb.dup
 
-          active_pal = @all_palette_rgba[0]
-          rgba = fb.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)
+          present(fb)
         elsif @show_map
           draw_automap
         else
-          # Select palette: red tint when taking damage (palettes 1-8)
-          # Pain palette (1-8 red), pickup palette (9 yellow)
-          pal_idx = if @item_pickup && @item_pickup.pickup_flash > 0
-                      9  # Yellow flash for item pickup
-                    elsif @player_state
-                      @player_state.damage_count.clamp(0, 8)
-                    else
-                      0
-                    end
-          active_pal = @all_palette_rgba[pal_idx]
-          rgba = @renderer.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)
+          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
 
           draw_debug_overlay if @show_debug
+          draw_net_status if @session
+          draw_match_status if @world.deathmatch?
         end
       end
 
-      def draw_debug_overlay
-        @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
+      # 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
+
+      # 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
+
+        # 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 new_hud_overlay
+        Array.new(Render::SCREEN_WIDTH * Render::SCREEN_HEIGHT, -1)
+      end
+
+      # 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
+
+      # 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)
+
+        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
+
+      def hud_tint_byte(value)
+        (value * 255.0).clamp(0.0, 255.0).to_i
+      end
+
+      def sync_renderer_visual_options
+        return unless @menu
+
+        @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
+
+      # 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
+          0
+        end
+      end
+
+      # 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)
+
+        winner = @world.match_winner
+        return unless winner
+
+        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
+
+      # 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
         yjit_status = defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled? ? 'ON' : 'OFF'
-        ang = (Math.atan2(@renderer.sin_angle, @renderer.cos_angle) * 180.0 / Math::PI).round(1)
+        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",
+                    "#{@fps_display} FPS  (#{shown})",
                     "YJIT: #{yjit_status}  (Y to toggle)",
                     "Ruby #{RUBY_VERSION}",
+                    "Renderer: #{renderer_name}",
                     "Map: #{@current_map}",
-                    "Pos: #{@renderer.player_x.round}, #{@renderer.player_y.round}",
-                    "Ang: #{ang}",
+                    "Pos: #{@player.x.round}, #{@player.y.round}",
+                    "Ang: #{ang}"
                   ]
                 else
                   [
-                    "FPS: #{@fps_display}",
+                    "FPS: #{@fps_display}  (#{shown})",
                     "YJIT: #{yjit_status}",
-                    "Pos: #{@renderer.player_x.round}, #{@renderer.player_y.round}",
-                    "Ang: #{ang}",
+                    "Renderer: #{renderer_name}",
+                    "Pos: #{@player.x.round}, #{@player.y.round}",
+                    "Ang: #{ang}"
                   ]
                 end
 
@@ -910,13 +704,21 @@ module Doom
 
             # 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
-              # 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)
+              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
@@ -924,7 +726,9 @@ module Doom
 
             case result
             when :start_game
-              apply_difficulty(@menu.selected_skill)
+              # 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!
@@ -952,22 +756,21 @@ module Doom
           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
-          if @monster_ai
-            @monster_ai.aggression = !@monster_ai.aggression
-            puts "Monster aggression: #{@monster_ai.aggression ? 'ON' : 'OFF'}"
-          end
+          @monster_ai.aggression = !@monster_ai.aggression if @monster_ai
         when Gosu::KB_M
           @show_map = !@show_map
         when Gosu::KB_F12
@@ -975,57 +778,53 @@ 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]
-        if damage
-          @player_state.take_damage((damage * @damage_multiplier).to_i)
-          @sound&.player_pain
-        end
+      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
-
-        # Reset item pickup, combat, and monster AI state
-        sprites = @combat&.instance_variable_get(:@sprites)
-        @item_pickup = Game::ItemPickup.new(@map, @player_state, @skill_hidden) if @item_pickup
-        @combat = Game::Combat.new(@map, @player_state, sprites, @skill_hidden, @sound) if @combat && sprites
-        sprites_mgr = @combat&.instance_variable_get(:@sprites)
-        @monster_ai = Game::MonsterAI.new(@map, @combat, @player_state, sprites_mgr, @skill_hidden, @sound) if @monster_ai && @combat
+        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
-        if @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
+        return unless @menu
 
-        # 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)
-        end
+        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
@@ -1035,7 +834,7 @@ module Doom
         when :all_weapons
           if value
             # Give all weapons that have sprites loaded
-            @gfx_weapons ||= @weapon_renderer&.instance_variable_get(:@gfx)&.weapons || {}
+            @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)
@@ -1045,6 +844,14 @@ module Doom
             @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
@@ -1070,22 +877,8 @@ module Doom
         @show_debug = true
       end
 
-      # DOOM thing flags: bit 0 = skill 1-2, bit 1 = skill 3, bit 2 = skill 4-5
       def compute_skill_hidden(skill)
-        flag_bit = case skill
-                   when Game::Menu::SKILL_BABY, Game::Menu::SKILL_EASY then 0x0001
-                   when Game::Menu::SKILL_MEDIUM then 0x0002
-                   when Game::Menu::SKILL_HARD, Game::Menu::SKILL_NIGHTMARE then 0x0004
-                   else 0x0007
-                   end
-        hidden = {}
-        @map.things.each_with_index do |thing, idx|
-          # Multiplayer-only things (bit 4) are hidden in single player
-          if (thing.flags & 0x0010) != 0 || (thing.flags & flag_bit) == 0
-            hidden[idx] = true
-          end
-        end
-        hidden
+        WindowLogic.skill_hidden(skill, @map.things)
       end
 
       def trigger_level_exit(exit_type)
@@ -1093,9 +886,9 @@ module Doom
         total_monsters = @monster_ai ? @monster_ai.monsters.size : 0
         killed = @combat ? @combat.dead_things.size : 0
 
-        total_items = Game::ItemPickup::ITEMS.keys.count { |t|
+        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
@@ -1108,56 +901,41 @@ module Doom
           items: picked, total_items: total_items,
           secrets: found_secrets, total_secrets: total_secrets,
           time_tics: @leveltime,
-          exit_type: exit_type,
+          exit_type: exit_type
         }
 
-        wad = @renderer.instance_variable_get(:@wad)
-        @intermission = Game::Intermission.new(wad, @status_bar.instance_variable_get(:@gfx), stats)
+        @intermission = Game::Intermission.new(@renderer.wad, @status_bar.gfx, stats)
       end
 
       def load_next_map(map_name)
         return unless map_name
 
-        wad = @renderer.instance_variable_get(:@wad)
+        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
-        palette = @palette
-        colormap = @renderer.instance_variable_get(:@colormap)
-        textures = @renderer.instance_variable_get(:@textures)
-        flats = @renderer.instance_variable_get(:@flats)
-        sprites = @renderer.instance_variable_get(:@sprites)
-        animations = @animations
-
-        @renderer = Render::Renderer.new(wad, map, textures, palette, colormap,
-                                          flats.values, sprites, animations)
-        ps = map.player_start
-        @renderer.set_player(ps.x, ps.y, 41, ps.angle)
-
-        @player_state.reset
-        @sector_actions = Game::SectorActions.new(map, @sound)
-        @sector_effects = Game::SectorEffects.new(map)
-
-        @skill_hidden = compute_skill_hidden(@skill || Game::Menu::SKILL_MEDIUM)
-        @item_pickup = Game::ItemPickup.new(map, @player_state, @skill_hidden)
-        @item_pickup.ammo_multiplier = (@skill == Game::Menu::SKILL_BABY) ? 2 : 1
-
-        combat_sprites = sprites
-        @combat = Game::Combat.new(map, @player_state, combat_sprites, @skill_hidden, @sound)
-        @monster_ai = Game::MonsterAI.new(map, @combat, @player_state, combat_sprites, @skill_hidden, @sound)
-        @monster_ai.aggression = true
-        @monster_ai.damage_multiplier = @damage_multiplier
-
-        @last_floor_height = nil
-        @move_momx = 0.0
-        @move_momy = 0.0
-        @leveltime = 0
-
-        update_player_height(ps.x, ps.y)
+        @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)
@@ -1171,52 +949,52 @@ module Doom
                              else 1.0
                              end
 
-        # Compute which things are hidden by this skill level
-        @skill_hidden = compute_skill_hidden(skill)
+        # 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
-        if skill == Game::Menu::SKILL_BABY
-          @player_state.armor = 50
-        end
+        @player_state.armor = 50 if skill == Game::Menu::SKILL_BABY
 
-        if @monster_ai
-          @monster_ai.aggression = true
-          @monster_ai.damage_multiplier = @damage_multiplier
-        end
+        respawn_player
 
+        @monster_ai.aggression = true
+        @monster_ai.damage_multiplier = @damage_multiplier
         # Baby: double ammo from pickups (matching DOOM skill 1)
-        if @item_pickup
-          @item_pickup.ammo_multiplier = (skill == Game::Menu::SKILL_BABY) ? 2 : 1
-        end
-
-        respawn_player
+        @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?
@@ -1249,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
@@ -1260,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})
@@ -1277,8 +1059,6 @@ module Doom
           nearby sprites (#{nearby.size}):
           #{sprite_lines.join("\n")}
         INFO
-
-        puts "Snapshot saved: #{prefix}.png + .txt"
       end
 
       # --- Automap ---
@@ -1300,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
@@ -1319,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]
@@ -1373,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)
@@ -1409,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