doom 0.2.0

data/lib/doom/map_loader.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module Doom
+  # MapLoader is responsible for loading and parsing map data from a WAD file
+  class MapLoader
+    # Map lumps that make up a complete map
+    MAP_LUMPS = %w[THINGS LINEDEFS SIDEDEFS VERTEXES SEGS SSECTORS NODES SECTORS REJECT BLOCKMAP].freeze
+
+    attr_reader :maps, :current_map
+
+    # Initialize a new MapLoader with the given WADLoader
+    # @param wad_loader [WADLoader] the WAD loader to use
+    def initialize(wad_loader)
+      @wad_loader = wad_loader
+      @maps = find_maps
+      @current_map = nil
+    end
+
+    # Find all maps in the WAD file
+    # @return [Array<String>] array of map names
+    def find_maps
+      map_names = []
+      
+      # In Doom, maps are identified by their name (e.g., E1M1, MAP01)
+      # followed by the map lumps (THINGS, LINEDEFS, etc.)
+      @wad_loader.directory.each_with_index do |entry, index|
+        # Check if this entry is followed by map lumps
+        if is_map_start?(index)
+          map_names << entry[:name]
+        end
+      end
+      
+      map_names
+    end
+
+    # Check if the entry at the given index is the start of a map
+    # @param index [Integer] the index in the directory
+    # @return [Boolean] true if the entry is the start of a map
+    def is_map_start?(index)
+      # Check if there are enough entries left
+      return false if index + MAP_LUMPS.size >= @wad_loader.directory.size
+      
+      # Check if the next entries match the map lumps
+      MAP_LUMPS.each_with_index do |lump_name, i|
+        return false unless @wad_loader.directory[index + i + 1][:name] == lump_name
+      end
+      
+      true
+    end
+
+    # Load a specific map
+    # @param map_name [String] the name of the map to load
+    # @return [Hash, nil] the map data or nil if not found
+    def load_map(map_name)
+      return nil unless @maps.include?(map_name)
+      
+      @current_map = {
+        name: map_name,
+        things: load_things(map_name),
+        linedefs: load_linedefs(map_name),
+        sidedefs: load_sidedefs(map_name),
+        vertexes: load_vertexes(map_name),
+        sectors: load_sectors(map_name)
+        # Other map components can be added as needed
+      }
+    end
+
+    # Load the THINGS lump for a map
+    # @param map_name [String] the name of the map
+    # @return [Array<Hash>] array of things
+    def load_things(map_name)
+      lump_data = get_map_lump(map_name, "THINGS")
+      return [] unless lump_data
+      
+      things = []
+      offset = 0
+      
+      # Each thing is 10 bytes
+      while offset < lump_data.size
+        thing_data = lump_data[offset..offset + 9]
+        x_pos = thing_data[0..1].unpack("s<")[0]
+        y_pos = thing_data[2..3].unpack("s<")[0]
+        angle = thing_data[4..5].unpack("s<")[0]
+        type = thing_data[6..7].unpack("s<")[0]
+        flags = thing_data[8..9].unpack("s<")[0]
+        
+        things << {
+          x: x_pos,
+          y: y_pos,
+          angle: angle,
+          type: type,
+          flags: flags
+        }
+        
+        offset += 10
+      end
+      
+      things
+    end
+
+    # Load the LINEDEFS lump for a map
+    # @param map_name [String] the name of the map
+    # @return [Array<Hash>] array of linedefs
+    def load_linedefs(map_name)
+      lump_data = get_map_lump(map_name, "LINEDEFS")
+      return [] unless lump_data
+      
+      linedefs = []
+      offset = 0
+      
+      # Each linedef is 14 bytes
+      while offset < lump_data.size
+        linedef_data = lump_data[offset..offset + 13]
+        start_vertex = linedef_data[0..1].unpack("s<")[0]
+        end_vertex = linedef_data[2..3].unpack("s<")[0]
+        flags = linedef_data[4..5].unpack("s<")[0]
+        special_type = linedef_data[6..7].unpack("s<")[0]
+        sector_tag = linedef_data[8..9].unpack("s<")[0]
+        right_sidedef = linedef_data[10..11].unpack("s<")[0]
+        left_sidedef = linedef_data[12..13].unpack("s<")[0]
+        
+        linedefs << {
+          start_vertex: start_vertex,
+          end_vertex: end_vertex,
+          flags: flags,
+          special_type: special_type,
+          sector_tag: sector_tag,
+          right_sidedef: right_sidedef,
+          left_sidedef: left_sidedef
+        }
+        
+        offset += 14
+      end
+      
+      linedefs
+    end
+
+    # Load the SIDEDEFS lump for a map
+    # @param map_name [String] the name of the map
+    # @return [Array<Hash>] array of sidedefs
+    def load_sidedefs(map_name)
+      lump_data = get_map_lump(map_name, "SIDEDEFS")
+      return [] unless lump_data
+      
+      sidedefs = []
+      offset = 0
+      
+      # Each sidedef is 30 bytes
+      while offset < lump_data.size
+        sidedef_data = lump_data[offset..offset + 29]
+        x_offset = sidedef_data[0..1].unpack("s<")[0]
+        y_offset = sidedef_data[2..3].unpack("s<")[0]
+        upper_texture = sidedef_data[4..11].unpack("Z*")[0]
+        lower_texture = sidedef_data[12..19].unpack("Z*")[0]
+        middle_texture = sidedef_data[20..27].unpack("Z*")[0]
+        sector = sidedef_data[28..29].unpack("s<")[0]
+        
+        sidedefs << {
+          x_offset: x_offset,
+          y_offset: y_offset,
+          upper_texture: upper_texture,
+          lower_texture: lower_texture,
+          middle_texture: middle_texture,
+          sector: sector
+        }
+        
+        offset += 30
+      end
+      
+      sidedefs
+    end
+
+    # Load the VERTEXES lump for a map
+    # @param map_name [String] the name of the map
+    # @return [Array<Hash>] array of vertexes
+    def load_vertexes(map_name)
+      lump_data = get_map_lump(map_name, "VERTEXES")
+      return [] unless lump_data
+      
+      vertexes = []
+      offset = 0
+      
+      # Each vertex is 4 bytes
+      while offset < lump_data.size
+        vertex_data = lump_data[offset..offset + 3]
+        x_pos = vertex_data[0..1].unpack("s<")[0]
+        y_pos = vertex_data[2..3].unpack("s<")[0]
+        
+        vertexes << {
+          x: x_pos,
+          y: y_pos
+        }
+        
+        offset += 4
+      end
+      
+      vertexes
+    end
+
+    # Load the SECTORS lump for a map
+    # @param map_name [String] the name of the map
+    # @return [Array<Hash>] array of sectors
+    def load_sectors(map_name)
+      lump_data = get_map_lump(map_name, "SECTORS")
+      return [] unless lump_data
+      
+      sectors = []
+      offset = 0
+      
+      # Each sector is 26 bytes
+      while offset < lump_data.size
+        sector_data = lump_data[offset..offset + 25]
+        floor_height = sector_data[0..1].unpack("s<")[0]
+        ceiling_height = sector_data[2..3].unpack("s<")[0]
+        floor_texture = sector_data[4..11].unpack("Z*")[0]
+        ceiling_texture = sector_data[12..19].unpack("Z*")[0]
+        light_level = sector_data[20..21].unpack("s<")[0]
+        special_type = sector_data[22..23].unpack("s<")[0]
+        tag = sector_data[24..25].unpack("s<")[0]
+        
+        sectors << {
+          floor_height: floor_height,
+          ceiling_height: ceiling_height,
+          floor_texture: floor_texture,
+          ceiling_texture: ceiling_texture,
+          light_level: light_level,
+          special_type: special_type,
+          tag: tag
+        }
+        
+        offset += 26
+      end
+      
+      sectors
+    end
+
+    # Get a specific map lump
+    # @param map_name [String] the name of the map
+    # @param lump_name [String] the name of the lump
+    # @return [String, nil] the lump data or nil if not found
+    def get_map_lump(map_name, lump_name)
+      map_index = @wad_loader.directory.find_index { |entry| entry[:name] == map_name }
+      return nil unless map_index
+      
+      lump_index = MAP_LUMPS.find_index(lump_name)
+      return nil unless lump_index
+      
+      # The lump is at map_index + lump_index + 1
+      entry = @wad_loader.directory[map_index + lump_index + 1]
+      return nil unless entry && entry[:name] == lump_name
+      
+      @wad_loader.get_lump(lump_name)
+    end
+  end
+end

data/lib/doom/renderer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Doom
+  # Base class for all renderers
+  class Renderer
+    attr_reader :window
+
+    # Initialize a new Renderer with the given window
+    # @param window [Doom::Window] the window to render to
+    def initialize(window)
+      @window = window
+    end
+
+    # Render the current frame
+    # This is an abstract method that should be overridden by subclasses
+    def render
+      raise NotImplementedError, "Subclasses must implement render"
+    end
+
+    # Clear the screen
+    def clear
+      # In Gosu, drawing is done directly to the window
+      # This method is a placeholder for potential buffer clearing operations
+    end
+
+    # Flush the rendered frame to the screen
+    def flush
+      # In Gosu, drawing is done directly to the window
+      # This method is a placeholder for potential buffer flushing operations
+    end
+  end
+end

data/lib/doom/sprite_loader.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Doom
+  # SpriteLoader is responsible for loading and parsing sprite data from a WAD file
+  class SpriteLoader
+    attr_reader :sprites
+
+    # Initialize a new SpriteLoader with the given WADLoader
+    # @param wad_loader [WADLoader] the WAD loader to use
+    def initialize(wad_loader)
+      @wad_loader = wad_loader
+      @sprites = {}
+      load_sprites
+    end
+
+    # Load all sprites from the WAD file
+    def load_sprites
+      # In Doom, sprites are stored between S_START and S_END markers
+      start_index = @wad_loader.directory.find_index { |entry| entry[:name] == "S_START" }
+      end_index = @wad_loader.directory.find_index { |entry| entry[:name] == "S_END" }
+      
+      return unless start_index && end_index && start_index < end_index
+      
+      # Extract all sprite lumps between S_START and S_END
+      (start_index + 1...end_index).each do |i|
+        entry = @wad_loader.directory[i]
+        next if entry[:size] == 0 # Skip markers
+        
+        sprite_name = entry[:name]
+        sprite_data = @wad_loader.get_lump(sprite_name)
+        
+        if sprite_data
+          @sprites[sprite_name] = parse_sprite(sprite_data)
+        end
+      end
+    end
+
+    # Parse a sprite lump
+    # @param sprite_data [String] the sprite lump data
+    # @return [Hash] the parsed sprite data
+    def parse_sprite(sprite_data)
+      # Doom sprites are stored in the Picture format
+      # Picture format header:
+      # - 2 bytes: width
+      # - 2 bytes: height
+      # - 2 bytes: left offset
+      # - 2 bytes: top offset
+      # - variable: column data
+      
+      width = sprite_data[0..1].unpack("v")[0]
+      height = sprite_data[2..3].unpack("v")[0]
+      left_offset = sprite_data[4..5].unpack("s<")[0]
+      top_offset = sprite_data[6..7].unpack("s<")[0]
+      
+      # The rest of the data is column data, which we'll store as raw bytes for now
+      # In a full implementation, we would parse this into a usable format for rendering
+      column_data = sprite_data[8..-1]
+      
+      {
+        width: width,
+        height: height,
+        left_offset: left_offset,
+        top_offset: top_offset,
+        column_data: column_data
+      }
+    end
+
+    # Get a specific sprite by name
+    # @param name [String] the name of the sprite
+    # @return [Hash, nil] the sprite data or nil if not found
+    def get_sprite(name)
+      @sprites[name]
+    end
+
+    # List all sprite names
+    # @return [Array<String>] array of sprite names
+    def sprite_names
+      @sprites.keys
+    end
+
+    # Check if a sprite exists
+    # @param name [String] the name of the sprite
+    # @return [Boolean] true if the sprite exists
+    def sprite_exists?(name)
+      @sprites.key?(name)
+    end
+  end
+end

data/lib/doom/sprite_renderer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Doom
+  # SpriteRenderer is responsible for rendering sprites (enemies, items, etc.)
+  class SpriteRenderer
+    attr_reader :sprite_loader
+
+    # Initialize a new SpriteRenderer with the given sprite loader
+    # @param sprite_loader [Doom::SpriteLoader] the sprite loader to use
+    def initialize(sprite_loader)
+      @sprite_loader = sprite_loader
+      @sprites = {}
+    end
+
+    # Load a specific sprite
+    # @param sprite_name [String] the name of the sprite to load
+    # @return [Hash, nil] the sprite data or nil if not found
+    def load_sprite(sprite_name)
+      return @sprites[sprite_name] if @sprites.key?(sprite_name)
+
+      sprite_data = @sprite_loader.get_sprite(sprite_name)
+      return nil unless sprite_data
+
+      # In a real implementation, this would convert the sprite data
+      # into a format that can be efficiently rendered
+      @sprites[sprite_name] = sprite_data
+    end
+
+    # Render a sprite
+    # @param sprite_name [String] the name of the sprite to render
+    # @param x [Integer] the x coordinate to render at
+    # @param y [Integer] the y coordinate to render at
+    # @param scale [Float] the scale to render at
+    # @param window [Doom::Window] the window to render to
+    def render_sprite(sprite_name, x, y, scale, window)
+      sprite = load_sprite(sprite_name)
+      return unless sprite
+
+      # In a real implementation, this would:
+      # 1. Calculate the screen coordinates for the sprite
+      # 2. Apply any necessary transformations (scaling, rotation)
+      # 3. Draw the sprite with proper transparency
+
+      # For now, we'll just draw a placeholder rectangle
+      width = sprite[:width] * scale
+      height = sprite[:height] * scale
+      color = Gosu::Color.new(255, 255, 0, 0) # Semi-transparent red
+      window.draw_quad(
+        x - width / 2, y - height, color,
+        x + width / 2, y - height, color,
+        x + width / 2, y, color,
+        x - width / 2, y, color
+      )
+    end
+  end
+end

data/lib/doom/texture_loader.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Doom
+  # TextureLoader is responsible for loading and parsing texture data from a WAD file
+  class TextureLoader
+    attr_reader :textures, :patch_names
+
+    # Initialize a new TextureLoader with the given WADLoader
+    # @param wad_loader [WADLoader] the WAD loader to use
+    def initialize(wad_loader)
+      @wad_loader = wad_loader
+      @textures = {}
+      @patch_names = []
+      load_patch_names
+      load_textures
+    end
+
+    # Load the PNAMES lump which contains patch names
+    def load_patch_names
+      pnames_data = @wad_loader.get_lump("PNAMES")
+      return unless pnames_data
+      
+      # First 4 bytes is the number of patch names
+      num_patches = pnames_data[0..3].unpack("V")[0]
+      
+      # Each patch name is 8 bytes
+      num_patches.times do |i|
+        offset = 4 + (i * 8)
+        patch_name = pnames_data[offset..offset + 7].unpack("Z*")[0]
+        @patch_names << patch_name
+      end
+    end
+
+    # Load the TEXTURE1 and TEXTURE2 lumps which contain texture definitions
+    def load_textures
+      load_texture_lump("TEXTURE1")
+      load_texture_lump("TEXTURE2")
+    end
+
+    # Load a specific texture lump
+    # @param lump_name [String] the name of the texture lump (TEXTURE1 or TEXTURE2)
+    def load_texture_lump(lump_name)
+      texture_data = @wad_loader.get_lump(lump_name)
+      return unless texture_data
+      
+      # First 4 bytes is the number of textures
+      num_textures = texture_data[0..3].unpack("V")[0]
+      
+      # Next num_textures * 4 bytes are offsets to each texture definition
+      offsets = []
+      num_textures.times do |i|
+        offset = 4 + (i * 4)
+        texture_offset = texture_data[offset..offset + 3].unpack("V")[0]
+        offsets << texture_offset
+      end
+      
+      # Parse each texture definition
+      offsets.each do |offset|
+        parse_texture_definition(texture_data, offset)
+      end
+    end
+
+    # Parse a texture definition
+    # @param texture_data [String] the texture lump data
+    # @param offset [Integer] the offset to the texture definition
+    def parse_texture_definition(texture_data, offset)
+      # Texture definition structure:
+      # - 8 bytes: texture name
+      # - 4 bytes: flags (unused)
+      # - 2 bytes: width
+      # - 2 bytes: height
+      # - 4 bytes: column directory (unused)
+      # - 2 bytes: number of patches
+      # - patches: array of patch definitions
+      
+      texture_name = texture_data[offset..offset + 7].unpack("Z*")[0]
+      # Skip flags (4 bytes)
+      width = texture_data[offset + 12..offset + 13].unpack("v")[0]
+      height = texture_data[offset + 14..offset + 15].unpack("v")[0]
+      # Skip column directory (4 bytes)
+      num_patches = texture_data[offset + 20..offset + 21].unpack("v")[0]
+      
+      patches = []
+      
+      # Parse each patch definition
+      num_patches.times do |i|
+        patch_offset = offset + 22 + (i * 10)
+        
+        # Patch definition structure:
+        # - 2 bytes: x offset
+        # - 2 bytes: y offset
+        # - 2 bytes: patch number (index into PNAMES)
+        # - 2 bytes: step dir (unused)
+        # - 2 bytes: color map (unused)
+        
+        x_offset = texture_data[patch_offset..patch_offset + 1].unpack("s<")[0]
+        y_offset = texture_data[patch_offset + 2..patch_offset + 3].unpack("s<")[0]
+        patch_num = texture_data[patch_offset + 4..patch_offset + 5].unpack("v")[0]
+        
+        patch_name = @patch_names[patch_num] if patch_num < @patch_names.size
+        
+        patches << {
+          x_offset: x_offset,
+          y_offset: y_offset,
+          patch_num: patch_num,
+          patch_name: patch_name
+        }
+      end
+      
+      @textures[texture_name] = {
+        name: texture_name,
+        width: width,
+        height: height,
+        patches: patches
+      }
+    end
+
+    # Get a specific texture by name
+    # @param name [String] the name of the texture
+    # @return [Hash, nil] the texture data or nil if not found
+    def get_texture(name)
+      @textures[name]
+    end
+
+    # List all texture names
+    # @return [Array<String>] array of texture names
+    def texture_names
+      @textures.keys
+    end
+
+    # Check if a texture exists
+    # @param name [String] the name of the texture
+    # @return [Boolean] true if the texture exists
+    def texture_exists?(name)
+      @textures.key?(name)
+    end
+  end
+end

data/lib/doom/texture_mapper.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Doom
+  # TextureMapper is responsible for mapping textures onto walls
+  class TextureMapper
+    attr_reader :texture_loader
+
+    # Initialize a new TextureMapper with the given texture loader
+    # @param texture_loader [Doom::TextureLoader] the texture loader to use
+    def initialize(texture_loader)
+      @texture_loader = texture_loader
+      @textures = {}
+    end
+
+    # Load a specific texture
+    # @param texture_name [String] the name of the texture to load
+    # @return [Hash, nil] the texture data or nil if not found
+    def load_texture(texture_name)
+      return @textures[texture_name] if @textures.key?(texture_name)
+
+      texture_data = @texture_loader.get_texture(texture_name)
+      return nil unless texture_data
+
+      # In a real implementation, this would convert the texture data
+      # into a format that can be efficiently rendered
+      @textures[texture_name] = texture_data
+    end
+
+    # Map a texture onto a wall
+    # @param texture_name [String] the name of the texture to map
+    # @param x [Integer] the x coordinate to start mapping
+    # @param y [Integer] the y coordinate to start mapping
+    # @param width [Integer] the width of the wall
+    # @param height [Integer] the height of the wall
+    # @param u_offset [Integer] the u offset into the texture
+    # @param v_offset [Integer] the v offset into the texture
+    # @param window [Doom::Window] the window to render to
+    def map_texture(texture_name, x, y, width, height, u_offset, v_offset, window)
+      texture = load_texture(texture_name)
+      return unless texture
+
+      # In a real implementation, this would:
+      # 1. Calculate the texture coordinates for each pixel of the wall
+      # 2. Sample the texture at those coordinates
+      # 3. Draw the resulting pixel to the screen
+
+      # For now, we'll just draw a placeholder rectangle
+      color = Gosu::Color.new(255, 128, 128, 128) # Semi-transparent gray
+      window.draw_quad(
+        x, y, color,
+        x + width, y, color,
+        x + width, y + height, color,
+        x, y + height, color
+      )
+    end
+  end
+end

data/lib/doom/version.rb

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