]> de.git.xonotic.org Git - xonotic/xonotic-data.pk3dir.git/blobdiff - qcsrc/common/weapons/w_shockwave.qc
Remove shell ammo from Shockwave
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / weapons / w_shockwave.qc
index 79d1115dc53ef452b896c722dcaf1a2a551d62bb..920a4f13c0d8bcd4cb384d1590fa0923e079f530 100644 (file)
@@ -2,7 +2,7 @@
 REGISTER_WEAPON(
 /* WEP_##id */ SHOCKWAVE,
 /* function */ W_Shockwave,
-/* ammotype */ IT_SHELLS,
+/* ammotype */ ammo_none,
 /* impulse  */ 2,
 /* flags    */ WEP_FLAG_NORMAL | WEP_FLAG_RELOADABLE | WEP_TYPE_HITSCAN,
 /* rating   */ BOT_PICKUP_RATING_LOW,
@@ -11,64 +11,66 @@ REGISTER_WEAPON(
 /* fullname */ _("Shockwave")
 );
 
-#define SHOCKWAVE_SETTINGS(w_cvar,w_prop) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_damage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_distance) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_edgedamage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_force) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_force_forwardbias) \
-       /*w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_force_velocitybias)*/ \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_force_zscale) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_damage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_edgedamage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_force) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_force_velocitybias) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_force_zscale) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_multiplier_accuracy) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_multiplier_distance) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_multiplier_min) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_jump_radius) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_multiplier_accuracy) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_multiplier_distance) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_multiplier_min) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_splash_damage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_splash_edgedamage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_splash_force) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_splash_force_forwardbias) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_splash_multiplier_accuracy) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_splash_multiplier_distance) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_splash_multiplier_min) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_splash_radius) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_spread_max) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, blast_spread_min) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_animtime) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_damage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_delay) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_force) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_multihit) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_no_doubleslap) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_nonplayerdamage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_range) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_refire) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_swing_side) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_swing_up) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_time) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, melee_traces) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_ammo) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_animtime) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_bulletconstant) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_bullets) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_damage) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_force) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_refire) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_speed) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, pellets_spread) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, primary) \
-       w_cvar(WEP_SHOCKWAVE, shockwave, MO_NONE, secondary) \
-       w_prop(WEP_SHOCKWAVE, shockwave, reloading_ammo, reload_ammo) \
-       w_prop(WEP_SHOCKWAVE, shockwave, reloading_time, reload_time) \
-       w_prop(WEP_SHOCKWAVE, shockwave, switchdelay_raise, switchdelay_raise) \
-       w_prop(WEP_SHOCKWAVE, shockwave, switchdelay_drop, switchdelay_drop)
+#define SHOCKWAVE_SETTINGS(w_cvar,w_prop) SHOCKWAVE_SETTINGS_LIST(w_cvar, w_prop, SHOCKWAVE, shockwave)
+#define SHOCKWAVE_SETTINGS_LIST(w_cvar,w_prop,id,sn) \
+       w_cvar(id, sn, MO_NONE, blast_damage) \
+       w_cvar(id, sn, MO_NONE, blast_distance) \
+       w_cvar(id, sn, MO_NONE, blast_edgedamage) \
+       w_cvar(id, sn, MO_NONE, blast_force) \
+       w_cvar(id, sn, MO_NONE, blast_force_forwardbias) \
+       w_cvar(id, sn, MO_NONE, blast_force_zscale) \
+       w_cvar(id, sn, MO_NONE, blast_jump_damage) \
+       w_cvar(id, sn, MO_NONE, blast_jump_edgedamage) \
+       w_cvar(id, sn, MO_NONE, blast_jump_force) \
+       w_cvar(id, sn, MO_NONE, blast_jump_force_velocitybias) \
+       w_cvar(id, sn, MO_NONE, blast_jump_force_zscale) \
+       w_cvar(id, sn, MO_NONE, blast_jump_multiplier_accuracy) \
+       w_cvar(id, sn, MO_NONE, blast_jump_multiplier_distance) \
+       w_cvar(id, sn, MO_NONE, blast_jump_multiplier_min) \
+       w_cvar(id, sn, MO_NONE, blast_jump_radius) \
+       w_cvar(id, sn, MO_NONE, blast_multiplier_accuracy) \
+       w_cvar(id, sn, MO_NONE, blast_multiplier_distance) \
+       w_cvar(id, sn, MO_NONE, blast_multiplier_min) \
+       w_cvar(id, sn, MO_NONE, blast_splash_damage) \
+       w_cvar(id, sn, MO_NONE, blast_splash_edgedamage) \
+       w_cvar(id, sn, MO_NONE, blast_splash_force) \
+       w_cvar(id, sn, MO_NONE, blast_splash_force_forwardbias) \
+       w_cvar(id, sn, MO_NONE, blast_splash_multiplier_accuracy) \
+       w_cvar(id, sn, MO_NONE, blast_splash_multiplier_distance) \
+       w_cvar(id, sn, MO_NONE, blast_splash_multiplier_min) \
+       w_cvar(id, sn, MO_NONE, blast_splash_radius) \
+       w_cvar(id, sn, MO_NONE, blast_spread_max) \
+       w_cvar(id, sn, MO_NONE, blast_spread_min) \
+       w_cvar(id, sn, MO_NONE, melee_animtime) \
+       w_cvar(id, sn, MO_NONE, melee_damage) \
+       w_cvar(id, sn, MO_NONE, melee_delay) \
+       w_cvar(id, sn, MO_NONE, melee_force) \
+       w_cvar(id, sn, MO_NONE, melee_multihit) \
+       w_cvar(id, sn, MO_NONE, melee_no_doubleslap) \
+       w_cvar(id, sn, MO_NONE, melee_nonplayerdamage) \
+       w_cvar(id, sn, MO_NONE, melee_range) \
+       w_cvar(id, sn, MO_NONE, melee_refire) \
+       w_cvar(id, sn, MO_NONE, melee_swing_side) \
+       w_cvar(id, sn, MO_NONE, melee_swing_up) \
+       w_cvar(id, sn, MO_NONE, melee_time) \
+       w_cvar(id, sn, MO_NONE, melee_traces) \
+       w_cvar(id, sn, MO_NONE, pellets_animtime) \
+       w_cvar(id, sn, MO_NONE, pellets_bulletconstant) \
+       w_cvar(id, sn, MO_NONE, pellets_bullets) \
+       w_cvar(id, sn, MO_NONE, pellets_damage) \
+       w_cvar(id, sn, MO_NONE, pellets_force) \
+       w_cvar(id, sn, MO_NONE, pellets_refire) \
+       w_cvar(id, sn, MO_NONE, pellets_speed) \
+       w_cvar(id, sn, MO_NONE, pellets_spread) \
+       w_cvar(id, sn, MO_NONE, primary) \
+       w_cvar(id, sn, MO_NONE, secondary) \
+       w_prop(id, sn, float,  reloading_ammo, reload_ammo) \
+       w_prop(id, sn, float,  reloading_time, reload_time) \
+       w_prop(id, sn, float,  switchdelay_raise, switchdelay_raise) \
+       w_prop(id, sn, float,  switchdelay_drop, switchdelay_drop) \
+       w_prop(id, sn, string, weaponreplace, weaponreplace) \
+       w_prop(id, sn, float,  weaponstart, weaponstart) \
+       w_prop(id, sn, float,  weaponstartoverride, weaponstartoverride)
 
 #ifdef SVQC
 SHOCKWAVE_SETTINGS(WEP_ADD_CVAR, WEP_ADD_PROP)
@@ -77,7 +79,7 @@ SHOCKWAVE_SETTINGS(WEP_ADD_CVAR, WEP_ADD_PROP)
 #ifdef SVQC
 void spawnfunc_weapon_shockwave()
 {
-       //if(autocvar_sv_q3acompat_machineshockwaveswap)
+       //if(autocvar_sv_q3acompat_machineshockwaveswap) // WEAPONTODO
        if(autocvar_sv_q3acompat_machineshotgunswap)
        if(self.classname != "droppedweapon")
        {
@@ -100,9 +102,9 @@ void W_Shockwave_Pellets(void)
        float sc;
        entity flash;
 
-       W_DecreaseAmmo(ammo_shells, WEP_CVAR(shockwave, pellets_ammo), WEP_CVAR(shockwave, reload_ammo));
+       //W_DecreaseAmmo(ammo_shells, WEP_CVAR(shockwave, pellets_ammo), WEP_CVAR(shockwave, reload_ammo));
 
-       W_SetupShot(self, TRUE, 5, "weapons/shockwave_fire.wav", CH_WEAPON_A, WEP_CVAR(shockwave, pellets_damage) * WEP_CVAR(shockwave, pellets_bullets));
+       W_SetupShot(self, TRUE, 5, "weapons/shotgun_fire.wav", CH_WEAPON_A, WEP_CVAR(shockwave, pellets_damage) * WEP_CVAR(shockwave, pellets_bullets));
        
        for(sc = 0; sc < WEP_CVAR(shockwave, pellets_bullets); ++sc)
        {
@@ -121,12 +123,12 @@ void W_Shockwave_Pellets(void)
        }
        endFireBallisticBullet();
 
-       pointparticles(particleeffectnum("shockwave_muzzleflash"), w_shotorg, w_shotdir * 1000, WEP_CVAR(shockwave, pellets_ammo));
+       pointparticles(particleeffectnum("shotgun_muzzleflash"), w_shotorg, w_shotdir * 1000, 5); // WEAPONTODO: why 5? this was pellets_ammo before
 
        // casing code
        if(autocvar_g_casings >= 1)
        {
-               for(sc = 0;sc < WEP_CVAR(shockwave, pellets_ammo); ++sc)
+               for(sc = 0;sc < 5; ++sc)
                {
                        SpawnCasing(
                                (
@@ -163,27 +165,29 @@ void W_Shockwave_Melee_Think()
        entity target_victim;
        vector targpos;
 
-       if(!self.cnt) // set start time of melee
+       // check to see if we can still continue, otherwise give up now
+       if((self.realowner.deadflag != DEAD_NO) && WEP_CVAR(shockwave, melee_no_doubleslap))
+       {
+               remove(self);
+               return;
+       }
+
+       // set start time of melee
+       if(!self.cnt)
        {
                self.cnt = time; 
                W_PlayStrengthSound(self.realowner);
        }
 
-       makevectors(self.realowner.v_angle); // update values for v_* vectors
+       // update values for v_* vectors
+       makevectors(self.realowner.v_angle);
        
        // calculate swing percentage based on time
        meleetime = WEP_CVAR(shockwave, melee_time) * W_WeaponRateFactor();
        swing = bound(0, (self.cnt + meleetime - time) / meleetime, 10);
        f = ((1 - swing) * WEP_CVAR(shockwave, melee_traces));
        
-       // check to see if we can still continue, otherwise give up now
-       if((self.realowner.deadflag != DEAD_NO) && WEP_CVAR(shockwave, melee_no_doubleslap))
-       {
-               remove(self);
-               return;
-       }
-       
-       // if okay, perform the traces needed for this frame 
+       // perform the traces needed for this frame 
        for(i=self.swing_prev; i < f; ++i)
        {
                swing_factor = ((1 - (i / WEP_CVAR(shockwave, melee_traces))) * 2 - 1);
@@ -193,7 +197,14 @@ void W_Shockwave_Melee_Think()
                        + (v_up * swing_factor * WEP_CVAR(shockwave, melee_swing_up))
                        + (v_right * swing_factor * WEP_CVAR(shockwave, melee_swing_side)));
 
-               WarpZone_traceline_antilag(self.realowner, self.realowner.origin + self.realowner.view_ofs, targpos, FALSE, self.realowner, ANTILAG_LATENCY(self.realowner));
+               WarpZone_traceline_antilag(
+                       self.realowner,
+                       (self.realowner.origin + self.realowner.view_ofs),
+                       targpos,
+                       FALSE,
+                       self.realowner,
+                       ANTILAG_LATENCY(self.realowner)
+               );
                
                // draw lightning beams for debugging
                te_lightning2(world, targpos, self.realowner.origin + self.realowner.view_ofs + v_forward * 5 - v_up * 5); 
@@ -201,28 +212,46 @@ void W_Shockwave_Melee_Think()
                
                is_player = (trace_ent.classname == "player" || trace_ent.classname == "body");
 
-               if((trace_fraction < 1) // if trace is good, apply the damage and remove self
+               if((trace_fraction < 1) // if trace is good, apply the damage and remove self if necessary
                        && (trace_ent.takedamage == DAMAGE_AIM)  
                        && (trace_ent != self.swing_alreadyhit)
                        && (is_player || WEP_CVAR(shockwave, melee_nonplayerdamage)))
                {
                        target_victim = trace_ent; // so it persists through other calls
                        
-                       if(is_player) // this allows us to be able to nerf the non-player damage done in e.g. assault or onslaught.
-                               swing_damage = (WEP_CVAR(shockwave, melee_damage * min(1, swing_factor + 1)));
+                       if(is_player) // this allows us to be able to nerf the non-player damage done in e.g. assault or onslaught
+                               swing_damage = (WEP_CVAR(shockwave, melee_damage) * min(1, swing_factor + 1));
                        else
-                               swing_damage = (WEP_CVAR(shockwave, melee_nonplayerdamage * min(1, swing_factor + 1)));
-                       
-                       //print(strcat(self.realowner.netname, " hitting ", target_victim.netname, " with ", strcat(ftos(swing_damage), " damage (factor: ", ftos(swing_factor), ") at "), ftos(time), " seconds.\n"));
-                       
-                       Damage(target_victim, self.realowner, self.realowner, 
-                               swing_damage, WEP_SHOCKWAVE | HITTYPE_SECONDARY, 
-                               self.realowner.origin + self.realowner.view_ofs, 
-                               v_forward * WEP_CVAR(shockwave, melee_force));
-                               
-                       if(accuracy_isgooddamage(self.realowner, target_victim)) { accuracy_add(self.realowner, WEP_SHOCKWAVE, 0, swing_damage); }
-                       
-                       if(WEP_CVAR(shockwave, melee_multihit)) // allow multiple hits with one swing, but not against the same player twice.
+                               swing_damage = (WEP_CVAR(shockwave, melee_nonplayerdamage) * min(1, swing_factor + 1));
+
+                       // trigger damage with this calculated info
+                       Damage(
+                               target_victim,
+                               self.realowner,
+                               self.realowner, 
+                               swing_damage,
+                               (WEP_SHOCKWAVE | HITTYPE_SECONDARY), 
+                               (self.realowner.origin + self.realowner.view_ofs), 
+                               (v_forward * WEP_CVAR(shockwave, melee_force))
+                       );
+
+                       // handle accuracy
+                       if(accuracy_isgooddamage(self.realowner, target_victim))
+                               { accuracy_add(self.realowner, WEP_SHOCKWAVE, 0, swing_damage); }
+
+                       #ifdef DEBUG_SHOCKWAVE
+                       print(sprintf(
+                               "MELEE: %s hitting %s with %f damage (factor: %f) at %f time.\n",
+                               self.realowner.netname,
+                               target_victim.netname,
+                               swing_damage,
+                               swing_factor,
+                               time
+                       ));
+                       #endif
+
+                       // allow multiple hits with one swing, but not against the same player twice
+                       if(WEP_CVAR(shockwave, melee_multihit))
                        {
                                self.swing_alreadyhit = target_victim;
                                continue; // move along to next trace
@@ -573,7 +602,7 @@ void W_Shockwave_Attack()
 
                        vector nearest_on_line = (w_shotorg + a * w_shotdir);
                        vector nearest_to_attacker = WarpZoneLib_NearestPointOnBox(center + head.mins, center + head.maxs, nearest_on_line);
-                       float distance_to_target = vlen(w_shotorg - nearest_to_attacker); // todo: use the findradius function for this
+                       float distance_to_target = vlen(w_shotorg - nearest_to_attacker); // WEAPONTODO: use the findradius function for this
 
                        if((distance_to_target <= WEP_CVAR(shockwave, blast_distance)) 
                                && (W_Shockwave_Attack_IsVisible(head, nearest_on_line, w_shotorg, attack_endpos)))
@@ -673,7 +702,6 @@ void W_Shockwave_Attack()
 
 float W_Shockwave(float req)
 {
-       float ammo_amount;
        switch(req)
        {
                case WR_AIM:
@@ -687,57 +715,48 @@ float W_Shockwave(float req)
                }
                case WR_THINK:
                {
-                       if(WEP_CVAR(shockwave, reload_ammo) && self.clip_load < WEP_CVAR(shockwave, pellets_ammo)) // forced reload
-                       {
-                               // don't force reload an empty shockwave if its melee attack is active
-                               if(!(WEP_CVAR(shockwave, secondary) && self.ammo_shells < WEP_CVAR(shockwave, pellets_ammo)))
-                                       WEP_ACTION(self.weapon, WR_RELOAD);
-                       }
-                       else
+                       if(self.BUTTON_ATCK)
                        {
-                               if(self.BUTTON_ATCK)
+                               switch(WEP_CVAR(shockwave, primary))
                                {
-                                       switch(WEP_CVAR(shockwave, primary))
+                                       case 1:
                                        {
-                                               case 1:
+                                               if(time >= self.shockwave_pelletstime) // handle refire separately so the secondary can be fired straight after a primary
                                                {
-                                                       if(time >= self.shockwave_pelletstime) // handle refire separately so the secondary can be fired straight after a primary
+                                                       if(weapon_prepareattack(0, WEP_CVAR(shockwave, pellets_animtime)))
                                                        {
-                                                               if(weapon_prepareattack(0, WEP_CVAR(shockwave, pellets_animtime)))
-                                                               {
-                                                                       W_Shockwave_Attack();
-                                                                       self.shockwave_pelletstime = time + WEP_CVAR(shockwave, pellets_refire) * W_WeaponRateFactor();
-                                                                       weapon_thinkf(WFRAME_FIRE1, WEP_CVAR(shockwave, pellets_animtime), w_ready);
-                                                               }
+                                                               W_Shockwave_Attack();
+                                                               self.shockwave_pelletstime = time + WEP_CVAR(shockwave, pellets_refire) * W_WeaponRateFactor();
+                                                               weapon_thinkf(WFRAME_FIRE1, WEP_CVAR(shockwave, pellets_animtime), w_ready);
                                                        }
-                                                       break;
                                                }
-                                               case 2:
+                                               break;
+                                       }
+                                       case 2:
+                                       {
+                                               if(time >= self.shockwave_pelletstime) // handle refire separately so the secondary can be fired straight after a primary
                                                {
-                                                       if(time >= self.shockwave_pelletstime) // handle refire separately so the secondary can be fired straight after a primary
+                                                       if(weapon_prepareattack(0, WEP_CVAR(shockwave, pellets_animtime)))
                                                        {
-                                                               if(weapon_prepareattack(0, WEP_CVAR(shockwave, pellets_animtime)))
-                                                               {
-                                                                       W_Shockwave_Pellets();
-                                                                       self.shockwave_pelletstime = time + WEP_CVAR(shockwave, pellets_refire) * W_WeaponRateFactor();
-                                                                       weapon_thinkf(WFRAME_FIRE1, WEP_CVAR(shockwave, pellets_animtime), w_ready);
-                                                               }
+                                                               W_Shockwave_Pellets();
+                                                               self.shockwave_pelletstime = time + WEP_CVAR(shockwave, pellets_refire) * W_WeaponRateFactor();
+                                                               weapon_thinkf(WFRAME_FIRE1, WEP_CVAR(shockwave, pellets_animtime), w_ready);
                                                        }
-                                                       break;
                                                }
+                                               break;
                                        }
                                }
-                               
-                               if(self.clip_load >= 0) // we are not currently reloading
-                               if(!self.crouch) // no crouchmelee please
-                               if(self.BUTTON_ATCK2 && WEP_CVAR(shockwave, secondary))
-                               if(weapon_prepareattack(1, WEP_CVAR(shockwave, melee_refire)))
-                               {
-                                       // attempt forcing playback of the anim by switching to another anim (that we never play) here...
-                                       weapon_thinkf(WFRAME_FIRE1, 0, W_Shockwave_Melee);
-                               }
                        }
                        
+                       if(self.clip_load >= 0) // we are not currently reloading
+                       if(!self.crouch) // no crouchmelee please
+                       if(self.BUTTON_ATCK2 && WEP_CVAR(shockwave, secondary))
+                       if(weapon_prepareattack(1, WEP_CVAR(shockwave, melee_refire)))
+                       {
+                               // attempt forcing playback of the anim by switching to another anim (that we never play) here...
+                               weapon_thinkf(WFRAME_FIRE1, 0, W_Shockwave_Melee);
+                       }
+
                        return TRUE;
                }
                case WR_INIT:
@@ -752,20 +771,10 @@ float W_Shockwave(float req)
                        SHOCKWAVE_SETTINGS(WEP_SKIPCVAR, WEP_SET_PROP)
                        return TRUE;
                }
-               case WR_SETUP:
-               {
-                       self.current_ammo = ammo_shells;
-                       return TRUE;
-               }
                case WR_CHECKAMMO1:
-               {
-                       ammo_amount = self.ammo_shells >= WEP_CVAR(shockwave, pellets_ammo);
-                       ammo_amount += self.(weapon_load[WEP_SHOCKWAVE]) >= WEP_CVAR(shockwave, pellets_ammo);
-                       return ammo_amount;
-               }
                case WR_CHECKAMMO2:
                {
-                       // melee attack is always available
+                       // shockwave has infinite ammo
                        return TRUE;
                }
                case WR_CONFIG:
@@ -775,7 +784,7 @@ float W_Shockwave(float req)
                }
                case WR_RELOAD:
                {
-                       W_Reload(WEP_CVAR(shockwave, pellets_ammo), "weapons/reload.wav");
+                       W_Reload(0, "weapons/reload.wav");
                        return TRUE;
                }
                case WR_SUICIDEMESSAGE: