doom 0.2.0 → 0.3.0

data/lib/doom/game.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Doom
-  # Game is the main class that ties everything together
-  class Game
-    attr_reader :window, :loaders, :renderers
-
-    # Initialize a new Game with the given WAD file
-    # @param wad_file [String] the path to the WAD file
-    # @param width [Integer] the width of the window
-    # @param height [Integer] the height of the window
-    # @param fullscreen [Boolean] whether the window should be fullscreen
-    def initialize(wad_file, width = 640, height = 480, fullscreen = false)
-      @wad_file = wad_file
-      @width = width
-      @height = height
-      @fullscreen = fullscreen
-      @loaders = {}
-      @renderers = {}
-      @current_map = nil
-      @player_data = {
-        health: 100,
-        armor: 0,
-        ammo: 50,
-        weapon: "Pistol"
-      }
-    end
-
-    # Start the game
-    # @param map_name [String] the name of the map to start on
-    def start(map_name = nil)
-      load_wad
-      setup_window
-      setup_renderers
-      load_map(map_name) if map_name
-      @window.show
-    end
-
-    # Load the WAD file
-    def load_wad
-      @loaders = Doom.load_wad(@wad_file)
-    end
-
-    # Setup the window
-    def setup_window
-      @window = Window.new(@width, @height, @fullscreen)
-      @window.game = self
-    end
-
-    # Setup the renderers
-    def setup_renderers
-      @renderers[:bsp] = BSPRenderer.new(@window, @loaders[:maps])
-      @renderers[:texture] = TextureMapper.new(@loaders[:textures])
-      @renderers[:sprite] = SpriteRenderer.new(@loaders[:sprites])
-      @renderers[:hud] = HUD.new(@window)
-    end
-
-    # Load a specific map
-    # @param map_name [String] the name of the map to load
-    def load_map(map_name)
-      @current_map = map_name
-      @renderers[:bsp].load_map(map_name)
-    end
-
-    # Update the game state
-    def update
-      # Will be implemented in Phase 3
-    end
-
-    # Draw the game
-    def draw
-      @renderers[:bsp].render if @current_map
-      @renderers[:hud].render(@player_data)
-    end
-
-    # Handle button press events
-    def button_down(id)
-      case id
-      when Gosu::KB_ESCAPE
-        @window.close
-      end
-    end
-  end
-end

data/lib/doom/hud.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Doom
-  # HUD is responsible for rendering the Heads-Up Display
-  class HUD
-    attr_reader :window
-
-    # Initialize a new HUD with the given window
-    # @param window [Doom::Window] the window to render to
-    def initialize(window)
-      @window = window
-      @font = Gosu::Font.new(20)
-    end
-
-    # Render the HUD
-    # @param player_data [Hash] the player data to display
-    def render(player_data = {})
-      # In a real implementation, this would render:
-      # - Health
-      # - Armor
-      # - Ammo
-      # - Weapons
-      # - Face
-      # - Keys
-      # - etc.
-
-      # For now, we'll just render some placeholder text
-      health = player_data[:health] || 100
-      armor = player_data[:armor] || 0
-      ammo = player_data[:ammo] || 50
-      weapon = player_data[:weapon] || "Pistol"
-
-      # Draw the HUD background
-      draw_background
-
-      # Draw the HUD elements
-      draw_health(health)
-      draw_armor(armor)
-      draw_ammo(ammo)
-      draw_weapon(weapon)
-    end
-
-    private
-
-    # Draw the HUD background
-    def draw_background
-      color = Gosu::Color.new(128, 0, 0, 0) # Semi-transparent black
-      @window.draw_quad(
-        0, @window.height - 80, color,
-        @window.width, @window.height - 80, color,
-        @window.width, @window.height, color,
-        0, @window.height, color
-      )
-    end
-
-    # Draw the health display
-    # @param health [Integer] the player's health
-    def draw_health(health)
-      @font.draw_text("Health: #{health}", 20, @window.height - 70, 0, 1, 1, Gosu::Color::RED)
-    end
-
-    # Draw the armor display
-    # @param armor [Integer] the player's armor
-    def draw_armor(armor)
-      @font.draw_text("Armor: #{armor}", 20, @window.height - 50, 0, 1, 1, Gosu::Color::GREEN)
-    end
-
-    # Draw the ammo display
-    # @param ammo [Integer] the player's ammo
-    def draw_ammo(ammo)
-      @font.draw_text("Ammo: #{ammo}", @window.width - 120, @window.height - 70, 0, 1, 1, Gosu::Color::YELLOW)
-    end
-
-    # Draw the weapon display
-    # @param weapon [String] the player's current weapon
-    def draw_weapon(weapon)
-      @font.draw_text("Weapon: #{weapon}", @window.width - 120, @window.height - 50, 0, 1, 1, Gosu::Color::WHITE)
-    end
-  end
-end

data/lib/doom/map_loader.rb

@@ -1,255 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-# 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

@@ -1,88 +0,0 @@
-# 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

@@ -1,56 +0,0 @@
-# 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