doom 0.2.0 → 0.3.0

data/lib/doom/texture_loader.rb

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

@@ -1,57 +0,0 @@
-# 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/wad_loader.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module Doom
-  # WADLoader is responsible for loading and parsing WAD files
-  class WADLoader
-    # WAD file header structure:
-    # - 4 bytes: WAD type (IWAD or PWAD)
-    # - 4 bytes: number of lumps
-    # - 4 bytes: directory offset
-    HEADER_SIZE = 12
-
-    # Directory entry structure:
-    # - 4 bytes: lump offset
-    # - 4 bytes: lump size
-    # - 8 bytes: lump name (null-terminated)
-    DIRECTORY_ENTRY_SIZE = 16
-
-    attr_reader :wad_type, :lumps, :directory, :filename, :num_lumps
-
-    # Initialize a new WADLoader with the given WAD file
-    # @param filename [String] path to the WAD file
-    def initialize(filename)
-      @filename = filename
-      @lumps = {}
-      @directory = []
-      load_wad
-    end
-
-    # Load and parse the WAD file
-    def load_wad
-      File.open(@filename, "rb") do |file|
-        read_header(file)
-        read_directory(file)
-        load_lumps(file)
-      end
-    end
-
-    # Read the WAD file header
-    # @param file [File] the WAD file
-    def read_header(file)
-      header = file.read(HEADER_SIZE)
-      @wad_type = header[0..3]
-      @num_lumps = header[4..7].unpack("V")[0]
-      directory_offset = header[8..11].unpack("V")[0]
-
-      # Validate WAD type
-      unless ["IWAD", "PWAD"].include?(@wad_type)
-        raise Error, "Invalid WAD type: #{@wad_type}"
-      end
-
-      # Seek to the directory
-      file.seek(directory_offset)
-    end
-
-    # Read the WAD directory
-    # @param file [File] the WAD file
-    def read_directory(file)
-      # The file position should already be at the directory after read_header
-      # We'll use the number of lumps from the instance variable
-
-      @num_lumps.times do
-        entry = file.read(DIRECTORY_ENTRY_SIZE)
-        lump_offset = entry[0..3].unpack("V")[0]
-        lump_size = entry[4..7].unpack("V")[0]
-        lump_name = entry[8..15].unpack("Z*")[0]
-
-        @directory << {
-          name: lump_name,
-          offset: lump_offset,
-          size: lump_size
-        }
-      end
-    end
-
-    # Load all lumps from the WAD file
-    # @param file [File] the WAD file
-    def load_lumps(file)
-      @directory.each do |entry|
-        next if entry[:size] == 0 # Skip markers
-
-        file.seek(entry[:offset])
-        @lumps[entry[:name]] = file.read(entry[:size])
-      end
-    end
-
-    # Get a specific lump by name
-    # @param name [String] the name of the lump
-    # @return [String, nil] the lump data or nil if not found
-    def get_lump(name)
-      @lumps[name]
-    end
-
-    # List all lump names
-    # @return [Array<String>] array of lump names
-    def lump_names
-      @lumps.keys
-    end
-
-    # Check if a lump exists
-    # @param name [String] the name of the lump
-    # @return [Boolean] true if the lump exists
-    def lump_exists?(name)
-      @lumps.key?(name)
-    end
-  end
-end

data/lib/doom/window.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "gosu"
-
-module Doom
-  # Window class for managing the game window
-  class Window < Gosu::Window
-    attr_reader :width, :height
-    attr_accessor :game
-
-    # Initialize a new Window with the given width and height
-    # @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(width = 640, height = 480, fullscreen = false)
-      super(width, height, fullscreen)
-      @width = width
-      @height = height
-      self.caption = "Ruby Doom"
-    end
-
-    # Update the game state
-    def update
-      @game.update if @game
-    end
-
-    # Draw the game
-    def draw
-      @game.draw if @game
-    end
-
-    # Handle button press events
-    def button_down(id)
-      if @game
-        @game.button_down(id)
-      else
-        close if id == Gosu::KB_ESCAPE
-      end
-    end
-  end
-end