doom 0.6.0 → 0.11.0

data/lib/doom/game/framebuffer_blitter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Shared framebuffer blitting for the full-screen menu and intermission
+    # screens. Both draw palette-index sprites into a flat 320x240 framebuffer,
+    # so the clipping loop lived duplicated in each. It lives here once and uses
+    # the renderer's screen constants instead of hardcoded 320/240.
+    #
+    # A "sprite" here is anything exposing #width and #column_pixels(x), where a
+    # column is an array of palette indices (nil = transparent).
+    module FramebufferBlitter
+      # Blit a sprite's opaque pixels at (x, y), clipping to the screen.
+      def blit_sprite(framebuffer, sprite, x, y)
+        return unless sprite
+
+        w = Render::SCREEN_WIDTH
+        h = Render::SCREEN_HEIGHT
+        sprite.width.times do |col_x|
+          sx = x + col_x
+          next if sx < 0 || sx >= w
+
+          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 >= h
+
+            framebuffer[(sy * w) + sx] = color
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doom/game/geometry.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Shared 2D geometry for the simulation. These three helpers were copy-pasted
+    # across combat, monster AI, player physics, world and sector actions (the
+    # last under the name point_line_dist); consolidated here so line-of-sight,
+    # collision and use-line checks share one definition.
+    #
+    # Pure functions of their arguments -- no state, no RNG, no wall clock -- so
+    # they stay deterministic and every peer computes the same result.
+    module Geometry
+      module_function
+
+      # Do the open segments A (ax1,ay1)->(ax2,ay2) and B (bx1,by1)->(bx2,by2)
+      # cross? Used for line-of-sight and hitscan against walls. Parallel or
+      # barely-crossing segments (tiny determinant) count as no intersection.
+      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
+
+        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
+
+      # Does the segment (x1,y1)->(x2,y2) pass within `radius` of the circle
+      # centred at (cx,cy)? The collision test for a body of that radius sliding
+      # against a wall.
+      def line_circle_intersect?(x1, y1, x2, y2, cx, cy, radius)
+        dx = cx - x1
+        dy = cy - y1
+        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.zero?
+
+        t = (((dx * line_dx) + (dy * line_dy)).to_f / line_len_sq).clamp(0.0, 1.0)
+        closest_x = x1 + (t * line_dx)
+        closest_y = y1 + (t * line_dy)
+        dist_sq = ((cx - closest_x)**2) + ((cy - closest_y)**2)
+        dist_sq < radius * radius
+      end
+
+      # Shortest distance from point (px,py) to the segment (x1,y1)->(x2,y2),
+      # clamped to the segment ends. Used for use-line and trigger proximity.
+      def point_to_segment_distance(px, py, x1, y1, x2, y2)
+        dx = px - x1
+        dy = py - y1
+        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.zero?
+
+        t = (((dx * line_dx) + (dy * line_dy)).to_f / line_len_sq).clamp(0.0, 1.0)
+        closest_x = x1 + (t * line_dx)
+        closest_y = y1 + (t * line_dy)
+        Math.sqrt(((px - closest_x)**2) + ((py - closest_y)**2))
+      end
+    end
+  end
+end

data/lib/doom/game/intermission.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require_relative 'framebuffer_blitter'
+
+module Doom
+  module Game
+    # Intermission screen shown between levels.
+    # Displays kill%, item%, secret%, time, and par time.
+    class Intermission
+      include FramebufferBlitter
+
+      # 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)
+        @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
+        return unless @counting_done && (@tic / 17).even?
+
+        # Blink hint via skull
+        skull = @skulls[@tic / 8 % 2]
+        draw_sprite(framebuffer, skull, 144, 210) if skull
+      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.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 = [(Render::SCREEN_HEIGHT - sprite.height) / 2, 0].max
+        blit_sprite(framebuffer, sprite, 0, y_offset)
+      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)
+        blit_sprite(framebuffer, sprite, x, y)
+      end
+    end
+  end
+end

data/lib/doom/game/item_pickup.rb

@@ -7,7 +7,7 @@ module Doom
     class ItemPickup
       PLAYER_RADIUS = 16.0
       THING_RADIUS = 20.0
-      PICKUP_DIST = PLAYER_RADIUS + THING_RADIUS  # 36 units (bounding box overlap)
+      PICKUP_DIST = PLAYER_RADIUS + THING_RADIUS # 36 units (bounding box overlap)
 
       # Item definitions: type => { category, value, ... }
       ITEMS = {
@@ -26,9 +26,9 @@ module Doom
         2049 => { cat: :ammo, ammo: :shells, amount: 20 },    # Box of shells
         2010 => { cat: :ammo, ammo: :rockets, amount: 1 },    # Rocket
         2046 => { cat: :ammo, ammo: :rockets, amount: 5 },    # Box of rockets
-        17   => { cat: :ammo, ammo: :cells, amount: 20 },     # Cell charge
-        2047 => { cat: :ammo, ammo: :cells, amount: 100 },    # Cell pack
-        8    => { cat: :backpack },                             # Backpack (doubles max ammo + some ammo)
+        17 => { cat: :ammo, ammo: :cells, amount: 20 }, # Cell charge
+        2047 => { cat: :ammo, ammo: :cells, amount: 100 }, # Cell pack
+        8 => { cat: :backpack }, # Backpack (doubles max ammo + some ammo)
 
         # Health
         2014 => { cat: :health, amount: 1, max: 200 },        # Health bonus (+1, up to 200)
@@ -37,132 +37,180 @@ module Doom
         2013 => { cat: :health, amount: 100, max: 200 },      # Soul sphere
 
         # Armor
-        2015 => { cat: :armor, amount: 1, max: 200 },         # Armor bonus (+1, up to 200)
+        2015 => { cat: :armor, amount: 1, max: 200 }, # Armor bonus (+1, up to 200)
         2018 => { cat: :armor, amount: 100, armor_type: 1 },   # Green armor (100%, absorbs 1/3)
         2019 => { cat: :armor, amount: 200, armor_type: 2 },   # Blue armor (200%, absorbs 1/2)
 
         # Keys
-        5  => { cat: :key, key: :blue_card },
-        6  => { cat: :key, key: :yellow_card },
+        5 => { cat: :key, key: :blue_card },
+        6 => { cat: :key, key: :yellow_card },
         13 => { cat: :key, key: :red_card },
         40 => { cat: :key, key: :blue_skull },
         39 => { cat: :key, key: :yellow_skull },
-        38 => { cat: :key, key: :red_skull },
+        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, 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)
+      # Pick up for one player. `picked_up` stays global on purpose: in coop an
+      # item taken by anyone is gone for everyone, as in DOOM. Deathmatch
+      # respawning is a separate concern.
+      def update(player)
+        state = player.state
         @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
+          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
-          end
+          next unless try_pickup(item, state)
+
+          @picked_up[idx] = true
+          @pickup_message = PICKUP_MESSAGES[thing.type]
+          @pickup_flash = FLASH_TICS
+          @message_tics = MESSAGETICS
         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)
+      def try_pickup(item, state)
         case item[:cat]
         when :weapon
-          give_weapon(item)
+          give_weapon(item, state)
         when :ammo
-          give_ammo(item[:ammo], item[:amount])
+          give_ammo(item[:ammo], item[:amount], state)
         when :backpack
-          give_backpack
+          give_backpack(state)
         when :health
-          give_health(item[:amount], item[:max])
+          give_health(item[:amount], item[:max], state)
         when :armor
-          give_armor(item)
+          give_armor(item, state)
         when :key
-          give_key(item[:key])
+          give_key(item[:key], state)
         else
           false
         end
       end
 
-      def give_weapon(item)
+      def give_weapon(item, state)
         weapon_idx = item[:weapon]
-        had_weapon = @player.has_weapons[weapon_idx]
+        had_weapon = state.has_weapons[weapon_idx]
 
-        @player.has_weapons[weapon_idx] = true
-        ammo_given = item[:ammo] ? give_ammo(item[:ammo], item[:amount]) : false
+        state.has_weapons[weapon_idx] = true
+        ammo_given = item[:ammo] ? give_ammo(item[:ammo], item[:amount], state) : false
 
         unless had_weapon
-          @player.switch_weapon(weapon_idx) unless @player.attacking
+          state.switch_weapon(weapon_idx) unless state.attacking
           return true
         end
 
         ammo_given
       end
 
-      def give_ammo(type, amount)
+      def give_ammo(type, amount, state)
+        amount *= @ammo_multiplier
         case type
         when :bullets
-          return false if @player.ammo_bullets >= @player.max_bullets
-          @player.ammo_bullets = [@player.ammo_bullets + amount, @player.max_bullets].min
+          return false if state.ammo_bullets >= state.max_bullets
+
+          state.ammo_bullets = [state.ammo_bullets + amount, state.max_bullets].min
         when :shells
-          return false if @player.ammo_shells >= @player.max_shells
-          @player.ammo_shells = [@player.ammo_shells + amount, @player.max_shells].min
+          return false if state.ammo_shells >= state.max_shells
+
+          state.ammo_shells = [state.ammo_shells + amount, state.max_shells].min
         when :rockets
-          return false if @player.ammo_rockets >= @player.max_rockets
-          @player.ammo_rockets = [@player.ammo_rockets + amount, @player.max_rockets].min
+          return false if state.ammo_rockets >= state.max_rockets
+
+          state.ammo_rockets = [state.ammo_rockets + amount, state.max_rockets].min
         when :cells
-          return false if @player.ammo_cells >= @player.max_cells
-          @player.ammo_cells = [@player.ammo_cells + amount, @player.max_cells].min
+          return false if state.ammo_cells >= state.max_cells
+
+          state.ammo_cells = [state.ammo_cells + amount, state.max_cells].min
         end
         true
       end
 
-      def give_backpack
-        @player.max_bullets = 400
-        @player.max_shells = 100
-        @player.max_rockets = 100
-        @player.max_cells = 600
-        give_ammo(:bullets, 10)
-        give_ammo(:shells, 4)
-        give_ammo(:rockets, 1)
-        give_ammo(:cells, 20)
+      def give_backpack(state)
+        state.max_bullets = 400
+        state.max_shells = 100
+        state.max_rockets = 100
+        state.max_cells = 600
+        give_ammo(:bullets, 10, state)
+        give_ammo(:shells, 4, state)
+        give_ammo(:rockets, 1, state)
+        give_ammo(:cells, 20, state)
         true
       end
 
-      def give_health(amount, max)
-        return false if @player.health >= max
-        @player.health = [@player.health + amount, max].min
+      def give_health(amount, max, state)
+        return false if state.health >= max
+
+        state.health = [state.health + amount, max].min
         true
       end
 
-      def give_armor(item)
+      def give_armor(item, state)
         if item[:armor_type]
           # Green/blue armor: only pick up if better than current
-          return false if @player.armor >= item[:amount]
-          @player.armor = item[:amount]
+          return false if state.armor >= item[:amount]
+
+          state.armor = item[:amount]
         else
           # Armor bonus: +1, up to max
-          return false if @player.armor >= item[:max]
-          @player.armor = [@player.armor + item[:amount], item[:max]].min
+          return false if state.armor >= item[:max]
+
+          state.armor = [state.armor + item[:amount], item[:max]].min
         end
         true
       end
 
-      def give_key(key)
-        return false if @player.keys[key]
-        @player.keys[key] = true
+      def give_key(key, state)
+        return false if state.keys[key]
+
+        state.keys[key] = true
         true
       end
     end