qcsrc/server/w_nex.qc

   1 #ifdef REGISTER_WEAPON
   2 REGISTER_WEAPON(NEX, w_nex, IT_CELLS, 7, WEP_FLAG_NORMAL | WEP_TYPE_HITSCAN, BOT_PICKUP_RATING_HIGH, "nex", "nex", _("Nex"))
   3 #else
   4 #ifdef SVQC
   5
   6 .float nex_load;
   7
   8 void W_Nex_SetAmmoCounter()
   9 {
  10         // set clip_load to the weapon we have switched to, if the gun uses reloading
  11         if(!autocvar_g_balance_nex_reload_ammo)
  12                 self.clip_load = 0; // also keeps crosshair ammo from displaying
  13         else
  14         {
  15                 self.clip_load = self.nex_load;
  16                 self.clip_size = autocvar_g_balance_nex_reload_ammo; // for the crosshair ammo display
  17         }
  18 }
  19
  20 void W_Nex_ReloadedAndReady()
  21 {
  22         float t;
  23
  24         // now do the ammo transfer
  25         self.clip_load = self.old_clip_load; // restore the ammo counter, in case we still had ammo in the weapon before reloading
  26         while(self.clip_load < autocvar_g_balance_nex_reload_ammo && self.ammo_cells) // make sure we don't add more ammo than we have
  27         {
  28                 self.clip_load += 1;
  29                 self.ammo_cells -= 1;
  30         }
  31         self.nex_load = self.clip_load;
  32
  33         t = ATTACK_FINISHED(self) - autocvar_g_balance_nex_reload_time - 1;
  34         ATTACK_FINISHED(self) = t;
  35         w_ready();
  36 }
  37
  38 void W_Nex_Reload()
  39 {
  40         // return if reloading is disabled for this weapon
  41         if(!autocvar_g_balance_nex_reload_ammo)
  42                 return;
  43
  44         if(!W_ReloadCheck(self.ammo_cells, min(autocvar_g_balance_nex_primary_ammo, autocvar_g_balance_nex_secondary_ammo)))
  45                 return;
  46
  47         float t;
  48
  49         sound (self, CHAN_WEAPON2, "weapons/reload.wav", VOL_BASE, ATTN_NORM);
  50
  51         t = max(time, ATTACK_FINISHED(self)) + autocvar_g_balance_nex_reload_time + 1;
  52         ATTACK_FINISHED(self) = t;
  53
  54         weapon_thinkf(WFRAME_RELOAD, autocvar_g_balance_nex_reload_time, W_Nex_ReloadedAndReady);
  55
  56         self.old_clip_load = self.clip_load;
  57         self.clip_load = -1;
  58 }
  59
  60 void SendCSQCNexBeamParticle(float charge) {
  61         vector v;
  62         v = WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos);
  63         WriteByte(MSG_BROADCAST, SVC_TEMPENTITY);
  64         WriteByte(MSG_BROADCAST, TE_CSQC_NEXGUNBEAMPARTICLE);
  65         WriteCoord(MSG_BROADCAST, w_shotorg_x);
  66         WriteCoord(MSG_BROADCAST, w_shotorg_y);
  67         WriteCoord(MSG_BROADCAST, w_shotorg_z);
  68         WriteCoord(MSG_BROADCAST, v_x);
  69         WriteCoord(MSG_BROADCAST, v_y);
  70         WriteCoord(MSG_BROADCAST, v_z);
  71         WriteByte(MSG_BROADCAST, bound(0, 255 * charge, 255));
  72 }
  73
  74 void W_Nex_Attack (float issecondary)
  75 {
  76         float mydmg, myforce, mymindist, mymaxdist, myhalflife, myforcehalflife, myammo, charge;
  77         if(issecondary)
  78         {
  79                 mydmg = autocvar_g_balance_nex_secondary_damage;
  80                 myforce = autocvar_g_balance_nex_secondary_force;
  81                 mymindist = autocvar_g_balance_nex_secondary_damagefalloff_mindist;
  82                 mymaxdist = autocvar_g_balance_nex_secondary_damagefalloff_maxdist;
  83                 myhalflife = autocvar_g_balance_nex_secondary_damagefalloff_halflife;
  84                 myforcehalflife = autocvar_g_balance_nex_secondary_damagefalloff_forcehalflife;
  85                 myammo = autocvar_g_balance_nex_secondary_ammo;
  86         }
  87         else
  88         {
  89                 mydmg = autocvar_g_balance_nex_primary_damage;
  90                 myforce = autocvar_g_balance_nex_primary_force;
  91                 mymindist = autocvar_g_balance_nex_primary_damagefalloff_mindist;
  92                 mymaxdist = autocvar_g_balance_nex_primary_damagefalloff_maxdist;
  93                 myhalflife = autocvar_g_balance_nex_primary_damagefalloff_halflife;
  94                 myforcehalflife = autocvar_g_balance_nex_primary_damagefalloff_forcehalflife;
  95                 myammo = autocvar_g_balance_nex_primary_ammo;
  96         }
  97
  98         float flying;
  99         flying = IsFlying(self); // do this BEFORE to make the trace values from FireRailgunBullet last
 100
 101         if(autocvar_g_balance_nex_charge)
 102         {
 103                 charge = autocvar_g_balance_nex_charge_mindmg / mydmg + (1 - autocvar_g_balance_nex_charge_mindmg / mydmg) * self.nex_charge;
 104                 self.nex_charge *= autocvar_g_balance_nex_charge_shot_multiplier; // do this AFTER setting mydmg/myforce
 105                 // O RLY? -- divVerent
 106                 // YA RLY -- FruitieX
 107         }
 108         else
 109                 charge = 1;
 110         mydmg *= charge;
 111         myforce *= charge;
 112
 113         W_SetupShot (self, TRUE, 5, "weapons/nexfire.wav", CHAN_WEAPON, mydmg);
 114         if(charge > autocvar_g_balance_nex_charge_limit && autocvar_g_balance_nex_charge_limit) // if the Nex is overcharged, we play an extra sound
 115         {
 116                 sound (self, CHAN_WEAPON2, "weapons/nexcharge.wav", VOL_BASE * (charge - 0.5 * autocvar_g_balance_nex_charge_limit) / (1 - 0.5 * autocvar_g_balance_nex_charge_limit), ATTN_NORM);
 117         }
 118
 119         yoda = 0;
 120         FireRailgunBullet (w_shotorg, w_shotorg + w_shotdir * MAX_SHOT_DISTANCE, mydmg, myforce, mymindist, mymaxdist, myhalflife, myforcehalflife, WEP_NEX);
 121
 122         if(yoda && flying)
 123                 AnnounceTo(self, "yoda");
 124
 125         //beam and muzzle flash done on client
 126         SendCSQCNexBeamParticle(charge);
 127
 128         // flash and burn the wall
 129         if (trace_ent.solid == SOLID_BSP && !(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT))
 130                 Damage_DamageInfo(trace_endpos, mydmg, 0, 0, myforce * w_shotdir, WEP_NEX, self);
 131
 132         // if this weapon is reloadable, decrease its load. Else decrease the player's ammo
 133         if not(self.items & IT_UNLIMITED_WEAPON_AMMO)
 134         {
 135                 if(autocvar_g_balance_nex_reload_ammo)
 136                 {
 137                         self.clip_load -= myammo;
 138                         self.nex_load = self.clip_load;
 139                 }
 140                 else
 141                         self.ammo_cells -= myammo;
 142         }
 143 }
 144
 145 void spawnfunc_weapon_nex (void); // defined in t_items.qc
 146
 147 .float nex_chargepool_pauseregen_finished;
 148 float w_nex(float req)
 149 {
 150         float dt;
 151         if (req == WR_AIM)
 152         {
 153                 self.BUTTON_ATCK = bot_aim(1000000, 0, 1, FALSE);
 154                 self.BUTTON_ATCK2 = bot_aim(1000000, 0, 1, FALSE);
 155         }
 156         else if (req == WR_THINK)
 157         {
 158                 if(autocvar_g_balance_nex_charge && self.nex_charge < autocvar_g_balance_nex_charge_limit)
 159                         self.nex_charge = min(1, self.nex_charge + autocvar_g_balance_nex_charge_rate * frametime / W_TICSPERFRAME);
 160
 161                 if(autocvar_g_balance_nex_secondary_chargepool)
 162                         if(self.nex_chargepool_ammo < 1)
 163                         {
 164                                 if(self.nex_chargepool_pauseregen_finished < time)
 165                                         self.nex_chargepool_ammo = min(1, self.nex_chargepool_ammo + autocvar_g_balance_nex_secondary_chargepool_regen * frametime / W_TICSPERFRAME);
 166                                 self.pauseregen_finished = max(self.pauseregen_finished, time + autocvar_g_balance_nex_secondary_chargepool_pause_health_regen);
 167                         }
 168
 169                 if(autocvar_g_balance_nex_reload_ammo && self.clip_load < min(autocvar_g_balance_nex_primary_ammo, autocvar_g_balance_nex_secondary_ammo)) // forced reload
 170                         W_Nex_Reload();
 171                 else
 172                 {
 173                         if (self.BUTTON_ATCK)
 174                         {
 175                                 if (weapon_prepareattack(0, autocvar_g_balance_nex_primary_refire))
 176                                 {
 177                                         W_Nex_Attack(0);
 178                                         weapon_thinkf(WFRAME_FIRE1, autocvar_g_balance_nex_primary_animtime, w_ready);
 179                                 }
 180                         }
 181                         if ((autocvar_g_balance_nex_secondary_charge && !autocvar_g_balance_nex_secondary) ? self.BUTTON_ZOOM : self.BUTTON_ATCK2)
 182                         {
 183                                 if(autocvar_g_balance_nex_secondary_charge)
 184                                 {
 185                                         self.nex_charge_rottime = time + autocvar_g_balance_nex_charge_rot_pause;
 186                                         dt = frametime / W_TICSPERFRAME;
 187
 188                                         if(self.nex_charge < 1)
 189                                         {
 190                                                 if(autocvar_g_balance_nex_secondary_chargepool)
 191                                                 {
 192                                                         if(autocvar_g_balance_nex_secondary_ammo)
 193                                                         {
 194                                                                 // always deplete if secondary is held
 195                                                                 self.nex_chargepool_ammo = max(0, self.nex_chargepool_ammo - autocvar_g_balance_nex_secondary_ammo * dt);
 196
 197                                                                 dt = min(dt, (1 - self.nex_charge) / autocvar_g_balance_nex_secondary_charge_rate);
 198                                                                 self.nex_chargepool_pauseregen_finished = time + autocvar_g_balance_nex_secondary_chargepool_pause_regen;
 199                                                                 dt = min(dt, self.nex_chargepool_ammo);
 200                                                                 dt = max(0, dt);
 201
 202                                                                 self.nex_charge += dt * autocvar_g_balance_nex_secondary_charge_rate;
 203                                                         }
 204                                                 }
 205
 206                                                 else if(autocvar_g_balance_nex_secondary_ammo)
 207                                                 {
 208                                                         if(self.BUTTON_ATCK2) // only eat ammo when the button is pressed
 209                                                         {
 210                                                                 dt = min(dt, (1 - self.nex_charge) / autocvar_g_balance_nex_secondary_charge_rate);
 211                                                                 if not(self.items & IT_UNLIMITED_WEAPON_AMMO)
 212                                                                 {
 213                                                                         // if this weapon is reloadable, decrease its load. Else decrease the player's ammo
 214                                                                         if(autocvar_g_balance_nex_reload_ammo)
 215                                                                         {
 216                                                                                 dt = min(dt, (self.clip_load - autocvar_g_balance_nex_primary_ammo) / autocvar_g_balance_nex_secondary_ammo);
 217                                                                                 dt = max(0, dt);
 218                                                                                 if(dt > 0)
 219                                                                                 {
 220                                                                                         self.clip_load = max(autocvar_g_balance_nex_secondary_ammo, self.clip_load - autocvar_g_balance_nex_secondary_ammo * dt);
 221                                                                                 }
 222                                                                                 self.nex_load = self.clip_load;
 223                                                                         }
 224                                                                         else
 225                                                                         {
 226                                                                                 dt = min(dt, (self.ammo_cells - autocvar_g_balance_nex_primary_ammo) / autocvar_g_balance_nex_secondary_ammo);
 227                                                                                 dt = max(0, dt);
 228                                                                                 if(dt > 0)
 229                                                                                 {
 230                                                                                         self.ammo_cells = max(autocvar_g_balance_nex_secondary_ammo, self.ammo_cells - autocvar_g_balance_nex_secondary_ammo * dt);
 231                                                                                 }
 232                                                                         }
 233                                                                 }
 234                                                                 self.nex_charge += dt * autocvar_g_balance_nex_secondary_charge_rate;
 235                                                         }
 236                                                 }
 237
 238                                                 else
 239                                                 {
 240                                                         dt = min(dt, (1 - self.nex_charge) / autocvar_g_balance_nex_secondary_charge_rate);
 241                                                         self.nex_charge += dt * autocvar_g_balance_nex_secondary_charge_rate;
 242                                                 }
 243                                         }
 244                                 }
 245                                 else if(autocvar_g_balance_nex_secondary)
 246                                 {
 247                                         if (weapon_prepareattack(0, autocvar_g_balance_nex_secondary_refire))
 248                                         {
 249                                                 W_Nex_Attack(1);
 250                                                 weapon_thinkf(WFRAME_FIRE1, autocvar_g_balance_nex_secondary_animtime, w_ready);
 251                                         }
 252                                 }
 253                         }
 254                 }
 255
 256                 if(autocvar_g_balance_nex_charge)
 257                 {
 258                         self.weaponentity_glowmod_x = autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_red_half * min(1, self.nex_charge / autocvar_g_balance_nex_charge_limit);
 259                         self.weaponentity_glowmod_y = autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_green_half * min(1, self.nex_charge / autocvar_g_balance_nex_charge_limit);
 260                         self.weaponentity_glowmod_z = autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_blue_half * min(1, self.nex_charge / autocvar_g_balance_nex_charge_limit);
 261
 262                         if(self.nex_charge > autocvar_g_balance_nex_charge_limit)
 263                         {
 264                                 self.weaponentity_glowmod_x = self.weaponentity_glowmod_x + autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_red_full * (self.nex_charge - autocvar_g_balance_nex_charge_limit) / (1 - autocvar_g_balance_nex_charge_limit);
 265                                 self.weaponentity_glowmod_y = self.weaponentity_glowmod_y + autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_green_full * (self.nex_charge - autocvar_g_balance_nex_charge_limit) / (1 - autocvar_g_balance_nex_charge_limit);
 266                                 self.weaponentity_glowmod_z = self.weaponentity_glowmod_z + autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_blue_full * (self.nex_charge - autocvar_g_balance_nex_charge_limit) / (1 - autocvar_g_balance_nex_charge_limit);
 267                         }
 268                 }
 269
 270         if(self.wish_reload)
 271         {
 272             if(self.switchweapon == self.weapon)
 273             {
 274                 if(self.weaponentity.state == WS_READY)
 275                 {
 276                     self.wish_reload = 0;
 277                     W_Nex_Reload();
 278                 }
 279             }
 280         }
 281         }
 282         else if (req == WR_PRECACHE)
 283         {
 284                 precache_model ("models/nexflash.md3");
 285                 precache_model ("models/weapons/g_nex.md3");
 286                 precache_model ("models/weapons/v_nex.md3");
 287                 precache_model ("models/weapons/h_nex.iqm");
 288                 precache_sound ("weapons/nexfire.wav");
 289                 precache_sound ("weapons/nexcharge.wav");
 290                 precache_sound ("weapons/nexwhoosh1.wav");
 291                 precache_sound ("weapons/nexwhoosh2.wav");
 292                 precache_sound ("weapons/nexwhoosh3.wav");
 293                 precache_sound ("weapons/reload.wav");
 294         }
 295         else if (req == WR_SETUP)
 296         {
 297                 weapon_setup(WEP_NEX);
 298                 W_Nex_SetAmmoCounter();
 299         }
 300         else if (req == WR_CHECKAMMO1)
 301         {
 302                 if(autocvar_g_balance_nex_reload_ammo)
 303                         return self.clip_load >= autocvar_g_balance_nex_primary_ammo;
 304                 else
 305                         return self.ammo_cells >= autocvar_g_balance_nex_primary_ammo;
 306         }
 307         else if (req == WR_CHECKAMMO2)
 308         {
 309                 if(autocvar_g_balance_nex_reload_ammo)
 310                         return self.clip_load >= autocvar_g_balance_nex_primary_ammo; // don't allow charging if we don't have enough ammo
 311                 else
 312                         return self.ammo_cells >= autocvar_g_balance_nex_primary_ammo; // don't allow charging if we don't have enough ammo
 313         }
 314         else if (req == WR_RELOAD)
 315         {
 316                 W_Nex_Reload();
 317         }
 318
 319         return TRUE;
 320 };
 321 #endif
 322 #ifdef CSQC
 323 float w_nex(float req)
 324 {
 325         if(req == WR_IMPACTEFFECT)
 326         {
 327                 vector org2;
 328                 org2 = w_org + w_backoff * 6;
 329                 pointparticles(particleeffectnum("nex_impact"), org2, '0 0 0', 1);
 330                 if(!w_issilent)
 331                         sound(self, CHAN_PROJECTILE, "weapons/neximpact.wav", VOL_BASE, ATTN_NORM);
 332         }
 333         else if(req == WR_PRECACHE)
 334         {
 335                 precache_sound("weapons/neximpact.wav");
 336         }
 337         else if (req == WR_SUICIDEMESSAGE)
 338                 w_deathtypestring = "%s did the impossible";
 339         else if (req == WR_KILLMESSAGE)
 340                 w_deathtypestring = "%s has been vaporized by %s";
 341         return TRUE;
 342 }
 343 #endif
 344 #endif