quake-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 76a4b7671e6182b04a0257b7ad6a229cefc9e5dc2e3c763529327e376b910f80
+  data.tar.gz: d855437be72bfaec56741b68bfd0497c578d21e67501c8383164f3c8ebd9abd6
+SHA512:
+  metadata.gz: 83f646634ab2dafd538fa3ab73814218871e01f0e09c2a10108f5a487e4d70476cfba4cccd15269887ee8f9ce05720b0c65739dd76f793b959f419b4bd1ce5ea
+  data.tar.gz: 877663d022ddfedb05cd9c0b3b630d04dcfdef084345f0e4183ea22733d351f87968105e062567efa090ca3d147ad8df8d9c46dbfdb65f3f8a71ec60761cfa61

data/bin/quake

@@ -0,0 +1,143 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+STDOUT.sync = true
+
+require_relative "../lib/quake"
+require_relative "../lib/quake/pak_downloader"
+require_relative "../lib/quake/window"
+require_relative "../lib/quake/camera"
+require_relative "../lib/quake/renderer/gl_wireframe"
+require_relative "../lib/quake/renderer/gl_texture_manager"
+require_relative "../lib/quake/renderer/gl_lightmap"
+require_relative "../lib/quake/renderer/gl_textured"
+require_relative "../lib/quake/renderer/gl_sky"
+require_relative "../lib/quake/renderer/gl_water"
+require_relative "../lib/quake/renderer/gl_brush_model"
+require_relative "../lib/quake/renderer/gl_alias_model"
+require_relative "../lib/quake/renderer/gl_viewmodel"
+require_relative "../lib/quake/renderer/gl_particles"
+require_relative "../lib/quake/renderer/gl_hud"
+require_relative "../lib/quake/wad/reader"
+require_relative "../lib/quake/game/player_state"
+require_relative "../lib/quake/game/item_pickups"
+require_relative "../lib/quake/sound/mixer"
+require_relative "../lib/quake/sound/events"
+require_relative "../lib/quake/game/engine"
+
+# Parse args
+if ARGV.include?("-v") || ARGV.include?("--version")
+  puts "quake-rb v#{Quake::VERSION}"
+  exit 0
+end
+
+basedir = ARGV.include?("-basedir") ? ARGV[ARGV.index("-basedir") + 1] : nil
+map_name = ARGV.include?("-map") ? ARGV[ARGV.index("-map") + 1] : "maps/e1m1.bsp"
+noclip = ARGV.include?("--noclip")
+
+if ARGV.include?("--yjit")
+  RubyVM::YJIT.enable
+  puts "YJIT enabled"
+elsif ARGV.include?("--zjit")
+  RubyVM::ZJIT.enable
+  puts "ZJIT enabled"
+end
+
+begin
+  basedir = Quake::PakDownloader.ensure_pak_available(basedir)
+rescue Quake::PakDownloader::DownloadError => e
+  warn "Error: #{e.message}"
+  exit 1
+end
+
+pak_path = File.join(basedir, "id1", "pak0.pak")
+
+engine = Quake::Game::Engine.new(
+  pak_path: pak_path,
+  window_visible: true,
+  enable_sound: true
+)
+engine.load_map(map_name)
+engine.player.noclip = noclip
+
+window = engine.window
+keys = {}
+running = true
+last_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+puts "Controls: WASD = move, Mouse = look, Space = jump, C = crouch, N = noclip, 1-8/scroll = weapons, ESC = quit"
+puts "Movement mode: #{noclip ? 'noclip' : 'normal'}"
+
+while running
+  now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  dt = [now - last_time, 0.05].min
+  last_time = now
+
+  window.poll_events do |event|
+    case event[:type]
+    when SDL::QUIT
+      running = false
+    when SDL::KEYDOWN
+      scancode = event[:key][:keysym][:scancode]
+      keys[scancode] = true
+      running = false if scancode == SDL::SCANCODE_ESCAPE
+      if scancode == SDL::SCANCODE_N
+        engine.player.noclip = !engine.player.noclip
+        puts "Noclip: #{engine.player.noclip ? 'ON' : 'OFF'}"
+      end
+      if scancode == SDL::SCANCODE_L
+        p = engine.player.position
+        leaf_idx = Quake::Bsp::Vis.point_in_leaf(engine.level, p)
+        leaf = engine.level.leafs[leaf_idx]
+        contents = case leaf&.contents
+                   when -1 then "EMPTY"
+                   when -2 then "SOLID"
+                   when -3 then "WATER"
+                   when -4 then "SLIME"
+                   when -5 then "LAVA"
+                   else leaf&.contents.to_s
+                   end
+        ts = Time.now.strftime("%H%M%S")
+        shot = "debug/shots/live_#{ts}.png"
+        engine.screenshot(shot)
+        puts "[log] pos=(#{p.x.round(1)}, #{p.y.round(1)}, #{p.z.round(1)}) " \
+             "yaw=#{engine.player.yaw.round(1)} pitch=#{engine.player.pitch.round(1)} " \
+             "leaf=#{leaf_idx} contents=#{contents} water_level=#{engine.player.water_level} " \
+             "shot=#{shot}"
+      end
+
+      weapon_slot = case scancode
+                    when SDL::SCANCODE_1 then 1
+                    when SDL::SCANCODE_2 then 2
+                    when SDL::SCANCODE_3 then 3
+                    when SDL::SCANCODE_4 then 4
+                    when SDL::SCANCODE_5 then 5
+                    when SDL::SCANCODE_6 then 6
+                    when SDL::SCANCODE_7 then 7
+                    when SDL::SCANCODE_8 then 8
+                    end
+      if weapon_slot
+        engine.player_state.select_weapon(weapon_slot)
+        engine.viewmodel&.set_weapon(engine.player_state.current_weapon_model)
+      end
+    when SDL::KEYUP
+      scancode = event[:key][:keysym][:scancode]
+      keys[scancode] = false
+    when SDL::MOUSEWHEEL
+      if event[:wheel][:y] > 0
+        engine.player_state.next_weapon
+      elsif event[:wheel][:y] < 0
+        engine.player_state.prev_weapon
+      end
+      engine.viewmodel&.set_weapon(engine.player_state.current_weapon_model)
+    when SDL::MOUSEMOTION
+      engine.player.rotate(event[:motion][:xrel], event[:motion][:yrel])
+    end
+  end
+
+  engine.set_keys(keys)
+  engine.tick(dt)
+  engine.swap_buffers
+end
+
+engine.shutdown

data/bin/quake-debug

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# Headless debug runner for Quake. Executes a script that drives the
+# engine without user input, captures screenshots, and dumps state.
+#
+# Usage:
+#   bin/quake-debug script.rb [options]
+#
+# Options:
+#   --visible       Show the window (default: hidden)
+#   --width N       Window width (default: 640)
+#   --height N      Window height (default: 360)
+#   --no-sound      Disable sound (default: disabled in debug)
+
+require_relative "../lib/quake"
+require_relative "../lib/quake/window"
+require_relative "../lib/quake/camera"
+require_relative "../lib/quake/renderer/gl_texture_manager"
+require_relative "../lib/quake/renderer/gl_lightmap"
+require_relative "../lib/quake/renderer/gl_textured"
+require_relative "../lib/quake/renderer/gl_sky"
+require_relative "../lib/quake/renderer/gl_water"
+require_relative "../lib/quake/renderer/gl_brush_model"
+require_relative "../lib/quake/renderer/gl_alias_model"
+require_relative "../lib/quake/renderer/gl_viewmodel"
+require_relative "../lib/quake/renderer/gl_particles"
+require_relative "../lib/quake/renderer/gl_hud"
+require_relative "../lib/quake/wad/reader"
+require_relative "../lib/quake/game/player_state"
+require_relative "../lib/quake/game/item_pickups"
+require_relative "../lib/quake/sound/mixer"
+require_relative "../lib/quake/sound/events"
+require_relative "../lib/quake/game/engine"
+require_relative "../lib/quake/debug/script"
+
+script_path = ARGV.find { |a| !a.start_with?("--") }
+unless script_path
+  warn "Usage: bin/quake-debug <script.rb> [--visible] [--width N] [--height N]"
+  exit 1
+end
+
+unless File.exist?(script_path)
+  warn "Script not found: #{script_path}"
+  exit 1
+end
+
+visible = ARGV.include?("--visible")
+enable_sound = !ARGV.include?("--no-sound") && visible # sound off by default in debug
+
+width_idx = ARGV.index("--width")
+height_idx = ARGV.index("--height")
+width = width_idx ? ARGV[width_idx + 1].to_i : 640
+height = height_idx ? ARGV[height_idx + 1].to_i : 360
+
+basedir = ARGV.include?("-basedir") ? ARGV[ARGV.index("-basedir") + 1] : "data"
+pak_path = File.join(basedir, "id1", "pak0.pak")
+
+puts "[quake-debug] window=#{width}x#{height} visible=#{visible} sound=#{enable_sound}"
+puts "[quake-debug] pak=#{pak_path}"
+puts "[quake-debug] script=#{script_path}"
+
+engine = Quake::Game::Engine.new(
+  pak_path: pak_path,
+  window_visible: visible,
+  window_width: width,
+  window_height: height,
+  enable_sound: enable_sound
+)
+
+dsl = Quake::Debug::Script.new(engine)
+
+begin
+  dsl.run_file(script_path)
+rescue => e
+  warn "[quake-debug] Script failed: #{e.class}: #{e.message}"
+  warn e.backtrace.first(10).join("\n")
+  exit 1
+ensure
+  engine.shutdown
+end
+
+puts "[quake-debug] done"

data/lib/quake/bsp/face_vertices.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Quake
+  module Bsp
+    module FaceVertices
+      def self.extract(level, face)
+        verts = Array.new(face.num_edges)
+        face.num_edges.times do |i|
+          surfedge = level.surfedges[face.first_edge + i]
+          if surfedge >= 0
+            edge = level.edges[surfedge]
+            verts[i] = level.vertices[edge.v0]
+          else
+            edge = level.edges[-surfedge]
+            verts[i] = level.vertices[edge.v1]
+          end
+        end
+        verts
+      end
+
+      # Extract vertices + texture coordinates for a face
+      # Returns a Surface with vertices, texcoords, and texinfo_index
+      def self.extract_surface(level, face)
+        texinfo = level.texinfo[face.texinfo_index]
+        texture = level.textures[texinfo.miptex_index] if texinfo
+
+        verts = Array.new(face.num_edges)
+        texcoords = Array.new(face.num_edges)
+
+        tex_w = (texture&.width || 64).to_f
+        tex_h = (texture&.height || 64).to_f
+
+        face.num_edges.times do |i|
+          surfedge = level.surfedges[face.first_edge + i]
+          if surfedge >= 0
+            edge = level.edges[surfedge]
+            v = level.vertices[edge.v0]
+          else
+            edge = level.edges[-surfedge]
+            v = level.vertices[edge.v1]
+          end
+
+          verts[i] = v
+
+          if texinfo
+            u = v.dot(texinfo.s_vec) + texinfo.s_offset
+            u /= tex_w
+
+            t = v.dot(texinfo.t_vec) + texinfo.t_offset
+            t /= tex_h
+
+            texcoords[i] = [u, t]
+          else
+            texcoords[i] = [0.0, 0.0]
+          end
+        end
+
+        Surface.new(vertices: verts, texcoords: texcoords,
+                    texinfo_index: face.texinfo_index)
+      end
+    end
+  end
+end

data/lib/quake/bsp/reader.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Quake
+  module Bsp
+    class Reader
+      BSP_VERSION = 29
+
+      LUMP_ENTITIES     = 0
+      LUMP_PLANES       = 1
+      LUMP_TEXTURES     = 2
+      LUMP_VERTICES     = 3
+      LUMP_VISIBILITY   = 4
+      LUMP_NODES        = 5
+      LUMP_TEXINFO      = 6
+      LUMP_FACES        = 7
+      LUMP_LIGHTING     = 8
+      LUMP_CLIPNODES    = 9
+      LUMP_LEAFS        = 10
+      LUMP_MARKSURFACES = 11
+      LUMP_EDGES        = 12
+      LUMP_SURFEDGES    = 13
+      LUMP_MODELS       = 14
+
+      NUM_LUMPS = 15
+
+      def initialize(data)
+        @data = data
+        @lumps = []
+      end
+
+      def parse
+        parse_header
+
+        Level.new(
+          vertices:     parse_vertices,
+          edges:        parse_edges,
+          faces:        parse_faces,
+          surfedges:    parse_surfedges,
+          planes:       parse_planes,
+          nodes:        parse_nodes,
+          leafs:        parse_leafs,
+          clipnodes:    parse_clipnodes,
+          texinfo:      parse_texinfo,
+          models:       parse_models,
+          marksurfaces: parse_marksurfaces,
+          entities:     parse_entities,
+          visibility:   parse_visibility,
+          lighting:     parse_lighting,
+          textures:     parse_textures
+        )
+      end
+
+      private
+
+      def parse_header
+        version = @data[0, 4].unpack1("l<")
+        raise "Unsupported BSP version: #{version} (expected #{BSP_VERSION})" unless version == BSP_VERSION
+
+        NUM_LUMPS.times do |i|
+          offset = 4 + i * 8
+          fileofs, filelen = @data[offset, 8].unpack("l<2")
+          @lumps << [fileofs, filelen]
+        end
+      end
+
+      def lump_data(index)
+        offset, length = @lumps[index]
+        @data[offset, length]
+      end
+
+      def parse_vertices
+        data = lump_data(LUMP_VERTICES)
+        count = data.bytesize / 12
+        result = Array.new(count)
+        count.times do |i|
+          x, y, z = data[i * 12, 12].unpack("e3")
+          result[i] = Math::Vec3.new(x, y, z)
+        end
+        result
+      end
+
+      def parse_edges
+        data = lump_data(LUMP_EDGES)
+        count = data.bytesize / 4
+        result = Array.new(count)
+        count.times do |i|
+          v0, v1 = data[i * 4, 4].unpack("v2")
+          result[i] = Edge.new(v0:, v1:)
+        end
+        result
+      end
+
+      def parse_faces
+        data = lump_data(LUMP_FACES)
+        count = data.bytesize / 20
+        result = Array.new(count)
+        count.times do |i|
+          raw = data[i * 20, 20]
+          plane_idx, side, first_edge, num_edges, texinfo_idx,
+            s0, s1, s2, s3, light_ofs = raw.unpack("s<2l<s<2C4l<")
+          result[i] = Face.new(
+            plane_index: plane_idx, side: side,
+            first_edge: first_edge, num_edges: num_edges,
+            texinfo_index: texinfo_idx, styles: [s0, s1, s2, s3],
+            light_offset: light_ofs
+          )
+        end
+        result
+      end
+
+      def parse_surfedges
+        data = lump_data(LUMP_SURFEDGES)
+        data.unpack("l<*")
+      end
+
+      def parse_planes
+        data = lump_data(LUMP_PLANES)
+        count = data.bytesize / 20
+        result = Array.new(count)
+        count.times do |i|
+          nx, ny, nz, dist, type = data[i * 20, 20].unpack("e4l<")
+          result[i] = Plane.new(
+            normal: Math::Vec3.new(nx, ny, nz), dist: dist, type: type
+          )
+        end
+        result
+      end
+
+      def parse_nodes
+        data = lump_data(LUMP_NODES)
+        count = data.bytesize / 24
+        result = Array.new(count)
+        count.times do |i|
+          raw = data[i * 24, 24]
+          plane_idx, c0, c1,
+            minx, miny, minz, maxx, maxy, maxz,
+            first_face, num_faces = raw.unpack("l<s<2s<6v2")
+          result[i] = Node.new(
+            plane_index: plane_idx,
+            children: [c0, c1],
+            mins: Math::Vec3.new(minx.to_f, miny.to_f, minz.to_f),
+            maxs: Math::Vec3.new(maxx.to_f, maxy.to_f, maxz.to_f),
+            first_face: first_face, num_faces: num_faces
+          )
+        end
+        result
+      end
+
+      def parse_leafs
+        data = lump_data(LUMP_LEAFS)
+        count = data.bytesize / 28
+        result = Array.new(count)
+        count.times do |i|
+          raw = data[i * 28, 28]
+          contents, visofs,
+            minx, miny, minz, maxx, maxy, maxz,
+            first_ms, num_ms,
+            a0, a1, a2, a3 = raw.unpack("l<2s<6v2C4")
+          result[i] = Leaf.new(
+            contents: contents, vis_offset: visofs,
+            mins: Math::Vec3.new(minx.to_f, miny.to_f, minz.to_f),
+            maxs: Math::Vec3.new(maxx.to_f, maxy.to_f, maxz.to_f),
+            first_marksurface: first_ms, num_marksurfaces: num_ms,
+            ambient_levels: [a0, a1, a2, a3]
+          )
+        end
+        result
+      end
+
+      def parse_clipnodes
+        data = lump_data(LUMP_CLIPNODES)
+        count = data.bytesize / 8
+        result = Array.new(count)
+        count.times do |i|
+          plane_idx, c0, c1 = data[i * 8, 8].unpack("l<s<2")
+          result[i] = ClipNode.new(plane_index: plane_idx, children: [c0, c1])
+        end
+        result
+      end
+
+      def parse_texinfo
+        data = lump_data(LUMP_TEXINFO)
+        count = data.bytesize / 40
+        result = Array.new(count)
+        count.times do |i|
+          raw = data[i * 40, 40]
+          floats = raw[0, 32].unpack("e8")
+          miptex, flags = raw[32, 8].unpack("l<2")
+          result[i] = TexInfo.new(
+            s_vec: Math::Vec3.new(floats[0], floats[1], floats[2]),
+            s_offset: floats[3],
+            t_vec: Math::Vec3.new(floats[4], floats[5], floats[6]),
+            t_offset: floats[7],
+            miptex_index: miptex, flags: flags
+          )
+        end
+        result
+      end
+
+      def parse_models
+        data = lump_data(LUMP_MODELS)
+        count = data.bytesize / 64
+        result = Array.new(count)
+        count.times do |i|
+          raw = data[i * 64, 64]
+          floats = raw[0, 36].unpack("e9")
+          ints = raw[36, 28].unpack("l<7")
+          result[i] = Model.new(
+            mins: Math::Vec3.new(floats[0], floats[1], floats[2]),
+            maxs: Math::Vec3.new(floats[3], floats[4], floats[5]),
+            origin: Math::Vec3.new(floats[6], floats[7], floats[8]),
+            head_nodes: ints[0..3],
+            vis_leafs: ints[4],
+            first_face: ints[5], num_faces: ints[6]
+          )
+        end
+        result
+      end
+
+      def parse_marksurfaces
+        data = lump_data(LUMP_MARKSURFACES)
+        data.unpack("v*")
+      end
+
+      def parse_entities
+        lump_data(LUMP_ENTITIES)&.force_encoding("ASCII")&.delete("\0") || ""
+      end
+
+      def parse_visibility
+        lump_data(LUMP_VISIBILITY) || ""
+      end
+
+      def parse_lighting
+        lump_data(LUMP_LIGHTING) || ""
+      end
+
+      def parse_textures
+        data = lump_data(LUMP_TEXTURES)
+        return [] if data.nil? || data.bytesize < 4
+
+        num_miptex = data[0, 4].unpack1("l<")
+        offsets = data[4, num_miptex * 4].unpack("l<#{num_miptex}")
+
+        offsets.map do |ofs|
+          if ofs < 0
+            nil
+          else
+            raw = data[ofs, 40]
+            next nil if raw.nil? || raw.bytesize < 40
+            name = raw[0, 16].unpack1("Z16")
+            width, height = raw[16, 8].unpack("V2")
+            mip_offsets = raw[24, 16].unpack("V4")
+            # Extract mip level 0 pixel data (8-bit indexed)
+            pixel_offset = ofs + mip_offsets[0]
+            pixel_count = width * height
+            pixels = data[pixel_offset, pixel_count]
+            MipTex.new(name: name, width: width, height: height,
+                       offsets: mip_offsets, pixels: pixels)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quake/bsp/types.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Quake
+  module Bsp
+    Edge      = Data.define(:v0, :v1)
+    Face      = Data.define(:plane_index, :side, :first_edge, :num_edges,
+                            :texinfo_index, :styles, :light_offset)
+    Plane     = Data.define(:normal, :dist, :type)
+    Node      = Data.define(:plane_index, :children, :mins, :maxs,
+                            :first_face, :num_faces)
+    Leaf      = Data.define(:contents, :vis_offset, :mins, :maxs,
+                            :first_marksurface, :num_marksurfaces, :ambient_levels)
+    ClipNode  = Data.define(:plane_index, :children)
+    TexInfo   = Data.define(:s_vec, :s_offset, :t_vec, :t_offset,
+                            :miptex_index, :flags)
+    Model     = Data.define(:mins, :maxs, :origin, :head_nodes,
+                            :vis_leafs, :first_face, :num_faces)
+    MipTex    = Data.define(:name, :width, :height, :offsets, :pixels)
+
+    # Pre-computed surface data for rendering
+    Surface = Data.define(:vertices, :texcoords, :texinfo_index)
+
+    Level = Data.define(
+      :vertices, :edges, :faces, :surfedges,
+      :planes, :nodes, :leafs, :clipnodes,
+      :texinfo, :models, :marksurfaces,
+      :entities, :visibility, :lighting, :textures
+    )
+  end
+end