quake-rb 0.1.0 → 0.2.0

data/lib/quake/game/player_state.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "set"
+require_relative "../math/vec3"
 
 module Quake
   module Game
@@ -33,8 +34,140 @@ module Quake
         lightning_gun:    :cells
       }.freeze
 
-      attr_accessor :health, :armor, :armor_type, :current_weapon
-      attr_reader :ammo, :weapons_owned
+      POWERUP_DURATIONS = {
+        biosuit: 30.0,
+        pentagram: 30.0,
+        ring: 30.0,
+        quad: 30.0
+      }.freeze
+
+      EF_DIMLIGHT = 8
+      EF_BLUE = 64
+      EF_RED = 128
+      POWERUP_EFFECT_BITS = EF_DIMLIGHT | EF_BLUE | EF_RED
+      FL_CLIENT = 8
+      FL_GODMODE = 64
+      FL_WATERJUMP = 2048
+      FL_JUMPRELEASED = 4096
+      WEAPON_ITEM_INDEX = {
+        shotgun: 0,
+        super_shotgun: 1,
+        nailgun: 2,
+        super_nailgun: 3,
+        grenade_launcher: 4,
+        rocket_launcher: 5,
+        lightning_gun: 6
+      }.freeze
+
+      # QuakeC weapons.qc/player.qc weapon fire parameters.
+      WEAPON_FIRE = {
+        axe: {
+          cooldown: 0.5,
+          ammo_type: nil,
+          ammo_cost: 0,
+          sound: "weapons/ax1.wav",
+          range: 64.0,
+          damage: 20,
+          animation_frames: 1..4,
+          kind: :axe
+        },
+        shotgun: {
+          cooldown: 0.5,
+          ammo_type: :shells,
+          ammo_cost: 1,
+          sound: "weapons/guncock.wav",
+          pellets: 6,
+          range: 2048.0,
+          spread_x: 0.04,
+          spread_y: 0.04,
+          damage: 4,
+          kick: :small,
+          animation_frames: 1..6,
+          kind: :bullets
+        },
+        super_shotgun: {
+          cooldown: 0.7,
+          ammo_type: :shells,
+          ammo_cost: 2,
+          sound: "weapons/shotgn2.wav",
+          pellets: 14,
+          range: 2048.0,
+          spread_x: 0.14,
+          spread_y: 0.08,
+          damage: 4,
+          kick: :big,
+          animation_frames: 1..6,
+          kind: :bullets
+        },
+        nailgun: {
+          cooldown: 0.2,
+          ammo_type: :nails,
+          ammo_cost: 1,
+          sound: "weapons/rocket1i.wav",
+          range: 1000.0,
+          damage: 9,
+          kick: :small,
+          animation_frames: 1..8,
+          kind: :spike
+        },
+        super_nailgun: {
+          cooldown: 0.2,
+          ammo_type: :nails,
+          ammo_cost: 2,
+          sound: "weapons/spike2.wav",
+          range: 1000.0,
+          damage: 18,
+          kick: :small,
+          animation_frames: 1..8,
+          kind: :spike
+        },
+        rocket_launcher: {
+          cooldown: 0.8,
+          ammo_type: :rockets,
+          ammo_cost: 1,
+          sound: "weapons/sgun1.wav",
+          range: 1000.0,
+          damage: 100,
+          damage_variance: 20,
+          radius_damage: 120,
+          kick: :small,
+          animation_frames: 1..6,
+          kind: :rocket
+        },
+        lightning_gun: {
+          cooldown: 0.1,
+          ammo_type: :cells,
+          ammo_cost: 1,
+          sound: "weapons/lhit.wav",
+          range: 600.0,
+          damage: 30,
+          kick: :small,
+          animation_frames: 1..4,
+          kind: :lightning
+        },
+        grenade_launcher: {
+          cooldown: 0.6,
+          ammo_type: :rockets,
+          ammo_cost: 1,
+          sound: "weapons/grenade.wav",
+          damage: 120,
+          radius_damage: 120,
+          kick: :small,
+          animation_frames: 1..6,
+          kind: :grenade
+        }
+      }.freeze
+
+      FireResult = Data.define(
+        :weapon, :sound, :pellets, :range, :spread_x, :spread_y,
+        :damage, :damage_variance, :radius_damage, :kick, :animation_frames, :kind
+      )
+
+      attr_accessor :health, :armor, :armor_type, :current_weapon, :flags, :deathtype,
+                    :deadflag, :view_offset, :weapon_model, :face_anim_time, :frags,
+                    :show_hostile, :b_switch, :w_switch, :centerprint
+      attr_reader :ammo, :weapons_owned, :keys_owned, :serverflags, :powerup_finished,
+                  :powerup_warning_time, :megahealth_rot_time, :effects, :weapon_gettime
 
       def initialize
         @health = 100
@@ -42,7 +175,25 @@ module Quake
         @armor_type = 0 # 0=none, 1=green(30%), 2=yellow(60%), 3=red(80%)
         @current_weapon = :shotgun
         @weapons_owned = Set.new([:axe, :shotgun])
+        @keys_owned = Set.new
+        @serverflags = 0
+        @flags = FL_CLIENT
         @ammo = { shells: 25, nails: 0, rockets: 0, cells: 0 }
+        @powerup_finished = {}
+        @powerup_warning_time = {}
+        @weapon_gettime = {}
+        @megahealth_rot_time = nil
+        @effects = 0
+        @deathtype = ""
+        @deadflag = DEAD_NO
+        @view_offset = DEFAULT_VIEW_OFFSET
+        @weapon_model = nil
+        @face_anim_time = 0.0
+        @frags = 0
+        @show_hostile = 0.0
+        @b_switch = 8
+        @w_switch = 8
+        @centerprint = nil
       end
 
       def current_ammo_type
@@ -55,6 +206,8 @@ module Quake
       end
 
       def current_weapon_model
+        return @weapon_model unless @weapon_model.nil?
+
         WEAPON_MODELS[@current_weapon]
       end
 
@@ -63,7 +216,7 @@ module Quake
         idx = WEAPONS.index(@current_weapon) || 0
         WEAPONS.size.times do
           idx = (idx + 1) % WEAPONS.size
-          if @weapons_owned.include?(WEAPONS[idx])
+          if selectable_weapon?(WEAPONS[idx])
             @current_weapon = WEAPONS[idx]
             return
           end
@@ -74,7 +227,7 @@ module Quake
         idx = WEAPONS.index(@current_weapon) || 0
         WEAPONS.size.times do
           idx = (idx - 1) % WEAPONS.size
-          if @weapons_owned.include?(WEAPONS[idx])
+          if selectable_weapon?(WEAPONS[idx])
             @current_weapon = WEAPONS[idx]
             return
           end
@@ -83,15 +236,89 @@ module Quake
 
       # Select weapon by slot number (1-8)
       def select_weapon(slot)
-        slot = slot.clamp(1, WEAPONS.size)
+        return unless (1..WEAPONS.size).cover?(slot)
+
         weapon = WEAPONS[slot - 1]
-        @current_weapon = weapon if @weapons_owned.include?(weapon)
+        @current_weapon = weapon if selectable_weapon?(weapon)
+      end
+
+      def handle_impulse_command(impulse)
+        command = impulse.to_i
+        if (1..WEAPONS.size).cover?(command)
+          select_weapon(command)
+        elsif command == 10
+          next_weapon
+        elsif command == 11
+          advance_serverflags_command
+        elsif command == 12
+          prev_weapon
+        end
       end
 
       def alive?
         @health > 0
       end
 
+      def classname
+        "player"
+      end
+
+      def can_fire_current_weapon?
+        _weapon, fire = effective_fire_definition
+        return false unless fire
+
+        ammo_type = fire[:ammo_type]
+        ammo_type.nil? || @ammo[ammo_type] >= fire[:ammo_cost]
+      end
+
+      def fire_current_weapon(water_level: 0, deathmatch: 0)
+        weapon, fire = effective_fire_definition
+        return nil unless fire
+        unless can_fire_current_weapon?
+          @current_weapon = best_weapon(water_level: water_level)
+          return nil
+        end
+
+        ammo_type = fire[:ammo_type]
+        @ammo[ammo_type] -= fire[:ammo_cost] if ammo_type && deathmatch.to_i != 4
+
+        damage = fire[:damage]
+        damage = 75 if weapon == :axe && deathmatch.to_i > 3
+
+        FireResult.new(
+          weapon: weapon,
+          sound: fire[:sound],
+          pellets: fire[:pellets],
+          range: fire[:range],
+          spread_x: fire[:spread_x],
+          spread_y: fire[:spread_y],
+          damage: damage,
+          damage_variance: fire[:damage_variance],
+          radius_damage: fire[:radius_damage],
+          kick: fire[:kick],
+          animation_frames: fire[:animation_frames],
+          kind: fire[:kind]
+        )
+      end
+
+      def best_weapon(water_level: 0)
+        return :lightning_gun if water_level <= 1 && @weapons_owned.include?(:lightning_gun) && @ammo[:cells] >= 1
+        return :super_nailgun if @weapons_owned.include?(:super_nailgun) && @ammo[:nails] >= 2
+        return :super_shotgun if @weapons_owned.include?(:super_shotgun) && @ammo[:shells] >= 2
+        return :nailgun if @weapons_owned.include?(:nailgun) && @ammo[:nails] >= 1
+        return :shotgun if @weapons_owned.include?(:shotgun) && @ammo[:shells] >= 1
+
+        :axe
+      end
+
+      def switch_to_best_weapon(water_level: 0)
+        @current_weapon = best_weapon(water_level: water_level)
+      end
+
+      def current_weapon_cooldown
+        WEAPON_FIRE.dig(@current_weapon, :cooldown) || 0.0
+      end
+
       # Max ammo capacities (from Quake defs.qc)
       MAX_HEALTH = 100
       MAX_MEGA_HEALTH = 250
@@ -100,58 +327,328 @@ module Quake
       MAX_NAILS = 200
       MAX_ROCKETS = 100
       MAX_CELLS = 100
+      DEAD_NO = 0
+      DEAD_DYING = 1
+      DEAD_DEAD = 2
+      DEAD_RESPAWNABLE = 3
+      DEFAULT_VIEW_OFFSET = Math::Vec3.new(0.0, 0.0, 22.0)
+      DEATH_VIEW_OFFSET = Math::Vec3.new(0.0, 0.0, -8.0)
+      GIB_VIEW_OFFSET = Math::Vec3.new(0.0, 0.0, 8.0)
+
+      ARMOR_SAVE = {
+        0 => 0.0,
+        1 => 0.3,
+        2 => 0.6,
+        3 => 0.8,
+        0.0 => 0.0,
+        0.3 => 0.3,
+        0.6 => 0.6,
+        0.8 => 0.8
+      }.freeze
 
       AMMO_CAPS = {
         shells: MAX_SHELLS, nails: MAX_NAILS,
         rockets: MAX_ROCKETS, cells: MAX_CELLS
       }.freeze
 
+      # QuakeC items.qc RankForWeapon: lower ranks are preferred on pickup.
+      WEAPON_PICKUP_RANK = {
+        lightning_gun: 1,
+        rocket_launcher: 2,
+        super_nailgun: 3,
+        grenade_launcher: 4,
+        super_shotgun: 5,
+        nailgun: 6
+      }.freeze
+
       # Add health, returns true if picked up
-      def add_health(amount, mega: false)
+      def add_health(amount, mega: false, game_time: nil)
         max = mega ? MAX_MEGA_HEALTH : MAX_HEALTH
+        return false if @health <= 0
         return false if @health >= max
 
+        amount = amount.to_f.ceil
         @health = [@health + amount, max].min
+        @megahealth_rot_time = game_time.to_f + 5.0 if mega && game_time
         true
       end
 
+      def update_megahealth(game_time)
+        return unless @megahealth_rot_time
+        if @health <= MAX_HEALTH
+          @megahealth_rot_time = nil
+          return
+        end
+        return if game_time < @megahealth_rot_time
+
+        ticks = ((game_time - @megahealth_rot_time).floor + 1).to_i
+        @health = [@health - ticks, MAX_HEALTH].max
+        @megahealth_rot_time += ticks
+        @megahealth_rot_time = nil if @health <= MAX_HEALTH
+      end
+
       # Add armor, returns true if picked up
       def add_armor(points, type)
-        # Only pick up if it's better than current armor
-        # type: 1=green(30%), 2=yellow(60%), 3=red(80%)
-        return false if type < @armor_type && @armor > 0
+        return false unless alive?
+
+        # QuakeC armor_touch compares armortype * armorvalue against
+        # incoming type * value, where armortype is the save fraction.
+        current_protection = ARMOR_SAVE.fetch(@armor_type, 0.0) * @armor
+        incoming_protection = ARMOR_SAVE.fetch(type, 0.0) * points
+        return false if current_protection >= incoming_protection
 
         @armor = [points, MAX_ARMOR].min
         @armor_type = type
         true
       end
 
+      def add_powerup(powerup, game_time:, finish_time: nil)
+        return false unless alive?
+
+        duration = POWERUP_DURATIONS.fetch(powerup)
+        @powerup_finished[powerup] = finish_time&.to_f || game_time.to_f + duration
+        @powerup_warning_time[powerup] = 1.0
+        true
+      end
+
+      def add_key(key)
+        return false unless alive?
+        return false if @keys_owned.include?(key)
+
+        @keys_owned.add(key)
+        true
+      end
+
+      def has_key?(key)
+        @keys_owned.include?(key)
+      end
+
+      def consume_key(key)
+        @keys_owned.delete?(key)
+      end
+
+      def add_sigil(flags)
+        return false unless alive?
+
+        sigil_flags = flags.to_i & 15
+        @serverflags |= sigil_flags
+        true
+      end
+
+      def advance_serverflags_command
+        @serverflags = (@serverflags * 2) + 1
+      end
+
+      def powerup_active?(powerup, game_time:)
+        (@powerup_finished[powerup] || 0.0) > game_time.to_f
+      end
+
+      def powerup_item_active?(powerup, game_time:)
+        finished = @powerup_finished[powerup]
+        finished && finished >= game_time.to_f
+      end
+
+      def invulnerable_to_damage?(game_time:)
+        finished = @powerup_finished[:pentagram]
+        finished && finished >= game_time.to_f
+      end
+
+      def update_powerups(game_time)
+        now = game_time.to_f
+        update_powerup_effects(now)
+        @powerup_finished.delete_if do |powerup, finished|
+          expired = finished < now
+          @powerup_warning_time.delete(powerup) if expired
+          expired
+        end
+      end
+
+      def update_powerup_effects(game_time)
+        @effects &= ~POWERUP_EFFECT_BITS
+
+        if powerup_active?(:pentagram, game_time: game_time)
+          @effects |= EF_DIMLIGHT
+          @effects |= EF_RED
+        end
+
+        if powerup_active?(:quad, game_time: game_time)
+          @effects |= EF_DIMLIGHT
+          @effects |= EF_BLUE
+        end
+      end
+
+      def clear_powerups_on_death
+        clear_temporary_powerups
+      end
+
+      def apply_changelevel_parms
+        if @health <= 0
+          reset_to_new_parms
+          return
+        end
+
+        @keys_owned.clear
+        clear_temporary_powerups
+        @megahealth_rot_time = nil
+        @health = [[@health, 50].max, 100].min
+        @ammo[:shells] = 25 if @ammo[:shells] < 25
+      end
+
+      def reset_spawn_runtime_fields
+        @flags = FL_CLIENT
+        @deathtype = ""
+        @deadflag = DEAD_NO
+        @view_offset = DEFAULT_VIEW_OFFSET
+        @weapon_model = nil
+        @face_anim_time = 0.0
+        @show_hostile = 0.0
+        @weapon_gettime.clear
+        clear_temporary_powerups
+      end
+
+      def reset_to_new_parms
+        @health = 100
+        @armor = 0
+        @armor_type = 0
+        @current_weapon = :shotgun
+        @weapons_owned = Set.new([:axe, :shotgun])
+        @keys_owned.clear
+        reset_spawn_runtime_fields
+        @ammo = { shells: 25, nails: 0, rockets: 0, cells: 0 }
+        @megahealth_rot_time = nil
+      end
+
+      def clear_temporary_powerups
+        @powerup_finished.clear
+        @powerup_warning_time.clear
+        @effects &= ~POWERUP_EFFECT_BITS
+      end
+
+      def take_damage(amount, game_time: nil)
+        amount = amount.to_f
+        save = (ARMOR_SAVE.fetch(@armor_type, 0.0) * amount).ceil
+        if save >= @armor
+          save = @armor
+          @armor_type = 0
+        end
+
+        @armor -= save
+        return { take: 0, save: save } if (@flags & FL_GODMODE) != 0
+        if game_time && invulnerable_to_damage?(game_time: game_time)
+          return { take: 0, save: save }
+        end
+
+        take = (amount - save).ceil
+        @health -= take
+        @health = -99 if @health < -99
+        { take: take, save: save }
+      end
+
+      def effective_fire_definition
+        if @current_weapon == :super_shotgun && @ammo[:shells] == 1
+          return [:shotgun, WEAPON_FIRE[:shotgun]]
+        end
+
+        if @current_weapon == :super_nailgun && @ammo[:nails] == 1
+          return [:nailgun, WEAPON_FIRE[:nailgun]]
+        end
+
+        [@current_weapon, WEAPON_FIRE[@current_weapon]]
+      end
+
+      def selectable_weapon?(weapon)
+        return false unless @weapons_owned.include?(weapon)
+
+        fire = WEAPON_FIRE[weapon]
+        return false unless fire
+
+        ammo_type = fire[:ammo_type]
+        ammo_type.nil? || @ammo[ammo_type] >= fire[:ammo_cost]
+      end
+
       # Add ammo, returns true if picked up
-      def add_ammo(type, amount)
+      def add_ammo(type, amount, auto_switch: false, water_level: 0)
+        return false unless alive?
+
         cap = AMMO_CAPS[type]
         return false unless cap
         return false if @ammo[type] >= cap
 
+        old_best = best_weapon(water_level: water_level) if auto_switch
         @ammo[type] = [@ammo[type] + amount, cap].min
+        @current_weapon = best_weapon(water_level: water_level) if auto_switch && @current_weapon == old_best
         true
       end
 
-      # Give weapon, returns true if picked up (always true for new weapons)
-      def give_weapon(weapon, ammo_type: nil, ammo_amount: 0)
+      def add_backpack(ammo:, weapon: nil, water_level: 0, game_time: nil, b_switch: nil)
+        return false unless alive?
+
+        ammo.each do |type, amount|
+          add_ammo(type, amount) if amount.positive?
+        end
+
+        if weapon
+          current = @current_weapon
+          give_weapon(weapon, game_time: game_time)
+          @current_weapon = current unless backpack_weapon_switch_allowed?(weapon, water_level, b_switch)
+        end
+        true
+      end
+
+      def backpack_weapon_switch_allowed?(weapon, water_level, b_switch)
+        return false if weapon == :lightning_gun && water_level.positive?
+
+        switch_limit = b_switch.to_i
+        switch_limit = 8 if switch_limit.zero?
+        weapon_code(weapon) <= switch_limit
+      end
+
+      def weapon_code(weapon)
+        case weapon
+        when :super_shotgun then 3
+        when :nailgun then 4
+        when :super_nailgun then 5
+        when :grenade_launcher then 6
+        when :rocket_launcher then 7
+        when :lightning_gun then 8
+        else 1
+        end
+      end
+
+      # Give weapon, returns true if Quake weapon_touch accepts the pickup.
+      def give_weapon(weapon, ammo_type: nil, ammo_amount: 0, water_level: 0, game_time: nil, w_switch: nil)
+        return false unless alive?
+
         had_weapon = @weapons_owned.include?(weapon)
         @weapons_owned.add(weapon)
+        record_weapon_gettime(weapon, game_time) unless had_weapon
 
-        ammo_picked = false
-        if ammo_type && ammo_amount > 0
-          ammo_picked = add_ammo(ammo_type, ammo_amount)
-        end
+        add_ammo(ammo_type, ammo_amount) if ammo_type && ammo_amount > 0
 
-        if !had_weapon
+        if weapon_pickup_rank(weapon) < weapon_pickup_rank(@current_weapon) &&
+           weapon_switch_allowed?(weapon, water_level, w_switch)
           @current_weapon = weapon
-          true
-        else
-          ammo_picked
         end
+        true
+      end
+
+      def weapon_switch_allowed?(weapon, water_level, w_switch)
+        return false if weapon == :lightning_gun && water_level.positive?
+
+        switch_limit = w_switch.to_i
+        switch_limit = 8 if switch_limit.zero?
+        weapon_code(weapon) <= switch_limit
+      end
+
+      def weapon_pickup_rank(weapon)
+        WEAPON_PICKUP_RANK.fetch(weapon, 7)
+      end
+
+      def record_weapon_gettime(weapon, game_time)
+        index = WEAPON_ITEM_INDEX[weapon]
+        return unless index && game_time
+
+        @weapon_gettime[index] = game_time.to_f
       end
     end
   end