quake-rb 0.1.0 → 0.2.0

data/lib/quake/mdl/reader.rb

@@ -8,6 +8,9 @@ module Quake
     class Reader
       IDPOLYHEADER = 0x4F504449 # "IDPO" in little-endian
       MDL_VERSION = 6
+      MAX_LBM_HEIGHT = 480
+      MAXALIASVERTS = 2000
+      ALIAS_BASE_SIZE_RATIO = 1.0 / 11.0
 
       def initialize(data)
         @data = data
@@ -16,7 +19,8 @@ module Quake
 
       def parse
         header = read_header
-        skins = read_skins(header)
+        validate_header!(header)
+        skins, skin_intervals = read_skins(header)
         stverts = read_stverts(header[:numverts])
         triangles = read_triangles(header[:numtris])
         frames = read_frames(header[:numframes], header[:numverts])
@@ -29,11 +33,15 @@ module Quake
           skin_width: header[:skinwidth],
           skin_height: header[:skinheight],
           skins: skins,
+          skin_intervals: skin_intervals,
           stverts: stverts,
           triangles: triangles,
           frames: frames,
           flags: header[:flags],
-          sync_type: header[:synctype]
+          sync_type: header[:synctype],
+          size: header[:size] * ALIAS_BASE_SIZE_RATIO,
+          mins: Math::Vec3.new(-16.0, -16.0, -16.0),
+          maxs: Math::Vec3.new(16.0, 16.0, 16.0)
         )
       end
 
@@ -42,7 +50,9 @@ module Quake
       def read_header
         ident, version = read_fmt("VV")
         raise "Not an MDL file (ident=0x#{ident.to_s(16)})" unless ident == IDPOLYHEADER
-        raise "Unsupported MDL version #{version}" unless version == MDL_VERSION
+        unless version == MDL_VERSION
+          raise "Mod_LoadAliasModel: wrong version number (#{version} should be #{MDL_VERSION})"
+        end
 
         sx, sy, sz = read_fmt("eee")
         ox, oy, oz = read_fmt("eee")
@@ -70,8 +80,35 @@ module Quake
         }
       end
 
+      def validate_header!(header)
+        if header[:skinheight] > MAX_LBM_HEIGHT
+          raise "model has a skin taller than #{MAX_LBM_HEIGHT}"
+        end
+
+        raise "model has no vertices" if header[:numverts] <= 0
+
+        if header[:numverts] > MAXALIASVERTS
+          raise "model has too many vertices"
+        end
+
+        raise "model has no triangles" if header[:numtris] <= 0
+
+        if (header[:skinwidth] & 0x03) != 0
+          raise "Mod_LoadAliasModel: skinwidth not multiple of 4"
+        end
+
+        if header[:numskins] < 1
+          raise "Mod_LoadAliasModel: Invalid # of skins: #{header[:numskins]}"
+        end
+
+        if header[:numframes] < 1
+          raise "Mod_LoadAliasModel: Invalid # of frames: #{header[:numframes]}"
+        end
+      end
+
       def read_skins(header)
         skins = []
+        skin_intervals = []
         skin_size = header[:skinwidth] * header[:skinheight]
 
         header[:numskins].times do
@@ -80,21 +117,62 @@ module Quake
           if skin_type == 0 # ALIAS_SKIN_SINGLE
             pixels = @data[@pos, skin_size]
             @pos += skin_size
-            skins << [pixels]
+            skins << [flood_fill_skin(pixels, header[:skinwidth], header[:skinheight])]
+            skin_intervals << nil
           else # ALIAS_SKIN_GROUP
             num_skins = read_fmt("V").first
-            _intervals = read_fmt("e" * num_skins) # timing intervals
+            intervals = read_fmt("e" * num_skins)
+            if intervals.any? { |interval| interval <= 0.0 }
+              raise "Mod_LoadAliasSkinGroup: interval<=0"
+            end
             group = []
             num_skins.times do
               pixels = @data[@pos, skin_size]
               @pos += skin_size
-              group << pixels
+              group << flood_fill_skin(pixels, header[:skinwidth], header[:skinheight])
             end
             skins << group
+            skin_intervals << intervals
           end
         end
 
-        skins
+        [skins, skin_intervals]
+      end
+
+      def flood_fill_skin(pixels, skinwidth, skinheight)
+        fillcolor = pixels.getbyte(0)
+        filledcolor = 0
+        return pixels if fillcolor == filledcolor || fillcolor == 255
+
+        skin = pixels.dup
+        fifo = [[0, 0]]
+        outpt = 0
+
+        while outpt < fifo.size
+          x, y = fifo[outpt]
+          outpt += 1
+          fdc = filledcolor
+          offset = x + skinwidth * y
+
+          [[-1, 0], [1, 0], [0, -1], [0, 1]].each do |dx, dy|
+            nx = x + dx
+            ny = y + dy
+            next if nx.negative? || nx >= skinwidth || ny.negative? || ny >= skinheight
+
+            neighbor = nx + skinwidth * ny
+            color = skin.getbyte(neighbor)
+            if color == fillcolor
+              skin.setbyte(neighbor, 255)
+              fifo << [nx, ny]
+            elsif color != 255
+              fdc = color
+            end
+          end
+
+          skin.setbyte(offset, fdc)
+        end
+
+        skin
       end
 
       def read_stverts(count)
@@ -141,6 +219,9 @@ module Quake
         _bbox_max = read_trivertx
 
         intervals = read_fmt("e" * num_frames)
+        if intervals.any? { |interval| interval <= 0.0 }
+          raise "Mod_LoadAliasGroup: interval<=0"
+        end
 
         frames = num_frames.times.map do
           read_single_frame(numverts)

data/lib/quake/mdl/types.rb

@@ -20,8 +20,8 @@ module Quake
     # Complete MDL model
     Model = Data.define(
       :scale, :scale_origin, :bounding_radius, :eye_position,
-      :skin_width, :skin_height, :skins,
-      :stverts, :triangles, :frames, :flags, :sync_type
+      :skin_width, :skin_height, :skins, :skin_intervals,
+      :stverts, :triangles, :frames, :flags, :sync_type, :size, :mins, :maxs
     )
 
     ALIAS_ONSEAM = 0x0020

data/lib/quake/pak/reader.rb

@@ -8,6 +8,7 @@ module Quake
       MAGIC = "PACK"
       HEADER_SIZE = 12
       DIR_ENTRY_SIZE = 64
+      MAX_FILES_IN_PACK = 2048
 
       attr_reader :entries
 
@@ -23,7 +24,7 @@ module Quake
       end
 
       def read(name)
-        entry = @entries[name] || @entries[name.downcase]
+        entry = @entries[name]
         raise "File not found in PAK: #{name}" unless entry
 
         @io.seek(entry.offset)
@@ -39,9 +40,12 @@ module Quake
       def parse_header
         header = @io.read(HEADER_SIZE)
         magic, dirofs, dirlen = header.unpack("a4V2")
-        raise "Not a PAK file: #{magic.inspect}" unless magic == MAGIC
+        raise "#{@path} is not a packfile" unless magic == MAGIC
 
         num_entries = dirlen / DIR_ENTRY_SIZE
+        if num_entries > MAX_FILES_IN_PACK
+          raise "#{@path} has #{num_entries} files"
+        end
         @io.seek(dirofs)
         dir_data = @io.read(dirlen)
 
@@ -49,7 +53,9 @@ module Quake
           offset = i * DIR_ENTRY_SIZE
           raw = dir_data[offset, DIR_ENTRY_SIZE]
           name, filepos, filelen = raw.unpack("Z56V2")
-          @entries[name.downcase] = Entry.new(name: name, offset: filepos, size: filelen)
+          next if @entries.key?(name)
+
+          @entries[name] = Entry.new(name: name, offset: filepos, size: filelen)
         end
       end
     end

data/lib/quake/palette.rb

@@ -17,13 +17,12 @@ module Quake
       @rgb[index]
     end
 
-    # Convert an array of 8-bit indexed pixels to RGBA bytes
-    # Last palette entry (255) is typically transparent
-    def indexed_to_rgba(pixels, transparent_index: 255)
+    # Convert an array of 8-bit indexed pixels to RGBA bytes.
+    def indexed_to_rgba(pixels, transparent_index: nil)
       rgba = String.new(capacity: pixels.bytesize * 4)
       pixels.each_byte do |idx|
         r, g, b = @rgb[idx]
-        a = (idx == transparent_index) ? 0 : 255
+        a = (transparent_index && idx == transparent_index) ? 0 : 255
         rgba << r << g << b << a
       end
       rgba

data/lib/quake/physics/hull_trace.rb

@@ -19,10 +19,37 @@ module Quake
     CONTENTS_WATER = -3
     CONTENTS_SLIME = -4
     CONTENTS_LAVA  = -5
+    CONTENTS_SKY   = -6
 
     DIST_EPSILON = 0.03125 # 1/32, same as Quake
+    BoxHull = Data.define(:clipnodes, :planes, :first_clipnode, :last_clipnode)
 
     module HullTrace
+      def self.hull_for_box(mins, maxs)
+        clipnodes = 6.times.map do |i|
+          side = i & 1
+          children = Array.new(2)
+          children[side] = CONTENTS_EMPTY
+          children[side ^ 1] = i == 5 ? CONTENTS_SOLID : i + 1
+
+          Quake::Bsp::ClipNode.new(plane_index: i, children: children)
+        end
+
+        planes = [
+          box_plane(type: 0, dist: maxs.x),
+          box_plane(type: 0, dist: mins.x),
+          box_plane(type: 1, dist: maxs.y),
+          box_plane(type: 1, dist: mins.y),
+          box_plane(type: 2, dist: maxs.z),
+          box_plane(type: 2, dist: mins.z)
+        ]
+
+        BoxHull.new(
+          clipnodes: clipnodes, planes: planes,
+          first_clipnode: 0, last_clipnode: 5
+        )
+      end
+
       # Check what content type a point is in, using the clipnode tree.
       # hull_clipnodes: array of ClipNode
       # planes: array of Plane
@@ -30,10 +57,14 @@ module Quake
       # point: Vec3
       def self.point_contents(clipnodes, planes, node_index, point)
         while node_index >= 0
+          if node_index >= clipnodes.size
+            raise "SV_HullPointContents: bad node number"
+          end
+
           node = clipnodes[node_index]
           plane = planes[node.plane_index]
 
-          dist = point.dot(plane.normal) - plane.dist
+          dist = plane_distance(plane, point)
           node_index = dist >= 0 ? node.children[0] : node.children[1]
         end
         node_index # negative value = content type
@@ -64,11 +95,29 @@ module Quake
         TraceResult.new(**result)
       end
 
+      # Quake's Mod_MakeHull0: duplicate the render node tree as clipnodes so
+      # point traces (hull 0) can reuse the same recursive hull check.  A node
+      # child < 0 encodes leaf -(child + 1); hull 0 replaces it with the leaf
+      # contents, exactly like the C loader.
+      def self.hull0_clipnodes(level)
+        return @hull0_clipnodes if @hull0_level&.equal?(level)
+
+        @hull0_level = level
+        @hull0_clipnodes = level.nodes.map do |node|
+          children = node.children.map do |child|
+            child >= 0 ? child : level.leafs[-child - 1].contents
+          end
+          Quake::Bsp::ClipNode.new(plane_index: node.plane_index, children: children)
+        end
+      end
+
       # Trace against the world AND all solid brush entities, returning the
       # nearest hit.  Brush entity traces are done in entity-local space
       # (subtract origin, trace sub-model hull, transform back).
+      # hull_num 0 is a point trace through the render-node hull, matching
+      # Quake's SV_TraceLine with MOVE_NOMONSTERS (world + SOLID_BSP only).
       def self.trace_world_and_entities(level, p1, p2, brush_entities, hull_num: 1)
-        clipnodes = level.clipnodes
+        clipnodes = hull_num.zero? ? hull0_clipnodes(level) : level.clipnodes
         planes = level.planes
 
         # World trace
@@ -79,9 +128,11 @@ module Quake
         # Trace against each brush entity's sub-model
         brush_entities&.each do |ent|
           next unless ent.brush_entity?
+          next if ent.removed?
           # Triggers are SOLID_TRIGGER in Quake: they detect overlap but
           # don't block movement. They're handled by check_triggers.
           next if ent.classname.start_with?("trigger_")
+          next if ent.classname == "func_illusionary"
           model = level.models[ent.model_index]
           next unless model
 
@@ -131,11 +182,15 @@ module Quake
           return
         end
 
+        if node_index >= clipnodes.size
+          raise "SV_RecursiveHullCheck: bad node number"
+        end
+
         node = clipnodes[node_index]
         plane = planes[node.plane_index]
 
-        d1 = p1.dot(plane.normal) - plane.dist
-        d2 = p2.dot(plane.normal) - plane.dist
+        d1 = plane_distance(plane, p1)
+        d2 = plane_distance(plane, p2)
 
         # Both on same side?
         if d1 >= 0 && d2 >= 0
@@ -188,6 +243,24 @@ module Quake
           end
         end
       end
+
+      private_class_method def self.plane_distance(plane, point)
+        case plane.type
+        when 0 then point.x - plane.dist
+        when 1 then point.y - plane.dist
+        when 2 then point.z - plane.dist
+        else point.dot(plane.normal) - plane.dist
+        end
+      end
+
+      private_class_method def self.box_plane(type:, dist:)
+        normal = case type
+                 when 0 then Math::Vec3.new(1.0, 0.0, 0.0)
+                 when 1 then Math::Vec3.new(0.0, 1.0, 0.0)
+                 else Math::Vec3.new(0.0, 0.0, 1.0)
+                 end
+        Quake::Bsp::Plane.new(normal: normal, dist: dist, type: type)
+      end
     end
   end
 end