doom 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 77ff94b86295598915c520657fb36512c6fc091d24d6660cc8dea588a8939062
+  data.tar.gz: 3b3632ab2f9adbd0d8d4078c71f5c9f941943dd30d96c951bb27e803256a87d1
+SHA512:
+  metadata.gz: 61d4a1cf4f3542c3ce93d4dc624b2cc36c4d93be39a9d65cc832198be7bbd04b9bd86cc7723d13181b80907809005571d7a9f85217e628d6f5a5b7a02e35908a
+  data.tar.gz: 514bc92b65f0934cbf31828e4553d6978d86932afa690f70b89a69ed6d6bbe71cb98e0d3bfbe86916e0c799498366eedcad2f74904f78be84fc3d559f43a8dd3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+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/README.md

@@ -0,0 +1,159 @@
+# Ruby Doom
+
+A Ruby gem that ports the classic Doom game to Ruby, focusing on core gameplay without sound or networking features.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'doom'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install 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:
+
+```bash
+# Show general information about a WAD file
+$ wad -i DOOM.WAD
+
+# List all maps in a WAD file
+$ wad -l DOOM.WAD
+
+# Show details for a specific map
+$ wad -m E1M1 DOOM.WAD
+
+# List all textures in a WAD file
+$ wad -t DOOM.WAD
+
+# Show details for a specific texture
+$ wad -x STARTAN1 DOOM.WAD
+
+# List all sprites in a WAD file
+$ wad -s DOOM.WAD
+
+# Show details for a specific sprite
+$ wad -p TROOA1 DOOM.WAD
+
+# Show help
+$ wad -h
+```
+
+#### Game Launcher
+
+The `doom` command allows you to start the game:
+
+```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
+```
+
+### 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(', ')}"
+```
+
+## Features
+
+### Phase 1: WAD File Loader
+
+- WAD file parsing
+- Map data extraction
+- Texture information parsing
+- Sprite data handling
+
+### Phase 2: Rendering Engine (Current)
+
+- Window management
+- BSP rendering
+- Texture mapping
+- Sprite rendering
+- HUD implementation
+- Basic game loop
+
+### Future Phases
+
+- Game mechanics
+- Advanced game loop and state management
+- Polishing
+
+## Development
+
+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.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/khasinski/doom-rb.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Legal
+
+Users must own a legal copy of Doom for the WAD files. This project complies with id Software's terms regarding Doom content.

data/bin/console

@@ -0,0 +1,15 @@
+#!/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/doom

@@ -0,0 +1,70 @@
+#!/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
+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
+  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
+  puts "Error: #{e.message}"
+  exit 1
+end

data/bin/setup

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

data/bin/wad

@@ -0,0 +1,152 @@
+#!/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

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

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

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