doom 0.6.0 → 0.11.0

data/lib/doom/render/zbuffer_renderer.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    # Experimental renderer path. It deliberately reuses the proven BSP
+    # visibility and texture sampling code while replacing the visibility
+    # target with a full, per-pixel depth buffer. This makes it possible to add
+    # mesh rasterisation and ray traced passes without changing game logic.
+    class ZBufferRenderer < Renderer
+      attr_reader :depth_buffer
+
+      MAX_DYNAMIC_LIGHTS = 8
+      LIGHT_LEVELS = 16
+      Light = Struct.new(:x, :y, :z, :radius, :energy)
+
+      def initialize(...)
+        super
+        @depth_buffer = Array.new(SCREEN_WIDTH * SCREEN_HEIGHT, Float::INFINITY)
+        @light_lut = build_light_lut
+      end
+
+      def render_frame
+        @depth_buffer.fill(Float::INFINITY)
+        @dynamic_lights = collect_dynamic_lights
+        super
+      end
+
+      # Opaque walls are the first geometry producer for the new depth target.
+      # BSP clipping remains the visibility algorithm for this initial stage;
+      # later raster passes can consume the per-pixel depth values written here.
+      def draw_wall_column_ex(x, y1, y2, texture_name, dist, light_level,
+                              tex_col, tex_y_start, scale, world_top)
+        clip_top = @ceiling_clip[x] + 1
+        clip_bottom = @floor_clip[x] - 1
+        first = [[y1, clip_top, 0].max, SCREEN_HEIGHT].min
+        last = [[y2, clip_bottom, SCREEN_HEIGHT - 1].min, -1].max
+
+        super
+
+        return if first > last || texture_name.nil? || texture_name.empty? || texture_name == '-'
+        return unless @textures[anim_texture(texture_name)]
+
+        # Reconstruct the world-space wall hit. Each dynamic source casts a
+        # visibility ray to it; one-sided linedefs produce hard shadows.
+        ray_distance = dist * @column_distscale[x]
+        hit_x = @player_x + (ray_distance * @column_cos[x])
+        hit_y = @player_y - (ray_distance * @column_sin[x])
+        visible_lights = @dynamic_lights.select do |light|
+          dx = light.x - hit_x
+          dy = light.y - hit_y
+          (dx * dx) + (dy * dy) < light.radius * light.radius && light_visible?(hit_x, hit_y, light)
+        end
+
+        y = first
+        while y <= last
+          offset = (y * SCREEN_WIDTH) + x
+          @depth_buffer[offset] = dist if dist < @depth_buffer[offset]
+          unless visible_lights.empty?
+            world_z = world_top - ((y - (HALF_HEIGHT - ((world_top - @player_z) * scale))) / scale)
+            intensity = visible_lights.sum do |light|
+              distance = Math.sqrt(((light.x - hit_x)**2) + ((light.y - hit_y)**2) + ((light.z - world_z)**2))
+              distance < light.radius ? light.energy * ((1.0 - (distance / light.radius))**2) : 0.0
+            end
+            level = (intensity * (LIGHT_LEVELS - 1)).to_i.clamp(0, LIGHT_LEVELS - 1)
+            @framebuffer[offset] = @light_lut[level][@framebuffer[offset]] if level.positive?
+          end
+          y += 1
+        end
+      end
+
+      private
+
+      def collect_dynamic_lights
+        return [] unless @combat
+
+        lights = @combat.projectiles.map do |projectile|
+          Light.new(projectile.x, projectile.y, projectile.z, 224.0, 1.0)
+        end
+        # Hitscan weapons have no projectile object. Their first attack frames
+        # still produce a real, short-lived muzzle light at the camera.
+        if @view_player&.state&.attacking && @view_player.state.attack_frame <= 1
+          lights << Light.new(
+            @view_player.x + (@view_player.cos_angle * 24.0),
+            @view_player.y + (@view_player.sin_angle * 24.0),
+            @view_player.z,
+            448.0,
+            1.8
+          )
+        end
+        @combat.puffs.each do |puff|
+          age = @leveltime - puff[:tic]
+          energy = (1.0 - (age / 12.0)).clamp(0.0, 1.0)
+          lights << Light.new(puff[:x], puff[:y], puff[:z], 192.0, energy * 0.8)
+        end
+        @combat.explosions.each do |explosion|
+          age = @leveltime - explosion[:tic]
+          energy = (1.0 - (age / 20.0)).clamp(0.0, 1.0)
+          lights << Light.new(explosion[:x], explosion[:y], explosion[:z] || @player_z,
+                              384.0, energy * 1.5)
+        end
+        lights.sort_by { |light| ((light.x - @player_x)**2) + ((light.y - @player_y)**2) }
+              .first(MAX_DYNAMIC_LIGHTS)
+      end
+
+      # A 2D ray query matches Doom's extruded sector geometry. Portal-aware
+      # height tests can later replace this conservative one-sided-wall test.
+      def light_visible?(from_x, from_y, light)
+        @map.linedefs.none? do |line|
+          next false if line.two_sided?
+
+          a = @map.vertices[line.v1]
+          b = @map.vertices[line.v2]
+          segments_intersect?(from_x, from_y, light.x, light.y, a.x, a.y, b.x, b.y)
+        end
+      end
+
+      def segments_intersect?(ax, ay, bx, by, cx, cy, dx, dy)
+        abx = bx - ax
+        aby = by - ay
+        cdx = dx - cx
+        cdy = dy - cy
+        denominator = (abx * cdy) - (aby * cdx)
+        return false if denominator.abs < 1e-9
+
+        acx = cx - ax
+        acy = cy - ay
+        t = ((acx * cdy) - (acy * cdx)) / denominator.to_f
+        u = ((acx * aby) - (acy * abx)) / denominator.to_f
+        t > 1e-4 && t < 0.9999 && u >= 0.0 && u <= 1.0
+      end
+
+      # Doom's target is palette-indexed. Precompute nearest palette entries
+      # for a warm additive light so the geometry pass remains deterministic.
+      def build_light_lut
+        colors = @palette.colors
+        LIGHT_LEVELS.times.map do |level|
+          amount = level.to_f / (LIGHT_LEVELS - 1)
+          colors.map do |red, green, blue|
+            target = [red + (255 * amount), green + (176 * amount), blue + (72 * amount)]
+                     .map { |channel| channel.clamp(0, 255) }
+            colors.each_index.min_by do |index|
+              candidate = colors[index]
+              ((candidate[0] - target[0])**2) + ((candidate[1] - target[1])**2) +
+                ((candidate[2] - target[2])**2)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doom/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Doom
-  VERSION = '0.6.0'
+  VERSION = '0.11.0'
 end

data/lib/doom/wad/flat.rb

@@ -23,7 +23,7 @@ module Doom
       end
 
       def [](x, y)
-        @pixels[(y & 63) * WIDTH + (x & 63)]
+        @pixels[((y & 63) * WIDTH) + (x & 63)]
       end
 
       def self.load_all(wad)

data/lib/doom/wad/hud_graphics.rb

@@ -22,8 +22,9 @@ module Doom
         @cache[name]
       end
 
-      private
-
+      # Load (and cache) a single named patch/graphic lump. Returns a HudSprite
+      # or nil if the lump is missing or too small. Public so the menu,
+      # intermission and font renderers can pull graphics by name.
       def load_graphic(name)
         return @cache[name] if @cache[name]
 
@@ -38,6 +39,8 @@ module Doom
         sprite
       end
 
+      private
+
       def parse_patch(name, data)
         width = data[0, 2].unpack1('v')
         height = data[2, 2].unpack1('v')
@@ -46,7 +49,7 @@ module Doom
 
         # Read column offsets
         column_offsets = width.times.map do |i|
-          data[8 + i * 4, 4].unpack1('V')
+          data[8 + (i * 4), 4].unpack1('V')
         end
 
         # Build column data
@@ -63,6 +66,7 @@ module Doom
 
         loop do
           break if pos >= data.size
+
           top_delta = data[pos].ord
           break if top_delta == 0xFF
 

data/lib/doom/wad/palette.rb

@@ -24,9 +24,9 @@ module Doom
         offset = palette_index * PALETTE_SIZE
         colors = COLORS.times.map do |i|
           [
-            data[offset + i * 3].ord,
-            data[offset + i * 3 + 1].ord,
-            data[offset + i * 3 + 2].ord
+            data[offset + (i * 3)].ord,
+            data[offset + (i * 3) + 1].ord,
+            data[offset + (i * 3) + 2].ord
           ]
         end
 

data/lib/doom/wad/patch.rb

@@ -30,7 +30,7 @@ module Doom
         top_offset = data[6, 2].unpack1('s<')
 
         column_offsets = width.times.map do |i|
-          data[8 + i * 4, 4].unpack1('V')
+          data[8 + (i * 4), 4].unpack1('V')
         end
 
         columns = column_offsets.map do |offset|

data/lib/doom/wad/reader.rb

@@ -26,17 +26,15 @@ module Doom
         entry = find_lump(name)
         return nil unless entry
 
-        @file.seek(entry.offset)
-        data = @file.read(entry.size)
+        # Route through read_lump_at, which reads from the file that actually
+        # owns the entry. After merge_pwad a lump the PWAD overrode (PLAYPAL,
+        # COLORMAP, TEXTUREx, PNAMES, a patch) lives in the PWAD file, so seeking
+        # this reader's own IWAD handle at the entry's offset would read garbage.
+        data = read_lump_at(entry)
         @lump_cache[name] = data
         data
       end
 
-      def read_lump_at(entry)
-        @file.seek(entry.offset)
-        @file.read(entry.size)
-      end
-
       def lumps_between(start_marker, end_marker)
         start_idx = @directory.index { |e| e.name == start_marker }
         end_idx = @directory.index { |e| e.name == end_marker }
@@ -45,8 +43,59 @@ module Doom
         @directory[start_idx + 1...end_idx]
       end
 
+      def pwad?
+        @type == PWAD
+      end
+
+      def iwad?
+        @type == IWAD
+      end
+
+      # Merge a PWAD on top of this IWAD.
+      # PWAD lumps override IWAD lumps with the same name.
+      # Map lumps (between map markers) are replaced as a group.
+      def merge_pwad(pwad)
+        raise Error, 'Can only merge a PWAD' unless pwad.pwad?
+
+        @lump_cache.clear
+
+        pwad.directory.each do |pwad_entry|
+          # Check if this lump already exists in the IWAD
+          existing_idx = @directory.index { |e| e.name == pwad_entry.name }
+          if existing_idx
+            # Replace it -- but we need to read from the PWAD file
+            @directory[existing_idx] = pwad_entry
+          else
+            # Append new lump
+            @directory << pwad_entry
+          end
+        end
+
+        # Keep the PWAD file open for reading its lumps
+        @pwad_files ||= []
+        @pwad_files << pwad
+        @num_lumps = @directory.size
+      end
+
+      # Read a lump by directory entry, checking if it belongs to a PWAD file
+      def read_lump_at(entry)
+        # Try PWAD files first (they may own this entry)
+        (@pwad_files || []).each do |pwad|
+          return pwad.read_lump_own(entry) if pwad.directory.include?(entry)
+        end
+        @file.seek(entry.offset)
+        @file.read(entry.size)
+      end
+
+      # Read a lump that belongs to this WAD's own file
+      def read_lump_own(entry)
+        @file.seek(entry.offset)
+        @file.read(entry.size)
+      end
+
       def close
         @file.close
+        (@pwad_files || []).each(&:close)
       end
 
       private
@@ -58,9 +107,9 @@ module Doom
         @directory_offset = data[8, 4].unpack1('V')
         @lump_cache = {}
 
-        unless [@type == IWAD, @type == PWAD].any?
-          raise Error, "Invalid WAD type: #{@type}"
-        end
+        return if [@type == IWAD, @type == PWAD].any?
+
+        raise Error, "Invalid WAD type: #{@type}"
       end
 
       def read_directory

data/lib/doom/wad/sound.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+
+module Doom
+  module Wad
+    # Loads DOOM sound effects from WAD and converts to WAV for Gosu playback.
+    # DOOM sound format: 8-byte header (2 format, 2 sample_rate, 4 num_samples)
+    # followed by unsigned 8-bit PCM samples.
+    class SoundManager
+      def initialize(wad)
+        @wad = wad
+        @cache = {} # name => Gosu::Sample
+        @temp_dir = File.join(Dir.tmpdir, "doom_rb_sounds_#{Process.pid}")
+        Dir.mkdir(@temp_dir) unless Dir.exist?(@temp_dir)
+
+        # Sounds are decoded into a per-process temp dir; clean it up when the
+        # process exits so repeated runs do not leak WAV files.
+        at_exit { cleanup }
+      end
+
+      # Get or load a sound effect. Returns a Gosu::Sample or nil.
+      def [](name)
+        return @cache[name] if @cache.key?(name)
+
+        lump_name = name.start_with?('DS') ? name : "DS#{name}"
+        entry = @wad.find_lump(lump_name)
+        return @cache[name] = nil unless entry
+
+        data = @wad.read_lump_at(entry)
+        return @cache[name] = nil if data.size < 8
+
+        # Parse DOOM sound header
+        _format = data[0, 2].unpack1('v')
+        sample_rate = data[2, 2].unpack1('v')
+        num_samples = data[4, 4].unpack1('V')
+
+        # PCM data starts at offset 8, skip 16 padding bytes at start and end
+        pcm_start = 8 + 16
+        pcm_end = 8 + num_samples - 16
+        pcm_data = data[pcm_start...pcm_end]
+        return @cache[name] = nil unless pcm_data && pcm_data.size > 0
+
+        # Convert to WAV file for Gosu
+        wav_path = File.join(@temp_dir, "#{lump_name}.wav")
+        write_wav(wav_path, pcm_data, sample_rate) unless File.exist?(wav_path)
+
+        @cache[name] = Gosu::Sample.new(wav_path)
+      rescue StandardError => e
+        # A bad or unplayable lump should silence that one sound, not crash the
+        # game -- but say so rather than swallowing the error entirely.
+        warn "SoundManager: could not load '#{name}': #{e.class}: #{e.message}"
+        @cache[name] = nil
+      end
+
+      def cleanup
+        FileUtils.rm_rf(@temp_dir) if @temp_dir && Dir.exist?(@temp_dir)
+      end
+
+      private
+
+      # Write unsigned 8-bit PCM data as a WAV file
+      def write_wav(path, pcm_data, sample_rate)
+        num_samples = pcm_data.size
+        data_size = num_samples
+        file_size = 36 + data_size
+
+        File.open(path, 'wb') do |f|
+          # RIFF header
+          f.write('RIFF')
+          f.write([file_size].pack('V'))
+          f.write('WAVE')
+
+          # fmt chunk
+          f.write('fmt ')
+          f.write([16].pack('V'))          # chunk size
+          f.write([1].pack('v'))           # PCM format
+          f.write([1].pack('v'))           # mono
+          f.write([sample_rate].pack('V')) # sample rate
+          f.write([sample_rate].pack('V')) # byte rate (sample_rate * 1 * 1)
+          f.write([1].pack('v'))           # block align
+          f.write([8].pack('v'))           # bits per sample
+
+          # data chunk
+          f.write('data')
+          f.write([data_size].pack('V'))
+          f.write(pcm_data)
+        end
+      end
+    end
+  end
+end

data/lib/doom/wad/sprite.rb

@@ -3,7 +3,7 @@
 module Doom
   module Wad
     class Sprite
-      attr_reader :name, :width, :height, :left_offset, :top_offset
+      attr_reader :name, :width, :height, :left_offset, :top_offset, :columns
 
       def initialize(name, width, height, left_offset, top_offset, columns)
         @name = name
@@ -34,20 +34,21 @@ module Doom
         # Read column offsets
         column_offsets = []
         width.times do |i|
-          column_offsets << data[8 + i * 4, 4].unpack1('V')
+          column_offsets << data[8 + (i * 4), 4].unpack1('V')
         end
 
         # Read columns
         columns = []
         width.times do |x|
-          column = Array.new(height, nil)  # nil = transparent
+          column = Array.new(height, nil) # nil = transparent
           offset = column_offsets[x]
 
           # Read posts for this column
           loop do
             break if offset >= data.size
+
             row_start = data[offset].ord
-            break if row_start == 255  # End of column marker
+            break if row_start == 255 # End of column marker
 
             post_height = data[offset + 1].ord
             break if post_height == 0 || offset + 3 + post_height > data.size
@@ -55,12 +56,10 @@ module Doom
             # Skip padding byte, read pixels, skip trailing padding
             post_height.times do |i|
               y = row_start + i
-              if y < height
-                column[y] = data[offset + 3 + i].ord
-              end
+              column[y] = data[offset + 3 + i].ord if y < height
             end
 
-            offset += post_height + 4  # row_start + count + padding + pixels + padding
+            offset += post_height + 4 # row_start + count + padding + pixels + padding
           end
 
           columns << column
@@ -120,6 +119,12 @@ module Doom
         48 => 'ELEC',   # Tall tech column
         35 => 'CBRA',   # Candelabra
 
+        # Dead bodies / gore decorations
+        10 => 'PLAY',   # Bloody mess
+        12 => 'PLAY',   # Bloody mess 2
+        15 => 'PLAY',   # Dead player
+        24 => 'POL5',   # Pool of blood and flesh
+
         # Barrels
         2035 => 'BAR1', # Exploding barrel
 
@@ -133,7 +138,18 @@ module Doom
         3005 => 'HEAD', # Cacodemon
         3006 => 'SKUL', # Lost soul
         7 => 'SPID',    # Spider Mastermind
-        16 => 'CYBR',   # Cyberdemon
+        16 => 'CYBR' # Cyberdemon
+      }.freeze
+
+      # Things that use a specific frame instead of 'A'
+      # From DOOM info.h mobjinfo spawnstate:
+      # MT_MISC10 (type 10) -> S_PLAY_XDIE9 = PLAY W (gibbed mess)
+      # MT_MISC12 (type 12) -> S_PLAY_DIE7 = PLAY N (dead body)
+      # MT_MISC15 (type 15) -> S_PLAY_DIE7 = PLAY N (dead body)
+      THING_DEFAULT_FRAME = {
+        10 => 'W',   # Bloody mess (gibbed)
+        12 => 'N',   # Bloody mess 2 (dead body flat)
+        15 => 'N' # Dead player (dead body flat)
       }.freeze
 
       def initialize(wad)
@@ -154,8 +170,9 @@ module Doom
         prefix = THING_SPRITES[thing_type]
         return nil unless prefix
 
-        sprite = load_sprite_frame(prefix, 'A', 0) ||
-                 load_sprite_frame(prefix, 'A', 1)
+        frame = THING_DEFAULT_FRAME[thing_type] || 'A'
+        sprite = load_sprite_frame(prefix, frame, 0) ||
+                 load_sprite_frame(prefix, frame, 1)
 
         @cache[thing_type] = sprite
         sprite
@@ -173,19 +190,23 @@ module Doom
         prefix = THING_SPRITES[thing_type]
         return nil unless prefix
 
+        frame = THING_DEFAULT_FRAME[thing_type] || 'A'
+
         # Check for rotation 0 (all angles) sprite first
-        sprite = load_sprite_frame(prefix, 'A', 0)
+        sprite = load_sprite_frame(prefix, frame, 0)
         return sprite if sprite
 
-        # Calculate rotation frame (1-8)
-        # DOOM: rot = (R_PointToAngle(thing) - thing->angle + ANG45/2*9) >> 29
-        # Rotation 1=front (viewer faces monster's front), 5=back
+        load_sprite_frame(prefix, frame, rotation_for(viewer_angle, thing_angle)) || @cache[thing_type]
+      end
+
+      # Which of the 8 rotation frames faces the viewer.
+      # DOOM: rot = (R_PointToAngle(thing) - thing->angle + ANG45/2*9) >> 29
+      # Rotation 1 = front (viewer faces the thing's front), 5 = back.
+      def rotation_for(viewer_angle, thing_angle)
         angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0) + Math::PI
-        angle_diff = angle_diff % (2 * Math::PI)
+        angle_diff %= (2 * Math::PI)
         angle_diff += 2 * Math::PI if angle_diff < 0
-        rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
-
-        load_sprite_frame(prefix, 'A', rotation) || @cache[thing_type]
+        (((angle_diff + (Math::PI / 8)) / (Math::PI / 4)).to_i % 8) + 1
       end
 
       # Get a specific frame (for death animations, etc.)
@@ -193,17 +214,22 @@ module Doom
         prefix = THING_SPRITES[thing_type]
         return nil unless prefix
 
-        # Death frames typically use rotation 0 (same from all angles)
+        get_frame_rotated(prefix, frame_letter, viewer_angle, thing_angle)
+      end
+
+      # Get a frame by explicit prefix (for barrel explosions where prefix differs from thing type)
+      def get_frame_by_prefix(prefix, frame_letter)
+        load_sprite_frame(prefix, frame_letter, 0)
+      end
+
+      # Get a frame by explicit prefix, honouring rotations. Players are drawn
+      # through this: PLAY has no thing type of its own, and its walk and
+      # attack frames are rotated while its death frames are not.
+      def get_frame_rotated(prefix, frame_letter, viewer_angle, thing_angle)
         sprite = load_sprite_frame(prefix, frame_letter, 0)
         return sprite if sprite
 
-        # Try with calculated rotation (same formula as get_rotated)
-        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0) + Math::PI
-        angle_diff = angle_diff % (2 * Math::PI)
-        angle_diff += 2 * Math::PI if angle_diff < 0
-        rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
-
-        load_sprite_frame(prefix, frame_letter, rotation)
+        load_sprite_frame(prefix, frame_letter, rotation_for(viewer_angle, thing_angle))
       end
 
       private
@@ -222,12 +248,12 @@ module Doom
           @sprite_index[key] = [name, false]
 
           # Check for mirrored second rotation (e.g., SPOSA2A8)
-          if name.length >= 8
-            frame2 = name[6]
-            rot2 = name[7].to_i
-            key2 = "#{prefix}#{frame2}#{rot2}"
-            @sprite_index[key2] = [name, true]
-          end
+          next unless name.length >= 8
+
+          frame2 = name[6]
+          rot2 = name[7].to_i
+          key2 = "#{prefix}#{frame2}#{rot2}"
+          @sprite_index[key2] = [name, true]
         end
       end
 
@@ -265,7 +291,7 @@ module Doom
 
       def mirror_sprite(sprite)
         # Flip columns horizontally, adjust left_offset
-        mirrored_columns = sprite.instance_variable_get(:@columns).reverse
+        mirrored_columns = sprite.columns.reverse
         mirrored_left = sprite.width - sprite.left_offset
         Sprite.new(
           "#{sprite.name}_M",

data/lib/doom/wad/texture.rb

@@ -38,14 +38,14 @@ module Doom
 
         count = data[0, 4].unpack1('V')
         count.times.map do |i|
-          data[4 + i * 8, 8].delete("\x00").upcase
+          data[4 + (i * 8), 8].delete("\x00").upcase
         end
       end
 
       def self.parse_texture_lump(data)
         num_textures = data[0, 4].unpack1('V')
         offsets = num_textures.times.map do |i|
-          data[4 + i * 4, 4].unpack1('V')
+          data[4 + (i * 4), 4].unpack1('V')
         end
 
         offsets.map do |offset|
@@ -60,7 +60,7 @@ module Doom
         patch_count = data[offset + 20, 2].unpack1('v')
 
         patch_refs = patch_count.times.map do |i|
-          po = offset + 22 + i * 10
+          po = offset + 22 + (i * 10)
           PatchRef.new(
             data[po, 2].unpack1('s<'),
             data[po + 2, 2].unpack1('s<'),
@@ -139,7 +139,7 @@ module Doom
         precompute_columns
       end
 
-      def column_pixels(x, _height_needed = nil)
+      def column_pixels(x)
         @column_cache[x & (@width - 1)]
       end
 
@@ -148,7 +148,7 @@ module Doom
       def precompute_columns
         @width.times do |x|
           posts = @columns[x]
-          pixels = Array.new(@height, 0)
+          pixels = Array.new(@height) # nil = transparent
           posts.each do |post|
             td = post.top_delta
             post.pixels.each_with_index do |color, i|