qcsrc/server/mutators/mutator_nades.qc

   1 .entity nade;
   2 .entity fake_nade;
   3 .float nade_refire;
   4
   5 void nade_timer_think()
   6 {
   7         self.skin = 8 - (self.owner.wait - time) / (autocvar_g_nades_nade_lifetime / 10);
   8         self.nextthink = time;
   9         if(!self.owner || wasfreed(self.owner))
  10                 remove(self);
  11
  12 }
  13
  14 void nade_burn_spawn(entity _nade)
  15 {
  16         float p;
  17
  18         switch(_nade.realowner.team)
  19         {
  20                 case NUM_TEAM_1: p = PROJECTILE_NADE_RED_BURN; break;
  21                 case NUM_TEAM_2: p = PROJECTILE_NADE_BLUE_BURN; break;
  22                 case NUM_TEAM_3: p = PROJECTILE_NADE_YELLOW_BURN; break;
  23                 case NUM_TEAM_4: p = PROJECTILE_NADE_PINK_BURN; break;
  24                 default:                 p = PROJECTILE_NADE_BURN; break;
  25         }
  26
  27         CSQCProjectile(_nade, TRUE, p, TRUE);
  28 }
  29
  30 void nade_spawn(entity _nade)
  31 {
  32         float p;
  33         entity timer = spawn();
  34         setmodel(timer, "models/ok_nade_counter/ok_nade_counter.md3");
  35         setattachment(timer, _nade, "");
  36         timer.classname = "nade_timer";
  37         timer.colormap = _nade.colormap;
  38         timer.glowmod = _nade.glowmod;
  39         timer.think = nade_timer_think;
  40         timer.nextthink = time;
  41         timer.wait = _nade.wait;
  42         timer.owner = _nade;
  43         timer.skin = 10;
  44
  45         switch(_nade.realowner.team)
  46         {
  47                 case NUM_TEAM_1: p = PROJECTILE_NADE_RED; break;
  48                 case NUM_TEAM_2: p = PROJECTILE_NADE_BLUE; break;
  49                 case NUM_TEAM_3: p = PROJECTILE_NADE_YELLOW; break;
  50                 case NUM_TEAM_4: p = PROJECTILE_NADE_PINK; break;
  51                 default:                 p = PROJECTILE_NADE; break;
  52         }
  53
  54         CSQCProjectile(_nade, TRUE, p, TRUE);
  55
  56 }
  57
  58 void nade_boom() // TODO: DamageInfo
  59 {
  60         string expef;
  61
  62         switch(self.realowner.team)
  63         {
  64                 case NUM_TEAM_1: expef = "nade_red_explode"; break;
  65                 case NUM_TEAM_2: expef = "nade_blue_explode"; break;
  66                 case NUM_TEAM_3: expef = "nade_yellow_explode"; break;
  67                 case NUM_TEAM_4: expef = "nade_pink_explode"; break;
  68                 default:                 expef = "nade_explode"; break;
  69         }
  70
  71         sound(self, CH_SHOTS_SINGLE, "misc/null.wav", VOL_BASE, ATTN_NORM);
  72         sound(self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
  73         pointparticles(particleeffectnum(expef), self.origin + '0 0 1', '0 0 0', 1);
  74
  75         self.takedamage = DAMAGE_NO;
  76         RadiusDamage(self, self.realowner, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage,
  77                                  autocvar_g_nades_nade_radius, self, autocvar_g_nades_nade_force, self.projectiledeathtype, self.enemy);
  78
  79         remove(self);
  80 }
  81
  82 void nade_touch()
  83 {
  84         PROJECTILE_TOUCH;
  85         setsize(self, '-2 -2 -2', '2 2 2');
  86         UpdateCSQCProjectile(self);
  87         if(self.health == autocvar_g_nades_nade_health)
  88         {
  89                 spamsound(self, CH_SHOTS, strcat("weapons/grenade_bounce", ftos(1 + rint(random() * 5)), ".wav"), VOL_BASE, ATTN_NORM);
  90                 return;
  91         }
  92
  93         self.enemy = other;
  94         nade_boom();
  95 }
  96
  97 void nade_beep()
  98 {
  99         sound(self, CH_SHOTS_SINGLE, "overkill/grenadebip.ogg", VOL_BASE, 0.5 *(ATTN_LARGE + ATTN_MAX));
 100         self.think = nade_boom;
 101         self.nextthink = max(self.wait, time);
 102 }
 103
 104 void nade_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 105 {
 106         if(DEATH_ISWEAPON(deathtype, WEP_LASER))
 107                 return;
 108
 109         if(DEATH_ISWEAPON(deathtype, WEP_NEX) || DEATH_ISWEAPON(deathtype, WEP_MINSTANEX))
 110         {
 111                 force *= 6;
 112                 damage = autocvar_g_nades_nade_health * 0.55;
 113         }
 114
 115         if(DEATH_ISWEAPON(deathtype, WEP_UZI))
 116                 damage = autocvar_g_nades_nade_health * 0.1;
 117
 118         if(DEATH_ISWEAPON(deathtype, WEP_SHOTGUN) && !(deathtype & HITTYPE_SECONDARY))
 119                 damage = autocvar_g_nades_nade_health * 1.1;
 120
 121         if(DEATH_ISWEAPON(deathtype, WEP_SHOTGUN) && (deathtype & HITTYPE_SECONDARY))
 122         {
 123                 damage = autocvar_g_nades_nade_health * 0.1;
 124                 force *= 15;
 125         }
 126
 127         self.velocity += force;
 128
 129         if(!damage)
 130                 return;
 131
 132         if(self.health == autocvar_g_nades_nade_health)
 133         {
 134                 sound(self, CH_SHOTS_SINGLE, "misc/null.wav", VOL_BASE, 0.5 *(ATTN_LARGE + ATTN_MAX));
 135                 self.nextthink = max(time + autocvar_g_nades_nade_lifetime, time);
 136                 self.think = nade_beep;
 137         }
 138
 139         self.health   -= damage;
 140         self.realowner = attacker;
 141
 142         if(self.health <= 0)
 143                 W_PrepareExplosionByDamage(attacker, nade_boom);
 144         else
 145                 nade_burn_spawn(self);
 146 }
 147
 148 void toss_nade(entity e, vector _velocity, float _time)
 149 {
 150         entity _nade = e.nade;
 151         e.nade = world;
 152
 153         remove(e.fake_nade);
 154         e.fake_nade = world;
 155
 156         makevectors(e.v_angle);
 157
 158         Kill_Notification(NOTIF_ONE_ONLY, e, MSG_CENTER_CPID, CPID_NADES);
 159
 160         setorigin(_nade, CENTER_OR_VIEWOFS(e) + (v_right * 10) * -1);
 161         setmodel(_nade, "models/weapons/v_ok_grenade.md3");
 162         setattachment(_nade, world, "");
 163         PROJECTILE_MAKETRIGGER(_nade);
 164         setsize(_nade, '-16 -16 -16', '16 16 16');
 165         _nade.movetype = MOVETYPE_BOUNCE;
 166
 167         if(e.crouch)
 168                 _nade.velocity = '0 0 -10';
 169         else if(autocvar_g_nades_nade_newton_style == 1)
 170                 _nade.velocity = e.velocity + _velocity;
 171         else if(autocvar_g_nades_nade_newton_style == 2)
 172                 _nade.velocity = _velocity;
 173         else
 174                 _nade.velocity = W_CalculateProjectileVelocity(e.velocity, _velocity, FALSE);
 175
 176         _nade.solid = SOLID_BBOX;
 177         _nade.touch = nade_touch;
 178         _nade.health = autocvar_g_nades_nade_health;
 179         _nade.takedamage = DAMAGE_AIM;
 180         _nade.event_damage = nade_damage;
 181         _nade.teleportable = TRUE;
 182
 183         nade_spawn(_nade);
 184
 185         if(_time)
 186         {
 187                 _nade.think = nade_boom;
 188                 _nade.nextthink = _time;
 189         }
 190
 191         e.nade_refire = time + autocvar_g_nades_nade_refire;
 192 }
 193
 194 void nade_prime()
 195 {
 196         if(self.nade)
 197                 remove(self.nade);
 198
 199         if(self.fake_nade)
 200                 remove(self.fake_nade);
 201
 202         self.nade = spawn();
 203         setmodel(self.nade, "null");
 204         setattachment(self.nade, self, "bip01 l hand");
 205         self.nade.classname = "nade";
 206         self.nade.realowner = self;
 207         self.nade.colormap = self.colormap;
 208         self.nade.glowmod = self.glowmod;
 209         self.nade.wait = time + autocvar_g_nades_nade_lifetime;
 210         self.nade.cnt = time;
 211         self.nade.think = nade_beep;
 212         self.nade.nextthink = max(self.nade.wait - 3, time);
 213         self.nade.projectiledeathtype = DEATH_NADE;
 214
 215         self.fake_nade = spawn();
 216         setmodel(self.fake_nade, "models/weapons/h_ok_grenade.iqm");
 217         setattachment(self.fake_nade, self.weaponentity, "");
 218         self.fake_nade.classname = "fake_nade";
 219         //self.fake_nade.viewmodelforclient = self;
 220         self.fake_nade.realowner = self.fake_nade.owner = self;
 221         self.fake_nade.colormap = self.colormap;
 222         self.fake_nade.glowmod = self.glowmod;
 223         self.fake_nade.think = SUB_Remove;
 224         self.fake_nade.nextthink = self.nade.wait;
 225 }
 226
 227 float CanThrowNade()
 228 {
 229         if(self.vehicle)
 230                 return FALSE;
 231
 232         if(gameover)
 233                 return FALSE;
 234
 235         if(self.deadflag != DEAD_NO)
 236                 return FALSE;
 237
 238         if not(autocvar_g_nades)
 239                 return FALSE; // allow turning them off mid match
 240
 241         if(forbidWeaponUse())
 242                 return FALSE;
 243
 244         if not(IS_PLAYER(self))
 245                 return FALSE;
 246
 247         return TRUE;
 248 }
 249
 250 MUTATOR_HOOKFUNCTION(nades_ForbidThrowing)
 251 {
 252         if(!g_weaponarena || !g_minstagib)
 253                 return FALSE; // TODO: fix this to support all modes that don't disable weapon dropping
 254
 255         if(!CanThrowNade())
 256                 return FALSE;
 257
 258         if(!self.nade)
 259         {
 260                 if(self.nade_refire < time)
 261                 {
 262                         Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_NADE_THROW);
 263                         nade_prime();
 264                         self.nade_refire = time + autocvar_g_nades_nade_refire;
 265                 }
 266         }
 267         else
 268         {
 269                 if(time - self.nade.cnt >= 1)
 270                 {
 271                         makevectors(self.v_angle);
 272                         float _force = time - self.nade.cnt;
 273                         _force /= autocvar_g_nades_nade_lifetime;
 274                         _force = autocvar_g_nades_nade_minforce + (_force * (autocvar_g_nades_nade_maxforce - autocvar_g_nades_nade_minforce));
 275                         toss_nade(self, (v_forward * 0.75 + v_up * 0.2 + v_right * 0.05) * _force, 0);
 276                 }
 277         }
 278
 279         return TRUE;
 280 }
 281
 282 MUTATOR_HOOKFUNCTION(nades_VehicleEnter)
 283 {
 284         if(other.nade)
 285                 toss_nade(other, '0 0 100', max(other.nade.wait, time + 0.05));
 286
 287         return FALSE;
 288 }
 289
 290 MUTATOR_HOOKFUNCTION(nades_PlayerPreThink)
 291 {
 292         float key_pressed = ((g_grappling_hook) ? self.button16 : self.BUTTON_HOOK);
 293
 294         if(self.nade)
 295                 if(self.nade.wait - 0.1 <= time)
 296                         toss_nade(self, '0 0 0', time + 0.05);
 297
 298         if(CanThrowNade())
 299         if(self.nade_refire < time)
 300         {
 301                 if(key_pressed)
 302                 {
 303                         if(!self.nade)
 304                                 nade_prime();
 305                 }
 306                 else if(time - self.nade.cnt >= 1)
 307                 {
 308                         if(self.nade)
 309                         {
 310                                 makevectors(self.v_angle);
 311                                 float _force = time - self.nade.cnt;
 312                                 _force /= autocvar_g_nades_nade_lifetime;
 313                                 _force = autocvar_g_nades_nade_minforce + (_force * (autocvar_g_nades_nade_maxforce - autocvar_g_nades_nade_minforce));
 314                                 toss_nade(self, (v_forward * 0.7 + v_up * 0.2 + v_right * 0.1) * _force, 0);
 315                         }
 316                 }
 317         }
 318
 319         return FALSE;
 320 }
 321
 322 MUTATOR_HOOKFUNCTION(nades_PlayerSpawn)
 323 {
 324         if(autocvar_g_nades_spawn)
 325                 self.nade_refire = time + autocvar_g_spawnshieldtime;
 326         else
 327                 self.nade_refire  = time + autocvar_g_nades_nade_refire;
 328
 329         return FALSE;
 330 }
 331
 332 MUTATOR_HOOKFUNCTION(nades_PlayerDies)
 333 {
 334         if(self.nade)
 335                 toss_nade(self, '0 0 100', max(self.nade.wait, time + 0.05));
 336
 337         return FALSE;
 338 }
 339
 340 MUTATOR_HOOKFUNCTION(nades_RemovePlayer)
 341 {
 342         if(self.nade)
 343                 remove(self.nade);
 344
 345         if(self.fake_nade)
 346                 remove(self.fake_nade);
 347
 348         return FALSE;
 349 }
 350
 351 MUTATOR_HOOKFUNCTION(nades_BuildMutatorsString)
 352 {
 353         ret_string = strcat(ret_string, ":Nades");
 354         return FALSE;
 355 }
 356
 357 MUTATOR_HOOKFUNCTION(nades_BuildMutatorsPrettyString)
 358 {
 359         ret_string = strcat(ret_string, ", Nades");
 360         return FALSE;
 361 }
 362
 363 MUTATOR_DEFINITION(mutator_nades)
 364 {
 365         MUTATOR_HOOK(ForbidThrowCurrentWeapon, nades_ForbidThrowing, CBC_ORDER_ANY);
 366         MUTATOR_HOOK(VehicleEnter, nades_VehicleEnter, CBC_ORDER_ANY);
 367         MUTATOR_HOOK(PlayerPreThink, nades_PlayerPreThink, CBC_ORDER_ANY);
 368         MUTATOR_HOOK(PlayerSpawn, nades_PlayerSpawn, CBC_ORDER_ANY);
 369         MUTATOR_HOOK(PlayerDies, nades_PlayerDies, CBC_ORDER_ANY);
 370         MUTATOR_HOOK(MakePlayerObserver, nades_RemovePlayer, CBC_ORDER_ANY);
 371         MUTATOR_HOOK(ClientDisconnect, nades_RemovePlayer, CBC_ORDER_ANY);
 372         MUTATOR_HOOK(BuildMutatorsString, nades_BuildMutatorsString, CBC_ORDER_ANY);
 373         MUTATOR_HOOK(BuildMutatorsPrettyString, nades_BuildMutatorsPrettyString, CBC_ORDER_ANY);
 374
 375         MUTATOR_ONADD
 376         {
 377                 precache_model("models/ok_nade_counter/ok_nade_counter.md3");
 378
 379                 precache_model("models/weapons/h_ok_grenade.iqm");
 380                 precache_model("models/weapons/v_ok_grenade.md3");
 381                 precache_sound("weapons/rocket_impact.wav");
 382                 precache_sound("weapons/grenade_bounce1.wav");
 383                 precache_sound("weapons/grenade_bounce2.wav");
 384                 precache_sound("weapons/grenade_bounce3.wav");
 385                 precache_sound("weapons/grenade_bounce4.wav");
 386                 precache_sound("weapons/grenade_bounce5.wav");
 387                 precache_sound("weapons/grenade_bounce6.wav");
 388                 precache_sound("overkill/grenadebip.ogg");
 389         }
 390
 391         return FALSE;
 392 }