doom 0.8.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

@@ -1,21 +1,25 @@
 # 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,
+        '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',
+        'E1M9' => 'E1M4'
       }.freeze
 
       # Counter animation speed (percentage points per tic)
@@ -24,10 +28,9 @@ module Doom
 
       attr_reader :finished, :next_map
 
-      def initialize(wad, hud_graphics, stats)
-        @wad = wad
+      def initialize(_wad, hud_graphics, stats)
         @gfx = hud_graphics
-        @stats = stats  # { map:, kills:, total_kills:, items:, total_items:, secrets:, total_secrets:, time_tics: }
+        @stats = stats # { map:, kills:, total_kills:, items:, total_items:, secrets:, total_secrets:, time_tics: }
         @finished = false
         @next_map = NEXT_MAP[stats[:map]]
         @tic = 0
@@ -110,11 +113,11 @@ module Doom
         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
+        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
@@ -134,7 +137,8 @@ module Doom
 
       def map_to_level_index(map_name)
         return 0 unless map_name
-        map_name[3].to_i - 1  # E1M1 -> 0, E1M2 -> 1, etc.
+
+        map_name[3].to_i - 1 # E1M1 -> 0, E1M2 -> 1, etc.
       end
 
       def load_graphics
@@ -164,29 +168,20 @@ module Doom
       end
 
       def load_patch(name)
-        @gfx.send(:load_graphic, 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 = (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
+
+        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)
@@ -205,7 +200,7 @@ module Doom
         draw_num_right(framebuffer, right_x, y, secs, pad: 2)
 
         # Colon
-        colon_x = right_x - num_width * 2 - 4
+        colon_x = right_x - (num_width * 2) - 4
         draw_sprite(framebuffer, @colon, colon_x, y) if @colon
 
         # Minutes
@@ -229,19 +224,7 @@ module Doom
       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
+        blit_sprite(framebuffer, sprite, x, y)
       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,17 +37,17 @@ 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
 
       MESSAGETICS = 140    # 4 * TICRATE (4 seconds, matching Chocolate Doom)
@@ -56,9 +56,8 @@ module Doom
       attr_reader :picked_up, :pickup_message, :pickup_flash, :message_tics
       attr_accessor :ammo_multiplier, :hidden_things
 
-      def initialize(map, player_state, hidden_things = {})
+      def initialize(map, hidden_things = {})
         @map = map
-        @player = player_state
         @picked_up = {}
         @hidden_things = hidden_things
         @ammo_multiplier = 1
@@ -73,132 +72,145 @@ module Doom
         @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
 
-          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
-            @pickup_message = PICKUP_MESSAGES[thing.type]
-            @pickup_flash = FLASH_TICS
-            @message_tics = MESSAGETICS
-          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.",
+        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)
-        amount = amount * @ammo_multiplier
+      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