doom 0.8.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e59cb32b1487d61b1c310ee5eae7ec30a702c64129c7fe5e18e1c06204d08208
-  data.tar.gz: f8f5450c3c37d661618234cf0abe80a5f0cd796aaa13694ee35d786ef25c5728
+  metadata.gz: e8f1be6b4e908fb60c850e5ac7e4e9d5ade8fff60fd7c9744d89da3132625e5a
+  data.tar.gz: bdbc30dcb9141292e4c6ae8d974b604b0d8cdb440dac964bc637615fd9cf53b4
 SHA512:
-  metadata.gz: 4a65c31832aff4838f924eb1263bda1f16ef6e820da9d776fa759656fdb9a58d83b2146ea30d5e0c236d1fc9e39206ad14312191f3bf5db70597cec815aef113
-  data.tar.gz: f6215f28a05e9924b9864f2f51d36cd694c4abfe7c0ad1618116486f62c72d26b0d7f609e945725b2218ee4b3e77e13eb3316153396977bf773673185d93ba40
+  metadata.gz: e5a2273db5baa4bb26c5d9d08cc78b734ef102d7b8d354a95109e44e72bb8deaf901b743aa59a9a3ff4f1770059d13b2e7069f3f8be5d6ccaec942b7b69d3053
+  data.tar.gz: 6cb2b7e235928e9a72ab95a87a44c7be3c84dbc0f59bcd45d7c0e40f0f3ebee54a46198baea930191b2355cc7a713e326d8c412354ab6eee103adf7ebe9bf5c9

data/LICENSE

@@ -0,0 +1,17 @@
+DOOM Ruby
+Copyright (C) 2025 Chris Hasinski
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of version 2 of the GNU General Public License as published by the
+Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+This matches the license of the original DOOM source release (GPL-2.0).
+
+The full text of the GNU General Public License, version 2, is available at:
+https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+
+SPDX-License-Identifier: GPL-2.0-only

data/README.md

@@ -1,12 +1,17 @@
 # DOOM Ruby
 
-A faithful port of the DOOM (1993) engine to pure Ruby. Renders the original WAD files with near pixel-perfect BSP rendering, full HUD, item pickups, and hitscan/projectile combat.
+A faithful port of the DOOM (1993) engine to Ruby. Play original WAD files with
+the classic software renderer, a hardware rasterizer, or a GPU ray tracer, in
+single-player or multiplayer.
 
 ![DOOM Ruby](demo.gif)
 
 ## Features
 
-- **Rendering**: BSP traversal, visplanes, drawsegs, sprite clipping, sky rendering matching Chocolate Doom
+- **Three renderers**: Classic BSP software rendering, OpenGL rasterization, and GPU ray tracing
+- **Dynamic lighting**: Projectile, explosion, emissive-floor, flashlight, shadow, and fog effects in the ray tracer
+- **Multiplayer**: Authoritative server/client play and deterministic peer-to-peer lockstep, with co-op and deathmatch
+- **Classic rendering**: BSP traversal, visplanes, drawsegs, sprite clipping, and sky rendering matching Chocolate Doom
 - **Combat**: Hitscan weapons (pistol, shotgun, chaingun), melee (fist, chainsaw), projectile rockets with splash damage
 - **Items**: Weapons, ammo, health, armor, keys -- all pickupable with correct DOOM behavior
 - **Movement**: Momentum-based physics with friction, smooth step transitions, wall sliding, view bob
@@ -50,14 +55,70 @@ doom /path/to/doom.wad
 | Space / E | Use (open doors) |
 | 1-7 | Switch weapons |
 | M | Toggle automap |
+| R | Cycle classic, rasterizer, and ray-tracing renderers |
 | Z | Toggle debug overlay |
 | Escape | Release mouse / Quit |
 
+## Renderers
+
+Select a renderer when starting the game:
+
+```bash
+doom --renderer=classic /path/to/doom.wad
+doom --renderer=rasterizer /path/to/doom.wad
+doom --renderer=raytracing /path/to/doom.wad
+```
+
+Press `R` during play to switch between them without restarting the simulation.
+
+- `classic` is the pixel-accurate software BSP renderer.
+- `rasterizer` builds a textured 3D world and draws it through Gosu's OpenGL context with a depth buffer.
+- `raytracing` traces primary, shadow, reflection, refraction, and indirect-light rays on the GPU using a stackless BVH. It includes dynamic lights, hard shadows, emissive nukage, fog, and a flashlight. It does not require dedicated hardware ray-intersection units.
+
+The ray tracer uses a hybrid raster pass for sprites. Its secondary rays are a
+single-bounce approximation rather than a converged path-traced image. Fog, the
+flashlight, and secondary rays can be toggled in the Options menu. See
+[Modern renderers](docs/modern-renderer.md) for implementation details and
+current limitations.
+
+## Multiplayer
+
+For an authoritative session suitable for more players over the internet, run
+a headless server and connect clients to it:
+
+```bash
+doom --serve --players=4 --port=5029 /path/to/doom.wad
+doom --join=server.example.com:5029 /path/to/doom.wad
+```
+
+For a small LAN, the original-style deterministic lockstep mode is also
+available:
+
+```bash
+doom --host --players=2 --port=5029 /path/to/doom.wad
+doom --connect=192.168.1.10:5029 /path/to/doom.wad
+```
+
+Add `--deathmatch` to host or serve a deathmatch. `--frags=N` sets its frag
+limit. Every participant must use the same WAD.
+
+## Frame rate
+
+Frame generation is decoupled from presentation: the engine renders as fast as
+it can and only presents to the display at its refresh rate, so the reported
+FPS is not clamped to vsync. The debug overlay (`Z`) shows both numbers --
+frames generated, and frames actually shown alongside the display's refresh
+rate.
+
+Turn it off with `UNCAPPED FPS` in the options menu, or start with `--vsync`
+to present every frame the old way.
+
 ## Requirements
 
 - Ruby 3.1+ (Ruby 4.0 with YJIT recommended for best performance)
-- Gosu gem (for window/graphics)
+- Gosu gem (for window, sound, and graphics)
 - SDL2 (native library required by Gosu)
+- OpenGL 3.3 or newer for the rasterizer and ray tracer
 
 ### Installing SDL2
 
@@ -134,7 +195,7 @@ please purchase DOOM from [Steam](https://store.steampowered.com/app/2280/Ultima
 
 ## License
 
-GPL-2.0 -- Same license as the original DOOM source code.
+GPL-2.0-only -- Same license as the original DOOM source code.
 
 ## Author
 

data/bin/doom

@@ -2,59 +2,169 @@
 # frozen_string_literal: true
 
 # Enable YJIT unless --no-yjit flag is passed (for live toggle demo)
-unless ARGV.delete('--no-yjit')
-  if defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enable)
-    RubyVM::YJIT.enable
-  end
+RubyVM::YJIT.enable if !ARGV.delete('--no-yjit') && defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enable)
+
+# Headless benchmark mode. Skips loading the full game stack (Gosu, sound,
+# menus, etc.) and runs the renderer in a tight loop. Self-contained: see
+# lib/doom/benchmark.rb.
+if ARGV.delete('--bench')
+  require_relative '../lib/doom/benchmark'
+  exit Doom::Benchmark.run(ARGV)
 end
 
 # Parse flags
 rubykaigi_mode = ARGV.delete('--rubykaigi') || ARGV.delete('--kaigi')
 
+# --native: run the real game with its renderer hot path compiled by
+# spinel_native (needs the spinel compiler; set SPINEL=/path/to/bin/spinel).
+ENV['DOOM_NATIVE'] = '1' if ARGV.delete('--native')
+
+# Multiplayer flags, parsed before the heavy requires so a bad invocation
+# fails fast rather than after a WAD load. Accepts --flag value and --flag=value.
+def take_flag(name)
+  idx = ARGV.index { |a| a == name || a.start_with?(name + '=') }
+  return nil unless idx
+
+  arg = ARGV.delete_at(idx)
+  return arg.split('=', 2).last if arg.include?('=')
+
+  ARGV.delete_at(idx)
+end
+
+renderer_name = take_flag('--renderer') || 'classic'
+
+# Parse a flag that must be a positive integer; fall back to `default` (with a
+# warning) if it is missing or malformed, so `--port foo` or `--frags -5` can't
+# silently mis-configure the session.
+def positive_int_flag(name, default)
+  raw = take_flag(name)
+  return default if raw.nil?
+
+  n = Integer(raw, exception: false)
+  return n if n&.positive?
+
+  warn "#{name}: expected a positive integer, got #{raw.inspect}; using #{default}"
+  default
+end
+
+net_host = ARGV.delete('--host')
+net_connect = take_flag('--connect')
+net_serve = ARGV.delete('--serve')
+net_join = take_flag('--join')
+net_port = positive_int_flag('--port', 5029)
+net_players = positive_int_flag('--players', 2)
+net_mode = ARGV.delete('--deathmatch') ? :deathmatch : :coop
+# Frag limit: 0 or absent means play on forever. Every peer has to pass the
+# same value -- it is not part of the handshake, only what the match reports.
+# --frags is optional; absent or malformed means no limit (nil).
+raw_frags = take_flag('--frags')
+net_frags = raw_frags && Integer(raw_frags, exception: false)
+net_frags = nil unless net_frags&.positive?
+
 # Parse arguments before loading heavy dependencies
 wad_path = ARGV.find { |a| !a.start_with?('-') }
 
+# Match the flags themselves, not the WAD argument: ARGV.find skips anything
+# starting with a dash, so `doom --help` never matched and fell through to
+# launching the game.
+wants_help = ARGV.include?('-h') || ARGV.include?('--help')
+wants_version = ARGV.include?('-v') || ARGV.include?('--version')
+
 # Show help (before loading anything)
-if wad_path == '-h' || wad_path == '--help'
-  puts "DOOM - Ruby port of the classic 1993 game"
+if wants_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 '  --bench        Run headless renderer benchmark (auto-downloads Freedoom)'
+  puts '                 Subflags: --json --frames=N --warmup=N --map=E1M1 --wad=PATH'
+  puts '  --vsync        Present every frame instead of uncapping generation'
+  puts '  --renderer NAME  Renderer: classic, rasterizer, or raytracing (R cycles them)'
+  puts
+  puts 'Multiplayer, authoritative server (for many players over the internet):'
+  puts '  --serve                Run a headless server others join (no window)'
+  puts '  --join HOST[:PORT]     Join a server'
   puts
-  puts "Usage: doom [OPTIONS] [WAD_FILE]"
+  puts 'Multiplayer, lockstep peer-to-peer (as in the original, for a small LAN):'
+  puts '  --host                 Host a game and wait for others to join'
+  puts '  --connect HOST[:PORT]  Join a hosted game'
   puts
-  puts "Options:"
-  puts "  -h, --help     Show this help message"
-  puts "  -v, --version  Show version"
+  puts '  --port N               Port to serve/host on or join/connect to (default 5029)'
+  puts '  --players N            Players to seat when serving or hosting (default 2)'
+  puts '  --deathmatch           Deathmatch instead of co-op'
+  puts '  --frags N              Frags to win a deathmatch (default: no limit)'
   puts
-  puts "If no WAD file is specified, doom will look for doom1.wad in:"
-  puts "  1. Current directory"
-  puts "  2. ~/.doom/"
+  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"
+  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
 
-if wad_path == '-v' || wad_path == '--version'
+if wants_version
   require_relative '../lib/doom/version'
   puts "DOOM Ruby v#{Doom::VERSION}"
   exit 0
 end
 
+# TruffleRuby on macOS: its Gosu build is not linked with SDL2, and macOS ships
+# only sdl2-compat, so preload it here (global) to satisfy Gosu's flat-namespace
+# symbol lookups. The window also needs the Cocoa main thread, which only the
+# JVM launch flag can give -- warn if it looks absent.
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'truffleruby' && RUBY_PLATFORM.include?('darwin')
+  begin
+    require 'fiddle'
+    %w[
+      /opt/homebrew/lib/libSDL2-2.0.0.dylib /opt/homebrew/lib/libSDL2.dylib
+      /usr/local/lib/libSDL2-2.0.0.dylib /usr/local/lib/libSDL2.dylib
+    ].each { |p| (Fiddle.dlopen(p); break) if File.exist?(p) }
+  rescue StandardError => e
+    warn "[doom] SDL2 preload for TruffleRuby failed (#{e.message}); the window may not open"
+  end
+  unless (ENV['JAVA_TOOL_OPTIONS'].to_s + ENV['TRUFFLERUBYOPT'].to_s).include?('XstartOnFirstThread')
+    warn "[doom] on TruffleRuby/macOS the window needs the main thread: run with " \
+         "`truffleruby --vm.XstartOnFirstThread bin/doom ...`"
+  end
+end
+
 # Now load the full library
 require_relative '../lib/doom'
 
 begin
   # Find or download WAD
   wad_path = Doom::WadDownloader.ensure_wad_available(wad_path)
-  Doom.run(wad_path, rubykaigi: rubykaigi_mode)
+  net = if net_serve
+          # Authoritative server for a big session: no window, just the tic
+          # loop and the clients that join it.
+          { role: :serve, port: net_port, players: net_players, mode: net_mode }
+        elsif net_join
+          host, _, port = net_join.rpartition(':')
+          host = net_join if host.empty?
+          { role: :join, host: host, port: port.empty? ? net_port : port.to_i }
+        elsif net_host
+          { role: :host, port: net_port, players: net_players, mode: net_mode }
+        elsif net_connect
+          host, _, port = net_connect.rpartition(':')
+          host = net_connect if host.empty?
+          { role: :client, host: host, port: port.empty? ? net_port : port.to_i }
+        end
+
+  Doom.run(wad_path, rubykaigi: rubykaigi_mode, net: net, frag_limit: net_frags,
+                     renderer: renderer_name)
 rescue Doom::WadDownloader::DownloadError => e
   puts "Error: #{e.message}"
   exit 1

data/lib/doom/benchmark.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+# Self-contained headless benchmark for the Doom-in-Ruby renderer.
+#
+# Designed to be extractable into a standalone benchmark repo: this file
+# requires the Doom library (renderer + WAD readers) and otherwise depends
+# only on Ruby's stdlib (net/http, json, zlib, fileutils).
+#
+# It auto-downloads Freedoom Phase 1 (~12MB zip, ~30MB extracted) on first
+# run and caches it under ~/.doom/freedoom1.wad. No window is opened.
+#
+# Usage:
+#   bin/doom --bench
+#   bin/doom --bench --json
+#   bin/doom --bench --frames=500 --warmup=50
+#   bin/doom --bench --wad=/path/to/some.wad
+#   bin/doom --bench --map=E1M3
+
+require 'json'
+require 'net/http'
+require 'uri'
+require 'fileutils'
+require 'zlib'
+
+# Stub Gosu so the renderer's Platform module can load without the gem.
+module Doom
+  module Platform
+    class GosuWindow; end unless defined?(GosuWindow)
+  end
+end
+
+require_relative 'wad/reader'
+require_relative 'wad/palette'
+require_relative 'wad/colormap'
+require_relative 'wad/flat'
+require_relative 'wad/patch'
+require_relative 'wad/texture'
+require_relative 'wad/sprite'
+require_relative 'map/data'
+require_relative 'game/player_state'
+require_relative 'game/sector_actions'
+require_relative 'render/renderer'
+
+module Doom
+  module Benchmark
+    FREEDOOM_VERSION = '0.13.0'
+    FREEDOOM_URL =
+      'https://github.com/freedoom/freedoom/releases/download/' \
+      "v#{FREEDOOM_VERSION}/freedoom-#{FREEDOOM_VERSION}.zip"
+    FREEDOOM_WAD_BASENAME = 'freedoom1.wad'
+    CACHE_DIR = File.join(Dir.home, '.doom')
+
+    DEFAULT_WARMUP = 30
+    DEFAULT_FRAMES = 200
+    DEFAULT_MAP = 'E1M1'
+
+    module_function
+
+    # Entry point. argv is what came after --bench.
+    # Returns process exit code.
+    def run(argv = [])
+      opts = parse_args(argv)
+      wad_path = opts[:wad] || ensure_freedoom_wad
+
+      game = load_game(wad_path, opts[:map])
+      result = bench_render(game, frames: opts[:frames], warmup: opts[:warmup])
+
+      result[:wad] = File.basename(wad_path)
+      result[:map] = opts[:map]
+      result[:ruby] = RUBY_DESCRIPTION
+      result[:jit] = jit_status
+
+      print_result(result, json: opts[:json])
+      0
+    rescue StandardError => e
+      warn "benchmark failed: #{e.class}: #{e.message}"
+      warn e.backtrace.first(10).join("\n")
+      1
+    end
+
+    def parse_args(argv)
+      opts = {
+        warmup: DEFAULT_WARMUP,
+        frames: DEFAULT_FRAMES,
+        map: DEFAULT_MAP,
+        wad: nil,
+        json: false
+      }
+      argv.each do |arg|
+        case arg
+        when '--json' then opts[:json] = true
+        when /\A--frames=(\d+)\z/ then opts[:frames] = Regexp.last_match(1).to_i
+        when /\A--warmup=(\d+)\z/ then opts[:warmup] = Regexp.last_match(1).to_i
+        when /\A--map=(\w+)\z/ then opts[:map] = Regexp.last_match(1).upcase
+        when /\A--wad=(.+)\z/ then opts[:wad] = Regexp.last_match(1)
+        end
+      end
+      opts
+    end
+
+    def jit_status
+      if defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enabled?) && RubyVM::YJIT.enabled?
+        'YJIT'
+      elsif defined?(RubyVM::ZJIT) && RubyVM::ZJIT.respond_to?(:enabled?) && RubyVM::ZJIT.enabled?
+        'ZJIT'
+      else
+        'OFF'
+      end
+    end
+
+    def ensure_freedoom_wad
+      cached = File.join(CACHE_DIR, FREEDOOM_WAD_BASENAME)
+      return cached if File.exist?(cached)
+
+      FileUtils.mkdir_p(CACHE_DIR)
+      tmp_zip = File.join(CACHE_DIR, "freedoom-#{FREEDOOM_VERSION}.zip.part")
+
+      warn "Downloading Freedoom Phase 1 v#{FREEDOOM_VERSION} (~12 MB)..."
+      download_file(FREEDOOM_URL, tmp_zip)
+
+      warn "Extracting #{FREEDOOM_WAD_BASENAME}..."
+      extract_from_zip(tmp_zip, FREEDOOM_WAD_BASENAME, cached)
+      File.delete(tmp_zip) if File.exist?(tmp_zip)
+
+      cached
+    end
+
+    # Download URL to dest, following redirects.
+    def download_file(url, dest, redirect_limit: 5)
+      raise 'too many redirects' if redirect_limit < 0
+
+      uri = URI.parse(url)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.request_get(uri.request_uri) do |resp|
+          case resp
+          when Net::HTTPSuccess
+            File.open(dest, 'wb') { |f| resp.read_body { |chunk| f.write(chunk) } }
+          when Net::HTTPRedirection
+            return download_file(resp['location'], dest, redirect_limit: redirect_limit - 1)
+          else
+            raise "HTTP #{resp.code} fetching #{url}"
+          end
+        end
+      end
+    end
+
+    # Minimal ZIP reader: locate one named file in a ZIP archive and extract
+    # it to dest. Supports stored (method 0) and deflated (method 8) entries.
+    # No ZIP64, no encryption, no spanning. Sufficient for the Freedoom zip.
+    def extract_from_zip(zip_path, target_basename, dest)
+      data = File.binread(zip_path)
+
+      eocd = find_eocd(data) or raise "ZIP end-of-central-directory not found in #{zip_path}"
+      _, _, _, _, _, _, cdir_offset, = data.byteslice(eocd, 22).unpack('VvvvvVVv')
+
+      ptr = cdir_offset
+      while data.byteslice(ptr, 4) == "PK\x01\x02".b
+        fields = data.byteslice(ptr, 46).unpack('VvvvvvvVVVvvvvvVV')
+        method = fields[4]
+        csize = fields[8]
+        fname_len = fields[10]
+        extra_len = fields[11]
+        comment_len = fields[12]
+        local_offset = fields[16]
+        fname = data.byteslice(ptr + 46, fname_len)
+
+        if File.basename(fname) == target_basename
+          lh = data.byteslice(local_offset, 30).unpack('VvvvvvVVVvv')
+          lh_fname_len = lh[9]
+          lh_extra_len = lh[10]
+          data_offset = local_offset + 30 + lh_fname_len + lh_extra_len
+          compressed = data.byteslice(data_offset, csize)
+
+          content = case method
+                    when 0 then compressed
+                    when 8 then Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(compressed)
+                    else raise "unsupported ZIP compression method #{method}"
+                    end
+
+          File.binwrite(dest, content)
+          return
+        end
+
+        ptr += 46 + fname_len + extra_len + comment_len
+      end
+
+      raise "#{target_basename} not found in #{zip_path}"
+    end
+
+    # EOCD record sits at the end of the file. Search backwards through the
+    # last 64KB (max comment size).
+    def find_eocd(data)
+      sig = "PK\x05\x06".b
+      max = data.size - 22
+      min = [max - 65_536, 0].max
+      max.downto(min) { |i| return i if data.byteslice(i, 4) == sig }
+      nil
+    end
+
+    def load_game(wad_path, map_name)
+      wad = Doom::Wad::Reader.new(wad_path)
+      palette = Doom::Wad::Palette.load(wad)
+      colormap = Doom::Wad::Colormap.load(wad)
+      flats = Doom::Wad::Flat.load_all(wad)
+      textures = Doom::Wad::TextureManager.new(wad)
+      sprites = Doom::Wad::SpriteManager.new(wad)
+      map = Doom::Map::MapData.load(wad, map_name)
+
+      renderer = Doom::Render::Renderer.new(
+        wad, map, textures, palette, colormap, flats, sprites
+      )
+      renderer.skip_background_fill = true
+
+      ps = map.player_start
+      renderer.set_player(ps.x, ps.y, 41, ps.angle)
+
+      { renderer: renderer, player_start: ps }
+    end
+
+    def bench_render(game, frames:, warmup:)
+      renderer = game[:renderer]
+
+      warmup.times { renderer.render_frame }
+
+      GC.start
+      GC.compact if GC.respond_to?(:compact)
+
+      gc_before = total_allocs
+      times = Array.new(frames)
+      frames.times do |i|
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        renderer.render_frame
+        t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        times[i] = t1 - t0
+      end
+      gc_after = total_allocs
+
+      sorted = times.sort
+      total = times.sum
+      {
+        frames: frames,
+        warmup: warmup,
+        avg_ms: (total / frames) * 1000,
+        median_ms: sorted[frames / 2] * 1000,
+        p95_ms: sorted[(frames * 0.95).to_i] * 1000,
+        p99_ms: sorted[(frames * 0.99).to_i] * 1000,
+        min_ms: sorted.first * 1000,
+        max_ms: sorted.last * 1000,
+        fps: frames / total,
+        allocs_per_frame: (gc_after - gc_before).to_f / frames
+      }
+    end
+
+    def total_allocs
+      GC.stat[:total_allocated_objects] || 0
+    rescue StandardError
+      0
+    end
+
+    def print_result(r, json:)
+      if json
+        puts JSON.generate(r)
+        return
+      end
+
+      puts 'DOOM-Ruby benchmark'
+      puts "  WAD:    #{r[:wad]} (#{r[:map]})"
+      puts "  Ruby:   #{r[:ruby]}"
+      puts "  JIT:    #{r[:jit]}"
+      puts ''
+      puts "Performance (#{r[:frames]} frames after #{r[:warmup]} warmup):"
+      puts '  avg     %.2f ms' % r[:avg_ms]
+      puts '  median  %.2f ms' % r[:median_ms]
+      puts '  p95     %.2f ms' % r[:p95_ms]
+      puts '  p99     %.2f ms' % r[:p99_ms]
+      puts '  min     %.2f ms' % r[:min_ms]
+      puts '  max     %.2f ms' % r[:max_ms]
+      puts '  fps     %.1f' % r[:fps]
+      puts '  allocs/frame  %.0f' % r[:allocs_per_frame] if r[:allocs_per_frame] > 0
+    end
+  end
+end

data/lib/doom/game/animations.rb

@@ -37,7 +37,7 @@ module Doom
         [true, 'BFALL1',   'BFALL4'],
         [true, 'SFALL1',   'SFALL4'],
         [true, 'WFALL1',   'WFALL4'],
-        [true, 'DBRAIN1',  'DBRAIN4'],
+        [true, 'DBRAIN1',  'DBRAIN4']
       ].freeze
 
       attr_reader :flat_translation, :texture_translation
@@ -61,7 +61,7 @@ module Doom
           @anims << {
             is_texture: is_texture,
             frames: frames,
-            speed: TICS_PER_FRAME,
+            speed: TICS_PER_FRAME
           }
         end
       end
@@ -92,6 +92,13 @@ module Doom
       def translate_texture(name)
         @texture_translation[name] || name
       end
+
+      # Every frame that may be selected later. Renderers use this while
+      # building immutable texture atlases, including when the first draw
+      # happens in a menu before update has populated the translations.
+      def frame_names
+        @anims.flat_map { |animation| animation[:frames] }.uniq
+      end
     end
   end
 end