doom 0.5.0 → 0.8.0

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

data/lib/doom/game/item_pickup.rb

@@ -50,31 +50,66 @@ module Doom
         38 => { cat: :key, key: :red_skull },
       }.freeze
 
-      attr_reader :picked_up
+      MESSAGETICS = 140    # 4 * TICRATE (4 seconds, matching Chocolate Doom)
+      FLASH_TICS = 8       # Yellow palette flash duration
 
-      def initialize(map, player_state)
+      attr_reader :picked_up, :pickup_message, :pickup_flash, :message_tics
+      attr_accessor :ammo_multiplier, :hidden_things
+
+      def initialize(map, player_state, hidden_things = {})
         @map = map
         @player = player_state
-        @picked_up = {}  # thing index => true (to avoid re-picking)
+        @picked_up = {}
+        @hidden_things = hidden_things
+        @ammo_multiplier = 1
+        @pickup_message = nil
+        @pickup_flash = 0     # Yellow screen flash (short)
+        @message_tics = 0     # Message display timer (long)
+      end
+
+      # Decay timers each tic
+      def update_flash
+        @pickup_flash -= 1 if @pickup_flash > 0
+        @message_tics -= 1 if @message_tics > 0
       end
 
       def update(player_x, player_y)
         @map.things.each_with_index do |thing, idx|
+          next if @hidden_things[idx]
           next if @picked_up[idx]
           item = ITEMS[thing.type]
           next unless item
 
-          # DOOM uses bounding box overlap: abs(dx) < sum_of_radii
           dx = (player_x - thing.x).abs
           dy = (player_y - thing.y).abs
           next if dx >= PICKUP_DIST || dy >= PICKUP_DIST
 
           if try_pickup(item)
             @picked_up[idx] = true
+            @pickup_message = PICKUP_MESSAGES[thing.type]
+            @pickup_flash = FLASH_TICS
+            @message_tics = MESSAGETICS
           end
         end
       end
 
+      PICKUP_MESSAGES = {
+        2001 => "A SHOTGUN!", 2002 => "A CHAINGUN!", 2003 => "A ROCKET LAUNCHER!",
+        2004 => "A PLASMA RIFLE!", 2005 => "A CHAINSAW!", 2006 => "A BFG9000!",
+        2007 => "PICKED UP A CLIP.", 2048 => "PICKED UP A BOX OF BULLETS.",
+        2008 => "PICKED UP 4 SHOTGUN SHELLS.", 2049 => "PICKED UP A BOX OF SHELLS.",
+        2010 => "PICKED UP A ROCKET.", 2046 => "PICKED UP A BOX OF ROCKETS.",
+        17 => "PICKED UP AN ENERGY CELL.", 2047 => "PICKED UP AN ENERGY CELL PACK.",
+        8 => "PICKED UP A BACKPACK FULL OF AMMO!",
+        2011 => "PICKED UP A STIMPACK.", 2012 => "PICKED UP A MEDIKIT.",
+        2014 => "PICKED UP A HEALTH BONUS.", 2015 => "PICKED UP AN ARMOR BONUS.",
+        2018 => "PICKED UP THE ARMOR.", 2019 => "PICKED UP THE MEGAARMOR!",
+        2013 => "SUPERCHARGE!",
+        5 => "PICKED UP A BLUE KEYCARD.", 6 => "PICKED UP A YELLOW KEYCARD.",
+        13 => "PICKED UP A RED KEYCARD.", 40 => "PICKED UP A BLUE SKULL KEY.",
+        39 => "PICKED UP A YELLOW SKULL KEY.", 38 => "PICKED UP A RED SKULL KEY.",
+      }.freeze
+
       private
 
       def try_pickup(item)
@@ -112,6 +147,7 @@ module Doom
       end
 
       def give_ammo(type, amount)
+        amount = amount * @ammo_multiplier
         case type
         when :bullets
           return false if @player.ammo_bullets >= @player.max_bullets

data/lib/doom/game/menu.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # DOOM main menu system with title screen, new game, and difficulty selection.
+    class Menu
+      SKULL_ANIM_TICS = 8  # Skull cursor blink rate
+
+      # Difficulty levels matching DOOM's skill levels
+      SKILL_BABY = 0      # I'm too young to die
+      SKILL_EASY = 1      # Hey, not too rough
+      SKILL_MEDIUM = 2    # Hurt me plenty
+      SKILL_HARD = 3      # Ultra-Violence
+      SKILL_NIGHTMARE = 4 # Nightmare!
+
+      # Menu states
+      STATE_TITLE = :title
+      STATE_MAIN = :main
+      STATE_SKILL = :skill
+      STATE_OPTIONS = :options
+      STATE_NONE = :none   # In-game, no menu
+
+      # Main menu items
+      MAIN_ITEMS = %i[new_game options quit].freeze
+
+      # Options menu items
+      OPTIONS_ITEMS = %i[god_mode infinite_ammo all_weapons fullscreen rubykaigi_mode].freeze
+      OPTIONS_LABELS = {
+        god_mode: "GOD MODE",
+        infinite_ammo: "INFINITE AMMO",
+        all_weapons: "ALL WEAPONS",
+        fullscreen: "FULLSCREEN",
+        rubykaigi_mode: "RUBYKAIGI MODE",
+      }.freeze
+
+      OPTIONS_X = 48
+      OPTIONS_Y = 50
+      OPTIONS_SPACING = 18
+
+      # Skill menu items
+      SKILL_ITEMS = [SKILL_BABY, SKILL_EASY, SKILL_MEDIUM, SKILL_HARD, SKILL_NIGHTMARE].freeze
+
+      # Menu item Y positions (from Chocolate Doom m_menu.c)
+      MAIN_X = 97
+      MAIN_Y = 64
+      MAIN_SPACING = 16
+
+      SKILL_X = 48
+      SKILL_Y = 63
+      SKILL_SPACING = 16
+
+      attr_reader :state, :selected_skill, :options, :font
+
+      def initialize(wad, hud_graphics, font = nil)
+        @wad = wad
+        @gfx = hud_graphics
+        @font = font
+        @state = STATE_TITLE
+        @cursor = 0
+        @skull_frame = 0
+        @skull_tic = 0
+        @selected_skill = SKILL_MEDIUM  # Default difficulty
+        @game_started = false
+
+        # Options toggles
+        @options = {
+          god_mode: false,
+          infinite_ammo: false,
+          all_weapons: false,
+          fullscreen: false,
+          rubykaigi_mode: false,
+        }
+
+        load_graphics
+      end
+
+      def active?
+        @state != STATE_NONE
+      end
+
+      def needs_background?
+        @state != STATE_TITLE
+      end
+
+      def update
+        @skull_tic += 1
+        if @skull_tic >= SKULL_ANIM_TICS
+          @skull_tic = 0
+          @skull_frame = 1 - @skull_frame
+        end
+      end
+
+      def render(framebuffer, palette_colors)
+        case @state
+        when STATE_TITLE
+          render_title(framebuffer)
+        when STATE_MAIN
+          render_main_menu(framebuffer)
+        when STATE_SKILL
+          render_skill_menu(framebuffer)
+        when STATE_OPTIONS
+          render_options_menu(framebuffer)
+        end
+      end
+
+      # Returns :start_game, :resume, :quit, or option action symbols
+      def handle_key(key)
+        case @state
+        when STATE_TITLE
+          @state = STATE_MAIN
+          @cursor = 0
+        when STATE_MAIN
+          handle_main_key(key)
+        when STATE_SKILL
+          handle_skill_key(key)
+        when STATE_OPTIONS
+          handle_options_key(key)
+        end
+      end
+
+      def dismiss
+        @state = STATE_NONE
+        @game_started = true
+      end
+
+      def show
+        @state = STATE_MAIN
+        @cursor = 0
+      end
+
+      private
+
+      def load_graphics
+        # Title screen
+        @title = load_patch('TITLEPIC')
+
+        # RubyKaigi title screen (pre-rendered palette indices)
+        kaigi_path = File.join(File.expand_path('../../..', __dir__), 'assets', 'kaigi_title.dat')
+        @kaigi_title = File.exist?(kaigi_path) ? Marshal.load(File.binread(kaigi_path)) : nil
+
+        # Main menu
+        @m_doom = load_patch('M_DOOM')
+        @m_newg = load_patch('M_NGAME')
+        @m_option = load_patch('M_OPTION')
+        @m_quitg = load_patch('M_QUITG')
+
+        # Skill menu
+        @m_skill = load_patch('M_SKILL')
+        @m_jkill = load_patch('M_JKILL')
+        @m_hurt = load_patch('M_HURT')
+        @m_rough = load_patch('M_ROUGH')  # Not used, but loaded
+        @m_ultra = load_patch('M_ULTRA')
+        @m_nmare = load_patch('M_NMARE')
+
+        # Episode (shareware only has 1)
+        @m_episod = load_patch('M_EPISOD')
+        @m_epi1 = load_patch('M_EPI1')
+
+        # Skull cursor
+        @skulls = [load_patch('M_SKULL1'), load_patch('M_SKULL2')]
+      end
+
+      def load_patch(name)
+        @gfx.send(:load_graphic, name)
+      end
+
+      def render_title(framebuffer)
+        if @options[:rubykaigi_mode] && @kaigi_title
+          # Draw kaigi title (raw palette indices, 320x200, offset 20px down)
+          @kaigi_title.each_with_index do |color, i|
+            x = i % 320
+            y = (i / 320) + 20
+            framebuffer[y * 320 + x] = color if y < 240
+          end
+        elsif @title
+          draw_fullscreen(framebuffer, @title)
+        end
+      end
+
+      def render_main_menu(framebuffer)
+        # Draw title logo
+        draw_sprite(framebuffer, @m_doom, 94, 2) if @m_doom
+
+        # Draw menu items
+        items = [@m_newg, @m_option, @m_quitg]
+        items.each_with_index do |item, i|
+          next unless item
+          draw_sprite(framebuffer, item, MAIN_X, MAIN_Y + i * MAIN_SPACING)
+        end
+
+        # Draw skull cursor
+        skull = @skulls[@skull_frame]
+        if skull
+          skull_x = MAIN_X - 32
+          skull_y = MAIN_Y + @cursor * MAIN_SPACING - 5
+          draw_sprite(framebuffer, skull, skull_x, skull_y)
+        end
+      end
+
+      def render_skill_menu(framebuffer)
+        # Draw skill title
+        draw_sprite(framebuffer, @m_skill, 38, 15) if @m_skill
+
+        # Draw skill items: baby, easy, medium, hard, nightmare
+        skill_items = [@m_jkill, @m_hurt, @m_rough, @m_ultra, @m_nmare]
+        skill_items.each_with_index do |item, i|
+          next unless item
+          draw_sprite(framebuffer, item, SKILL_X, SKILL_Y + i * SKILL_SPACING)
+        end
+
+        # Draw skull cursor
+        skull = @skulls[@skull_frame]
+        if skull
+          skull_x = SKILL_X - 32
+          skull_y = SKILL_Y + @cursor * SKILL_SPACING - 5
+          draw_sprite(framebuffer, skull, skull_x, skull_y)
+        end
+      end
+
+      def handle_main_key(key)
+        case key
+        when :up
+          @cursor = (@cursor - 1) % MAIN_ITEMS.size
+        when :down
+          @cursor = (@cursor + 1) % MAIN_ITEMS.size
+        when :enter
+          case MAIN_ITEMS[@cursor]
+          when :new_game
+            @state = STATE_SKILL
+            @cursor = SKILL_MEDIUM  # Default to "Hurt me plenty"
+          when :options
+            @state = STATE_OPTIONS
+            @cursor = 0
+          when :quit
+            return :quit
+          end
+        when :escape
+          if @game_started
+            # Resume game
+            @state = STATE_NONE
+            return :resume
+          else
+            @state = STATE_TITLE
+          end
+        end
+        nil
+      end
+
+      def handle_skill_key(key)
+        case key
+        when :up
+          @cursor = (@cursor - 1) % SKILL_ITEMS.size
+        when :down
+          @cursor = (@cursor + 1) % SKILL_ITEMS.size
+        when :enter
+          @selected_skill = SKILL_ITEMS[@cursor]
+          @state = STATE_NONE
+          @game_started = true
+          return :start_game
+        when :escape
+          @state = STATE_MAIN
+          @cursor = 0
+        end
+        nil
+      end
+
+      def render_options_menu(framebuffer)
+        # Draw title using font
+        @font&.draw_centered(framebuffer, "OPTIONS", 20)
+
+        # Draw each option with ON/OFF status
+        OPTIONS_ITEMS.each_with_index do |item, i|
+          y = OPTIONS_Y + i * OPTIONS_SPACING
+          label = OPTIONS_LABELS[item]
+          value = @options[item] ? "ON" : "OFF"
+          @font&.draw_text(framebuffer, label, OPTIONS_X, y)
+          @font&.draw_text(framebuffer, value, 260, y)
+        end
+
+        # Draw skull cursor
+        skull = @skulls[@skull_frame]
+        if skull
+          skull_x = OPTIONS_X - 32
+          skull_y = OPTIONS_Y + @cursor * OPTIONS_SPACING - 5
+          draw_sprite(framebuffer, skull, skull_x, skull_y)
+        end
+      end
+
+      def handle_options_key(key)
+        case key
+        when :up
+          @cursor = (@cursor - 1) % OPTIONS_ITEMS.size
+        when :down
+          @cursor = (@cursor + 1) % OPTIONS_ITEMS.size
+        when :enter
+          item = OPTIONS_ITEMS[@cursor]
+          @options[item] = !@options[item]
+          return { action: :toggle_option, option: item, value: @options[item] }
+        when :escape
+          @state = STATE_MAIN
+          @cursor = 1  # Options is the second main menu item
+        end
+        nil
+      end
+
+      def draw_fullscreen(framebuffer, sprite)
+        return unless sprite
+        # TITLEPIC is 320x200, our screen is 320x240
+        # Draw it centered vertically (offset by 20 pixels)
+        y_offset = 20
+        sprite.width.times do |x|
+          col = sprite.column_pixels(x)
+          next unless col
+          col.each_with_index do |color, y|
+            next unless color
+            screen_y = y + y_offset
+            next if screen_y < 0 || screen_y >= 240
+            framebuffer[screen_y * 320 + x] = color
+          end
+        end
+      end
+
+      def draw_sprite(framebuffer, sprite, x, y)
+        return unless sprite
+        sprite.width.times do |col_x|
+          screen_x = x + col_x
+          next if screen_x < 0 || screen_x >= 320
+
+          col = sprite.column_pixels(col_x)
+          next unless col
+
+          col.each_with_index do |color, col_y|
+            next unless color
+            screen_y = y + col_y
+            next if screen_y < 0 || screen_y >= 240
+            framebuffer[screen_y * 320 + screen_x] = color
+          end
+        end
+      end
+    end
+  end
+end