doom 0.5.0 → 0.8.0

data/lib/doom/platform/gosu_window.rb

@@ -7,6 +7,37 @@ module Doom
     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
@@ -48,9 +79,12 @@ module Doom
         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)
-        super(Render::SCREEN_WIDTH * SCALE, Render::SCREEN_HEIGHT * SCALE, false)
+      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)
+        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)
+        SDLKeyboardGrab.setup
 
         @renderer = renderer
         @palette = palette
@@ -63,6 +97,13 @@ module Doom
         @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
@@ -75,13 +116,25 @@ 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
 
         # Precompute sector colors for automap
         @sector_colors = build_sector_colors
 
-        # Pre-build palette lookup for speed
-        @palette_rgba = palette.colors.map { |r, g, b| [r, g, b, 255].pack('CCCC') }
+        # Pre-build palette RGBA lookups for all 14 palettes (0=normal, 1-8=pain red)
+        @all_palette_rgba = []
+        wad = renderer.instance_variable_get(:@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') }
+        end
+        @palette_rgba = @all_palette_rgba[0]
       end
 
       def update
@@ -90,6 +143,18 @@ module Doom
         delta_time = now - @last_update_time
         @last_update_time = now
 
+        # Menu is active -- only update menu animation, skip game logic
+        if @menu&.active?
+          @menu.update
+          return
+        end
+
+        # Intermission screen active
+        if @intermission
+          @intermission.update
+          return
+        end
+
         handle_input(delta_time)
 
         # Update player state (per-frame for smooth bob)
@@ -106,7 +171,36 @@ module Doom
           @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
         end
         @animations&.update(@leveltime)
 
@@ -117,30 +211,74 @@ module Doom
         if @sector_actions
           @sector_actions.update_player_position(@renderer.player_x, @renderer.player_y)
           @sector_actions.update
+
+          # 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 = @item_pickup.picked_up
+          @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
 
         # 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
 
         # Render HUD on top
-        if @weapon_renderer
+        if @weapon_renderer && !@player_state&.dead
           @weapon_renderer.render(@renderer.framebuffer)
         end
         if @status_bar
           @status_bar.render(@renderer.framebuffer)
         end
+
+        # 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
+
+        # Red tint when dead
+        if @player_state&.dead
+          apply_death_tint(@renderer.framebuffer)
+        end
       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
 
@@ -198,8 +336,9 @@ module Doom
           try_move(@move_momx * delta_time, @move_momy * delta_time)
         end
 
-        # Handle firing (left click, Z, or Shift - Ctrl conflicts with macOS spaces)
+        # 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
@@ -208,6 +347,7 @@ module Doom
           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
 
@@ -296,7 +436,7 @@ module Doom
       end
 
       def facing_linedef?(px, py, cos_angle, sin_angle, v1, v2)
-        # Calculate linedef normal (perpendicular to line, pointing to front side)
+        # Calculate linedef normal (perpendicular to line)
         line_dx = v2.x - v1.x
         line_dy = v2.y - v1.y
 
@@ -304,24 +444,26 @@ module Doom
         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
 
-        # Check if player is on the front side (normal side) of the line
+        # Determine which side the player is on
         to_player_x = px - v1.x
         to_player_y = py - v1.y
-        dot_player = to_player_x * normal_x + to_player_y * normal_y
+        side = to_player_x * normal_x + to_player_y * normal_y
 
-        # Player must be on front side
-        return false if dot_player < 0
+        # 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
+        # Check if player is facing toward the line (relaxed angle check)
         dot_facing = cos_angle * (-normal_x) + sin_angle * (-normal_y)
-        dot_facing > 0.5  # Must be roughly facing the line
+        dot_facing > 0.2  # ~78 degree cone, matching DOOM's generous use check
       end
 
       def handle_weapon_switch
@@ -471,6 +613,7 @@ module Doom
         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]
@@ -497,7 +640,7 @@ module Doom
           return segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
         end
 
-        # BLOCKING flag blocks crossing even on two-sided linedefs
+        # 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)
         end
@@ -547,8 +690,9 @@ module Doom
         # 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
+        # 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]
@@ -613,18 +757,73 @@ module Doom
       end
 
       def draw
-        if @show_map
+        # 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)
+          return
+        end
+
+        # 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)
+          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)
+          @screen_melt = nil if @screen_melt.done?
+          return
+        end
+
+        if @menu&.active?
+          if @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)
+
+          # 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)
+        elsif @show_map
           draw_automap
         else
-          # Fast RGBA conversion using pre-built palette
-          rgba = @renderer.framebuffer.map { |idx| @palette_rgba[idx] }.join
+          # 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
+            Render::SCREEN_WIDTH, Render::SCREEN_HEIGHT, rgba
           )
-
           @screen_image.draw(0, 0, 0, SCALE, SCALE)
 
           draw_debug_overlay if @show_debug
@@ -632,46 +831,143 @@ module Doom
       end
 
       def draw_debug_overlay
-        sector = @map.sector_at(@renderer.player_x, @renderer.player_y)
-        return unless sector
-
-        # Find sector index
-        sector_idx = @map.sectors.index(sector)
+        @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
 
-        lines = [
-          "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_status = defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled? ? 'ON' : 'OFF'
+        ang = (Math.atan2(@renderer.sin_angle, @renderer.cos_angle) * 180.0 / Math::PI).round(1)
+
+        lines = if @menu&.options&.[](:rubykaigi_mode)
+                  [
+                    "#{@fps_display} FPS",
+                    "YJIT: #{yjit_status}  (Y to toggle)",
+                    "Ruby #{RUBY_VERSION}",
+                    "Map: #{@current_map}",
+                    "Pos: #{@renderer.player_x.round}, #{@renderer.player_y.round}",
+                    "Ang: #{ang}",
+                  ]
+                else
+                  [
+                    "FPS: #{@fps_display}",
+                    "YJIT: #{yjit_status}",
+                    "Pos: #{@renderer.player_x.round}, #{@renderer.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
+              # 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
+
+            # Play confirmation sound on select
+            @sound&.menu_select if key == :enter
+
+            case result
+            when :start_game
+              apply_difficulty(@menu.selected_skill)
+            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_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
         when Gosu::KB_M
           @show_map = !@show_map
         when Gosu::KB_F12
@@ -679,6 +975,250 @@ 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
+      end
+
+      def apply_death_tint(framebuffer)
+        # Death keeps damage_count at max so the pain palette stays red
+        @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
+
+        # 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
+
+        # 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
+      end
+
+      def handle_option_toggle(option, value)
+        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&.instance_variable_get(:@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 :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)
+
+        # God mode: invincible for stress-free demos
+        @player_state.god_mode = true
+        @player_state.health = 100
+
+        # 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
+
+      # 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
+      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 { |t|
+          @map.things.any? { |th| th.type == t }
+        }
+        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,
+        }
+
+        wad = @renderer.instance_variable_get(:@wad)
+        @intermission = Game::Intermission.new(wad, @status_bar.instance_variable_get(:@gfx), stats)
+      end
+
+      def load_next_map(map_name)
+        return unless map_name
+
+        wad = @renderer.instance_variable_get(:@wad)
+        @current_map = map_name
+
+        # Load new map data
+        map = Map::MapData.load(wad, map_name)
+        @map = map
+
+        # 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)
+      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
+
+        # Compute which things are hidden by this skill level
+        @skill_hidden = compute_skill_hidden(skill)
+
+        # Baby mode: start with some armor
+        if skill == Game::Menu::SKILL_BABY
+          @player_state.armor = 50
+        end
+
+        if @monster_ai
+          @monster_ai.aggression = true
+          @monster_ai.damage_multiplier = @damage_multiplier
+        end
+
+        # 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
+      end
+
+      def setup_yjit_toggle
+        return if @yjit_toggle_ready || !defined?(RubyVM::YJIT)
+        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")
+            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}"
+      end
+
       def needs_cursor?
         !@mouse_captured
       end