doom 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3cb562e8b88b905638cfa8792337bc1b7f818753fa90587bda474784513a6bd
-  data.tar.gz: 1f421713b797c02dfc10e2f9bdd3ad0981a631f88bc94df161aa5a792b539094
+  metadata.gz: e59cb32b1487d61b1c310ee5eae7ec30a702c64129c7fe5e18e1c06204d08208
+  data.tar.gz: f8f5450c3c37d661618234cf0abe80a5f0cd796aaa13694ee35d786ef25c5728
 SHA512:
-  metadata.gz: b06fd18ebfa1c5755e27c11b49e9e568fc4e2acfc7bc2b9760e7b7dda500a438afe9a6ecf0e33aa4f17c2271a6c28205e6bbb793e3b9c618c4df24b8bf74679a
-  data.tar.gz: ed5387b2c42963956cfe42c1cfe790a8f7f0e89a15c5a38934780b5ceaca34e3e64456756280d9c8f2d280763ef0fff89434dd8e826dc2e9e0184e25c4f94508
+  metadata.gz: 4a65c31832aff4838f924eb1263bda1f16ef6e820da9d776fa759656fdb9a58d83b2146ea30d5e0c236d1fc9e39206ad14312191f3bf5db70597cec815aef113
+  data.tar.gz: f6215f28a05e9924b9864f2f51d36cd694c4abfe7c0ad1618116486f62c72d26b0d7f609e945725b2218ee4b3e77e13eb3316153396977bf773673185d93ba40

data/bin/doom

@@ -8,8 +8,11 @@ unless ARGV.delete('--no-yjit')
   end
 end
 
+# Parse flags
+rubykaigi_mode = ARGV.delete('--rubykaigi') || ARGV.delete('--kaigi')
+
 # Parse arguments before loading heavy dependencies
-wad_path = ARGV[0]
+wad_path = ARGV.find { |a| !a.start_with?('-') }
 
 # Show help (before loading anything)
 if wad_path == '-h' || wad_path == '--help'
@@ -51,7 +54,7 @@ require_relative '../lib/doom'
 begin
   # Find or download WAD
   wad_path = Doom::WadDownloader.ensure_wad_available(wad_path)
-  Doom.run(wad_path)
+  Doom.run(wad_path, rubykaigi: rubykaigi_mode)
 rescue Doom::WadDownloader::DownloadError => e
   puts "Error: #{e.message}"
   exit 1

data/lib/doom/game/combat.rb

@@ -22,14 +22,22 @@ module Doom
         64   => 700,  # Archvile
         71   => 400,  # Pain Elemental
         84   => 20,   # Wolfenstein SS
+        2035 => 20,   # Explosive barrel
       }.freeze
 
       MONSTER_RADIUS = {
         3004 => 20, 9 => 20, 3001 => 20, 3002 => 30, 58 => 30,
         3003 => 24, 69 => 24, 3005 => 31, 3006 => 16, 16 => 40,
         7 => 128, 65 => 20, 64 => 20, 71 => 31, 84 => 20,
+        2035 => 10,  # Barrel
       }.freeze
 
+      # Barrel (explosive, not a monster but damageable)
+      BARREL_TYPE = 2035
+      BARREL_HP = 20
+      BARREL_SPLASH_RADIUS = 128.0
+      BARREL_SPLASH_DAMAGE = 128
+
       # Normal death frame sequences per sprite prefix (rotation 0 only)
       # Identified by sprite heights: frames go from standing height to flat on ground
       DEATH_FRAMES = {
@@ -46,10 +54,19 @@ module Doom
         'CPOS' => %w[H I J K L M N],   # Heavy Weapon Dude
         'PAIN' => %w[H I J K L M],     # Pain Elemental
         'SSWV' => %w[I J K L M],       # Wolfenstein SS
+        'BEXP' => %w[A B C D E],       # Barrel explosion
       }.freeze
 
       DEATH_ANIM_TICS = 6  # Tics per death frame
 
+      # Pain chance per monster (out of 256, from mobjinfo)
+      PAIN_CHANCE = {
+        3004 => 200, 9 => 170, 3001 => 200, 3002 => 180, 58 => 180,
+        3003 => 50, 69 => 50, 3005 => 128, 3006 => 256, 16 => 40,
+        7 => 40, 65 => 170, 64 => 10, 71 => 128, 84 => 170,
+      }.freeze
+      PAIN_DURATION = 6  # Tics monster is stunned when in pain
+
       # Projectile constants
       ROCKET_SPEED = 20.0       # Map units per tic (matches DOOM's mobjinfo MISSILESPEED)
       ROCKET_DAMAGE = 20        # Direct hit base (DOOM: 1d8 * 20)
@@ -57,43 +74,121 @@ module Doom
       SPLASH_RADIUS = 128.0     # Splash damage radius
       SPLASH_DAMAGE = 128       # Max splash damage at center
 
-      Projectile = Struct.new(:x, :y, :z, :dx, :dy, :type, :spawn_tic)
+      # Monster projectile definitions
+      MONSTER_PROJECTILES = {
+        imp:    { sprite: 'BAL1', speed: 10.0, damage: [3, 24], radius: 6, splash: false },
+        baron:  { sprite: 'BAL7', speed: 15.0, damage: [8, 64], radius: 6, splash: false },
+        caco:   { sprite: 'BAL2', speed: 10.0, damage: [5, 40], radius: 6, splash: false },
+      }.freeze
+
+      # Map monster type to projectile type
+      MONSTER_PROJECTILE_TYPE = {
+        3001 => :imp,     # Imp
+        3003 => :baron,   # Baron
+        69   => :baron,   # Hell Knight
+        3005 => :caco,    # Cacodemon
+      }.freeze
+
+      Projectile = Struct.new(:x, :y, :z, :dx, :dy, :dz, :type, :spawn_tic, :sprite_prefix, :target)
 
       # Weapon damage: DOOM does (P_Random()%3 + 1) * multiplier
       # Pistol/chaingun: 1*5..3*5 = 5-15 per bullet
       # Shotgun: 7 pellets, each 1*5..3*5 = 5-15
       # Fist/chainsaw: 1*2..3*2 = 2-10
 
-      def initialize(map, player_state, sprites)
+      def initialize(map, player_state, sprites, hidden_things = {}, sound_engine = nil)
         @map = map
         @player = player_state
         @sprites = sprites
+        @hidden_things = hidden_things
+        @sound = sound_engine
         @monster_hp = {}     # thing_idx => current HP
         @dead_things = {}    # thing_idx => { tic: death_start_tic, prefix: sprite_prefix }
+        @pain_until = {}     # thing_idx => tic when pain ends
         @projectiles = []    # Active projectiles in flight
         @explosions = []     # Active explosions (for rendering)
+        @puffs = []          # Bullet puff effects
+        @player_x = 0.0
+        @player_y = 0.0
+        @player_z = 0.0
         @tic = 0
       end
 
-      attr_reader :dead_things, :projectiles, :explosions
+      def update_player_pos(x, y, z = nil)
+        @player_x = x
+        @player_y = y
+        @player_z = z if z
+      end
+
+      # Spawn a monster projectile (fireball, etc.)
+      # Matches Chocolate Doom's P_SpawnMissile: calculates momz for vertical aim
+      def spawn_monster_projectile(monster_x, monster_y, monster_z, monster_type, damage_multiplier)
+        proj_type = MONSTER_PROJECTILE_TYPE[monster_type]
+        return unless proj_type
+
+        info = MONSTER_PROJECTILES[proj_type]
+        return unless info
+
+        dx = @player_x - monster_x
+        dy = @player_y - monster_y
+        dist = Math.sqrt(dx * dx + dy * dy)
+        return if dist < 1
+
+        # Normalize direction and apply speed
+        speed = info[:speed]
+        ndx = dx / dist * speed
+        ndy = dy / dist * speed
+
+        # P_SpawnMissile: momz = (target.z - source.z) / (dist / speed)
+        # This makes the projectile arc toward the target's height
+        target_z = @player_z - 16  # Aim at player center (z + height/2, roughly)
+        travel_tics = dist / speed
+        travel_tics = 1.0 if travel_tics < 1.0
+        ndz = (target_z - monster_z) / travel_tics
+
+        @projectiles << Projectile.new(
+          monster_x + ndx * 2, monster_y + ndy * 2, monster_z,
+          ndx, ndy, ndz, proj_type, @tic, info[:sprite], :player
+        )
+      end
+
+      attr_reader :dead_things, :projectiles, :explosions, :puffs
+
+      def in_pain?(thing_idx)
+        @pain_until[thing_idx] && @tic < @pain_until[thing_idx]
+      end
 
       def dead?(thing_idx)
         @dead_things.key?(thing_idx)
       end
 
-      # Get the current death frame sprite for a dead monster
+      # Get the current death frame sprite for a dead monster/barrel
       def death_sprite(thing_idx, thing_type, viewer_angle, thing_angle)
         info = @dead_things[thing_idx]
         return nil unless info
 
-        frames = DEATH_FRAMES[info[:prefix]]
+        prefix = info[:prefix]
+        frames = DEATH_FRAMES[prefix]
         return nil unless frames
 
         elapsed = @tic - info[:tic]
-        frame_idx = (elapsed / DEATH_ANIM_TICS).clamp(0, frames.size - 1)
+        frame_idx = elapsed / DEATH_ANIM_TICS
+
+        # Barrels disappear after explosion animation (S_NULL in Chocolate Doom)
+        if thing_type == BARREL_TYPE && frame_idx >= frames.size
+          return nil
+        end
+
+        frame_idx = frame_idx.clamp(0, frames.size - 1)
         frame_letter = frames[frame_idx]
 
-        @sprites.get_frame(thing_type, frame_letter, viewer_angle, thing_angle)
+        # Use prefix directly if it differs from the thing's sprite (e.g. BEXP for barrels)
+        thing_prefix = @sprites.prefix_for(thing_type)
+        if prefix != thing_prefix
+          @sprites.get_frame_by_prefix(prefix, frame_letter)
+        else
+          @sprites.get_frame(thing_type, frame_letter, viewer_angle, thing_angle)
+        end
       end
 
       # Called each game tic
@@ -101,6 +196,7 @@ module Doom
         @tic += 1
         update_projectiles
         update_explosions
+        @puffs.reject! { |p| @tic - p[:tic] > 12 }
       end
 
       # Fire the current weapon
@@ -122,44 +218,74 @@ module Doom
       private
 
       def spawn_rocket(px, py, pz, cos_a, sin_a)
-        # Spawn slightly ahead of the player
         @projectiles << Projectile.new(
           px + cos_a * 20, py + sin_a * 20, pz,
-          cos_a * ROCKET_SPEED, sin_a * ROCKET_SPEED,
-          :rocket, @tic
+          cos_a * ROCKET_SPEED, sin_a * ROCKET_SPEED, 0.0,
+          :rocket, @tic, 'MISL', :monsters
         )
       end
 
       def update_projectiles
         @projectiles.reject! do |proj|
-          # Move projectile
           new_x = proj.x + proj.dx
           new_y = proj.y + proj.dy
+          new_z = proj.z + (proj.dz || 0)
 
-          # Check wall collision
           hit_wall = hits_wall?(proj.x, proj.y, new_x, new_y)
 
-          # Check monster collision
-          hit_monster = nil
-          @map.things.each_with_index do |thing, idx|
-            next unless MONSTER_HP[thing.type]
-            next if @dead_things[idx]
-            radius = (MONSTER_RADIUS[thing.type] || 20) + ROCKET_RADIUS
-            dx = new_x - thing.x
-            dy = new_y - thing.y
-            if dx * dx + dy * dy < radius * radius
-              hit_monster = idx
-              break
+          # Check if projectile hit the floor or ceiling
+          sector = @map.sector_at(new_x, new_y)
+          if sector
+            hit_wall = true if new_z <= sector.floor_height || new_z >= sector.ceiling_height
+          end
+          hit = false
+
+          if proj.target == :monsters
+            # Player projectile: check monster collision
+            hit_monster = nil
+            @map.things.each_with_index do |thing, idx|
+              next unless MONSTER_HP[thing.type]
+              next if @dead_things[idx]
+              radius = (MONSTER_RADIUS[thing.type] || 20) + ROCKET_RADIUS
+              dx = new_x - thing.x
+              dy = new_y - thing.y
+              if dx * dx + dy * dy < radius * radius
+                hit_monster = idx
+                break
+              end
+            end
+
+            if hit_wall || hit_monster
+              explode(new_x, new_y, hit_monster) if proj.type == :rocket
+              hit_monster ? apply_damage(hit_monster, (rand(8) + 1) * 5) : nil unless proj.type == :rocket
+              hit = true
+            end
+          elsif proj.target == :player
+            # Monster projectile: check player collision
+            player_radius = 16
+            dx = new_x - @player_x
+            dy = new_y - @player_y
+            if hit_wall || (dx * dx + dy * dy < (player_radius + 6) ** 2)
+              unless hit_wall
+                info = MONSTER_PROJECTILES[proj.type]
+                if info
+                  min_d, max_d = info[:damage]
+                  @player.take_damage(rand(min_d..max_d))
+                end
+              end
+              # Spawn fireball explosion
+              @explosions << { x: new_x, y: new_y, z: proj.z, tic: @tic, sprite: proj.sprite_prefix }
+              hit = true
             end
           end
 
-          if hit_wall || hit_monster
-            explode(new_x, new_y, hit_monster)
-            true  # Remove projectile
+          if hit
+            true
           else
             proj.x = new_x
             proj.y = new_y
-            false # Keep projectile
+            proj.z = new_z
+            false
           end
         end
       end
@@ -188,7 +314,7 @@ module Doom
         end
 
         # Spawn explosion visual
-        @explosions << { x: x, y: y, tic: @tic }
+        @explosions << { x: x, y: y, tic: @tic, sprite: 'MISL' }
       end
 
       def update_explosions
@@ -198,17 +324,21 @@ module Doom
 
       def hits_wall?(x1, y1, x2, y2)
         @map.linedefs.each do |ld|
-          # One-sided walls always block
-          blocks = ld.sidedef_left == 0xFFFF || (ld.flags & 0x0001 != 0)
-          unless blocks
-            next unless ld.sidedef_left < 0xFFFF
+          # One-sided walls always block projectiles
+          if ld.sidedef_left == 0xFFFF
+            blocks = true
+          elsif ld.sidedef_left < 0xFFFF
+            # Two-sided: only block if opening is too small for a projectile
+            # BLOCKING flag (0x0001) stops players/monsters but NOT projectiles
             front = @map.sidedefs[ld.sidedef_right]
             back = @map.sidedefs[ld.sidedef_left]
             fs = @map.sectors[front.sector]
             bs = @map.sectors[back.sector]
             max_floor = [fs.floor_height, bs.floor_height].max
             min_ceil = [fs.ceiling_height, bs.ceiling_height].min
-            blocks = (min_ceil - max_floor) < 56
+            blocks = (min_ceil - max_floor) < 1  # Closed door/wall
+          else
+            next
           end
           next unless blocks
 
@@ -252,6 +382,7 @@ module Doom
           best_dist = wall_dist
 
           @map.things.each_with_index do |thing, idx|
+            next if @hidden_things[idx]
             next unless MONSTER_HP[thing.type]
             next if @dead_things[idx]
 
@@ -263,6 +394,12 @@ module Doom
             end
           end
 
+          # Spawn bullet puff at hit location
+          puff_x = px + ca * best_dist
+          puff_y = py + sa * best_dist
+          puff_z = @player_z
+          @puffs << { x: puff_x, y: puff_y, z: puff_z, tic: @tic }
+
           if best_idx
             damage = (rand(3) + 1) * multiplier
             apply_damage(best_idx, damage)
@@ -306,8 +443,54 @@ module Doom
         @monster_hp[thing_idx] -= damage
 
         if @monster_hp[thing_idx] <= 0
-          prefix = @sprites.prefix_for(thing.type)
-          @dead_things[thing_idx] = { tic: @tic, prefix: prefix } if prefix
+          return if @dead_things[thing_idx]  # Already dead
+
+          if thing.type == BARREL_TYPE
+            @dead_things[thing_idx] = { tic: @tic, prefix: 'BEXP' }
+            @sound&.explosion
+            barrel_explode(thing.x, thing.y, thing_idx)
+          else
+            prefix = @sprites.prefix_for(thing.type)
+            @dead_things[thing_idx] = { tic: @tic, prefix: prefix } if prefix
+            @sound&.monster_death(thing.type)
+          end
+        else
+          # Pain state: monster flinches (not barrels)
+          if thing.type != BARREL_TYPE
+            pain_chance = PAIN_CHANCE[thing.type] || 128
+            if rand(256) < pain_chance
+              @pain_until[thing_idx] = @tic + PAIN_DURATION
+              @sound&.monster_pain(thing.type)
+            end
+          end
+        end
+      end
+
+      def barrel_explode(x, y, barrel_idx)
+        @explosions << { x: x, y: y, tic: @tic, sprite: 'MISL' }
+
+        # Splash damage to monsters and other barrels (chain reactions!)
+        @map.things.each_with_index do |thing, idx|
+          next unless MONSTER_HP[thing.type]
+          next if @dead_things[idx]
+          next if idx == barrel_idx
+
+          dx = x - thing.x
+          dy = y - thing.y
+          dist = Math.sqrt(dx * dx + dy * dy)
+          next if dist >= BARREL_SPLASH_RADIUS
+
+          damage = ((BARREL_SPLASH_DAMAGE * (1.0 - dist / BARREL_SPLASH_RADIUS))).to_i
+          apply_damage(idx, damage) if damage > 0
+        end
+
+        # Splash damage to player
+        dx = x - @player_x
+        dy = y - @player_y
+        dist = Math.sqrt(dx * dx + dy * dy)
+        if dist < BARREL_SPLASH_RADIUS
+          damage = ((BARREL_SPLASH_DAMAGE * (1.0 - dist / BARREL_SPLASH_RADIUS))).to_i
+          @player.take_damage(damage) if damage > 0
         end
       end
 
@@ -318,18 +501,21 @@ module Doom
           v1 = @map.vertices[ld.v1]
           v2 = @map.vertices[ld.v2]
 
-          # One-sided always blocks; two-sided only if impassable
-          blocks = (ld.sidedef_left == 0xFFFF) || (ld.flags & 0x0001 != 0)
-          unless blocks
-            next unless ld.sidedef_left < 0xFFFF
+          # One-sided always blocks hitscan
+          if ld.sidedef_left == 0xFFFF
+            blocks = true
+          elsif ld.sidedef_left < 0xFFFF
+            # Two-sided: only blocks if opening is too small
+            # BLOCKING flag does NOT stop hitscan (only affects movement)
             front = @map.sidedefs[ld.sidedef_right]
             back = @map.sidedefs[ld.sidedef_left]
             fs = @map.sectors[front.sector]
             bs = @map.sectors[back.sector]
-            # Blocks if opening is too small (step or low ceiling)
             max_floor = [fs.floor_height, bs.floor_height].max
             min_ceil = [fs.ceiling_height, bs.ceiling_height].min
             blocks = (min_ceil - max_floor) < 56
+          else
+            next
           end
           next unless blocks
 

data/lib/doom/game/intermission.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Intermission screen shown between levels.
+    # Displays kill%, item%, secret%, time, and par time.
+    class Intermission
+      # Episode 1 par times in seconds (from Chocolate Doom)
+      PAR_TIMES = {
+        'E1M1' => 30, 'E1M2' => 75, 'E1M3' => 120, 'E1M4' => 90,
+        'E1M5' => 165, 'E1M6' => 180, 'E1M7' => 180, 'E1M8' => 30, 'E1M9' => 165,
+      }.freeze
+
+      # Next map progression
+      NEXT_MAP = {
+        'E1M1' => 'E1M2', 'E1M2' => 'E1M3', 'E1M3' => 'E1M4', 'E1M4' => 'E1M5',
+        'E1M5' => 'E1M6', 'E1M6' => 'E1M7', 'E1M7' => 'E1M8', 'E1M8' => nil,
+        'E1M9' => 'E1M4',
+      }.freeze
+
+      # Counter animation speed (percentage points per tic)
+      COUNT_SPEED = 2
+      TICS_PER_COUNT = 1
+
+      attr_reader :finished, :next_map
+
+      def initialize(wad, hud_graphics, stats)
+        @wad = wad
+        @gfx = hud_graphics
+        @stats = stats  # { map:, kills:, total_kills:, items:, total_items:, secrets:, total_secrets:, time_tics: }
+        @finished = false
+        @next_map = NEXT_MAP[stats[:map]]
+        @tic = 0
+
+        # Animated counters (count up from 0 to actual value)
+        @kill_count = 0
+        @item_count = 0
+        @secret_count = 0
+        @time_count = 0
+        @counting_done = false
+
+        # Target percentages
+        @kill_pct = @stats[:total_kills] > 0 ? (@stats[:kills] * 100 / @stats[:total_kills]) : 100
+        @item_pct = @stats[:total_items] > 0 ? (@stats[:items] * 100 / @stats[:total_items]) : 100
+        @secret_pct = @stats[:total_secrets] > 0 ? (@stats[:secrets] * 100 / @stats[:total_secrets]) : 100
+        @time_secs = @stats[:time_tics] / 35
+
+        @par_time = PAR_TIMES[stats[:map]] || 0
+
+        load_graphics
+      end
+
+      def update
+        @tic += 1
+        return if @counting_done
+
+        # Animate counters
+        if @kill_count < @kill_pct
+          @kill_count = [@kill_count + COUNT_SPEED, @kill_pct].min
+        elsif @item_count < @item_pct
+          @item_count = [@item_count + COUNT_SPEED, @item_pct].min
+        elsif @secret_count < @secret_pct
+          @secret_count = [@secret_count + COUNT_SPEED, @secret_pct].min
+        elsif @time_count < @time_secs
+          @time_count = [@time_count + 3, @time_secs].min
+        else
+          @counting_done = true
+        end
+      end
+
+      def render(framebuffer)
+        # Background
+        draw_background(framebuffer)
+
+        # "Finished" text + level name
+        draw_sprite(framebuffer, @wifinish, 64, 4) if @wifinish
+        level_idx = map_to_level_index(@stats[:map])
+        lv = @level_names[level_idx]
+        draw_sprite(framebuffer, lv, (320 - (lv&.width || 0)) / 2, 24) if lv
+
+        # Kill, Item, Secret percentages
+        y = 60
+        draw_sprite(framebuffer, @wiostk, 50, y) if @wiostk
+        draw_percent(framebuffer, 260, y, @kill_count)
+
+        y += 24
+        draw_sprite(framebuffer, @wiosti, 50, y) if @wiosti
+        draw_percent(framebuffer, 260, y, @item_count)
+
+        y += 24
+        draw_sprite(framebuffer, @wiosts, 50, y) if @wiosts
+        draw_percent(framebuffer, 260, y, @secret_count)
+
+        # Time
+        y += 30
+        draw_sprite(framebuffer, @witime, 16, y) if @witime
+        draw_time(framebuffer, 160, y, @time_count)
+
+        # Par time
+        draw_sprite(framebuffer, @wipar, 176, y) if @wipar
+        draw_time(framebuffer, 292, y, @par_time)
+
+        # "Entering" next level (after counting done)
+        if @counting_done && @next_map
+          y += 30
+          draw_sprite(framebuffer, @wienter, 64, y) if @wienter
+          next_idx = map_to_level_index(@next_map)
+          nlv = @level_names[next_idx]
+          draw_sprite(framebuffer, nlv, (320 - (nlv&.width || 0)) / 2, y + 18) if nlv
+        end
+
+        # "Press any key" hint after counting
+        if @counting_done && (@tic / 17) % 2 == 0
+          # Blink hint via skull
+          skull = @skulls[@tic / 8 % 2]
+          draw_sprite(framebuffer, skull, 144, 210) if skull
+        end
+      end
+
+      def handle_key
+        if @counting_done
+          @finished = true
+        else
+          # Skip counting animation
+          @kill_count = @kill_pct
+          @item_count = @item_pct
+          @secret_count = @secret_pct
+          @time_count = @time_secs
+          @counting_done = true
+        end
+      end
+
+      private
+
+      def map_to_level_index(map_name)
+        return 0 unless map_name
+        map_name[3].to_i - 1  # E1M1 -> 0, E1M2 -> 1, etc.
+      end
+
+      def load_graphics
+        # Intermission number digits
+        @nums = (0..9).map { |n| load_patch("WINUM#{n}") }
+        @percent = load_patch('WIPCNT')
+        @colon = load_patch('WICOLON')
+        @minus = load_patch('WIMINUS')
+
+        # Labels
+        @wiostk = load_patch('WIOSTK')   # "Kills"
+        @wiosti = load_patch('WIOSTI')   # "Items"
+        @wiosts = load_patch('WIOSTS')   # "Scrt" (Secrets)
+        @witime = load_patch('WITIME')   # "Time"
+        @wipar = load_patch('WIPAR')     # "Par"
+        @wifinish = load_patch('WIF')    # "Finished"
+        @wienter = load_patch('WIENTER') # "Entering"
+
+        # Map background
+        @wimap = load_patch('WIMAP0')
+
+        # Level names (WILV00-WILV08)
+        @level_names = (0..8).map { |n| load_patch("WILV0#{n}") }
+
+        # Skull cursor
+        @skulls = [load_patch('M_SKULL1'), load_patch('M_SKULL2')]
+      end
+
+      def load_patch(name)
+        @gfx.send(:load_graphic, name)
+      end
+
+      def draw_background(framebuffer)
+        return unless @wimap
+        draw_fullscreen(framebuffer, @wimap)
+      end
+
+      def draw_fullscreen(framebuffer, sprite)
+        return unless sprite
+        y_offset = (240 - sprite.height) / 2
+        y_offset = [y_offset, 0].max
+        sprite.width.times do |x|
+          next if x >= 320
+          col = sprite.column_pixels(x)
+          next unless col
+          col.each_with_index do |color, y|
+            next unless color
+            sy = y + y_offset
+            next if sy < 0 || sy >= 240
+            framebuffer[sy * 320 + x] = color
+          end
+        end
+      end
+
+      def draw_percent(framebuffer, right_x, y, value)
+        # Draw percent sign
+        draw_sprite(framebuffer, @percent, right_x, y) if @percent
+
+        # Draw number right-aligned before percent
+        draw_num_right(framebuffer, right_x - 2, y, value)
+      end
+
+      def draw_time(framebuffer, right_x, y, seconds)
+        mins = seconds / 60
+        secs = seconds % 60
+
+        # Draw seconds (2 digits, zero-padded)
+        draw_num_right(framebuffer, right_x, y, secs, pad: 2)
+
+        # Colon
+        colon_x = right_x - num_width * 2 - 4
+        draw_sprite(framebuffer, @colon, colon_x, y) if @colon
+
+        # Minutes
+        draw_num_right(framebuffer, colon_x - 2, y, mins)
+      end
+
+      def num_width
+        @nums[0]&.width || 14
+      end
+
+      def draw_num_right(framebuffer, right_x, y, value, pad: 0)
+        w = num_width
+        str = value.to_i.to_s
+        str = str.rjust(pad, '0') if pad > 0
+        x = right_x
+        str.reverse.each_char do |ch|
+          x -= w
+          digit = @nums[ch.to_i]
+          draw_sprite(framebuffer, digit, x, y) if digit
+        end
+      end
+
+      def draw_sprite(framebuffer, sprite, x, y)
+        return unless sprite
+        sprite.width.times do |col_x|
+          sx = x + col_x
+          next if sx < 0 || sx >= 320
+          col = sprite.column_pixels(col_x)
+          next unless col
+          col.each_with_index do |color, col_y|
+            next unless color
+            sy = y + col_y
+            next if sy < 0 || sy >= 240
+            framebuffer[sy * 320 + sx] = color
+          end
+        end
+      end
+    end
+  end
+end