doom 0.2.0 → 0.4.0

metadata

@@ -1,57 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: doom
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Chris Hasinski
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: gosu
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
+        version: '1.4'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '3.12'
 - !ruby/object:Gem::Dependency
-  name: gosu
+  name: chunky_png
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-description: Ruby Doom is a Ruby gem that ports the classic Doom game to Ruby
+description: A faithful port of the Doom (1993) rendering engine to Ruby. Supports
+  original WAD files with near pixel-perfect BSP rendering.
 email:
 - krzysztof.hasinski@gmail.com
 executables:
@@ -59,32 +61,31 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE.txt
 - README.md
-- bin/console
 - bin/doom
-- bin/setup
-- bin/wad
 - lib/doom.rb
-- lib/doom/bsp_renderer.rb
-- lib/doom/game.rb
-- lib/doom/hud.rb
-- lib/doom/map_loader.rb
-- lib/doom/renderer.rb
-- lib/doom/sprite_loader.rb
-- lib/doom/sprite_renderer.rb
-- lib/doom/texture_loader.rb
-- lib/doom/texture_mapper.rb
+- lib/doom/game/player_state.rb
+- lib/doom/game/sector_actions.rb
+- lib/doom/map/data.rb
+- lib/doom/platform/gosu_window.rb
+- lib/doom/render/renderer.rb
+- lib/doom/render/status_bar.rb
+- lib/doom/render/weapon_renderer.rb
 - lib/doom/version.rb
-- lib/doom/wad_loader.rb
-- lib/doom/window.rb
+- lib/doom/wad/colormap.rb
+- lib/doom/wad/flat.rb
+- lib/doom/wad/hud_graphics.rb
+- lib/doom/wad/palette.rb
+- lib/doom/wad/patch.rb
+- lib/doom/wad/reader.rb
+- lib/doom/wad/sprite.rb
+- lib/doom/wad/texture.rb
+- lib/doom/wad_downloader.rb
 homepage: https://github.com/khasinski/doom-rb
 licenses:
-- MIT
-metadata:
-  homepage_uri: https://github.com/khasinski/doom-rb
-  source_code_uri: https://github.com/khasinski/doom-rb
-  changelog_uri: https://github.com/khasinski/doom-rb/blob/master/CHANGELOG.md
+- GPL-2.0
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -92,14 +93,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: A Ruby port of the classic Doom game
+summary: Doom engine port in pure Ruby
 test_files: []

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2023 Chris Hasiński
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/bin/console

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "doom"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other setup tasks here

data/bin/wad

@@ -1,152 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "doom"
-require "optparse"
-
-options = {
-  action: nil,
-  map: nil,
-  texture: nil,
-  sprite: nil
-}
-
-parser = OptionParser.new do |opts|
-  opts.banner = "Usage: wad [options] WAD_FILE"
-
-  opts.on("-l", "--list-maps", "List all maps in the WAD file") do
-    options[:action] = :list_maps
-  end
-
-  opts.on("-m", "--map MAP", "Show details for a specific map") do |map|
-    options[:action] = :show_map
-    options[:map] = map
-  end
-
-  opts.on("-t", "--list-textures", "List all textures in the WAD file") do
-    options[:action] = :list_textures
-  end
-
-  opts.on("-x", "--texture TEXTURE", "Show details for a specific texture") do |texture|
-    options[:action] = :show_texture
-    options[:texture] = texture
-  end
-
-  opts.on("-s", "--list-sprites", "List all sprites in the WAD file") do
-    options[:action] = :list_sprites
-  end
-
-  opts.on("-p", "--sprite SPRITE", "Show details for a specific sprite") do |sprite|
-    options[:action] = :show_sprite
-    options[:sprite] = sprite
-  end
-
-  opts.on("-i", "--info", "Show general information about the WAD file") do
-    options[:action] = :show_info
-  end
-
-  opts.on("-h", "--help", "Show this help message") do
-    puts opts
-    exit
-  end
-end
-
-parser.parse!
-
-if ARGV.empty?
-  puts "Error: WAD file is required"
-  puts parser
-  exit 1
-end
-
-wad_file = ARGV[0]
-unless File.exist?(wad_file)
-  puts "Error: WAD file '#{wad_file}' not found"
-  exit 1
-end
-
-begin
-  loaders = Doom.load_wad(wad_file)
-
-  case options[:action]
-  when :list_maps
-    puts "Maps in #{wad_file}:"
-    loaders[:maps].maps.each do |map|
-      puts "  #{map}"
-    end
-
-  when :show_map
-    map_name = options[:map]
-    if loaders[:maps].maps.include?(map_name)
-      map_data = loaders[:maps].load_map(map_name)
-      puts "Map: #{map_name}"
-      puts "  Things: #{map_data[:things].size}"
-      puts "  Linedefs: #{map_data[:linedefs].size}"
-      puts "  Sidedefs: #{map_data[:sidedefs].size}"
-      puts "  Vertexes: #{map_data[:vertexes].size}"
-      puts "  Sectors: #{map_data[:sectors].size}"
-    else
-      puts "Error: Map '#{map_name}' not found"
-      exit 1
-    end
-
-  when :list_textures
-    puts "Textures in #{wad_file}:"
-    loaders[:textures].texture_names.each do |texture|
-      puts "  #{texture}"
-    end
-
-  when :show_texture
-    texture_name = options[:texture]
-    if loaders[:textures].texture_exists?(texture_name)
-      texture_data = loaders[:textures].get_texture(texture_name)
-      puts "Texture: #{texture_name}"
-      puts "  Width: #{texture_data[:width]}"
-      puts "  Height: #{texture_data[:height]}"
-      puts "  Patches: #{texture_data[:patches].size}"
-      texture_data[:patches].each_with_index do |patch, i|
-        puts "    Patch #{i + 1}: #{patch[:patch_name]} (#{patch[:x_offset]}, #{patch[:y_offset]})"
-      end
-    else
-      puts "Error: Texture '#{texture_name}' not found"
-      exit 1
-    end
-
-  when :list_sprites
-    puts "Sprites in #{wad_file}:"
-    loaders[:sprites].sprite_names.each do |sprite|
-      puts "  #{sprite}"
-    end
-
-  when :show_sprite
-    sprite_name = options[:sprite]
-    if loaders[:sprites].sprite_exists?(sprite_name)
-      sprite_data = loaders[:sprites].get_sprite(sprite_name)
-      puts "Sprite: #{sprite_name}"
-      puts "  Width: #{sprite_data[:width]}"
-      puts "  Height: #{sprite_data[:height]}"
-      puts "  Offset: (#{sprite_data[:left_offset]}, #{sprite_data[:top_offset]})"
-    else
-      puts "Error: Sprite '#{sprite_name}' not found"
-      exit 1
-    end
-
-  when :show_info
-    puts "WAD File: #{wad_file}"
-    puts "Type: #{loaders[:wad].wad_type}"
-    puts "Directory entries: #{loaders[:wad].directory.size}"
-    puts "Lumps: #{loaders[:wad].lumps.size}"
-    puts "Maps: #{loaders[:maps].maps.size}"
-    puts "Textures: #{loaders[:textures].texture_names.size}"
-    puts "Sprites: #{loaders[:sprites].sprite_names.size}"
-
-  else
-    puts "Please specify an action. Use --help for options."
-    exit 1
-  end
-
-rescue Doom::Error => e
-  puts "Error: #{e.message}"
-  exit 1
-end

data/lib/doom/bsp_renderer.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Doom
-  # BSPRenderer is responsible for rendering the level using Binary Space Partitioning
-  class BSPRenderer < Renderer
-    attr_reader :map_loader
-
-    # Initialize a new BSPRenderer with the given window and map loader
-    # @param window [Doom::Window] the window to render to
-    # @param map_loader [Doom::MapLoader] the map loader to use
-    def initialize(window, map_loader)
-      super(window)
-      @map_loader = map_loader
-      @current_map = nil
-    end
-
-    # Load a specific map
-    # @param map_name [String] the name of the map to load
-    def load_map(map_name)
-      @current_map = @map_loader.load_map(map_name)
-    end
-
-    # Render the current map
-    def render
-      return unless @current_map
-
-      # In a real implementation, this would:
-      # 1. Determine the player's position and angle
-      # 2. Traverse the BSP tree to find visible walls
-      # 3. Render the walls with texture mapping
-      # 4. Render sprites (enemies, items, etc.)
-      
-      # For now, we'll just render a simple wireframe of the map
-      render_wireframe
-    end
-
-    private
-
-    # Render a simple wireframe of the map
-    def render_wireframe
-      # Get the vertexes and linedefs from the current map
-      vertexes = @current_map[:vertexes]
-      linedefs = @current_map[:linedefs]
-
-      # Calculate scale and offset to fit the map in the window
-      scale, offset_x, offset_y = calculate_scale_and_offset(vertexes)
-
-      # Draw each linedef as a line
-      linedefs.each do |linedef|
-        start_vertex = vertexes[linedef[:start_vertex]]
-        end_vertex = vertexes[linedef[:end_vertex]]
-
-        # Transform the vertexes to screen coordinates
-        x1 = offset_x + start_vertex[:x] * scale
-        y1 = offset_y + start_vertex[:y] * scale
-        x2 = offset_x + end_vertex[:x] * scale
-        y2 = offset_y + end_vertex[:y] * scale
-
-        # Draw the line
-        @window.draw_line(x1, y1, Gosu::Color::WHITE, x2, y2, Gosu::Color::WHITE)
-      end
-    end
-
-    # Calculate the scale and offset to fit the map in the window
-    # @param vertexes [Array<Hash>] the vertexes of the map
-    # @return [Array<Float, Float, Float>] the scale, offset_x, and offset_y
-    def calculate_scale_and_offset(vertexes)
-      # Find the min and max coordinates
-      min_x = vertexes.map { |v| v[:x] }.min
-      max_x = vertexes.map { |v| v[:x] }.max
-      min_y = vertexes.map { |v| v[:y] }.min
-      max_y = vertexes.map { |v| v[:y] }.max
-
-      # Calculate the width and height of the map
-      map_width = max_x - min_x
-      map_height = max_y - min_y
-
-      # Calculate the scale to fit the map in the window
-      scale_x = @window.width * 0.8 / map_width
-      scale_y = @window.height * 0.8 / map_height
-      scale = [scale_x, scale_y].min
-
-      # Calculate the offset to center the map
-      offset_x = (@window.width - map_width * scale) / 2 - min_x * scale
-      offset_y = (@window.height - map_height * scale) / 2 - min_y * scale
-
-      [scale, offset_x, offset_y]
-    end
-  end
-end

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