Port new code to all weapons, part 2

diff --git a/qcsrc/server/w_crylink.qc b/qcsrc/server/w_crylink.qc
index 7be90ae12d7a4ba159f7a3e590398a427f88fa4e..9d9f32edf3732c5e1aa3fa5920707fd0b9a2411e 100644 (file)
--- a/qcsrc/server/w_crylink.qc
+++ b/qcsrc/server/w_crylink.qc
@@ -9,9 +9,6 @@ REGISTER_WEAPON(CRYLINK, w_crylink, IT_CELLS, 6, WEP_FLAG_NORMAL | WEP_TYPE_SPLA
 .entity queuenext;
 .entity queueprev;
 
-// weapon load persistence, for weapons that support reloading
-.float crylink_load;
-
 void W_Crylink_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -19,7 +16,7 @@ void W_Crylink_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.crylink_load;
+               self.clip_load = self.weapon_load[WEP_CRYLINK];
                self.clip_size = autocvar_g_balance_crylink_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -358,7 +355,7 @@ void W_Crylink_Attack (void)
                if(autocvar_g_balance_crylink_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_crylink_primary_ammo;
-                       self.crylink_load = self.clip_load;
+                       self.weapon_load[WEP_CRYLINK] = self.clip_load;
                }
                else
                        self.ammo_cells -= autocvar_g_balance_crylink_primary_ammo;
@@ -471,7 +468,7 @@ void W_Crylink_Attack2 (void)
                if(autocvar_g_balance_crylink_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_crylink_secondary_ammo;
-                       self.crylink_load = self.clip_load;
+                       self.weapon_load[WEP_CRYLINK] = self.clip_load;
                }
                else
                        self.ammo_cells -= autocvar_g_balance_crylink_secondary_ammo;
@@ -656,7 +653,7 @@ float w_crylink(float req)
                        return TRUE;
 
                ammo_amount = self.ammo_cells >= autocvar_g_balance_crylink_primary_ammo;
-               ammo_amount += self.crylink_load >= autocvar_g_balance_crylink_primary_ammo;
+               ammo_amount += self.weapon_load[WEP_CRYLINK] >= autocvar_g_balance_crylink_primary_ammo;
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
@@ -666,13 +663,13 @@ float w_crylink(float req)
                        return TRUE;
 
                ammo_amount = self.ammo_cells >= autocvar_g_balance_crylink_secondary_ammo;
-               ammo_amount += self.crylink_load >= autocvar_g_balance_crylink_secondary_ammo;
+               ammo_amount += self.weapon_load[WEP_CRYLINK] >= autocvar_g_balance_crylink_secondary_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
        {
                // all weapons must be fully loaded when we spawn
-               self.crylink_load = autocvar_g_balance_crylink_reload_ammo;
+               self.weapon_load[WEP_CRYLINK] = autocvar_g_balance_crylink_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_electro.qc b/qcsrc/server/w_electro.qc
index 215290b3435e38efc97dbed3f9b1c30d737e2a12..d6b555e0768c51c0f788fadfa8b8974e9f86e4ac 100644 (file)
--- a/qcsrc/server/w_electro.qc
+++ b/qcsrc/server/w_electro.qc
@@ -5,9 +5,6 @@ REGISTER_WEAPON(ELECTRO, w_electro, IT_CELLS, 5, WEP_FLAG_NORMAL | WEP_TYPE_SPLA
 .float electro_count;
 .float electro_secondarytime;
 
-// weapon load persistence, for weapons that support reloading
-.float electro_load;
-
 void W_Electro_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -15,7 +12,7 @@ void W_Electro_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.electro_load;
+               self.clip_load = self.weapon_load[WEP_ELECTRO];
                self.clip_size = autocvar_g_balance_electro_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -142,7 +139,7 @@ void W_Electro_Attack()
                if(autocvar_g_balance_electro_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_electro_primary_ammo;
-                       self.electro_load = self.clip_load;
+                       self.weapon_load[WEP_ELECTRO] = self.clip_load;
                }
                else
                        self.ammo_cells -= autocvar_g_balance_electro_primary_ammo;
@@ -189,7 +186,7 @@ void W_Electro_Attack2()
                if(autocvar_g_balance_electro_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_electro_secondary_ammo;
-                       self.electro_load = self.clip_load;
+                       self.weapon_load[WEP_ELECTRO] = self.clip_load;
                }
                else
                        self.ammo_cells -= autocvar_g_balance_electro_secondary_ammo;
@@ -282,48 +279,52 @@ float lgbeam_checkammo()
 
 void lgbeam_think()
 {
-       self.owner.prevlgfire = time;
-       if (self != self.owner.lgbeam)
+       entity owner_player;
+       owner_player = self.owner;
+
+       owner_player.prevlgfire = time;
+       if (self != owner_player.lgbeam)
        {
                remove(self);
                return;
        }
 
-       if (self.owner.weaponentity.state != WS_INUSE || !lgbeam_checkammo() || self.owner.deadflag != DEAD_NO || !self.owner.BUTTON_ATCK || self.owner.freezetag_frozen)
+       if (owner_player.weaponentity.state != WS_INUSE || !lgbeam_checkammo() || owner_player.deadflag != DEAD_NO || !owner_player.BUTTON_ATCK || owner_player.freezetag_frozen)
        {
-               if(self == self.owner.lgbeam)
-                       self.owner.lgbeam = world;
+               if(self == owner_player.lgbeam)
+                       owner_player.lgbeam = world;
                remove(self);
                return;
        }
 
        self.nextthink = time;
 
-       makevectors(self.owner.v_angle);
+       makevectors(owner_player.v_angle);
 
        float dt, f;
        dt = frametime;
+
        // if this weapon is reloadable, decrease its load. Else decrease the player's ammo
-       if not(self.owner.items & IT_UNLIMITED_WEAPON_AMMO)
+       if not(owner_player.items & IT_UNLIMITED_WEAPON_AMMO)
        {
                if(autocvar_g_balance_electro_primary_ammo)
                {
                        if(autocvar_g_balance_electro_reload_ammo)
                        {
-                               dt = min(dt, self.owner.clip_load / autocvar_g_balance_electro_primary_ammo);
-                               self.owner.clip_load = max(0, self.owner.clip_load - autocvar_g_balance_electro_primary_ammo * frametime);
-                               self.owner.electro_load = self.owner.clip_load;
+                               dt = min(dt, owner_player.clip_load / autocvar_g_balance_electro_primary_ammo);
+                               owner_player.clip_load = max(0, owner_player.clip_load - autocvar_g_balance_electro_primary_ammo * frametime);
+                               owner_player.weapon_load[WEP_ELECTRO] = owner_player.clip_load;
                        }
                        else
                        {
-                               dt = min(dt, self.owner.ammo_cells / autocvar_g_balance_electro_primary_ammo);
-                               self.owner.ammo_cells = max(0, self.owner.ammo_cells - autocvar_g_balance_electro_primary_ammo * frametime);
+                               dt = min(dt, owner_player.ammo_cells / autocvar_g_balance_electro_primary_ammo);
+                               owner_player.ammo_cells = max(0, owner_player.ammo_cells - autocvar_g_balance_electro_primary_ammo * frametime);
                        }
                }
        }
 
-       W_SetupShot_Range(self.owner, TRUE, 0, "", 0, autocvar_g_balance_electro_primary_damage * dt, autocvar_g_balance_electro_primary_range);
-       WarpZone_traceline_antilag(self.owner, w_shotorg, w_shotend, MOVE_NORMAL, self.owner, ANTILAG_LATENCY(self.owner));
+       W_SetupShot_Range(owner_player, TRUE, 0, "", 0, autocvar_g_balance_electro_primary_damage * dt, autocvar_g_balance_electro_primary_range);
+       WarpZone_traceline_antilag(owner_player, w_shotorg, w_shotend, MOVE_NORMAL, owner_player, ANTILAG_LATENCY(owner_player));
 
        // apply the damage
        if(trace_ent)
@@ -333,11 +334,11 @@ void lgbeam_think()
 
                f = ExponentialFalloff(autocvar_g_balance_electro_primary_falloff_mindist, autocvar_g_balance_electro_primary_falloff_maxdist, autocvar_g_balance_electro_primary_falloff_halflifedist, vlen(WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos) - w_shotorg));
 
-               if(accuracy_isgooddamage(self.owner, trace_ent))
-                       accuracy_add(self.owner, WEP_ELECTRO, 0, autocvar_g_balance_electro_primary_damage * dt * f);
-               Damage (trace_ent, self.owner, self.owner, autocvar_g_balance_electro_primary_damage * dt * f, WEP_ELECTRO, trace_endpos, force * dt);
+               if(accuracy_isgooddamage(owner_player, trace_ent))
+                       accuracy_add(owner_player, WEP_ELECTRO, 0, autocvar_g_balance_electro_primary_damage * dt * f);
+               Damage (trace_ent, owner_player, owner_player, autocvar_g_balance_electro_primary_damage * dt * f, WEP_ELECTRO, trace_endpos, force * dt);
        }
-       W_Plasma_TriggerCombo(trace_endpos, autocvar_g_balance_electro_primary_comboradius, self.owner);
+       W_Plasma_TriggerCombo(trace_endpos, autocvar_g_balance_electro_primary_comboradius, owner_player);
 
        // draw effect
        if(w_shotorg != self.hook_start)
@@ -544,20 +545,20 @@ float w_electro(float req)
                {
                        ammo_amount = !autocvar_g_balance_electro_primary_ammo || (self.ammo_cells > 0);
                        if(autocvar_g_balance_electro_lightning)
-                               ammo_amount += self.electro_load > 0;
+                               ammo_amount += self.weapon_load[WEP_ELECTRO] > 0;
                }
                else
                {
                        ammo_amount = self.ammo_cells >= autocvar_g_balance_electro_primary_ammo;
                        if(autocvar_g_balance_electro_lightning)
-                               ammo_amount += self.electro_load >= autocvar_g_balance_electro_primary_ammo;
+                               ammo_amount += self.weapon_load[WEP_ELECTRO] >= autocvar_g_balance_electro_primary_ammo;
                }
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_electro_secondary_ammo;
-               ammo_amount += self.electro_load >= autocvar_g_balance_electro_secondary_ammo;
+               ammo_amount += self.weapon_load[WEP_ELECTRO] >= autocvar_g_balance_electro_secondary_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
@@ -565,7 +566,7 @@ float w_electro(float req)
                self.electro_secondarytime = time;
 
                // all weapons must be fully loaded when we spawn
-               self.electro_load = autocvar_g_balance_electro_reload_ammo;
+               self.weapon_load[WEP_ELECTRO] = autocvar_g_balance_electro_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_fireball.qc b/qcsrc/server/w_fireball.qc
index 98571d30d0ff1d911646cbda49b2458c765c7441..b95a1e2a7a3e0c724b295ce1d9f44e310586b15a 100644 (file)
--- a/qcsrc/server/w_fireball.qc
+++ b/qcsrc/server/w_fireball.qc
@@ -6,9 +6,6 @@ REGISTER_WEAPON(FIREBALL, w_fireball, IT_FUEL, 9, WEP_TYPE_SPLASH, BOT_PICKUP_RA
 .vector fireball_impactvec;
 .float fireball_primarytime;
 
-// weapon load persistence, for weapons that support reloading
-.float fireball_load;
-
 void W_Fireball_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -16,7 +13,7 @@ void W_Fireball_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.fireball_load;
+               self.clip_load = self.weapon_load[WEP_FIREBALL];
                self.clip_size = autocvar_g_balance_fireball_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -230,7 +227,7 @@ void W_Fireball_Attack1_Frame0()
                if(autocvar_g_balance_fireball_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_fireball_primary_ammo;
-                       self.fireball_load = self.clip_load;
+                       self.weapon_load[WEP_FIREBALL] = self.clip_load;
                }
                else
                        self.ammo_fuel -= autocvar_g_balance_fireball_primary_ammo;
@@ -291,7 +288,7 @@ void W_Fireball_Attack2()
                if(autocvar_g_balance_fireball_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_fireball_secondary_ammo;
-                       self.fireball_load = self.clip_load;
+                       self.weapon_load[WEP_FIREBALL] = self.clip_load;
                }
                else
                        self.ammo_fuel -= autocvar_g_balance_fireball_secondary_ammo;
@@ -415,13 +412,13 @@ float w_fireball(float req)
        else if (req == WR_CHECKAMMO1)
        {
                ammo_amount = self.ammo_fuel >= autocvar_g_balance_fireball_primary_ammo;
-               ammo_amount += self.fireball_load >= autocvar_g_balance_fireball_primary_ammo;
+               ammo_amount += self.weapon_load[WEP_FIREBALL] >= autocvar_g_balance_fireball_primary_ammo;
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
        {
                ammo_amount = self.ammo_fuel >= autocvar_g_balance_fireball_secondary_ammo;
-               ammo_amount += self.fireball_load >= autocvar_g_balance_fireball_secondary_ammo;
+               ammo_amount += self.weapon_load[WEP_FIREBALL] >= autocvar_g_balance_fireball_secondary_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
@@ -429,7 +426,7 @@ float w_fireball(float req)
                self.fireball_primarytime = time;
 
                // all weapons must be fully loaded when we spawn
-               self.fireball_load = autocvar_g_balance_fireball_reload_ammo;
+               self.weapon_load[WEP_FIREBALL] = autocvar_g_balance_fireball_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_grenadelauncher.qc b/qcsrc/server/w_grenadelauncher.qc
index bea8e2f609447b78f47fbee5311c6e9f182ea0ff..a3ba552b934c89cda7f9c94d4d8c88c2022c3bfc 100644 (file)
--- a/qcsrc/server/w_grenadelauncher.qc
+++ b/qcsrc/server/w_grenadelauncher.qc
@@ -5,9 +5,6 @@ REGISTER_WEAPON(GRENADE_LAUNCHER, w_glauncher, IT_ROCKETS, 4, WEP_FLAG_NORMAL |
 .float gl_detonate_later;
 .float gl_bouncecnt;
 
-// weapon load persistence, for weapons that support reloading
-.float grenadelauncher_load;
-
 void W_GrenadeLauncher_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -15,7 +12,7 @@ void W_GrenadeLauncher_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.grenadelauncher_load;
+               self.clip_load = self.weapon_load[WEP_GRENADE_LAUNCHER];
                self.clip_size = autocvar_g_balance_grenadelauncher_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -193,7 +190,7 @@ void W_Grenade_Attack (void)
                if(autocvar_g_balance_grenadelauncher_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_grenadelauncher_primary_ammo;
-                       self.grenadelauncher_load = self.clip_load;
+                       self.weapon_load[WEP_GRENADE_LAUNCHER] = self.clip_load;
                }
                else
                        self.ammo_rockets -= autocvar_g_balance_grenadelauncher_primary_ammo;
@@ -250,7 +247,7 @@ void W_Grenade_Attack2 (void)
                if(autocvar_g_balance_grenadelauncher_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_grenadelauncher_secondary_ammo;
-                       self.grenadelauncher_load = self.clip_load;
+                       self.weapon_load[WEP_GRENADE_LAUNCHER] = self.clip_load;
                }
                else
                        self.ammo_rockets -= autocvar_g_balance_grenadelauncher_secondary_ammo;
@@ -387,19 +384,19 @@ float w_glauncher(float req)
        else if (req == WR_CHECKAMMO1)
        {
                ammo_amount = self.ammo_rockets >= autocvar_g_balance_grenadelauncher_primary_ammo;
-               ammo_amount += self.grenadelauncher_load >= autocvar_g_balance_grenadelauncher_primary_ammo;
+               ammo_amount += self.weapon_load[WEP_GRENADE_LAUNCHER] >= autocvar_g_balance_grenadelauncher_primary_ammo;
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
        {
                ammo_amount = self.ammo_rockets >= autocvar_g_balance_grenadelauncher_secondary_ammo;
-               ammo_amount += self.grenadelauncher_load >= autocvar_g_balance_grenadelauncher_secondary_ammo;
+               ammo_amount += self.weapon_load[WEP_GRENADE_LAUNCHER] >= autocvar_g_balance_grenadelauncher_secondary_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
        {
                // all weapons must be fully loaded when we spawn
-               self.grenadelauncher_load = autocvar_g_balance_grenadelauncher_reload_ammo;
+               self.weapon_load[WEP_GRENADE_LAUNCHER] = autocvar_g_balance_grenadelauncher_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_hlac.qc b/qcsrc/server/w_hlac.qc
index ecca801400f036db423a3c5bbf85270dc52ab7b6..bb27001ba03bd0a99311ba7ad26973a0f3dca365 100644 (file)
--- a/qcsrc/server/w_hlac.qc
+++ b/qcsrc/server/w_hlac.qc
@@ -3,9 +3,6 @@ REGISTER_WEAPON(HLAC, w_hlac, IT_CELLS, 6, WEP_FLAG_NORMAL | WEP_TYPE_SPLASH, BO
 #else
 #ifdef SVQC
 
-// weapon load persistence, for weapons that support reloading
-.float hlac_load;
-
 void W_HLAC_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -13,7 +10,7 @@ void W_HLAC_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.hlac_load;
+               self.clip_load = self.weapon_load[WEP_HLAC];
                self.clip_size = autocvar_g_balance_hlac_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -54,7 +51,7 @@ void W_HLAC_Attack (void)
                if(autocvar_g_balance_hlac_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_hlac_primary_ammo;
-                       self.hlac_load = self.clip_load;
+                       self.weapon_load[WEP_HLAC] = self.clip_load;
                }
                else
                        self.ammo_cells -= autocvar_g_balance_hlac_primary_ammo;
@@ -155,7 +152,7 @@ void W_HLAC_Attack2 (void)
                if(autocvar_g_balance_hlac_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_hlac_secondary_ammo;
-                       self.hlac_load = self.clip_load;
+                       self.weapon_load[WEP_HLAC] = self.clip_load;
                }
                else
                        self.ammo_cells -= autocvar_g_balance_hlac_secondary_ammo;
@@ -250,19 +247,19 @@ float w_hlac(float req)
        else if (req == WR_CHECKAMMO1)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_hlac_primary_ammo;
-               ammo_amount += self.hlac_load >= autocvar_g_balance_hlac_primary_ammo;
+               ammo_amount += self.weapon_load[WEP_HLAC] >= autocvar_g_balance_hlac_primary_ammo;
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_hlac_secondary_ammo;
-               ammo_amount += self.hlac_load >= autocvar_g_balance_hlac_secondary_ammo;
+               ammo_amount += self.weapon_load[WEP_HLAC] >= autocvar_g_balance_hlac_secondary_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
        {
                // all weapons must be fully loaded when we spawn
-               self.hlac_load = autocvar_g_balance_hlac_reload_ammo;
+               self.weapon_load[WEP_HLAC] = autocvar_g_balance_hlac_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_minelayer.qc b/qcsrc/server/w_minelayer.qc
index e3fe77450a8796197952f6646917428d6411c28c..5739d6e45701dd1909bd5982ee363ae3377fe31f 100644 (file)
--- a/qcsrc/server/w_minelayer.qc
+++ b/qcsrc/server/w_minelayer.qc
@@ -6,9 +6,6 @@ void W_Mine_Think (void);
 .float minelayer_detonate, minelayer_mines;
 .float mine_time;
 
-// weapon load persistence, for weapons that support reloading
-.float minelayer_load;
-
 void W_MineLayer_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -16,7 +13,7 @@ void W_MineLayer_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.minelayer_load;
+               self.clip_load = self.weapon_load[WEP_MINE_LAYER];
                self.clip_size = autocvar_g_balance_minelayer_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -246,7 +243,7 @@ void W_Mine_Attack (void)
                if(autocvar_g_balance_minelayer_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_minelayer_ammo;
-                       self.minelayer_load = self.clip_load;
+                       self.weapon_load[WEP_MINE_LAYER] = self.clip_load;
                }
                else
                        self.ammo_rockets -= autocvar_g_balance_minelayer_ammo;
@@ -455,7 +452,7 @@ float w_minelayer(float req)
                {
                        if(autocvar_g_balance_minelayer_reload_ammo)
                        {
-                               if(self.ammo_rockets < autocvar_g_balance_minelayer_ammo && self.minelayer_load < autocvar_g_balance_minelayer_ammo)
+                               if(self.ammo_rockets < autocvar_g_balance_minelayer_ammo && self.weapon_load[WEP_MINE_LAYER] < autocvar_g_balance_minelayer_ammo)
                                        ammo_amount = TRUE;
                        }
                        else if(self.ammo_rockets < autocvar_g_balance_minelayer_ammo)
@@ -470,7 +467,7 @@ float w_minelayer(float req)
        else if (req == WR_RESETPLAYER)
        {
                // all weapons must be fully loaded when we spawn
-               self.minelayer_load = autocvar_g_balance_minelayer_reload_ammo;
+               self.weapon_load[WEP_MINE_LAYER] = autocvar_g_balance_minelayer_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_minstanex.qc b/qcsrc/server/w_minstanex.qc
index 9981ad2692749ee3da2a2b8c9197a46d32ac7fe9..91132e7d20ba01764c9245ff1761a4a128ec77c3 100644 (file)
--- a/qcsrc/server/w_minstanex.qc
+++ b/qcsrc/server/w_minstanex.qc
@@ -4,9 +4,6 @@ REGISTER_WEAPON(MINSTANEX, w_minstanex, IT_CELLS, 7, WEP_FLAG_HIDDEN | WEP_FLAG_
 #ifdef SVQC
 .float minstanex_lasthit;
 
-// weapon load persistence, for weapons that support reloading
-.float minstanex_load;
-
 void W_Minstanex_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -14,7 +11,7 @@ void W_Minstanex_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.minstanex_load;
+               self.clip_load = self.weapon_load[WEP_MINSTANEX];
                self.clip_size = autocvar_g_balance_minstanex_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -118,7 +115,7 @@ void W_MinstaNex_Attack (void)
                                self.clip_load -= - 1;
                        else
                                self.clip_load -= autocvar_g_balance_minstanex_ammo;
-                       self.minstanex_load = self.clip_load;
+                       self.weapon_load[WEP_MINSTANEX] = self.clip_load;
                }
                else
                {
@@ -289,7 +286,7 @@ float w_minstanex(float req)
        else if (req == WR_CHECKAMMO1)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_minstanex_ammo;
-               ammo_amount += self.minstanex_load >= autocvar_g_balance_minstanex_ammo;
+               ammo_amount += self.weapon_load[WEP_MINSTANEX] >= autocvar_g_balance_minstanex_ammo;
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
@@ -297,7 +294,7 @@ float w_minstanex(float req)
                if(!autocvar_g_balance_minstanex_laser_ammo)
                        return TRUE;
                ammo_amount = self.ammo_cells >= autocvar_g_balance_minstanex_laser_ammo;
-               ammo_amount += self.minstanex_load >= autocvar_g_balance_minstanex_laser_ammo;
+               ammo_amount += self.weapon_load[WEP_MINSTANEX] >= autocvar_g_balance_minstanex_laser_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
@@ -305,7 +302,7 @@ float w_minstanex(float req)
                self.minstanex_lasthit = 0;
 
                // all weapons must be fully loaded when we spawn
-               self.minstanex_load = autocvar_g_balance_minstanex_reload_ammo;
+               self.weapon_load[WEP_MINSTANEX] = autocvar_g_balance_minstanex_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_nex.qc b/qcsrc/server/w_nex.qc
index c33ac4087f0964d28f21a4fc0439d67470fa0d2c..fd0cbf9ab8b1f7da027379cd7e45c6cb909a2bb2 100644 (file)
--- a/qcsrc/server/w_nex.qc
+++ b/qcsrc/server/w_nex.qc
@@ -3,9 +3,6 @@ REGISTER_WEAPON(NEX, w_nex, IT_CELLS, 7, WEP_FLAG_NORMAL | WEP_TYPE_HITSCAN, BOT
 #else
 #ifdef SVQC
 
-// weapon load persistence, for weapons that support reloading
-.float nex_load;
-
 void W_Nex_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -13,7 +10,7 @@ void W_Nex_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.nex_load;
+               self.clip_load = self.weapon_load[WEP_NEX];
                self.clip_size = autocvar_g_balance_nex_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -107,7 +104,7 @@ void W_Nex_Attack (float issecondary)
                if(autocvar_g_balance_nex_reload_ammo)
                {
                        self.clip_load -= myammo;
-                       self.nex_load = self.clip_load;
+                       self.weapon_load[WEP_NEX] = self.clip_load;
                }
                else
                        self.ammo_cells -= myammo;
@@ -192,7 +189,7 @@ float w_nex(float req)
                                                                                {
                                                                                        self.clip_load = max(autocvar_g_balance_nex_secondary_ammo, self.clip_load - autocvar_g_balance_nex_secondary_ammo * dt);
                                                                                }
-                                                                               self.nex_load = self.clip_load;
+                                                                               self.weapon_load[WEP_NEX] = self.clip_load;
                                                                        }
                                                                        else
                                                                        {
@@ -261,20 +258,20 @@ float w_nex(float req)
        else if (req == WR_CHECKAMMO1)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_nex_primary_ammo;
-               ammo_amount += (autocvar_g_balance_nex_reload_ammo && self.nex_load >= autocvar_g_balance_nex_primary_ammo);
+               ammo_amount += (autocvar_g_balance_nex_reload_ammo && self.weapon_load[WEP_NEX] >= autocvar_g_balance_nex_primary_ammo);
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
        {
                // don't allow charging if we don't have enough ammo
                ammo_amount = self.ammo_cells >= autocvar_g_balance_nex_secondary_ammo;
-               ammo_amount += self.nex_load >= autocvar_g_balance_nex_secondary_ammo;
+               ammo_amount += self.weapon_load[WEP_NEX] >= autocvar_g_balance_nex_secondary_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
        {
                // all weapons must be fully loaded when we spawn
-               self.nex_load = autocvar_g_balance_nex_reload_ammo;
+               self.weapon_load[WEP_NEX] = autocvar_g_balance_nex_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_rocketlauncher.qc b/qcsrc/server/w_rocketlauncher.qc
index a87650a929e88e334473b66f70ef690285b06644..50b9ad0aad554a8f061dcc0b858bc049f486d999 100644 (file)
--- a/qcsrc/server/w_rocketlauncher.qc
+++ b/qcsrc/server/w_rocketlauncher.qc
@@ -5,9 +5,6 @@ REGISTER_WEAPON(ROCKET_LAUNCHER, w_rlauncher, IT_ROCKETS, 9, WEP_FLAG_NORMAL | W
 .float rl_release;
 .float rl_detonate_later;
 
-// weapon load persistence, for weapons that support reloading
-.float rocketlauncher_load;
-
 void W_RocketLauncher_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -15,7 +12,7 @@ void W_RocketLauncher_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.rocketlauncher_load;
+               self.clip_load = self.weapon_load[WEP_ROCKET_LAUNCHER];
                self.clip_size = autocvar_g_balance_rocketlauncher_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -280,7 +277,7 @@ void W_Rocket_Attack (void)
                if(autocvar_g_balance_rocketlauncher_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_rocketlauncher_ammo;
-                       self.rocketlauncher_load = self.clip_load;
+                       self.weapon_load[WEP_ROCKET_LAUNCHER] = self.clip_load;
                }
                else
                        self.ammo_rockets -= autocvar_g_balance_rocketlauncher_ammo;
@@ -496,7 +493,7 @@ float w_rlauncher(float req)
                {
                        if(autocvar_g_balance_rocketlauncher_reload_ammo)
                        {
-                               if(self.ammo_rockets < autocvar_g_balance_rocketlauncher_ammo && self.rocketlauncher_load < autocvar_g_balance_rocketlauncher_ammo)
+                               if(self.ammo_rockets < autocvar_g_balance_rocketlauncher_ammo && self.weapon_load[WEP_ROCKET_LAUNCHER] < autocvar_g_balance_rocketlauncher_ammo)
                                        ammo_amount = TRUE;
                        }
                        else if(self.ammo_rockets < autocvar_g_balance_rocketlauncher_ammo)
@@ -511,7 +508,7 @@ float w_rlauncher(float req)
                self.rl_release = 0;
 
                // all weapons must be fully loaded when we spawn
-               self.rocketlauncher_load = autocvar_g_balance_rocketlauncher_reload_ammo;
+               self.weapon_load[WEP_ROCKET_LAUNCHER] = autocvar_g_balance_rocketlauncher_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_seeker.qc b/qcsrc/server/w_seeker.qc
index 7d14148c2593c2fd95d16eb13365c7ff2c9f4417..d3b7f45789b977523b810b807ed8c51d05443a90 100644 (file)
--- a/qcsrc/server/w_seeker.qc
+++ b/qcsrc/server/w_seeker.qc
@@ -5,9 +5,6 @@ REGISTER_WEAPON(SEEKER, w_seeker, IT_ROCKETS, 8, WEP_FLAG_NORMAL | WEP_TYPE_SPLA
 //.float proxytime; = autoswitch
 //.float tl; = wait
 
-// weapon load persistence, for weapons that support reloading
-.float seeker_load;
-
 void W_Seeker_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -15,7 +12,7 @@ void W_Seeker_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.seeker_load;
+               self.clip_load = self.weapon_load[WEP_SEEKER];
                self.clip_size = autocvar_g_balance_seeker_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -190,7 +187,7 @@ void Seeker_Fire_Missile(vector f_diff)
                if(autocvar_g_balance_seeker_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_seeker_missile_ammo;
-                       self.seeker_load = self.clip_load;
+                       self.weapon_load[WEP_SEEKER] = self.clip_load;
                }
                else
                        self.ammo_rockets -= autocvar_g_balance_seeker_missile_ammo;
@@ -335,7 +332,7 @@ void Seeker_Fire_Tag()
                if(autocvar_g_balance_seeker_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_seeker_tag_ammo;
-                       self.seeker_load = self.clip_load;
+                       self.weapon_load[WEP_SEEKER] = self.clip_load;
                }
                else
                        self.ammo_rockets -= autocvar_g_balance_seeker_tag_ammo;
@@ -403,7 +400,7 @@ void Seeker_Fire_Flac()
                if(autocvar_g_balance_seeker_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_seeker_flac_ammo;
-                       self.seeker_load = self.clip_load;
+                       self.weapon_load[WEP_SEEKER] = self.clip_load;
                }
                else
                        self.ammo_rockets -= autocvar_g_balance_seeker_flac_ammo;
@@ -512,19 +509,19 @@ float w_seeker(float req)
        else if (req == WR_CHECKAMMO1)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_seeker_missile_ammo;
-               ammo_amount += self.seeker_load >= autocvar_g_balance_seeker_missile_ammo;
+               ammo_amount += self.weapon_load[WEP_SEEKER] >= autocvar_g_balance_seeker_missile_ammo;
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_seeker_flac_ammo;
-               ammo_amount += self.seeker_load >= autocvar_g_balance_seeker_flac_ammo;
+               ammo_amount += self.weapon_load[WEP_SEEKER] >= autocvar_g_balance_seeker_flac_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
        {
                // all weapons must be fully loaded when we spawn
-               self.seeker_load = autocvar_g_balance_seeker_reload_ammo;
+               self.weapon_load[WEP_SEEKER] = autocvar_g_balance_seeker_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_shotgun.qc b/qcsrc/server/w_shotgun.qc
index 2930dd480d6cf79fc4640ffca0ff34fdaf5709e2..c355fc19d712775f6b83908389888653e44ecc09 100644 (file)
--- a/qcsrc/server/w_shotgun.qc
+++ b/qcsrc/server/w_shotgun.qc
@@ -3,9 +3,6 @@ REGISTER_WEAPON(SHOTGUN, w_shotgun, IT_SHELLS, 2, WEP_FLAG_NORMAL | WEP_TYPE_HIT
 #else
 #ifdef SVQC
 
-// weapon load persistence, for weapons that support reloading
-.float shotgun_load;
-
 void W_Shotgun_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -13,7 +10,7 @@ void W_Shotgun_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.shotgun_load;
+               self.clip_load = self.weapon_load[WEP_SHOTGUN];
                self.clip_size = autocvar_g_balance_shotgun_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -55,7 +52,7 @@ void W_Shotgun_Attack (void)
                if(autocvar_g_balance_shotgun_reload_ammo)
                {
                        self.clip_load -= ammoamount;
-                       self.shotgun_load = self.clip_load;
+                       self.weapon_load[WEP_SHOTGUN] = self.clip_load;
                }
                else
                        self.ammo_shells -= ammoamount;
@@ -193,7 +190,7 @@ float w_shotgun(float req)
        else if (req == WR_CHECKAMMO1)
        {
                ammo_amount = self.ammo_shells >= autocvar_g_balance_shotgun_primary_ammo;
-               ammo_amount += self.shotgun_load >= autocvar_g_balance_shotgun_primary_ammo;
+               ammo_amount += self.weapon_load[WEP_SHOTGUN] >= autocvar_g_balance_shotgun_primary_ammo;
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
@@ -204,7 +201,7 @@ float w_shotgun(float req)
        else if (req == WR_RESETPLAYER)
        {
                // all weapons must be fully loaded when we spawn
-               self.shotgun_load = autocvar_g_balance_shotgun_reload_ammo;
+               self.weapon_load[WEP_SHOTGUN] = autocvar_g_balance_shotgun_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_sniperrifle.qc b/qcsrc/server/w_sniperrifle.qc
index 4b4cd951cecdd770eb93832dfdc637ed1d780665..34fab001ee14afd932a86480e0f79e3775f688c9 100644 (file)
--- a/qcsrc/server/w_sniperrifle.qc
+++ b/qcsrc/server/w_sniperrifle.qc
@@ -8,9 +8,6 @@ REGISTER_WEAPON(SNIPERRIFLE, w_sniperrifle, IT_NAILS, 7, WEP_FLAG_NORMAL | WEP_T
 
 .float sniperrifle_accumulator;
 
-// weapon load persistence, for weapons that support reloading
-.float sniperrifle_load;
-
 void W_SniperRifle_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -18,7 +15,7 @@ void W_SniperRifle_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.sniperrifle_load;
+               self.clip_load = self.weapon_load[WEP_SNIPERRIFLE];
                self.clip_size = autocvar_g_balance_sniperrifle_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -42,7 +39,7 @@ void W_SniperRifle_FireBullet(float pSpread, float pDamage, float pHeadshotAdded
                if(autocvar_g_balance_sniperrifle_reload_ammo)
                {
                        self.clip_load -= pAmmo;
-                       self.sniperrifle_load = self.clip_load;
+                       self.weapon_load[WEP_SNIPERRIFLE] = self.clip_load;
                }
                else
                        self.ammo_nails -= pAmmo;
@@ -221,13 +218,13 @@ float w_sniperrifle(float req)
        else if (req == WR_CHECKAMMO1)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_sniperrifle_primary_ammo;
-               ammo_amount += self.sniperrifle_load >= autocvar_g_balance_sniperrifle_primary_ammo;
+               ammo_amount += self.weapon_load[WEP_SNIPERRIFLE] >= autocvar_g_balance_sniperrifle_primary_ammo;
                return ammo_amount;
        }
        else if (req == WR_CHECKAMMO2)
        {
                ammo_amount = self.ammo_cells >= autocvar_g_balance_sniperrifle_secondary_ammo;
-               ammo_amount += self.sniperrifle_load >= autocvar_g_balance_sniperrifle_secondary_ammo;
+               ammo_amount += self.weapon_load[WEP_SNIPERRIFLE] >= autocvar_g_balance_sniperrifle_secondary_ammo;
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
@@ -235,7 +232,7 @@ float w_sniperrifle(float req)
                self.sniperrifle_accumulator = time - autocvar_g_balance_sniperrifle_bursttime;
 
                // all weapons must be fully loaded when we spawn
-               self.sniperrifle_load = autocvar_g_balance_sniperrifle_reload_ammo;
+               self.weapon_load[WEP_SNIPERRIFLE] = autocvar_g_balance_sniperrifle_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {

diff --git a/qcsrc/server/w_uzi.qc b/qcsrc/server/w_uzi.qc
index b4d4a75eb080c3815d36604e07cded8aba6279e9..9ceb48f534a933c70eb8dab7bf109f7c55cf2354 100644 (file)
--- a/qcsrc/server/w_uzi.qc
+++ b/qcsrc/server/w_uzi.qc
@@ -3,9 +3,6 @@ REGISTER_WEAPON(UZI, w_uzi, IT_NAILS, 3, WEP_FLAG_NORMAL | WEP_TYPE_HITSCAN, BOT
 #else
 #ifdef SVQC
 
-// weapon load persistence, for weapons that support reloading
-.float uzi_load;
-
 void W_UZI_SetAmmoCounter()
 {
        // set clip_load to the weapon we have switched to, if the gun uses reloading
@@ -13,7 +10,7 @@ void W_UZI_SetAmmoCounter()
                self.clip_load = 0; // also keeps crosshair ammo from displaying
        else
        {
-               self.clip_load = self.uzi_load;
+               self.clip_load = self.weapon_load[WEP_UZI];
                self.clip_size = autocvar_g_balance_uzi_reload_ammo; // for the crosshair ammo display
        }
 }
@@ -101,7 +98,7 @@ void W_UZI_Attack (float deathtype)
                                self.clip_load -= autocvar_g_balance_uzi_first_ammo;
                        else
                                self.clip_load -= autocvar_g_balance_uzi_sustained_ammo;
-                       self.uzi_load = self.clip_load;
+                       self.weapon_load[WEP_UZI] = self.clip_load;
                }
                else
                {
@@ -148,7 +145,7 @@ void uzi_mode1_fire_auto()
                if(autocvar_g_balance_uzi_reload_ammo)
                {
                        self.clip_load -= autocvar_g_balance_uzi_sustained_ammo;
-                       self.uzi_load = self.clip_load;
+                       self.weapon_load[WEP_UZI] = self.clip_load;
                }
                else
                        self.ammo_nails -= autocvar_g_balance_uzi_sustained_ammo;
@@ -267,7 +264,7 @@ float w_uzi(float req)
                                        if(autocvar_g_balance_uzi_reload_ammo)
                                        {
                                                self.clip_load -= autocvar_g_balance_uzi_burst_ammo;
-                                               self.uzi_load = self.clip_load;
+                                               self.weapon_load[WEP_UZI] = self.clip_load;
                                        }
                                        else
                                                self.ammo_nails -= autocvar_g_balance_uzi_burst_ammo;
@@ -321,9 +318,9 @@ float w_uzi(float req)
                if(autocvar_g_balance_uzi_reload_ammo)
                {
                        if(autocvar_g_balance_uzi_mode == 1)
-                               ammo_amount += self.uzi_load >= autocvar_g_balance_uzi_sustained_ammo;
+                               ammo_amount += self.weapon_load[WEP_UZI] >= autocvar_g_balance_uzi_sustained_ammo;
                        else
-                               ammo_amount += self.uzi_load >= autocvar_g_balance_uzi_first_ammo;
+                               ammo_amount += self.weapon_load[WEP_UZI] >= autocvar_g_balance_uzi_first_ammo;
                }
                return ammo_amount;
        }
@@ -337,16 +334,16 @@ float w_uzi(float req)
                if(autocvar_g_balance_uzi_reload_ammo)
                {
                        if(autocvar_g_balance_uzi_mode == 1)
-                               ammo_amount += self.uzi_load >= autocvar_g_balance_uzi_burst_ammo;
+                               ammo_amount += self.weapon_load[WEP_UZI] >= autocvar_g_balance_uzi_burst_ammo;
                        else
-                               ammo_amount += self.uzi_load >= autocvar_g_balance_uzi_first_ammo;
+                               ammo_amount += self.weapon_load[WEP_UZI] >= autocvar_g_balance_uzi_first_ammo;
                }
                return ammo_amount;
        }
        else if (req == WR_RESETPLAYER)
        {
                // all weapons must be fully loaded when we spawn
-               self.uzi_load = autocvar_g_balance_uzi_reload_ammo;
+               self.weapon_load[WEP_UZI] = autocvar_g_balance_uzi_reload_ammo;
        }
        else if (req == WR_RELOAD)
        {