doom 0.8.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.8.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 }
@@ -57,7 +55,8 @@ module Doom
       # 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?
+        raise Error, 'Can only merge a PWAD' unless pwad.pwad?
+
         @lump_cache.clear
 
         pwad.directory.each do |pwad_entry|
@@ -78,13 +77,11 @@ module Doom
         @num_lumps = @directory.size
       end
 
-      # Override read_lump_at to check if entry belongs to a PWAD file
+      # 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|
-          if pwad.directory.include?(entry)
-            return pwad.read_lump_own(entry)
-          end
+          return pwad.read_lump_own(entry) if pwad.directory.include?(entry)
         end
         @file.seek(entry.offset)
         @file.read(entry.size)
@@ -110,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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'tmpdir'
+require 'fileutils'
 
 module Doom
   module Wad
@@ -10,9 +11,13 @@ module Doom
     class SoundManager
       def initialize(wad)
         @wad = wad
-        @cache = {}  # name => Gosu::Sample
+        @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.
@@ -42,7 +47,10 @@ module Doom
         write_wav(wav_path, pcm_data, sample_rate) unless File.exist?(wav_path)
 
         @cache[name] = Gosu::Sample.new(wav_path)
-      rescue => e
+      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
 
@@ -60,12 +68,12 @@ module Doom
 
         File.open(path, 'wb') do |f|
           # RIFF header
-          f.write("RIFF")
+          f.write('RIFF')
           f.write([file_size].pack('V'))
-          f.write("WAVE")
+          f.write('WAVE')
 
           # fmt chunk
-          f.write("fmt ")
+          f.write('fmt ')
           f.write([16].pack('V'))          # chunk size
           f.write([1].pack('v'))           # PCM format
           f.write([1].pack('v'))           # mono
@@ -75,7 +83,7 @@ module Doom
           f.write([8].pack('v'))           # bits per sample
 
           # data chunk
-          f.write("data")
+          f.write('data')
           f.write([data_size].pack('V'))
           f.write(pcm_data)
         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
@@ -139,7 +138,7 @@ 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'
@@ -150,7 +149,7 @@ module Doom
       THING_DEFAULT_FRAME = {
         10 => 'W',   # Bloody mess (gibbed)
         12 => 'N',   # Bloody mess 2 (dead body flat)
-        15 => 'N',   # Dead player (dead body flat)
+        15 => 'N' # Dead player (dead body flat)
       }.freeze
 
       def initialize(wad)
@@ -197,15 +196,17 @@ module Doom
         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, frame, 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.)
@@ -213,17 +214,7 @@ module Doom
         prefix = THING_SPRITES[thing_type]
         return nil unless prefix
 
-        # Death frames typically use rotation 0 (same from all angles)
-        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)
+        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)
@@ -231,6 +222,16 @@ module Doom
         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
+
+        load_sprite_frame(prefix, frame_letter, rotation_for(viewer_angle, thing_angle))
+      end
+
       private
 
       def build_sprite_index
@@ -247,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
 
@@ -290,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)  # nil = transparent
+          pixels = Array.new(@height) # nil = transparent
           posts.each do |post|
             td = post.top_delta
             post.pixels.each_with_index do |color, i|