doom 0.6.0 → 0.11.0

data/lib/doom/wad_downloader.rb

@@ -9,7 +9,7 @@ module Doom
   class WadDownloader
     # Doom shareware WAD v1.9 (freely distributable)
     SHAREWARE_URL = 'https://raw.githubusercontent.com/Akbar30Bill/DOOM_wads/master/doom1.wad'
-    SHAREWARE_SIZE = 4_196_020  # Expected size in bytes
+    SHAREWARE_SIZE = 4_196_020 # Expected size in bytes
     SHAREWARE_FILENAME = 'doom1.wad'
 
     class DownloadError < StandardError; end
@@ -27,20 +27,18 @@ module Doom
       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
+      raise DownloadError, "WAD file not found: #{custom_path}" if custom_path
 
       prompt_and_download(home_wad)
     end
 
     def self.prompt_and_download(destination)
-      puts "No DOOM WAD file found."
+      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 '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] "
+      print 'Download shareware DOOM? [Y/n] '
 
       response = $stdin.gets&.strip&.downcase
       if response.nil? || response.empty? || response == 'y' || response == 'yes'
@@ -48,56 +46,22 @@ module Doom
         destination
       else
         puts
-        puts "To play DOOM, you need a WAD file. Options:"
+        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"
+        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..."
+      puts 'Downloading DOOM shareware...'
 
       # Create directory if needed
       FileUtils.mkdir_p(File.dirname(destination))
 
-      uri = URI.parse(SHAREWARE_URL)
-      downloaded = 0
-
-      ssl_opts = { use_ssl: uri.scheme == 'https' }
-      # Workaround for SSL certificate issues on some systems
-      begin
-        Net::HTTP.start(uri.host, uri.port, **ssl_opts) { |h| h.head(uri) }
-      rescue OpenSSL::SSL::SSLError
-        puts "SSL certificate verification failed, retrying without verification..."
-        ssl_opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
-      end
-
-      Net::HTTP.start(uri.host, uri.port, **ssl_opts) 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
+      download_from_url(SHAREWARE_URL, destination)
 
       puts
       puts "Downloaded to: #{destination}"
@@ -105,23 +69,41 @@ module Doom
 
       # 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
+      return unless actual_size < 1_000_000 # Less than 1MB is suspicious
+
+      File.delete(destination)
+      raise DownloadError, "Download appears incomplete (#{actual_size} bytes)"
     end
 
-    def self.download_from_url(url, destination)
+    # Fetch a URL to a destination file, following redirects and streaming a
+    # progress bar. Retries without SSL verification if the certificate cannot
+    # be verified (a workaround for broken system cert stores) -- and because
+    # the check runs here, it applies to redirect targets too, not just the
+    # first URL.
+    def self.download_from_url(url, destination, redirect_limit: 5)
+      raise DownloadError, 'Too many redirects' if redirect_limit.negative?
+
       uri = URI.parse(url)
-      downloaded = 0
+      ssl_opts = { use_ssl: uri.scheme == 'https' }
 
-      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      if ssl_opts[:use_ssl]
+        begin
+          Net::HTTP.start(uri.host, uri.port, **ssl_opts) { |h| h.head(uri) }
+        rescue OpenSSL::SSL::SSLError
+          puts 'SSL certificate verification failed, retrying without verification...'
+          ssl_opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+
+      downloaded = 0
+      Net::HTTP.start(uri.host, uri.port, **ssl_opts) 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)
+            return download_from_url(response['location'], destination,
+                                     redirect_limit: redirect_limit - 1)
           when Net::HTTPSuccess
             total_size = response['content-length']&.to_i || SHAREWARE_SIZE
 
@@ -143,7 +125,7 @@ module Doom
       percent = (downloaded.to_f / total * 100).to_i
       bar_width = 40
       filled = (percent * bar_width / 100)
-      bar = '=' * filled + '-' * (bar_width - filled)
+      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)"

data/lib/doom.rb

@@ -11,14 +11,43 @@ require_relative 'doom/wad/texture'
 require_relative 'doom/wad/sprite'
 require_relative 'doom/wad/hud_graphics'
 require_relative 'doom/map/data'
+require_relative 'doom/game/random'
+require_relative 'doom/game/geometry'
+require_relative 'doom/game/state_hash'
 require_relative 'doom/game/player_state'
+require_relative 'doom/game/player'
+require_relative 'doom/game/ticcmd'
+require_relative 'doom/game/player_physics'
 require_relative 'doom/game/sector_actions'
 require_relative 'doom/game/animations'
 require_relative 'doom/game/item_pickup'
 require_relative 'doom/game/combat'
 require_relative 'doom/game/sector_effects'
 require_relative 'doom/game/monster_ai'
+require_relative 'doom/game/world'
+require_relative 'doom/game/snapshot'
+require_relative 'doom/net/protocol'
+require_relative 'doom/net/transport'
+require_relative 'doom/net/desync_monitor'
+require_relative 'doom/net/lockstep'
+require_relative 'doom/net/session'
+require_relative 'doom/net/game_server'
+require_relative 'doom/net/client'
+require_relative 'doom/game/menu'
+require_relative 'doom/game/intermission'
+require_relative 'doom/wad/sound'
+require_relative 'doom/game/sound_engine'
+require_relative 'doom/render/font'
 require_relative 'doom/render/renderer'
+require_relative 'doom/render/zbuffer_renderer'
+require_relative 'doom/render/world_mesh'
+require_relative 'doom/render/hardware_renderer'
+require_relative 'doom/render/ray_tracing/bvh'
+require_relative 'doom/render/ray_tracing/material_state'
+require_relative 'doom/render/ray_tracing/texture_atlas'
+require_relative 'doom/render/ray_tracing_renderer'
+require_relative 'doom/render/renderer_factory'
+require_relative 'doom/render/screen_melt'
 require_relative 'doom/render/status_bar'
 require_relative 'doom/render/weapon_renderer'
 require_relative 'doom/platform/gosu_window'
@@ -27,11 +56,40 @@ module Doom
   class Error < StandardError; end
 
   class << self
-    def run(wad_path, map_name: 'E1M1')
+    def run(wad_path, map_name: 'E1M1', rubykaigi: false, net: nil, frag_limit: nil, renderer: :classic)
+      return run_server(wad_path, map_name, net, frag_limit) if net && net[:role] == :serve
+      return run_client(wad_path, map_name, net, renderer) if net && net[:role] == :join
+
+      session = build_session(net, map_name)
+      if session
+        # The host decides the map, seed and mode; a client is told them. Wait
+        # for that before loading anything, so both sides load the same level.
+        map_name = wait_for_session(session) || map_name
+      end
+
       puts "Loading WAD: #{wad_path}"
       wad = Wad::Reader.new(wad_path)
       puts "  #{wad.type}: #{wad.num_lumps} lumps"
 
+      # If it's a PWAD, we need a base IWAD for resources (palette, textures, etc.)
+      if wad.pwad?
+        iwad_path = find_iwad
+        unless iwad_path
+          raise Error,
+                'PWAD requires a base IWAD (doom1.wad). Place it in the current directory or ~/.doom/'
+        end
+
+        puts "  PWAD detected, loading base IWAD: #{iwad_path}"
+        base_wad = Wad::Reader.new(iwad_path)
+        base_wad.merge_pwad(wad)
+        wad = base_wad
+
+        # Auto-detect map name from PWAD lumps
+        pwad_map = wad.directory.find { |e| e.name =~ /^(E\dM\d|MAP\d\d)$/ }
+        map_name = pwad_map.name if pwad_map
+        puts "  Using map: #{map_name}"
+      end
+
       puts 'Loading palette...'
       palette = Wad::Palette.load(wad)
 
@@ -63,7 +121,7 @@ module Doom
         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)
+        Map::Thing.new(0, 0, 90, 1, 0)
       end
 
       puts 'Initializing animations...'
@@ -71,22 +129,187 @@ module Doom
       animations = Game::Animations.new(textures.texture_names, flat_names)
 
       puts 'Creating renderer...'
-      renderer = Render::Renderer.new(wad, map, textures, palette, colormap, flats, sprites, animations)
-      renderer.set_player(player_start.x, player_start.y, 41, player_start.angle)
+      # No initial camera pose needed: the world owns the player, and draw aims
+      # the camera at it every frame.
+      renderer = Render::RendererFactory.build(renderer, wad, map, textures, palette, colormap,
+                                               flats, sprites, animations)
 
-      puts 'Setting up player state and HUD...'
-      player_state = Game::PlayerState.new
+      puts 'Building world...'
+      sound_mgr = Wad::SoundManager.new(wad)
+      sound_engine = Game::SoundEngine.new(sound_mgr)
+      # One RNG shared by every subsystem that touches game state -- its index is
+      # part of the simulation, so all peers must draw from the same sequence.
+      # In a session the seed and mode come from the host, so every peer builds
+      # the same world; solo play picks its own.
+      random = Game::Random.new(session ? session.seed : 0)
+      world = Game::World.new(map, sprites: sprites, sound: sound_engine, random: random,
+                                   mode: session ? session.mode : :coop,
+                                   frag_limit: frag_limit)
+      ids = session ? session.player_ids : [0]
+      ids.each { |id| world.add_player(id: id) }
+      player = world.player(session ? session.local_id : 0)
+      player_state = player.state
+
+      puts 'Setting up HUD...'
       status_bar = Render::StatusBar.new(hud_graphics, player_state)
       weapon_renderer = Render::WeaponRenderer.new(hud_graphics, player_state)
-      sector_actions = Game::SectorActions.new(map)
-      sector_effects = Game::SectorEffects.new(map)
-      item_pickup = Game::ItemPickup.new(map, player_state)
-      combat = Game::Combat.new(map, player_state, sprites)
-      monster_ai = Game::MonsterAI.new(map, combat)
+      doom_font = Render::Font.new(wad, hud_graphics)
+      menu = Game::Menu.new(wad, hud_graphics, doom_font)
+      menu.instance_variable_set(:@state, Game::Menu::STATE_NONE) if ENV['DOOM_DEBUG_POSE']
+
+      # RubyKaigi mode: god mode, no aggression, benchmark HUD
+      if rubykaigi
+        menu.options[:rubykaigi_mode] = true
+        menu.options[:god_mode] = true
+      end
 
       puts 'Starting game window...'
-      window = Platform::GosuWindow.new(renderer, palette, map, player_state, status_bar, weapon_renderer, sector_actions, animations, sector_effects, item_pickup, combat, monster_ai)
+      window = Platform::GosuWindow.new(renderer, palette, world, status_bar, weapon_renderer,
+                                        animations, menu, sound_engine, session: session)
+      # A networked game skips the title screen: the other players are already
+      # waiting, and there is nothing to configure that the host has not set.
+      menu.instance_variable_set(:@state, Game::Menu::STATE_NONE) if session
       window.show
+    ensure
+      session&.quit
+    end
+
+    private
+
+    # Headless authoritative server. Loads only what the simulation needs (no
+    # renderer, HUD or window), then runs the tic loop forever, letting clients
+    # join, play and leave. The one place the engine runs without a display.
+    def run_server(wad_path, map_name, net, frag_limit)
+      wad = Wad::Reader.new(wad_path)
+      wad = merge_pwad_if_needed(wad) { |name| map_name = name }
+      sprites = Wad::SpriteManager.new(wad)
+      map = Map::MapData.load(wad, map_name)
+
+      world = Game::World.new(map, sprites: sprites, mode: net[:mode],
+                                   random: Game::Random.new, frag_limit: frag_limit)
+      transport = Net::Transport.new(port: net[:port])
+      server = Net::GameServer.new(world: world, transport: transport, max_players: net[:players])
+
+      puts "Serving #{net[:mode]} on #{map_name}, port #{transport.local_port}."
+      puts 'Players join with:  doom --join <this-host>:%d' % transport.local_port
+      puts 'Ctrl-C to stop.'
+
+      last_report = Time.now
+      loop do
+        server.poll
+        server.advance(limit: 8)
+        server.reap
+        now = Time.now
+        if now - last_report >= 2.0
+          puts "  tic #{server.tic}, #{server.player_count} players"
+          last_report = now
+        end
+        sleep 0.002
+      end
+    ensure
+      transport&.close
+    end
+
+    # Join an authoritative server. The world comes from the server as a
+    # snapshot, so we block on the join (there is nothing to render yet), then
+    # open a window that follows the server's frame stream instead of
+    # simulating locally.
+    def run_client(wad_path, _map_name, net, renderer_type)
+      wad = merge_pwad_if_needed(Wad::Reader.new(wad_path)) { |name| name }
+      palette = Wad::Palette.load(wad)
+      colormap = Wad::Colormap.load(wad)
+      flats = Wad::Flat.load_all(wad)
+      textures = Wad::TextureManager.new(wad)
+      sprites = Wad::SpriteManager.new(wad)
+      hud_graphics = Wad::HudGraphics.new(wad)
+      animations = Game::Animations.new(textures.texture_names, flats.map(&:name))
+      sound_engine = Game::SoundEngine.new(Wad::SoundManager.new(wad))
+
+      puts "Connecting to #{net[:host]}:#{net[:port]}..."
+      client = Net::Client.new(host: net[:host], port: net[:port], sprites: sprites,
+                               sound: sound_engine,
+                               load_map: ->(name) { Map::MapData.load(wad, name) })
+      wait_for_client(client)
+      puts "  Joined as player #{client.local_id}."
+
+      world = client.world
+      renderer = Render::RendererFactory.build(renderer_type, wad, world.map, textures, palette, colormap,
+                                               flats, sprites, animations)
+      player_state = world.player(client.local_id).state
+      status_bar = Render::StatusBar.new(hud_graphics, player_state)
+      weapon_renderer = Render::WeaponRenderer.new(hud_graphics, player_state)
+      menu = Game::Menu.new(wad, hud_graphics, Render::Font.new(wad, hud_graphics))
+      menu.instance_variable_set(:@state, Game::Menu::STATE_NONE)
+
+      window = Platform::GosuWindow.new(renderer, palette, world, status_bar, weapon_renderer,
+                                        animations, menu, sound_engine, client: client)
+      window.show
+    ensure
+      client&.quit
+    end
+
+    def wait_for_client(client, timeout: 30)
+      deadline = Time.now + timeout
+      until client.playing?
+        raise Error, 'timed out joining the server' if Time.now > deadline
+
+        client.poll
+        sleep 0.01
+      end
+    end
+
+    # Shared PWAD handling: if `wad` is a PWAD, merge it onto a base IWAD and
+    # yield the auto-detected map name. Returns the wad to use.
+    def merge_pwad_if_needed(wad)
+      return wad unless wad.pwad?
+
+      iwad_path = find_iwad
+      raise Error, 'PWAD requires a base IWAD (doom1.wad) in the current directory or ~/.doom/' unless iwad_path
+
+      base = Wad::Reader.new(iwad_path)
+      base.merge_pwad(wad)
+      pwad_map = base.directory.find { |e| e.name =~ /^(E\dM\d|MAP\d\d)$/ }
+      yield pwad_map.name if pwad_map && block_given?
+      base
+    end
+
+    def build_session(net, map_name)
+      return nil unless net
+
+      case net[:role]
+      when :host
+        puts "Hosting on port #{net[:port]}, waiting for #{net[:players]} players..."
+        Net::Session.host(port: net[:port], players: net[:players],
+                          map: map_name, mode: net[:mode])
+      when :client
+        puts "Connecting to #{net[:host]}:#{net[:port]}..."
+        Net::Session.connect(host: net[:host], port: net[:port])
+      end
+    end
+
+    # Block until the handshake finishes. This is the one place blocking is
+    # right: there is no game to render yet.
+    def wait_for_session(session, timeout: 120)
+      deadline = Time.now + timeout
+      until session.started?
+        raise Error, 'timed out waiting for the other players' if Time.now > deadline
+
+        session.poll
+        sleep 0.02
+      end
+
+      puts "  Joined as player #{session.local_id} of #{session.num_players} " \
+           "(#{session.mode}, map #{session.map_name})"
+      session.map_name
+    end
+
+    def find_iwad
+      candidates = [
+        File.join(Dir.pwd, 'doom1.wad'),
+        File.join(Dir.pwd, 'doom.wad'),
+        File.join(Dir.home, '.doom', 'doom1.wad')
+      ]
+      candidates.find { |p| File.exist?(p) }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: doom
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Chris Hasinski
@@ -23,6 +23,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opengl-bindings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -51,8 +79,36 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-description: A faithful port of the Doom (1993) rendering engine to Ruby. Supports
-  original WAD files with near pixel-perfect BSP rendering.
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.90'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.90'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.27'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.27'
+description: A faithful port of the Doom (1993) engine to Ruby with classic software
+  rendering, OpenGL rasterization, GPU ray tracing, and multiplayer.
 email:
 - krzysztof.hasinski@gmail.com
 executables:
@@ -60,21 +116,56 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - bin/doom
 - lib/doom.rb
+- lib/doom/benchmark.rb
 - lib/doom/game/animations.rb
 - lib/doom/game/combat.rb
+- lib/doom/game/framebuffer_blitter.rb
+- lib/doom/game/geometry.rb
+- lib/doom/game/intermission.rb
 - lib/doom/game/item_pickup.rb
+- lib/doom/game/menu.rb
 - lib/doom/game/monster_ai.rb
+- lib/doom/game/player.rb
+- lib/doom/game/player_physics.rb
 - lib/doom/game/player_state.rb
+- lib/doom/game/random.rb
 - lib/doom/game/sector_actions.rb
 - lib/doom/game/sector_effects.rb
+- lib/doom/game/snapshot.rb
+- lib/doom/game/sound_engine.rb
+- lib/doom/game/state_hash.rb
+- lib/doom/game/ticcmd.rb
+- lib/doom/game/world.rb
 - lib/doom/map/data.rb
+- lib/doom/net/client.rb
+- lib/doom/net/desync_monitor.rb
+- lib/doom/net/game_server.rb
+- lib/doom/net/lockstep.rb
+- lib/doom/net/protocol.rb
+- lib/doom/net/session.rb
+- lib/doom/net/transport.rb
 - lib/doom/platform/gosu_window.rb
+- lib/doom/platform/sdl.rb
+- lib/doom/platform/window_logic.rb
+- lib/doom/render/font.rb
+- lib/doom/render/hardware_renderer.rb
+- lib/doom/render/ray_tracing/bvh.rb
+- lib/doom/render/ray_tracing/material_state.rb
+- lib/doom/render/ray_tracing/texture_atlas.rb
+- lib/doom/render/ray_tracing_renderer.rb
 - lib/doom/render/renderer.rb
+- lib/doom/render/renderer_factory.rb
+- lib/doom/render/screen_melt.rb
+- lib/doom/render/spinel_native/kernel.rb
+- lib/doom/render/spinel_native_renderer.rb
 - lib/doom/render/status_bar.rb
 - lib/doom/render/weapon_renderer.rb
+- lib/doom/render/world_mesh.rb
+- lib/doom/render/zbuffer_renderer.rb
 - lib/doom/version.rb
 - lib/doom/wad/colormap.rb
 - lib/doom/wad/flat.rb
@@ -82,13 +173,15 @@ files:
 - lib/doom/wad/palette.rb
 - lib/doom/wad/patch.rb
 - lib/doom/wad/reader.rb
+- lib/doom/wad/sound.rb
 - lib/doom/wad/sprite.rb
 - lib/doom/wad/texture.rb
 - lib/doom/wad_downloader.rb
 homepage: https://github.com/khasinski/doom
 licenses:
-- GPL-2.0
-metadata: {}
+- GPL-2.0-only
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -103,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
-summary: Doom engine port in pure Ruby
+summary: Doom engine port with multiplayer and modern renderers
 test_files: []