quake-rb 0.1.0 → 0.2.0

data/lib/quake/entity.rb

@@ -5,37 +5,76 @@ module Quake
   # All Quake entities (players, monsters, items, triggers, brush models)
   # are defined as key-value property bags in the BSP entity string.
   class Entity
+    FL_FLY = 1
+    FL_SWIM = 2
+    FL_CLIENT = 8
+    FL_MONSTER = 32
+    FL_GODMODE = 64
+    IT_ARMOR1 = 8192
+    IT_ARMOR2 = 16_384
+    IT_ARMOR3 = 32_768
+    IT_ARMOR_MASK = IT_ARMOR1 | IT_ARMOR2 | IT_ARMOR3
+
     attr_accessor :properties, :position, :angle, :angles, :classname,
                   :model_index, :think_time, :state, :move_dir,
                   :target, :targetname, :speed, :wait, :lip, :health,
-                  :sounds, :message
+                  :height, :sounds, :message, :count, :spawnflags, :killtarget,
+                  :frame, :skin, :flags, :effects, :velocity, :style, :lightstyle,
+                  :armortype, :armorvalue, :invincible_finished,
+                  :dmg_take, :dmg_save, :dmg_inflictor, :items,
+                  :super_damage_finished
 
     def initialize(properties = {})
-      @properties = properties
+      @properties = properties.dup
       @classname = properties["classname"] || ""
+      @spawnflags = (properties["spawnflags"] || "0").to_i
+      apply_spawn_defaults
 
       # Parse common fields
-      @position = parse_vec3(properties["origin"]) || Math::Vec3::ORIGIN
-      @angle = (properties["angle"] || "0").to_f
-      @angles = parse_vec3(properties["angles"]) || Math::Vec3::ORIGIN
+      @position = parse_vec3(@properties["origin"]) || Math::Vec3::ORIGIN
+      @velocity = parse_vec3(@properties["velocity"]) || Math::Vec3::ORIGIN
+      @angle = (@properties["angle"] || "0").to_f
+      @angles = parse_vec3(@properties["angles"]) || Math::Vec3::ORIGIN
 
       # Brush model reference: "*1", "*2", etc.
       @model_index = nil
-      if (model_str = properties["model"])
+      if (model_str = @properties["model"])
         @model_index = model_str[1..].to_i if model_str.start_with?("*")
       end
 
       # Targeting
-      @target = properties["target"]
-      @targetname = properties["targetname"]
+      @target = @properties["target"]
+      @targetname = @properties["targetname"]
+      @killtarget = @properties["killtarget"]
 
       # Movement/behavior
-      @speed = (properties["speed"] || default_speed).to_f
-      @wait = (properties["wait"] || "3").to_f
-      @lip = (properties["lip"] || "8").to_f
-      @health = (properties["health"] || "0").to_f
-      @sounds = (properties["sounds"] || "0").to_i
-      @message = properties["message"]
+      @speed = quake_float("speed", default_speed, zero_defaults_for: [
+                             "func_door", "func_plat", "func_button", "func_train",
+                             "trigger_push", "trigger_monsterjump"
+                           ])
+      @wait = quake_float("wait", default_wait, zero_defaults_for: [
+                            "func_door", "func_button", "trigger_multiple", "trap_shooter"
+                          ])
+      @lip = quake_float("lip", default_lip, zero_defaults_for: ["func_door", "func_button"])
+      @health = (@properties["health"] || default_health).to_f
+      @height = quake_float("height", default_height, zero_defaults_for: ["trigger_monsterjump"])
+      @sounds = (@properties["sounds"] || "0").to_i
+      @message = @properties["message"]
+      @count = quake_int("count", default_count, zero_defaults_for: ["trigger_counter"])
+      @frame = quake_int("frame", default_frame)
+      @skin = quake_int("skin", default_skin)
+      @flags = quake_int("flags", "0") | default_runtime_flags
+      @takedamage = quake_int("takedamage", default_takedamage)
+      @armortype = quake_float("armortype", "0")
+      @armorvalue = quake_float("armorvalue", "0")
+      @invincible_finished = quake_float("invincible_finished", "0")
+      @items = quake_int("items", "0")
+      @super_damage_finished = quake_float("super_damage_finished", "0")
+      @dmg_take = quake_float("dmg_take", "0")
+      @dmg_save = quake_float("dmg_save", "0")
+      @dmg_inflictor = nil
+      @effects = quake_int("effects", "0") if @properties.key?("effects")
+      @style = quake_int("style", default_style, zero_defaults_for: ["light_fluorospark"])
 
       # Runtime state
       @state = :idle
@@ -47,8 +86,49 @@ module Quake
 
     def brush_entity? = !@model_index.nil?
 
+    def removed? = !!@removed
+
+    def damageable?
+      return false if removed?
+
+      @takedamage != 0
+    end
+
+    def take_damage(amount, game_time: nil)
+      return 0.0 unless damageable?
+
+      result = absorb_damage(amount, game_time: game_time)
+      apply_health_damage(result[:take]) if result[:take].positive?
+      result[:take].to_f
+    end
+
+    def absorb_damage(amount, game_time: nil)
+      damage = amount.to_f
+      save = (@armortype * damage).ceil
+      if save >= @armorvalue
+        save = @armorvalue
+        @armortype = 0.0
+        @items -= @items & IT_ARMOR_MASK
+      end
+      @armorvalue -= save
+      protected = (@flags & FL_GODMODE) != 0 ||
+                  (game_time && @invincible_finished.positive? && @invincible_finished >= game_time.to_f)
+      take = protected ? 0.0 : (damage - save).ceil.to_f
+      { take: take, save: save.to_f, protected: protected }
+    end
+
+    def apply_health_damage(taken)
+      @health -= taken
+      @health = -99.0 if @health < -99.0
+      if @health <= 0
+        @removed = true
+      end
+    end
+
     # Direction vector from the "angle" field (Quake convention)
     def forward_vector
+      return angles_forward_vector if @angles != Math::Vec3::ORIGIN
+
       case @angle.to_i
       when -1 # UP
         Math::Vec3.new(0.0, 0.0, 1.0)
@@ -62,48 +142,356 @@ module Quake
 
     private
 
+    def angles_forward_vector
+      if @angles.x.zero? && @angles.y == -1.0 && @angles.z.zero?
+        return Math::Vec3.new(0.0, 0.0, 1.0)
+      end
+      if @angles.x.zero? && @angles.y == -2.0 && @angles.z.zero?
+        return Math::Vec3.new(0.0, 0.0, -1.0)
+      end
+
+      yaw = @angles.y * ::Math::PI / 180.0
+      pitch = @angles.x * ::Math::PI / 180.0
+      Math::Vec3.new(
+        ::Math.cos(pitch) * ::Math.cos(yaw),
+        ::Math.cos(pitch) * ::Math.sin(yaw),
+        -::Math.sin(pitch)
+      )
+    end
+
+    def apply_spawn_defaults
+      @properties["model"] ||= default_model
+    end
+
     def parse_vec3(str)
       return nil unless str
-      parts = str.split.map(&:to_f)
-      return nil unless parts.size == 3
+      parts = str.split.first(3).map(&:to_f)
+      parts << 0.0 while parts.size < 3
       Math::Vec3.new(parts[0], parts[1], parts[2])
     end
 
+    def quake_float(key, default, zero_defaults_for: [])
+      raw = @properties[key]
+      return default.to_f unless raw
+
+      value = raw.to_f
+      value.zero? && zero_defaults_for.include?(@classname) ? default.to_f : value
+    end
+
+    def quake_int(key, default, zero_defaults_for: [])
+      raw = @properties[key]
+      return default.to_i unless raw
+
+      value = raw.to_i
+      value.zero? && zero_defaults_for.include?(@classname) ? default.to_i : value
+    end
+
     def default_speed
       case @classname
       when "func_door" then "100"
       when "func_plat" then "150"
       when "func_button" then "40"
       when "func_train" then "100"
+      when "trigger_push" then "1000"
+      when "trigger_monsterjump" then "200"
       else "100"
       end
     end
+
+    def default_wait
+      case @classname
+      when "func_button" then "1"
+      when "trigger_multiple" then "0.2"
+      when "trigger_once", "trigger_secret", "trigger_counter" then "-1"
+      when "path_corner" then "0"
+      when "trap_shooter" then "1"
+      else "3"
+      end
+    end
+
+    def default_lip
+      case @classname
+      when "func_button" then "4"
+      else "8"
+      end
+    end
+
+    def default_count
+      case @classname
+      when "trigger_counter" then "2"
+      else "0"
+      end
+    end
+
+    def default_style
+      case @classname
+      when "light_fluorospark" then "10"
+      else "0"
+      end
+    end
+
+    def default_height
+      case @classname
+      when "trigger_monsterjump" then "200"
+      else "0"
+      end
+    end
+
+    def default_takedamage
+      if @classname.start_with?("monster_") ||
+         @classname == "misc_explobox" ||
+         @classname == "misc_explobox2"
+        "2"
+      else
+        "0"
+      end
+    end
+
+    def default_runtime_flags
+      return 0 unless @classname.start_with?("monster_")
+
+      flags = FL_MONSTER
+      flags |= FL_FLY if @classname == "monster_wizard"
+      flags |= FL_SWIM if @classname == "monster_fish"
+      flags
+    end
+
+    def default_health
+      case @classname
+      when "monster_army" then "30"
+      when "monster_dog" then "25"
+      when "monster_ogre" then "200"
+      when "monster_knight" then "75"
+      when "monster_wizard" then "80"
+      when "monster_demon1" then "300"
+      when "monster_zombie" then "60"
+      when "monster_fish" then "25"
+      when "misc_explobox", "misc_explobox2" then "20"
+      else "0"
+      end
+    end
+
+    def default_model
+      case @classname
+      when "monster_army" then "progs/soldier.mdl"
+      when "monster_dog" then "progs/dog.mdl"
+      when "monster_ogre" then "progs/ogre.mdl"
+      when "monster_knight" then "progs/knight.mdl"
+      when "monster_wizard" then "progs/wizard.mdl"
+      when "monster_demon1" then "progs/demon.mdl"
+      when "monster_zombie" then "progs/zombie.mdl"
+      when "weapon_supershotgun" then "progs/g_shot.mdl"
+      when "weapon_nailgun" then "progs/g_nail.mdl"
+      when "weapon_supernailgun" then "progs/g_nail2.mdl"
+      when "weapon_grenadelauncher" then "progs/g_rock.mdl"
+      when "weapon_rocketlauncher" then "progs/g_rock2.mdl"
+      when "weapon_lightning" then "progs/g_light.mdl"
+      when "item_health" then health_model
+      when "item_shells" then ammo_box_model("shell")
+      when "item_spikes" then ammo_box_model("nail")
+      when "item_rockets" then ammo_box_model("rock")
+      when "item_cells" then ammo_box_model("batt")
+      when "item_armor1", "item_armor2", "item_armorInv" then "progs/armor.mdl"
+      when "item_artifact_invulnerability" then "progs/invulner.mdl"
+      when "item_artifact_envirosuit" then "progs/suit.mdl"
+      when "item_artifact_invisibility" then "progs/invisibl.mdl"
+      when "item_artifact_super_damage" then "progs/quaddama.mdl"
+      when "item_backpack" then "progs/backpack.mdl"
+      when "item_key1" then "progs/w_s_key.mdl"
+      when "item_key2" then "progs/w_g_key.mdl"
+      when "item_sigil" then sigil_model
+      when "item_weapon" then legacy_weapon_ammo_model
+      when "misc_explobox" then "maps/b_explob.bsp"
+      when "misc_explobox2" then "maps/b_exbox2.bsp"
+      when "light_globe" then "progs/s_light.spr"
+      when "light_torch_small_walltorch" then "progs/flame.mdl"
+      when "light_flame_large_yellow", "light_flame_small_yellow", "light_flame_small_white" then "progs/flame2.mdl"
+      when "viewthing" then "progs/player.mdl"
+      when "misc_teleporttrain" then "progs/teleport.mdl"
+      end
+    end
+
+    def default_frame
+      case @classname
+      when "light_flame_large_yellow" then "1"
+      else "0"
+      end
+    end
+
+    def default_skin
+      case @classname
+      when "item_armor2" then "1"
+      when "item_armorInv" then "2"
+      else "0"
+      end
+    end
+
+    def health_model
+      if (@spawnflags & 1) != 0
+        "maps/b_bh10.bsp"
+      elsif (@spawnflags & 2) != 0
+        "maps/b_bh100.bsp"
+      else
+        "maps/b_bh25.bsp"
+      end
+    end
+
+    def ammo_box_model(prefix)
+      suffix = (@spawnflags & 1) != 0 ? "1" : "0"
+      "maps/b_#{prefix}#{suffix}.bsp"
+    end
+
+    def sigil_model
+      if (@spawnflags & 8) != 0
+        "progs/end4.mdl"
+      elsif (@spawnflags & 4) != 0
+        "progs/end3.mdl"
+      elsif (@spawnflags & 2) != 0
+        "progs/end2.mdl"
+      elsif (@spawnflags & 1) != 0
+        "progs/end1.mdl"
+      end
+    end
+
+    def legacy_weapon_ammo_model
+      big = (@spawnflags & 8) != 0
+      if (@spawnflags & 2) != 0
+        big ? "maps/b_rock1.bsp" : "maps/b_rock0.bsp"
+      elsif (@spawnflags & 4) != 0
+        big ? "maps/b_nail1.bsp" : "maps/b_nail0.bsp"
+      elsif (@spawnflags & 1) != 0
+        big ? "maps/b_shell1.bsp" : "maps/b_shell0.bsp"
+      end
+    end
   end
 
   # Parses the BSP entity string into an array of Entity objects.
   module EntityParser
+    SINGLE_CHAR_TOKENS = "{})(:'"
+    FIELD_NAMES = %w[
+      absmax absmin aflag aiment air_finished ammo_cells ammo_nails
+      ammo_rockets ammo_shells angles armortype armorvalue attack_finished
+      attack_state avelocity axhitme blocked bubble_count button0 button1
+      button2 chain classname cnt colormap count currentammo deadflag
+      deathtype delay dest dest1 dest2 distance dmg dmg_inflictor dmg_save
+      dmg_take effects enemy finalangle finaldest fixangle flags fly_sound
+      frags frame goalentity gravity groundentity health height ideal_yaw
+      impulse invincible_finished invincible_sound invincible_time
+      invisible_finished invisible_sound invisible_time items jump_flag
+      killtarget lastruntime lefty light_lev lip ltime mangle map max_health
+      maxs maxspeed mdl message mins model modelindex movedir movetarget
+      movetype netname nextthink noise noise1 noise2 noise3 noise4 oldenemy
+      oldorigin origin owner pain_finished pausetime pos1 pos2 rad_time
+      radsuit_finished search_time show_hostile size skin solid sounds
+      spawnflags speed state style super_damage_finished super_sound
+      super_time swim_flag t_length t_width takedamage target targetname team
+      teleport_time think touch trigger_field use v_angle velocity view_ofs
+      voided volume wad wait waitmax waitmin walkframe waterlevel watertype
+      weapon weaponframe weaponmodel worldtype yaw_speed
+    ].each_with_object({}) { |name, fields| fields[name] = true }.freeze
+
     def self.parse(entity_string)
+      return [] if entity_string.nil?
+
       entities = []
       current = nil
+      tokens = tokenize(entity_string)
+      index = 0
+
+      while index < tokens.length
+        token = tokens[index]
+        if current.nil?
+          raise "ED_LoadFromFile: found #{token} when expecting {" unless token == "{"
 
-      entity_string.each_line do |line|
-        line = line.strip
-        case line
-        when "{"
           current = {}
-        when "}"
-          entities << Entity.new(current) if current
+          index += 1
+          next
+        end
+
+        if token == "}"
+          entities << Entity.new(current) if current["classname"]
           current = nil
-        else
-          if current && line =~ /\A"([^"]+)"\s+"([^"]*)"\z/
-            current[$1] = $2
+          index += 1
+          next
+        end
+
+        key = normalize_key(token)
+        index += 1
+        raise "ED_ParseEntity: EOF without closing brace" if index >= tokens.length
+
+        value = tokens[index]
+        raise "ED_ParseEntity: closing brace without data" if value == "}"
+
+        value = decode_string(value)
+
+        unless key.start_with?("_") || (key != "angle" && !FIELD_NAMES[key])
+          if key == "angle"
+            current["angles"] = "0 #{value} 0"
+          else
+            current[key] = value
           end
         end
+        index += 1
       end
 
+      raise "ED_ParseEntity: EOF without closing brace" if current
+
       entities
     end
 
+    def self.tokenize(data)
+      tokens = []
+      index = 0
+
+      while index < data.length
+        char = data[index]
+        break if char == "\0"
+
+        if char.ord <= 32
+          index += 1
+          next
+        end
+
+        if char == "/" && data[index + 1] == "/"
+          index += 2
+          index += 1 while index < data.length && data[index] != "\n"
+          next
+        end
+
+        if char == '"'
+          index += 1
+          start = index
+          index += 1 while index < data.length && data[index] != '"'
+          tokens << data[start...index]
+          index += 1
+          next
+        end
+
+        if SINGLE_CHAR_TOKENS.include?(char)
+          tokens << char
+          index += 1
+          next
+        end
+
+        start = index
+        while index < data.length && data[index].ord > 32 && !SINGLE_CHAR_TOKENS.include?(data[index])
+          index += 1
+        end
+        tokens << data[start...index]
+      end
+
+      tokens
+    end
+
+    def self.normalize_key(key)
+      key = "light_lev" if key == "light"
+      key.rstrip
+    end
+
+    def self.decode_string(value)
+      value.gsub(/\\./) { |match| match == "\\n" ? "\n" : "\\" }
+    end
+
     # Build a lookup table: targetname -> [Entity]
     def self.build_target_map(entities)
       map = Hash.new { |h, k| h[k] = [] }