doom 0.2.0 → 0.3.0

data/lib/doom/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Doom
-  VERSION = "0.2.0"
+  VERSION = '0.3.0'
 end

data/lib/doom/wad/colormap.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Colormap
+      MAPS = 34
+      MAP_SIZE = 256
+
+      attr_reader :maps
+
+      def initialize(maps)
+        @maps = maps
+      end
+
+      def [](map_index)
+        @maps[map_index]
+      end
+
+      def map_color(color_index, light_level)
+        map_index = 31 - (light_level >> 3)
+        map_index = map_index.clamp(0, 31)
+        @maps[map_index][color_index]
+      end
+
+      def self.load(wad)
+        data = wad.read_lump('COLORMAP')
+        raise Error, 'COLORMAP lump not found' unless data
+
+        maps = MAPS.times.map do |i|
+          offset = i * MAP_SIZE
+          data[offset, MAP_SIZE].bytes
+        end
+
+        new(maps)
+      end
+    end
+  end
+end

data/lib/doom/wad/flat.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Flat
+      WIDTH = 64
+      HEIGHT = 64
+      SIZE = WIDTH * HEIGHT
+
+      attr_reader :name, :pixels
+
+      def width
+        WIDTH
+      end
+
+      def height
+        HEIGHT
+      end
+
+      def initialize(name, pixels)
+        @name = name
+        @pixels = pixels
+      end
+
+      def [](x, y)
+        @pixels[(y & 63) * WIDTH + (x & 63)]
+      end
+
+      def to_png(palette, filename)
+        require 'chunky_png'
+
+        img = ChunkyPNG::Image.new(WIDTH, HEIGHT)
+        @pixels.each_with_index do |color_index, i|
+          x = i % WIDTH
+          y = i / WIDTH
+          r, g, b = palette[color_index]
+          img[x, y] = ChunkyPNG::Color.rgb(r, g, b)
+        end
+        img.save(filename)
+      end
+
+      def self.load(wad, name)
+        data = wad.read_lump(name)
+        return nil unless data
+        raise Error, "Invalid flat size: #{data.size}" unless data.size == SIZE
+
+        new(name, data.bytes)
+      end
+
+      def self.load_all(wad)
+        entries = wad.lumps_between('F_START', 'F_END')
+        entries.map do |entry|
+          next if entry.size != SIZE
+
+          data = wad.read_lump_at(entry)
+          new(entry.name, data.bytes)
+        end.compact
+      end
+    end
+  end
+end

data/lib/doom/wad/palette.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Palette
+      COLORS = 256
+      PALETTES = 14
+      PALETTE_SIZE = COLORS * 3
+
+      attr_reader :colors
+
+      def initialize(colors)
+        @colors = colors
+      end
+
+      def [](index)
+        @colors[index]
+      end
+
+      def self.load(wad, palette_index = 0)
+        data = wad.read_lump('PLAYPAL')
+        raise Error, 'PLAYPAL lump not found' unless data
+
+        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
+          ]
+        end
+
+        new(colors)
+      end
+    end
+  end
+end

data/lib/doom/wad/patch.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Patch
+      Post = Struct.new(:top_delta, :pixels)
+
+      attr_reader :name, :width, :height, :left_offset, :top_offset, :columns
+
+      def initialize(name, width, height, left_offset, top_offset, columns)
+        @name = name
+        @width = width
+        @height = height
+        @left_offset = left_offset
+        @top_offset = top_offset
+        @columns = columns
+      end
+
+      def self.load(wad, name)
+        data = wad.read_lump(name)
+        return nil unless data
+
+        parse(name, data)
+      end
+
+      def self.parse(name, data)
+        width = data[0, 2].unpack1('v')
+        height = data[2, 2].unpack1('v')
+        left_offset = data[4, 2].unpack1('s<')
+        top_offset = data[6, 2].unpack1('s<')
+
+        column_offsets = width.times.map do |i|
+          data[8 + i * 4, 4].unpack1('V')
+        end
+
+        columns = column_offsets.map do |offset|
+          read_column(data, offset)
+        end
+
+        new(name, width, height, left_offset, top_offset, columns)
+      end
+
+      def self.read_column(data, offset)
+        posts = []
+        pos = offset
+
+        loop do
+          top_delta = data[pos].ord
+          break if top_delta == 0xFF
+
+          length = data[pos + 1].ord
+          pixels = data[pos + 3, length].bytes
+          posts << Post.new(top_delta, pixels)
+          pos += length + 4
+        end
+
+        posts
+      end
+    end
+  end
+end

data/lib/doom/wad/reader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Reader
+      IWAD = 'IWAD'
+      PWAD = 'PWAD'
+
+      DirectoryEntry = Struct.new(:offset, :size, :name)
+
+      attr_reader :type, :num_lumps, :directory
+
+      def initialize(path)
+        @file = File.open(path, 'rb')
+        read_header
+        read_directory
+      end
+
+      def find_lump(name)
+        @directory.find { |entry| entry.name == name.upcase }
+      end
+
+      def read_lump(name)
+        return @lump_cache[name] if @lump_cache.key?(name)
+
+        entry = find_lump(name)
+        return nil unless entry
+
+        @file.seek(entry.offset)
+        data = @file.read(entry.size)
+        @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 }
+        return [] unless start_idx && end_idx
+
+        @directory[start_idx + 1...end_idx]
+      end
+
+      def close
+        @file.close
+      end
+
+      private
+
+      def read_header
+        data = @file.read(12)
+        @type = data[0, 4]
+        @num_lumps = data[4, 4].unpack1('V')
+        @directory_offset = data[8, 4].unpack1('V')
+        @lump_cache = {}
+
+        unless [@type == IWAD, @type == PWAD].any?
+          raise Error, "Invalid WAD type: #{@type}"
+        end
+      end
+
+      def read_directory
+        @file.seek(@directory_offset)
+        @directory = @num_lumps.times.map do
+          data = @file.read(16)
+          DirectoryEntry.new(
+            data[0, 4].unpack1('V'),
+            data[4, 4].unpack1('V'),
+            data[8, 8].delete("\x00").upcase
+          )
+        end
+      end
+    end
+  end
+end

data/lib/doom/wad/sprite.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Sprite
+      attr_reader :name, :width, :height, :left_offset, :top_offset
+
+      def initialize(name, width, height, left_offset, top_offset, columns)
+        @name = name
+        @width = width
+        @height = height
+        @left_offset = left_offset
+        @top_offset = top_offset
+        @columns = columns
+      end
+
+      def column_pixels(x)
+        @columns[x] || []
+      end
+
+      # Load a sprite from a WAD patch lump
+      def self.load(wad, lump_name)
+        entry = wad.directory.find { |e| e.name == lump_name }
+        return nil unless entry
+
+        data = wad.read_lump_at(entry)
+        return nil if data.size < 8
+
+        width = data[0, 2].unpack1('v')
+        height = data[2, 2].unpack1('v')
+        left_offset = data[4, 2].unpack1('s<')
+        top_offset = data[6, 2].unpack1('s<')
+
+        # Read column offsets
+        column_offsets = []
+        width.times do |i|
+          column_offsets << data[8 + i * 4, 4].unpack1('V')
+        end
+
+        # Read columns
+        columns = []
+        width.times do |x|
+          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
+
+            post_height = data[offset + 1].ord
+            break if post_height == 0 || offset + 3 + post_height > data.size
+
+            # 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
+            end
+
+            offset += post_height + 4  # row_start + count + padding + pixels + padding
+          end
+
+          columns << column
+        end
+
+        new(lump_name, width, height, left_offset, top_offset, columns)
+      end
+    end
+
+    class SpriteManager
+      # Map thing types to sprite prefixes
+      THING_SPRITES = {
+        # Ammo
+        2007 => 'CLIP', # Clip
+        2048 => 'AMMO', # Box of ammo
+        2008 => 'SHEL', # Shells
+        2049 => 'SBOX', # Box of shells
+        2010 => 'ROCK', # Rocket
+        2046 => 'BROK', # Box of rockets
+        2047 => 'CELL', # Cell charge
+        17 => 'CELP',   # Cell pack
+
+        # Weapons
+        2001 => 'SHOT', # Shotgun
+        2002 => 'MGUN', # Chaingun
+        2003 => 'LAUN', # Rocket launcher
+        2004 => 'PLAS', # Plasma rifle
+        2006 => 'BFUG', # BFG 9000
+        2005 => 'CSAW', # Chainsaw
+
+        # Health/Armor
+        2011 => 'STIM', # Stimpack
+        2012 => 'MEDI', # Medikit
+        2014 => 'BON1', # Health bonus
+        2015 => 'BON2', # Armor bonus
+        2018 => 'ARM1', # Green armor
+        2019 => 'ARM2', # Blue armor
+
+        # Keys
+        5 => 'BKEY',    # Blue keycard
+        6 => 'YKEY',    # Yellow keycard
+        13 => 'RKEY',   # Red keycard
+        40 => 'BSKU',   # Blue skull
+        39 => 'YSKU',   # Yellow skull
+        38 => 'RSKU',   # Red skull
+
+        # Decorations
+        2028 => 'COLU', # Light column
+        30 => 'COL1',   # Tall green pillar
+        31 => 'COL2',   # Short green pillar
+        32 => 'COL3',   # Tall red pillar
+        33 => 'COL4',   # Short red pillar
+        34 => 'CAND',   # Candle
+        44 => 'TBLU',   # Tall blue torch
+        45 => 'TGRN',   # Tall green torch
+        46 => 'TRED',   # Tall red torch
+        48 => 'ELEC',   # Tall tech column
+        35 => 'CBRA',   # Candelabra
+
+        # Barrels
+        2035 => 'BAR1', # Exploding barrel
+
+        # Monsters
+        3004 => 'POSS', # Zombieman
+        9 => 'SPOS',    # Shotgun guy
+        3001 => 'TROO', # Imp
+        3002 => 'SARG', # Demon
+        58 => 'SARG',   # Spectre (same as Demon)
+        3003 => 'BOSS', # Baron of Hell
+        3005 => 'HEAD', # Cacodemon
+        3006 => 'SKUL', # Lost soul
+        7 => 'SPID',    # Spider Mastermind
+        16 => 'CYBR',   # Cyberdemon
+      }.freeze
+
+      def initialize(wad)
+        @wad = wad
+        @cache = {}
+        @rotation_cache = {}
+      end
+
+      # Get default sprite (rotation 0 or 1)
+      def [](thing_type)
+        return @cache[thing_type] if @cache.key?(thing_type)
+
+        prefix = THING_SPRITES[thing_type]
+        return nil unless prefix
+
+        # Try to find sprite with A0 (all angles) or A1 (front facing)
+        sprite = Sprite.load(@wad, "#{prefix}A0") ||
+                 Sprite.load(@wad, "#{prefix}A1")
+
+        @cache[thing_type] = sprite
+        sprite
+      end
+
+      # Get sprite prefix for a thing type
+      def prefix_for(thing_type)
+        THING_SPRITES[thing_type]
+      end
+
+      # Get sprite for specific rotation (1-8, or 0 for all angles)
+      # viewer_angle: angle from viewer to sprite in radians
+      # thing_angle: thing's facing angle in degrees
+      def get_rotated(thing_type, viewer_angle, thing_angle)
+        prefix = THING_SPRITES[thing_type]
+        return nil unless prefix
+
+        # Check cache for rotation 0 (all angles) sprite
+        cache_key = "#{prefix}A0"
+        if @rotation_cache.key?(cache_key)
+          return @rotation_cache[cache_key] if @rotation_cache[cache_key]
+        else
+          sprite = Sprite.load(@wad, cache_key)
+          @rotation_cache[cache_key] = sprite
+          return sprite if sprite
+        end
+
+        # Calculate rotation frame (1-8)
+        # Doom rotations: 1=front, 2=front-right, 3=right, etc. (clockwise)
+        # The angle we need is: viewer's angle to sprite - sprite's facing angle
+        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0)
+
+        # Normalize to 0-2π
+        angle_diff = angle_diff % (2 * Math::PI)
+        angle_diff += 2 * Math::PI if angle_diff < 0
+
+        # Convert to rotation frame (1-8)
+        # Each rotation covers 45 degrees (π/4 radians)
+        # Add π/8 to center the ranges
+        rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
+
+        cache_key = "#{prefix}A#{rotation}"
+        unless @rotation_cache.key?(cache_key)
+          @rotation_cache[cache_key] = Sprite.load(@wad, cache_key)
+        end
+
+        @rotation_cache[cache_key] || @cache[thing_type]
+      end
+    end
+  end
+end

data/lib/doom/wad/texture.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Texture
+      PatchRef = Struct.new(:x_offset, :y_offset, :patch_index)
+
+      attr_reader :name, :width, :height, :patch_refs
+
+      def initialize(name, width, height, patch_refs)
+        @name = name
+        @width = width
+        @height = height
+        @patch_refs = patch_refs
+        @columns = nil
+      end
+
+      def columns
+        @columns ||= build_columns
+      end
+
+      def build_columns
+        # Will be built when patches are composited
+        nil
+      end
+
+      def self.load_all(wad)
+        pnames = load_pnames(wad)
+        textures = {}
+
+        %w[TEXTURE1 TEXTURE2].each do |lump_name|
+          data = wad.read_lump(lump_name)
+          next unless data
+
+          parse_texture_lump(data).each do |tex|
+            textures[tex.name] = tex
+          end
+        end
+
+        { textures: textures, pnames: pnames }
+      end
+
+      def self.load_pnames(wad)
+        data = wad.read_lump('PNAMES')
+        return [] unless data
+
+        count = data[0, 4].unpack1('V')
+        count.times.map do |i|
+          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')
+        end
+
+        offsets.map do |offset|
+          parse_texture(data, offset)
+        end
+      end
+
+      def self.parse_texture(data, offset)
+        name = data[offset, 8].delete("\x00").upcase
+        width = data[offset + 12, 2].unpack1('v')
+        height = data[offset + 14, 2].unpack1('v')
+        patch_count = data[offset + 20, 2].unpack1('v')
+
+        patch_refs = patch_count.times.map do |i|
+          po = offset + 22 + i * 10
+          PatchRef.new(
+            data[po, 2].unpack1('s<'),
+            data[po + 2, 2].unpack1('s<'),
+            data[po + 4, 2].unpack1('v')
+          )
+        end
+
+        new(name, width, height, patch_refs)
+      end
+    end
+
+    class TextureManager
+      attr_reader :textures, :pnames, :patches
+
+      def initialize(wad)
+        @wad = wad
+        result = Texture.load_all(wad)
+        @textures = result[:textures]
+        @pnames = result[:pnames]
+        @patches = {}
+        @composite_cache = {}
+      end
+
+      def [](name)
+        return nil if name.nil? || name.empty? || name == '-'
+
+        @composite_cache[name] ||= build_composite(name.upcase)
+      end
+
+      def get_patch(index)
+        name = @pnames[index]
+        return nil unless name
+
+        @patches[name] ||= Patch.load(@wad, name)
+      end
+
+      private
+
+      def build_composite(name)
+        texture = @textures[name]
+        return nil unless texture
+
+        columns = Array.new(texture.width) { [] }
+
+        texture.patch_refs.each do |pref|
+          patch = get_patch(pref.patch_index)
+          next unless patch
+
+          patch.columns.each_with_index do |posts, px|
+            tx = pref.x_offset + px
+            next if tx < 0 || tx >= texture.width
+
+            posts.each do |post|
+              columns[tx] << Patch::Post.new(
+                pref.y_offset + post.top_delta,
+                post.pixels
+              )
+            end
+          end
+        end
+
+        CompositeTexture.new(name, texture.width, texture.height, columns)
+      end
+    end
+
+    class CompositeTexture
+      attr_reader :name, :width, :height, :columns
+
+      def initialize(name, width, height, columns)
+        @name = name
+        @width = width
+        @height = height
+        @columns = columns
+      end
+
+      def column_pixels(x, height_needed = nil)
+        x = x % @width
+        posts = @columns[x]
+        height_needed ||= @height
+
+        pixels = Array.new(height_needed, 0)
+        posts.each do |post|
+          post.pixels.each_with_index do |color, i|
+            y = (post.top_delta + i) % @height
+            pixels[y] = color if y < height_needed
+          end
+        end
+        pixels
+      end
+    end
+  end
+end