doom 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77ff94b86295598915c520657fb36512c6fc091d24d6660cc8dea588a8939062
-  data.tar.gz: 3b3632ab2f9adbd0d8d4078c71f5c9f941943dd30d96c951bb27e803256a87d1
+  metadata.gz: 70d72175c1f115b3363e188d7075047bc32cece4f3a3dd1feda17dc6f965b07f
+  data.tar.gz: 22eb9172267c578a6fbaa3dd526ec19e8d4587dba9a349080ad1626d3e04fd92
 SHA512:
-  metadata.gz: 61d4a1cf4f3542c3ce93d4dc624b2cc36c4d93be39a9d65cc832198be7bbd04b9bd86cc7723d13181b80907809005571d7a9f85217e628d6f5a5b7a02e35908a
-  data.tar.gz: 514bc92b65f0934cbf31828e4553d6978d86932afa690f70b89a69ed6d6bbe71cb98e0d3bfbe86916e0c799498366eedcad2f74904f78be84fc3d559f43a8dd3
+  metadata.gz: 6f5fdd281119ba4bec5a29b8f9cd32f8d0aa37d1674125c3095835ba24942e66e6356037c3e424f320578cac5b1ed94dc7738388d3ced296f8de22ce78e9e79e
+  data.tar.gz: 35de5ff2f711aa4084a54d811d26b919cf8f1b00be1d9b06597b7e7aac09eab3ee8ff597b1ece2ac451d175dad2faf3c16bc73f3dbf56b50867407509fc4f234

data/README.md

@@ -1,159 +1,119 @@
-# Ruby Doom
+# DOOM Ruby
 
-A Ruby gem that ports the classic Doom game to Ruby, focusing on core gameplay without sound or networking features.
+A faithful ruby port of the DOOM (1993) rendering engine to Ruby.
 
-## Installation
+![DOOM Ruby Screenshot](https://raw.githubusercontent.com/khasinski/doom-rb/main/e1m1_spawn.png)
 
-Add this line to your application's Gemfile:
+## Features
 
-```ruby
-gem 'doom'
-```
+- Pure Ruby implementation of DOOM's BSP rendering engine
+- Accurate wall, floor, and ceiling rendering with proper texture mapping
+- Sprite rendering with depth-correct clipping
+- Original DOOM lighting and colormap support
+- Mouse look and WASD movement controls
+- Supports original WAD files (shareware and registered)
 
-And then execute:
+## Installation
 
 ```bash
-$ bundle install
+gem install doom
 ```
 
-Or install it yourself as:
+## Quick Start
+
+Just run `doom` - it will offer to download the free shareware version:
 
 ```bash
-$ gem install doom
+doom
 ```
 
-## Requirements
-
-- Ruby 2.6 or higher
-- A legal copy of Doom for the WAD files (e.g., DOOM.WAD)
-
-## Usage
-
-### Command Line Interface
-
-The gem includes two command-line tools:
-
-#### WAD Explorer
-
-The `wad` command allows you to explore WAD files:
+Or specify your own WAD file:
 
 ```bash
-# Show general information about a WAD file
-$ wad -i DOOM.WAD
-
-# List all maps in a WAD file
-$ wad -l DOOM.WAD
+doom /path/to/doom.wad
+```
 
-# Show details for a specific map
-$ wad -m E1M1 DOOM.WAD
+## Controls
 
-# List all textures in a WAD file
-$ wad -t DOOM.WAD
+| Key | Action |
+|-----|--------|
+| W / Up Arrow | Move forward |
+| S / Down Arrow | Move backward |
+| A | Strafe left |
+| D | Strafe right |
+| Left Arrow | Turn left |
+| Right Arrow | Turn right |
+| Mouse | Look around (click to capture) |
+| Escape | Release mouse / Quit |
 
-# Show details for a specific texture
-$ wad -x STARTAN1 DOOM.WAD
+## Requirements
 
-# List all sprites in a WAD file
-$ wad -s DOOM.WAD
+- Ruby 3.1 or higher
+- Gosu gem (for window/graphics)
+- SDL2 (native library required by Gosu)
 
-# Show details for a specific sprite
-$ wad -p TROOA1 DOOM.WAD
+### Installing SDL2
 
-# Show help
-$ wad -h
+**macOS:**
+```bash
+brew install sdl2
 ```
 
-#### Game Launcher
-
-The `doom` command allows you to start the game:
-
+**Ubuntu/Debian:**
 ```bash
-# Start the game with default settings
-$ doom DOOM.WAD
-
-# Start the game with a specific map
-$ doom -m E1M1 DOOM.WAD
-
-# Start the game with a custom window size
-$ doom -w 800 -h 600 DOOM.WAD
-
-# Start the game in fullscreen mode
-$ doom -f DOOM.WAD
-
-# Show help
-$ doom --help
+sudo apt-get install build-essential libsdl2-dev libgl1-mesa-dev libfontconfig1-dev
 ```
 
-### Ruby API
-
-You can also use the Ruby API in your own code:
-
-```ruby
-require 'doom'
-
-# Load a WAD file
-loaders = Doom.load_wad('path/to/DOOM.WAD')
-
-# Access WAD information
-wad_loader = loaders[:wad]
-puts "WAD type: #{wad_loader.wad_type}"
-puts "Number of lumps: #{wad_loader.lumps.size}"
-
-# Access map information
-map_loader = loaders[:maps]
-puts "Available maps: #{map_loader.maps.join(', ')}"
-
-# Load a specific map
-map_data = map_loader.load_map('E1M1')
-puts "Number of things in E1M1: #{map_data[:things].size}"
-
-# Access texture information
-texture_loader = loaders[:textures]
-puts "Available textures: #{texture_loader.texture_names.join(', ')}"
-
-# Access sprite information
-sprite_loader = loaders[:sprites]
-puts "Available sprites: #{sprite_loader.sprite_names.join(', ')}"
+**Fedora:**
+```bash
+sudo dnf install SDL2-devel mesa-libGL-devel fontconfig-devel gcc-c++
 ```
 
-## Features
+**Arch Linux:**
+```bash
+sudo pacman -S sdl2 mesa
+```
 
-### Phase 1: WAD File Loader
+**Windows:**
+No additional setup needed - the gem includes SDL2.
 
-- WAD file parsing
-- Map data extraction
-- Texture information parsing
-- Sprite data handling
+## Development
 
-### Phase 2: Rendering Engine (Current)
+```bash
+git clone https://github.com/khasinski/doom-rb.git
+cd doom-rb
+bundle install
+ruby bin/doom doom1.wad
+```
 
-- Window management
-- BSP rendering
-- Texture mapping
-- Sprite rendering
-- HUD implementation
-- Basic game loop
+Run specs:
 
-### Future Phases
+```bash
+bundle exec rspec
+```
 
-- Game mechanics
-- Advanced game loop and state management
-- Polishing
+## Technical Details
 
-## Development
+This implementation includes:
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+- **BSP Traversal**: Front-to-back rendering using the map's BSP tree
+- **Visplanes**: Floor/ceiling rendering with R_CheckPlane splitting
+- **Drawsegs**: Wall segment tracking for proper sprite clipping
+- **Texture Mapping**: Perspective-correct texture coordinates
+- **Lighting**: Distance-based light diminishing with colormaps
 
-To install this gem onto your local machine, run `bundle exec rake install`.
+## Legal
 
-## Contributing
+DOOM is a registered trademark of id Software LLC. This is an unofficial fan project.
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/khasinski/doom-rb.
+The shareware version of DOOM (Episode 1) is freely distributable. For the full game,
+please purchase DOOM from [Steam](https://store.steampowered.com/app/2280/Ultimate_Doom/),
+[GOG](https://www.gog.com/pl/game/doom_doom_ii), or other retailers.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+GPL-2.0 - Same license as the original DOOM source code.
 
-## Legal
+## Author
 
-Users must own a legal copy of Doom for the WAD files. This project complies with id Software's terms regarding Doom content.
+Chris Hasinski ([@khasinski](https://github.com/khasinski))

data/bin/doom

@@ -1,70 +1,59 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "doom"
-require "optparse"
-
-options = {
-  map: nil,
-  width: 640,
-  height: 480,
-  fullscreen: false
-}
-
-parser = OptionParser.new do |opts|
-  opts.banner = "Usage: doom [options] WAD_FILE"
-
-  opts.on("-m", "--map MAP", "Start the game with a specific map") do |map|
-    options[:map] = map
-  end
-
-  opts.on("-w", "--width WIDTH", Integer, "Set the window width (default: 640)") do |width|
-    options[:width] = width
-  end
-
-  opts.on("-h", "--height HEIGHT", Integer, "Set the window height (default: 480)") do |height|
-    options[:height] = height
-  end
-
-  opts.on("-f", "--fullscreen", "Start in fullscreen mode") do
-    options[:fullscreen] = true
-  end
-
-  opts.on("--help", "Show this help message") do
-    puts opts
-    exit
-  end
+# Enable YJIT if available (Ruby 3.1+) for better performance
+if defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enable)
+  RubyVM::YJIT.enable
 end
 
-parser.parse!
-
-if ARGV.empty?
-  puts "Error: WAD file is required"
-  puts parser
-  exit 1
+# Parse arguments before loading heavy dependencies
+wad_path = ARGV[0]
+
+# Show help (before loading anything)
+if wad_path == '-h' || wad_path == '--help'
+  puts "DOOM - Ruby port of the classic 1993 game"
+  puts
+  puts "Usage: doom [OPTIONS] [WAD_FILE]"
+  puts
+  puts "Options:"
+  puts "  -h, --help     Show this help message"
+  puts "  -v, --version  Show version"
+  puts
+  puts "If no WAD file is specified, doom will look for doom1.wad in:"
+  puts "  1. Current directory"
+  puts "  2. ~/.doom/"
+  puts
+  puts "If not found, you'll be prompted to download the shareware version."
+  puts
+  puts "Controls:"
+  puts "  W/Up      - Move forward"
+  puts "  S/Down    - Move backward"
+  puts "  A         - Strafe left"
+  puts "  D         - Strafe right"
+  puts "  Left      - Turn left"
+  puts "  Right     - Turn right"
+  puts "  Mouse     - Look around (click to capture)"
+  puts "  Escape    - Release mouse / Quit"
+  exit 0
 end
 
-wad_file = ARGV[0]
-unless File.exist?(wad_file)
-  puts "Error: WAD file '#{wad_file}' not found"
-  exit 1
+if wad_path == '-v' || wad_path == '--version'
+  require_relative '../lib/doom/version'
+  puts "DOOM Ruby v#{Doom::VERSION}"
+  exit 0
 end
 
+# Now load the full library
+require_relative '../lib/doom'
+
 begin
-  puts "Starting Doom with WAD file: #{wad_file}"
-  puts "Map: #{options[:map] || 'Default'}"
-  puts "Window size: #{options[:width]}x#{options[:height]}"
-  puts "Fullscreen: #{options[:fullscreen]}"
-  
-  Doom.start_game(
-    wad_file,
-    options[:map],
-    options[:width],
-    options[:height],
-    options[:fullscreen]
-  )
-rescue Doom::Error => e
+  # Find or download WAD
+  wad_path = Doom::WadDownloader.ensure_wad_available(wad_path)
+  Doom.run(wad_path)
+rescue Doom::WadDownloader::DownloadError => e
   puts "Error: #{e.message}"
   exit 1
-end
+rescue Interrupt
+  puts "\nQuitting..."
+  exit 0
+end

data/lib/doom/map/data.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module Doom
+  module Map
+    Vertex = Struct.new(:x, :y)
+
+    Thing = Struct.new(:x, :y, :angle, :type, :flags)
+
+    Linedef = Struct.new(:v1, :v2, :flags, :special, :tag, :sidedef_right, :sidedef_left) do
+      FLAGS = {
+        BLOCKING: 0x0001,
+        BLOCKMONSTERS: 0x0002,
+        TWOSIDED: 0x0004,
+        DONTPEGTOP: 0x0008,
+        DONTPEGBOTTOM: 0x0010,
+        SECRET: 0x0020,
+        SOUNDBLOCK: 0x0040,
+        DONTDRAW: 0x0080,
+        MAPPED: 0x0100
+      }.freeze
+
+      def two_sided?
+        (flags & FLAGS[:TWOSIDED]) != 0
+      end
+
+      def upper_unpegged?
+        (flags & FLAGS[:DONTPEGTOP]) != 0
+      end
+
+      def lower_unpegged?
+        (flags & FLAGS[:DONTPEGBOTTOM]) != 0
+      end
+    end
+
+    Sidedef = Struct.new(:x_offset, :y_offset, :upper_texture, :lower_texture, :middle_texture, :sector)
+
+    Sector = Struct.new(:floor_height, :ceiling_height, :floor_texture, :ceiling_texture, :light_level, :special, :tag)
+
+    Seg = Struct.new(:v1, :v2, :angle, :linedef, :direction, :offset)
+
+    Subsector = Struct.new(:seg_count, :first_seg)
+
+    class Node
+      SUBSECTOR_FLAG = 0x8000
+
+      attr_reader :x, :y, :dx, :dy, :bbox_right, :bbox_left, :child_right, :child_left
+
+      BBox = Struct.new(:top, :bottom, :left, :right)
+
+      def initialize(x, y, dx, dy, bbox_right, bbox_left, child_right, child_left)
+        @x = x
+        @y = y
+        @dx = dx
+        @dy = dy
+        @bbox_right = bbox_right
+        @bbox_left = bbox_left
+        @child_right = child_right
+        @child_left = child_left
+      end
+
+      def right_is_subsector?
+        (@child_right & SUBSECTOR_FLAG) != 0
+      end
+
+      def left_is_subsector?
+        (@child_left & SUBSECTOR_FLAG) != 0
+      end
+
+      def right_index
+        @child_right & ~SUBSECTOR_FLAG
+      end
+
+      def left_index
+        @child_left & ~SUBSECTOR_FLAG
+      end
+    end
+
+    class MapData
+      attr_reader :name, :things, :vertices, :linedefs, :sidedefs, :sectors, :segs, :subsectors, :nodes
+
+      def initialize(name)
+        @name = name
+        @things = []
+        @vertices = []
+        @linedefs = []
+        @sidedefs = []
+        @sectors = []
+        @segs = []
+        @subsectors = []
+        @nodes = []
+      end
+
+      def self.load(wad, map_name)
+        map = new(map_name)
+
+        lump_idx = wad.directory.index { |e| e.name == map_name.upcase }
+        raise Error, "Map #{map_name} not found" unless lump_idx
+
+        map.load_things(wad.read_lump_at(wad.directory[lump_idx + 1]))
+        map.load_linedefs(wad.read_lump_at(wad.directory[lump_idx + 2]))
+        map.load_sidedefs(wad.read_lump_at(wad.directory[lump_idx + 3]))
+        map.load_vertices(wad.read_lump_at(wad.directory[lump_idx + 4]))
+        map.load_segs(wad.read_lump_at(wad.directory[lump_idx + 5]))
+        map.load_subsectors(wad.read_lump_at(wad.directory[lump_idx + 6]))
+        map.load_nodes(wad.read_lump_at(wad.directory[lump_idx + 7]))
+        map.load_sectors(wad.read_lump_at(wad.directory[lump_idx + 8]))
+
+        map
+      end
+
+      def load_things(data)
+        count = data.size / 10
+        count.times do |i|
+          offset = i * 10
+          @things << Thing.new(
+            data[offset, 2].unpack1('s<'),
+            data[offset + 2, 2].unpack1('s<'),
+            data[offset + 4, 2].unpack1('v'),
+            data[offset + 6, 2].unpack1('v'),
+            data[offset + 8, 2].unpack1('v')
+          )
+        end
+      end
+
+      def load_vertices(data)
+        count = data.size / 4
+        count.times do |i|
+          offset = i * 4
+          @vertices << Vertex.new(
+            data[offset, 2].unpack1('s<'),
+            data[offset + 2, 2].unpack1('s<')
+          )
+        end
+      end
+
+      def load_linedefs(data)
+        count = data.size / 14
+        count.times do |i|
+          offset = i * 14
+          @linedefs << Linedef.new(
+            data[offset, 2].unpack1('v'),
+            data[offset + 2, 2].unpack1('v'),
+            data[offset + 4, 2].unpack1('v'),
+            data[offset + 6, 2].unpack1('v'),
+            data[offset + 8, 2].unpack1('v'),
+            data[offset + 10, 2].unpack1('s<'),
+            data[offset + 12, 2].unpack1('s<')
+          )
+        end
+      end
+
+      def load_sidedefs(data)
+        count = data.size / 30
+        count.times do |i|
+          offset = i * 30
+          @sidedefs << Sidedef.new(
+            data[offset, 2].unpack1('s<'),
+            data[offset + 2, 2].unpack1('s<'),
+            data[offset + 4, 8].delete("\x00").strip,
+            data[offset + 12, 8].delete("\x00").strip,
+            data[offset + 20, 8].delete("\x00").strip,
+            data[offset + 28, 2].unpack1('v')
+          )
+        end
+      end
+
+      def load_sectors(data)
+        count = data.size / 26
+        count.times do |i|
+          offset = i * 26
+          @sectors << Sector.new(
+            data[offset, 2].unpack1('s<'),
+            data[offset + 2, 2].unpack1('s<'),
+            data[offset + 4, 8].delete("\x00").strip,
+            data[offset + 12, 8].delete("\x00").strip,
+            data[offset + 20, 2].unpack1('v'),
+            data[offset + 22, 2].unpack1('v'),
+            data[offset + 24, 2].unpack1('v')
+          )
+        end
+      end
+
+      def load_segs(data)
+        count = data.size / 12
+        count.times do |i|
+          offset = i * 12
+          @segs << Seg.new(
+            data[offset, 2].unpack1('v'),
+            data[offset + 2, 2].unpack1('v'),
+            data[offset + 4, 2].unpack1('s<'),
+            data[offset + 6, 2].unpack1('v'),
+            data[offset + 8, 2].unpack1('v'),
+            data[offset + 10, 2].unpack1('s<')
+          )
+        end
+      end
+
+      def load_subsectors(data)
+        count = data.size / 4
+        count.times do |i|
+          offset = i * 4
+          @subsectors << Subsector.new(
+            data[offset, 2].unpack1('v'),
+            data[offset + 2, 2].unpack1('v')
+          )
+        end
+      end
+
+      def load_nodes(data)
+        count = data.size / 28
+        count.times do |i|
+          offset = i * 28
+          bbox_right = Node::BBox.new(
+            data[offset + 8, 2].unpack1('s<'),
+            data[offset + 10, 2].unpack1('s<'),
+            data[offset + 12, 2].unpack1('s<'),
+            data[offset + 14, 2].unpack1('s<')
+          )
+          bbox_left = Node::BBox.new(
+            data[offset + 16, 2].unpack1('s<'),
+            data[offset + 18, 2].unpack1('s<'),
+            data[offset + 20, 2].unpack1('s<'),
+            data[offset + 22, 2].unpack1('s<')
+          )
+          @nodes << Node.new(
+            data[offset, 2].unpack1('s<'),
+            data[offset + 2, 2].unpack1('s<'),
+            data[offset + 4, 2].unpack1('s<'),
+            data[offset + 6, 2].unpack1('s<'),
+            bbox_right,
+            bbox_left,
+            data[offset + 24, 2].unpack1('v'),
+            data[offset + 26, 2].unpack1('v')
+          )
+        end
+      end
+
+      def player_start
+        @things.find { |t| t.type == 1 }
+      end
+
+      # Find the sector at a given position by traversing the BSP tree
+      def sector_at(x, y)
+        subsector = subsector_at(x, y)
+        return nil unless subsector
+
+        # Get sector from first seg of subsector
+        seg = @segs[subsector.first_seg]
+        return nil unless seg
+
+        linedef = @linedefs[seg.linedef]
+        sidedef_idx = seg.direction == 0 ? linedef.sidedef_right : linedef.sidedef_left
+        return nil if sidedef_idx < 0
+
+        @sectors[@sidedefs[sidedef_idx].sector]
+      end
+
+      # Find the subsector containing a point
+      def subsector_at(x, y)
+        node_idx = @nodes.size - 1
+        while (node_idx & Node::SUBSECTOR_FLAG) == 0
+          node = @nodes[node_idx]
+          side = point_on_side(x, y, node)
+          node_idx = side == 0 ? node.child_right : node.child_left
+        end
+        @subsectors[node_idx & ~Node::SUBSECTOR_FLAG]
+      end
+
+      private
+
+      def point_on_side(x, y, node)
+        dx = x - node.x
+        dy = y - node.y
+        left = dy * node.dx
+        right = dx * node.dy
+        right >= left ? 0 : 1
+      end
+    end
+  end
+end