doom 0.2.0 → 0.3.0

data/lib/doom/wad_downloader.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'fileutils'
+
+module Doom
+  # Downloads the shareware DOOM1.WAD if not present
+  class WadDownloader
+    # Official Doom shareware WAD, uploaded by id Software to archive.org
+    SHAREWARE_URL = 'https://archive.org/download/doom-shareware_1996/DOOM1.WAD'
+    SHAREWARE_SIZE = 4_196_020  # Expected size in bytes
+    SHAREWARE_FILENAME = 'doom1.wad'
+
+    class DownloadError < StandardError; end
+
+    def self.ensure_wad_available(custom_path = nil)
+      # If custom path provided and exists, use it
+      return custom_path if custom_path && File.exist?(custom_path)
+
+      # Check current directory for doom1.wad
+      local_wad = File.join(Dir.pwd, SHAREWARE_FILENAME)
+      return local_wad if File.exist?(local_wad)
+
+      # Check home directory .doom folder
+      home_wad = File.join(Dir.home, '.doom', SHAREWARE_FILENAME)
+      return home_wad if File.exist?(home_wad)
+
+      # No WAD found - offer to download
+      if custom_path
+        raise DownloadError, "WAD file not found: #{custom_path}"
+      end
+
+      prompt_and_download(home_wad)
+    end
+
+    def self.prompt_and_download(destination)
+      puts "No DOOM WAD file found."
+      puts
+      puts "Would you like to download the shareware version of DOOM (4 MB)?"
+      puts "This is the free, legally distributable version with Episode 1."
+      puts
+      print "Download shareware DOOM? [Y/n] "
+
+      response = $stdin.gets&.strip&.downcase
+      if response.nil? || response.empty? || response == 'y' || response == 'yes'
+        download_shareware(destination)
+        destination
+      else
+        puts
+        puts "To play DOOM, you need a WAD file. Options:"
+        puts "  1. Run 'doom' again and accept the shareware download"
+        puts "  2. Copy your own doom1.wad or doom.wad to the current directory"
+        puts "  3. Specify a WAD path: doom /path/to/your.wad"
+        exit 1
+      end
+    end
+
+    def self.download_shareware(destination)
+      puts
+      puts "Downloading DOOM shareware..."
+
+      # Create directory if needed
+      FileUtils.mkdir_p(File.dirname(destination))
+
+      uri = URI.parse(SHAREWARE_URL)
+      downloaded = 0
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        request = Net::HTTP::Get.new(uri)
+
+        http.request(request) do |response|
+          case response
+          when Net::HTTPRedirection
+            # Follow redirect
+            return download_from_url(response['location'], destination)
+          when Net::HTTPSuccess
+            total_size = response['content-length']&.to_i || SHAREWARE_SIZE
+
+            File.open(destination, 'wb') do |file|
+              response.read_body do |chunk|
+                file.write(chunk)
+                downloaded += chunk.size
+                print_progress(downloaded, total_size)
+              end
+            end
+          else
+            raise DownloadError, "Download failed: #{response.code} #{response.message}"
+          end
+        end
+      end
+
+      puts
+      puts "Downloaded to: #{destination}"
+      puts
+
+      # Verify file size
+      actual_size = File.size(destination)
+      if actual_size < 1_000_000  # Less than 1MB is suspicious
+        File.delete(destination)
+        raise DownloadError, "Download appears incomplete (#{actual_size} bytes)"
+      end
+    end
+
+    def self.download_from_url(url, destination)
+      uri = URI.parse(url)
+      downloaded = 0
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        request = Net::HTTP::Get.new(uri)
+
+        http.request(request) do |response|
+          case response
+          when Net::HTTPRedirection
+            return download_from_url(response['location'], destination)
+          when Net::HTTPSuccess
+            total_size = response['content-length']&.to_i || SHAREWARE_SIZE
+
+            File.open(destination, 'wb') do |file|
+              response.read_body do |chunk|
+                file.write(chunk)
+                downloaded += chunk.size
+                print_progress(downloaded, total_size)
+              end
+            end
+          else
+            raise DownloadError, "Download failed: #{response.code} #{response.message}"
+          end
+        end
+      end
+    end
+
+    def self.print_progress(downloaded, total)
+      percent = (downloaded.to_f / total * 100).to_i
+      bar_width = 40
+      filled = (percent * bar_width / 100)
+      bar = '=' * filled + '-' * (bar_width - filled)
+      mb_downloaded = (downloaded / 1_048_576.0).round(1)
+      mb_total = (total / 1_048_576.0).round(1)
+      print "\r[#{bar}] #{percent}% (#{mb_downloaded}/#{mb_total} MB)"
+    end
+  end
+end

data/lib/doom.rb

@@ -1,46 +1,65 @@
 # frozen_string_literal: true
 
-require_relative "doom/version"
-require_relative "doom/wad_loader"
-require_relative "doom/map_loader"
-require_relative "doom/texture_loader"
-require_relative "doom/sprite_loader"
-require_relative "doom/window"
-require_relative "doom/renderer"
-require_relative "doom/bsp_renderer"
-require_relative "doom/texture_mapper"
-require_relative "doom/sprite_renderer"
-require_relative "doom/hud"
-require_relative "doom/game"
+require_relative 'doom/version'
+require_relative 'doom/wad_downloader'
+require_relative 'doom/wad/reader'
+require_relative 'doom/wad/palette'
+require_relative 'doom/wad/colormap'
+require_relative 'doom/wad/flat'
+require_relative 'doom/wad/patch'
+require_relative 'doom/wad/texture'
+require_relative 'doom/wad/sprite'
+require_relative 'doom/map/data'
+require_relative 'doom/render/renderer'
+require_relative 'doom/platform/gosu_window'
 
 module Doom
   class Error < StandardError; end
 
-  # Load a WAD file and return loaders for its components
-  # @param filename [String] path to the WAD file
-  # @return [Hash] hash containing the various loaders
-  def self.load_wad(filename)
-    wad_loader = WADLoader.new(filename)
-    map_loader = MapLoader.new(wad_loader)
-    texture_loader = TextureLoader.new(wad_loader)
-    sprite_loader = SpriteLoader.new(wad_loader)
-
-    {
-      wad: wad_loader,
-      maps: map_loader,
-      textures: texture_loader,
-      sprites: sprite_loader
-    }
-  end
+  class << self
+    def run(wad_path, map_name: 'E1M1')
+      puts "Loading WAD: #{wad_path}"
+      wad = Wad::Reader.new(wad_path)
+      puts "  #{wad.type}: #{wad.num_lumps} lumps"
+
+      puts 'Loading palette...'
+      palette = Wad::Palette.load(wad)
+
+      puts 'Loading colormap...'
+      colormap = Wad::Colormap.load(wad)
+
+      puts 'Loading flats...'
+      flats = Wad::Flat.load_all(wad)
+      puts "  #{flats.size} flats"
+
+      puts 'Loading textures...'
+      textures = Wad::TextureManager.new(wad)
+      puts "  #{textures.textures.size} textures, #{textures.pnames.size} patches"
+
+      puts 'Loading sprites...'
+      sprites = Wad::SpriteManager.new(wad)
+
+      puts "Loading map #{map_name}..."
+      map = Map::MapData.load(wad, map_name)
+      puts "  #{map.vertices.size} vertices, #{map.linedefs.size} linedefs"
+      puts "  #{map.segs.size} segs, #{map.subsectors.size} subsectors, #{map.nodes.size} nodes"
+
+      # Find player start
+      player_start = map.player_start
+      if player_start
+        puts "  Player start: (#{player_start.x}, #{player_start.y}) angle #{player_start.angle}"
+      else
+        puts '  Warning: No player start found!'
+        player_start = Map::Thing.new(0, 0, 90, 1, 0)
+      end
+
+      puts 'Creating renderer...'
+      renderer = Render::Renderer.new(wad, map, textures, palette, colormap, flats, sprites)
+      renderer.set_player(player_start.x, player_start.y, 41, player_start.angle)
 
-  # Start the game with the given WAD file
-  # @param wad_file [String] path to the WAD file
-  # @param map_name [String] name of the map to start on (optional)
-  # @param width [Integer] width of the window (default: 640)
-  # @param height [Integer] height of the window (default: 480)
-  # @param fullscreen [Boolean] whether to start in fullscreen mode (default: false)
-  def self.start_game(wad_file, map_name = nil, width = 640, height = 480, fullscreen = false)
-    game = Game.new(wad_file, width, height, fullscreen)
-    game.start(map_name)
+      puts 'Starting game window...'
+      window = Platform::GosuWindow.new(renderer, palette, map)
+      window.show
+    end
   end
 end

metadata

@@ -1,57 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: doom
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Chris Hasinski
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-12-21 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,26 @@ 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/map/data.rb
+- lib/doom/platform/gosu_window.rb
+- lib/doom/render/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/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 +88,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