quake-rb 0.1.0 → 0.2.0

data/lib/quake/game/item_pickups.rb

@@ -8,6 +8,8 @@ module Quake
     # entities, applies effects to PlayerState, marks items as picked up.
     class ItemPickups
       PICKUP_RADIUS = 32.0 # units (roughly player bbox width)
+      PLAYER_MINS = Math::Vec3.new(-16.0, -16.0, -24.0)
+      PLAYER_MAXS = Math::Vec3.new(16.0, 16.0, 32.0)
 
       # Pickup definitions: classname -> { type:, ... }
       ITEMS = {
@@ -20,10 +22,11 @@ module Quake
         "item_armorInv" => { type: :armor, points: 200, armor_type: 3 }, # red
 
         # Ammo
-        "item_shells" => { type: :ammo, ammo_type: :shells, amount: 20 },
-        "item_spikes" => { type: :ammo, ammo_type: :nails, amount: 25 },
-        "item_rockets" => { type: :ammo, ammo_type: :rockets, amount: 5 },
-        "item_cells" => { type: :ammo, ammo_type: :cells, amount: 6 },
+        "item_shells" => { type: :ammo, ammo_type: :shells, amount: 20, big_amount: 40 },
+        "item_spikes" => { type: :ammo, ammo_type: :nails, amount: 25, big_amount: 50 },
+        "item_rockets" => { type: :ammo, ammo_type: :rockets, amount: 5, big_amount: 10 },
+        "item_cells" => { type: :ammo, ammo_type: :cells, amount: 6, big_amount: 12 },
+        "item_weapon" => { type: :legacy_weapon_ammo },
 
         # Weapons (give weapon + starting ammo)
         "weapon_supershotgun" => {
@@ -55,36 +58,149 @@ module Quake
         "item_artifact_super_damage" => { type: :powerup, powerup: :quad },
         "item_artifact_invulnerability" => { type: :powerup, powerup: :pentagram },
         "item_artifact_envirosuit" => { type: :powerup, powerup: :biosuit },
-        "item_artifact_invisibility" => { type: :powerup, powerup: :ring }
+        "item_artifact_invisibility" => { type: :powerup, powerup: :ring },
+
+        # Keys
+        "item_key1" => { type: :key, key: :silver },
+        "item_key2" => { type: :key, key: :gold },
+
+        # Episode runes
+        "item_sigil" => { type: :sigil },
+
+        # Dropped by killed players in QuakeC DropBackpack.
+        "item_backpack" => { type: :backpack }
+      }.freeze
+
+      BACKPACK_WEAPONS = {
+        1 => :shotgun,
+        2 => :super_shotgun,
+        4 => :nailgun,
+        8 => :super_nailgun,
+        16 => :grenade_launcher,
+        32 => :rocket_launcher,
+        64 => :lightning_gun,
+        4096 => :axe
+      }.freeze
+      SUB_REGEN_SOUND = "items/itembk2.wav"
+
+      # QuakeC items.qc netnames used by the "You got the ..." sprints.
+      WEAPON_NETNAMES = {
+        super_shotgun: "Double-barrelled Shotgun",
+        nailgun: "nailgun",
+        super_nailgun: "Super Nailgun",
+        grenade_launcher: "Grenade Launcher",
+        rocket_launcher: "Rocket Launcher",
+        lightning_gun: "Thunderbolt"
+      }.freeze
+
+      AMMO_NETNAMES = {
+        shells: "shells",
+        nails: "nails",
+        rockets: "rockets",
+        cells: "cells"
+      }.freeze
+
+      # Legacy item_weapon boxes use "spikes" for nails (items.qc).
+      LEGACY_AMMO_NETNAMES = {
+        shells: "shells",
+        nails: "spikes",
+        rockets: "rockets"
+      }.freeze
+
+      POWERUP_NETNAMES = {
+        quad: "Quad Damage",
+        pentagram: "Pentagram of Protection",
+        ring: "Ring of Shadows",
+        biosuit: "Biosuit"
+      }.freeze
+
+      KEY_NETNAMES = {
+        silver: "silver key",
+        gold: "gold key"
       }.freeze
 
-      def initialize(entities)
+      # items.qc BackpackTouch netnames (set in DropBackpack spawns).
+      BACKPACK_WEAPON_NETNAMES = {
+        axe: "Axe",
+        shotgun: "Shotgun",
+        super_shotgun: "Double-barrelled Shotgun",
+        nailgun: "Nailgun",
+        super_nailgun: "Super Nailgun",
+        grenade_launcher: "Grenade Launcher",
+        rocket_launcher: "Rocket Launcher",
+        lightning_gun: "Thunderbolt"
+      }.freeze
+
+      def initialize(entities, deathmatch: 0)
         @item_entities = entities.select { |e| ITEMS.key?(e.classname) }
         @picked_up = Set.new # entity object_ids that have been collected
+        @deathmatch = deathmatch.to_i
+      end
+
+      def add_entity(ent)
+        @item_entities << ent if ITEMS.key?(ent.classname)
+      end
+
+      def update(game_time, player_state: nil)
+        events = []
+        @item_entities.each do |ent|
+          next if ent.removed?
+
+          if ent.instance_variable_get(:@think) == :sub_remove && ent.think_time <= game_time
+            ent.instance_variable_set(:@removed, true)
+            next
+          end
+
+          next unless @picked_up.include?(ent.object_id)
+          next if ent.think_time > game_time
+
+          case ent.instance_variable_get(:@think)
+          when :sub_regen
+            regen_item(ent)
+            events << { classname: ent.classname, type: :respawn, entity: ent, sound: SUB_REGEN_SOUND }
+          when :item_megahealth_rot
+            update_megahealth_item(ent, game_time)
+          end
+        end
+        events
       end
 
       # Check for pickups near player position. Returns array of pickup
       # event hashes (for sound/effect triggering).
-      def check_pickups(player_pos, player_state)
+      def check_pickups(player_pos, player_state, game_time: 0.0, water_level: 0)
+        return [] unless player_state.alive?
+
         events = []
 
         @item_entities.each do |ent|
+          next if ent.removed?
           next if @picked_up.include?(ent.object_id)
+          next if ent.instance_variable_get(:@solid) == 0
 
-          dx = player_pos.x - ent.position.x
-          dy = player_pos.y - ent.position.y
-          dz = player_pos.z - ent.position.z
-          dist_sq = dx * dx + dy * dy + dz * dz
-
-          next if dist_sq > PICKUP_RADIUS * PICKUP_RADIUS
+          next unless touches_item?(player_pos, ent)
 
           defn = ITEMS[ent.classname]
           next unless defn
 
-          picked = try_pickup(player_state, defn, ent)
+          # Built before try_pickup mutates PlayerState (QuakeC prints
+          # from pre-pickup state, e.g. BackpackTouch weapon ownership).
+          message = pickup_message(defn, ent, player_state)
+          picked = try_pickup(player_state, defn, ent, game_time: game_time, water_level: water_level)
           if picked
-            @picked_up.add(ent.object_id)
-            events << { classname: ent.classname, type: defn[:type], entity: ent }
+            leaves_item = leave_weapon_pickup?(defn)
+            unless leaves_item
+              @picked_up.add(ent.object_id)
+              hide_picked_item(ent, defn, game_time)
+            end
+            events << {
+              classname: ent.classname,
+              type: defn[:type],
+              entity: ent,
+              sound: pickup_sound(defn, ent),
+              extra_sounds: ent.instance_variable_get(:@extra_pickup_sounds),
+              use_targets: !leaves_item,
+              message: message
+            }
           end
         end
 
@@ -95,43 +211,478 @@ module Quake
         @picked_up.include?(entity.object_id)
       end
 
+      def owns_megahealth_rot_for?(player_state)
+        @item_entities.any? do |ent|
+          @picked_up.include?(ent.object_id) &&
+            ent.instance_variable_get(:@think) == :item_megahealth_rot &&
+            ent.instance_variable_get(:@owner).equal?(player_state)
+        end
+      end
+
+      def hide_picked_item(ent, defn, game_time)
+        if defn[:type] == :backpack
+          ent.instance_variable_set(:@removed, true)
+        else
+          ent.instance_variable_set(:@mdl, ent["model"]) unless ent.instance_variable_get(:@mdl)
+          ent.properties["model"] = ""
+          ent.instance_variable_set(:@solid, 0)
+          return if dropped_powerup?(ent, defn)
+
+          schedule_regen(ent, defn, game_time)
+        end
+      end
+
       private
 
-      def try_pickup(ps, defn, ent)
+      # SV_LinkEdict expands FL_ITEM entities' trigger bounds by 15 units
+      # in x/y so items are easier to grab.
+      FL_ITEM_EXPANSION = Math::Vec3.new(15.0, 15.0, 0.0)
+
+      def touches_item?(player_pos, ent)
+        mins = ent.instance_variable_get(:@mins)
+        maxs = ent.instance_variable_get(:@maxs)
+        return radius_touch?(player_pos, ent.position) unless mins && maxs
+
+        boxes_overlap?(player_pos + PLAYER_MINS, player_pos + PLAYER_MAXS,
+                       ent.position + mins - FL_ITEM_EXPANSION,
+                       ent.position + maxs + FL_ITEM_EXPANSION)
+      end
+
+      def radius_touch?(player_pos, item_pos)
+        dx = player_pos.x - item_pos.x
+        dy = player_pos.y - item_pos.y
+        dz = player_pos.z - item_pos.z
+        (dx * dx + dy * dy + dz * dz) <= PICKUP_RADIUS * PICKUP_RADIUS
+      end
+
+      def boxes_overlap?(a_mins, a_maxs, b_mins, b_maxs)
+        a_mins.x <= b_maxs.x && a_maxs.x >= b_mins.x &&
+          a_mins.y <= b_maxs.y && a_maxs.y >= b_mins.y &&
+          a_mins.z <= b_maxs.z && a_maxs.z >= b_mins.z
+      end
+
+      def regen_item(ent)
+        ent.properties["model"] = ent.instance_variable_get(:@mdl).to_s
+        ent.instance_variable_set(:@solid, 1)
+        ent.think_time = 0.0
+        ent.instance_variable_set(:@respawn_sound, SUB_REGEN_SOUND)
+        @picked_up.delete(ent.object_id)
+      end
+
+      def update_megahealth_item(ent, game_time)
+        owner = ent.instance_variable_get(:@owner)
+        if owner && owner.health > PlayerState::MAX_HEALTH
+          owner.health -= 1
+          ent.think_time = game_time.to_f + 1.0
+        else
+          if silly_old_deathmatch?
+            ent.instance_variable_set(:@think, nil)
+            ent.think_time = 0.0
+          else
+            ent.instance_variable_set(:@think, :sub_regen)
+            ent.think_time = game_time.to_f + 20.0
+          end
+        end
+      end
+
+      def schedule_regen(ent, defn, game_time)
+        delay, think = regen_delay_and_think(ent, defn)
+        return unless delay
+
+        ent.think_time = game_time.to_f + delay
+        ent.instance_variable_set(:@think, think)
+      end
+
+      def regen_delay_and_think(ent, defn)
         case defn[:type]
         when :health
-          # Health items: check spawnflags for mega/rotten
-          amount = defn[:amount]
-          mega = false
-          if (flags = ent["spawnflags"])
-            flags = flags.to_i
-            if flags & 1 != 0 # rotten (small health, 15hp, can exceed 100 but not by much)
-              amount = 15
-            elsif flags & 2 != 0 # mega health
-              amount = 100
-              mega = true
-            end
+          if health_mega?(ent)
+            return [nil, nil] if deathmatch_four?
+
+            [5.0, :item_megahealth_rot]
+          else
+            return [nil, nil] if silly_old_deathmatch?
+
+            [20.0, :sub_regen]
           end
-          ps.add_health(amount, mega: mega)
+        when :armor
+          return [nil, nil] if silly_old_deathmatch?
+
+          [20.0, :sub_regen]
+        when :ammo, :legacy_weapon_ammo
+          return [nil, nil] if silly_old_deathmatch?
+
+          [deathmatch_fast_ammo_respawn? ? 15.0 : 30.0, :sub_regen]
+        when :weapon
+          [30.0, :sub_regen]
+        when :powerup
+          if %w[item_artifact_invulnerability item_artifact_invisibility].include?(ent.classname)
+            [300.0, :sub_regen]
+          else
+            [60.0, :sub_regen]
+          end
+        end
+      end
+
+      def deathmatch_fast_ammo_respawn?
+        @deathmatch == 3 || @deathmatch == 5
+      end
+
+      def silly_old_deathmatch?
+        @deathmatch == 2
+      end
+
+      def deathmatch_four?
+        @deathmatch == 4
+      end
+
+      def clear_deathmatch_four_quad_resources(ps, ent)
+        return unless deathmatch_four?
+        return unless ent.classname == "item_artifact_super_damage"
+
+        ps.armor_type = 0
+        ps.armor = 0
+        ps.ammo[:cells] = 0
+      end
+
+      def leave_weapon_pickup?(defn)
+        defn[:type] == :weapon && [2, 3, 5].include?(@deathmatch)
+      end
+
+      def health_mega?(ent)
+        healtype = ent.instance_variable_get(:@healtype)
+        return healtype == 2 unless healtype.nil?
+
+        (ent.spawnflags & 2) != 0
+      end
+
+      def try_pickup(ps, defn, ent, game_time:, water_level:)
+        case defn[:type]
+        when :health
+          return false if deathmatch_four_invincible_player?(ps, game_time)
+
+          amount, mega = health_pickup_fields(defn, ent)
+          picked = ps.add_health(amount, mega: mega, game_time: deathmatch_four? ? nil : game_time)
+          ent.instance_variable_set(:@owner, ps) if picked && mega
+          picked
 
         when :armor
+          return false if deathmatch_four_invincible_player?(ps, game_time)
+
           ps.add_armor(defn[:points], defn[:armor_type])
 
         when :ammo
-          ps.add_ammo(defn[:ammo_type], defn[:amount])
+          amount = ammo_amount(defn, ent)
+          ps.add_ammo(ammo_type(defn, ent), amount, auto_switch: true, water_level: water_level)
+
+        when :legacy_weapon_ammo
+          ammo = legacy_weapon_ammo(ent)
+          return true unless ammo
+
+          ps.add_ammo(ammo[:type], ammo[:amount], auto_switch: true, water_level: water_level)
 
         when :weapon
+          return false if leave_weapon_pickup?(defn) && ps.weapons_owned.include?(defn[:weapon])
+
           ps.give_weapon(defn[:weapon],
                          ammo_type: defn[:ammo_type],
-                         ammo_amount: defn[:ammo_amount])
+                         ammo_amount: defn[:ammo_amount],
+                         water_level: water_level,
+                         game_time: game_time,
+                         w_switch: ps.respond_to?(:w_switch) ? ps.w_switch : 8)
 
         when :powerup
-          # Powerups always pick up (full implementation would add timed effects)
-          true
+          picked = ps.add_powerup(powerup_type(defn, ent), game_time: game_time, finish_time: recovered_powerup_finish_time(ent))
+          clear_deathmatch_four_quad_resources(ps, ent) if picked
+          picked
+
+        when :key
+          ps.add_key(key_type(defn, ent))
+
+        when :sigil
+          picked = ps.add_sigil(ent.spawnflags)
+          if picked
+            ps.instance_variable_set(:@centerprint, "You got the rune!")
+            ent.classname = ""
+          end
+          picked
+
+        when :backpack
+          return pickup_deathmatch_four_backpack(ps, ent, game_time: game_time) if deathmatch_four?
+
+          picked = ps.add_backpack(
+            ammo: backpack_ammo(ent),
+            weapon: backpack_weapon(ent),
+            water_level: water_level,
+            game_time: game_time,
+            b_switch: ps.respond_to?(:b_switch) ? ps.b_switch : 8
+          )
+          apply_deathmatch_rocket_backpack_minimum(ps, ent) if picked
+          picked
         else
           false
         end
       end
+
+      def ammo_amount(defn, ent)
+        aflag = ent.instance_variable_get(:@aflag)
+        return aflag if aflag
+
+        flags = (ent["spawnflags"] || "0").to_i
+        if flags & 1 != 0
+          defn.fetch(:big_amount, defn[:amount])
+        else
+          defn[:amount]
+        end
+      end
+
+      def deathmatch_four_invincible_player?(ps, game_time)
+        deathmatch_four? &&
+          (ps.powerup_item_active?(:pentagram, game_time: game_time) ||
+           ps.powerup_warning_time.key?(:pentagram))
+      end
+
+      def ammo_type(defn, ent)
+        weapon = ent.instance_variable_get(:@weapon)
+        case weapon
+        when 1 then :shells
+        when 2 then :nails
+        when 3 then :rockets
+        when 4 then :cells
+        else defn[:ammo_type]
+        end
+      end
+
+      def key_type(defn, ent)
+        case ent.instance_variable_get(:@items)
+        when 131_072 then :silver
+        when 262_144 then :gold
+        else defn[:key]
+        end
+      end
+
+      def powerup_type(defn, ent)
+        return :quad if ent.instance_variable_get(:@touch) == :q_touch
+        return :ring if ent.instance_variable_get(:@touch) == :r_touch
+
+        defn[:powerup]
+      end
+
+      def powerup_finish_time(ent)
+        cnt = ent.instance_variable_get(:@cnt)
+        cnt&.positive? ? cnt : nil
+      end
+
+      def recovered_powerup_finish_time(ent)
+        dropped_powerup_touch?(ent) ? powerup_finish_time(ent) : nil
+      end
+
+      def dropped_powerup?(ent, defn)
+        defn[:type] == :powerup &&
+          dropped_powerup_touch?(ent) &&
+          ent.instance_variable_get(:@think) == :sub_remove &&
+          powerup_finish_time(ent)
+      end
+
+      def dropped_powerup_touch?(ent)
+        %i[q_touch r_touch].include?(ent.instance_variable_get(:@touch))
+      end
+
+      def health_pickup_fields(defn, ent)
+        healamount = ent.instance_variable_get(:@healamount)
+        healtype = ent.instance_variable_get(:@healtype)
+        return [healamount, healtype == 2] unless healamount.nil? || healtype.nil?
+
+        flags = (ent["spawnflags"] || "0").to_i
+        if flags & 1 != 0
+          [15, false]
+        elsif flags & 2 != 0
+          [100, true]
+        else
+          [defn[:amount], false]
+        end
+      end
+
+      def legacy_weapon_ammo(ent)
+        spawned = legacy_spawned_ammo(ent)
+        return spawned if spawned
+
+        flags = (ent["spawnflags"] || "0").to_i
+        big = (flags & 8) != 0
+        if (flags & 2) != 0
+          { type: :rockets, amount: big ? 10 : 5 }
+        elsif (flags & 4) != 0
+          { type: :nails, amount: big ? 40 : 20 }
+        elsif (flags & 1) != 0
+          { type: :shells, amount: big ? 40 : 20 }
+        end
+      end
+
+      def legacy_spawned_ammo(ent)
+        weapon = ent.instance_variable_get(:@weapon)
+        amount = ent.instance_variable_get(:@aflag)
+        return unless weapon && amount
+
+        type = case weapon
+               when 1 then :shells
+               when 2 then :nails
+               when 3 then :rockets
+               end
+        type && { type: type, amount: amount }
+      end
+
+      # QuakeC items.qc pickup sprints ("You receive 25 health",
+      # "You got the nailgun", ...). Sigils use a centerprint instead.
+      def pickup_message(defn, ent, ps)
+        case defn[:type]
+        when :health
+          amount, = health_pickup_fields(defn, ent)
+          "You receive #{amount} health"
+        when :armor
+          "You got armor"
+        when :ammo
+          "You got the #{AMMO_NETNAMES[ammo_type(defn, ent)]}"
+        when :legacy_weapon_ammo
+          ammo = legacy_weapon_ammo(ent)
+          ammo && "You got the #{LEGACY_AMMO_NETNAMES[ammo[:type]]}"
+        when :weapon
+          "You got the #{WEAPON_NETNAMES[defn[:weapon]]}"
+        when :powerup
+          "You got the #{powerup_netname(defn, ent)}"
+        when :key
+          "You got the #{key_netname(defn, ent)}"
+        when :backpack
+          backpack_message(ent, ps)
+        end
+      end
+
+      def powerup_netname(defn, ent)
+        powerup = powerup_type(defn, ent)
+        return "OctaPower" if powerup == :quad && deathmatch_four?
+
+        ent.instance_variable_get(:@netname) || POWERUP_NETNAMES[powerup]
+      end
+
+      def key_netname(defn, ent)
+        ent.instance_variable_get(:@netname) || KEY_NETNAMES[key_type(defn, ent)]
+      end
+
+      # items.qc BackpackTouch: "You get " + optional "the <weapon>" +
+      # comma-separated ammo counts. Deathmatch 4 backpacks just give
+      # health.
+      def backpack_message(ent, ps)
+        return "You get 10 additional health" if deathmatch_four?
+
+        parts = []
+        weapon = backpack_weapon(ent)
+        if weapon && !ps.weapons_owned.include?(weapon)
+          parts << "the #{BACKPACK_WEAPON_NETNAMES[weapon]}"
+        end
+        backpack_ammo(ent).each do |type, amount|
+          parts << "#{amount} #{type}" if amount.positive?
+        end
+        "You get #{parts.join(', ')}"
+      end
+
+      def pickup_sound(defn, ent)
+        case defn[:type]
+        when :health
+          ent.instance_variable_get(:@noise) || health_sound(ent)
+        when :armor
+          "items/armor1.wav"
+        when :ammo, :legacy_weapon_ammo
+          "weapons/lock4.wav"
+        when :backpack
+          ent.instance_variable_get(:@noise) || "weapons/lock4.wav"
+        when :weapon
+          "weapons/pkup.wav"
+        when :powerup
+          ent.instance_variable_get(:@noise) || powerup_sound(defn[:powerup])
+        when :key
+          ent.instance_variable_get(:@noise) || "misc/medkey.wav"
+        when :sigil
+          ent.instance_variable_get(:@noise) || "misc/runekey.wav"
+        end
+      end
+
+      def health_sound(ent)
+        flags = (ent["spawnflags"] || "0").to_i
+        if flags & 1 != 0
+          "items/r_item1.wav"
+        elsif flags & 2 != 0
+          "items/r_item2.wav"
+        else
+          "items/health1.wav"
+        end
+      end
+
+      def powerup_sound(powerup)
+        case powerup
+        when :biosuit
+          "items/suit.wav"
+        when :pentagram
+          "items/protect.wav"
+        when :ring
+          "items/inv1.wav"
+        when :quad
+          "items/damage.wav"
+        end
+      end
+
+      def backpack_ammo(ent)
+        {
+          shells: backpack_field(ent, :ammo_shells),
+          nails: backpack_field(ent, :ammo_nails),
+          rockets: backpack_field(ent, :ammo_rockets),
+          cells: backpack_field(ent, :ammo_cells)
+        }
+      end
+
+      def backpack_weapon(ent)
+        BACKPACK_WEAPONS[backpack_field(ent, :items)]
+      end
+
+      def apply_deathmatch_rocket_backpack_minimum(ps, ent)
+        return unless deathmatch_fast_ammo_respawn?
+        item_bit = backpack_field(ent, :items)
+        rocket_weapon = if item_bit.zero?
+                          %i[grenade_launcher rocket_launcher].include?(ps.current_weapon)
+                        else
+                          [16, 32].include?(item_bit)
+                        end
+        return unless rocket_weapon
+        return unless ps.ammo[:rockets] < 5
+
+        ps.ammo[:rockets] = 5
+      end
+
+      def pickup_deathmatch_four_backpack(ps, ent, game_time:)
+        return false if deathmatch_four_invincible_player?(ps, game_time)
+
+        ps.health += 10
+        if ps.health > 250 && ps.health < 300
+          ent.instance_variable_set(:@noise, "items/protect3.wav")
+        else
+          ent.instance_variable_set(:@noise, "weapons/lock4.wav")
+        end
+
+        return true unless ps.health > 299
+        return true if deathmatch_four_invincible_player?(ps, game_time)
+
+        finish_time = game_time.to_f + 30.0
+        ps.add_powerup(:pentagram, game_time: game_time, finish_time: finish_time)
+        ps.add_powerup(:quad, game_time: game_time, finish_time: finish_time)
+        ps.ammo[:cells] = 0
+        ent.instance_variable_set(:@extra_pickup_sounds, ["boss1/sight1.wav"])
+        true
+      end
+
+      def backpack_field(ent, field)
+        value = ent.instance_variable_get(:"@#{field}")
+        return value.to_i if value
+
+        ent[field.to_s].to_i
+      end
     end
   end
 end