6 bool autocvar_g_nades_nade_small;
9 REGISTER_STAT(NADES_SMALL, int, autocvar_g_nades_nade_small)
12 entity Nade_TrailEffect(int proj, int nade_team)
16 case PROJECTILE_NADE: return EFFECT_NADE_TRAIL(nade_team);
17 case PROJECTILE_NADE_BURN: return EFFECT_NADE_TRAIL_BURN(nade_team);
20 FOREACH(Nades, true, LAMBDA(
21 for (int j = 0; j < 2; j++)
23 if (it.m_projectile[j] == proj)
25 string trail = it.m_trail[j].eent_eff_name;
26 if (trail) return it.m_trail[j];
37 REGISTER_MUTATOR(cl_nades, true);
38 MUTATOR_HOOKFUNCTION(cl_nades, HUD_Draw_overlay)
40 if (STAT(HEALING_ORB) <= time) return false;
41 MUTATOR_ARGV(0, vector) = NADE_TYPE_HEAL.m_color;
42 MUTATOR_ARGV(0, float) = STAT(HEALING_ORB_ALPHA);
45 MUTATOR_HOOKFUNCTION(cl_nades, Ent_Projectile)
47 if (self.cnt == PROJECTILE_NAPALM_FOUNTAIN)
50 self.traileffect = EFFECT_FIREBALL.m_id;
53 if (Nade_FromProjectile(self.cnt) != NADE_TYPE_Null)
55 setmodel(self, MDL_PROJECTILE_NADE);
56 entity trail = Nade_TrailEffect(self.cnt, self.team);
57 if (trail.eent_eff_name) self.traileffect = trail.m_id;
61 MUTATOR_HOOKFUNCTION(cl_nades, EditProjectile)
63 if (self.cnt == PROJECTILE_NAPALM_FOUNTAIN)
65 loopsound(self, CH_SHOTS_SINGLE, SND(FIREBALL_FLY2), VOL_BASE, ATTEN_NORM);
66 self.mins = '-16 -16 -16';
67 self.maxs = '16 16 16';
70 entity nade_type = Nade_FromProjectile(self.cnt);
71 if (nade_type == NADE_TYPE_Null) return;
72 if(STAT(NADES_SMALL, NULL))
74 self.mins = '-8 -8 -8';
79 self.mins = '-16 -16 -16';
80 self.maxs = '16 16 16';
82 self.colormod = nade_type.m_color;
83 self.move_movetype = MOVETYPE_BOUNCE;
84 self.move_touch = func_null;
86 self.avelocity = randomvec() * 720;
88 if (nade_type == NADE_TYPE_TRANSLOCATE || nade_type == NADE_TYPE_SPAWN)
89 self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
91 self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY;
93 bool Projectile_isnade(int p)
95 return Nade_FromProjectile(p) != NADE_TYPE_Null;
97 void DrawAmmoNades(vector myPos, vector mySize, bool draw_expanding, float expand_time)
99 float bonusNades = STAT(NADE_BONUS);
100 float bonusProgress = STAT(NADE_BONUS_SCORE);
101 float bonusType = STAT(NADE_BONUS_TYPE);
102 Nade def = Nades_from(bonusType);
103 vector nadeColor = def.m_color;
104 string nadeIcon = def.m_icon;
106 vector iconPos, textPos;
108 if(autocvar_hud_panel_ammo_iconalign)
110 iconPos = myPos + eX * 2 * mySize.y;
116 textPos = myPos + eX * mySize.y;
119 if(bonusNades > 0 || bonusProgress > 0)
121 DrawNadeProgressBar(myPos, mySize, bonusProgress, nadeColor);
123 if(autocvar_hud_panel_ammo_text)
124 drawstring_aspect(textPos, ftos(bonusNades), eX * (2/3) * mySize.x + eY * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
127 drawpic_aspect_skin_expanding(iconPos, nadeIcon, '1 1 0' * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL, expand_time);
129 drawpic_aspect_skin(iconPos, nadeIcon, '1 1 0' * mySize.y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
136 #include <common/gamemodes/all.qh>
137 #include <common/monsters/spawn.qh>
138 #include <common/monsters/sv_monsters.qh>
139 #include <server/g_subs.qh>
141 REGISTER_MUTATOR(nades, cvar("g_nades"));
143 .float nade_time_primed;
145 .entity nade_spawnloc;
147 void nade_timer_think()
149 self.skin = 8 - (self.owner.wait - time) / (autocvar_g_nades_nade_lifetime / 10);
150 self.nextthink = time;
151 if(!self.owner || wasfreed(self.owner))
155 void nade_burn_spawn(entity _nade)
157 CSQCProjectile(_nade, true, Nades_from(_nade.nade_type).m_projectile[true], true);
160 void nade_spawn(entity _nade)
162 entity timer = new(nade_timer);
163 setmodel(timer, MDL_NADE_TIMER);
164 setattachment(timer, _nade, "");
165 timer.colormap = _nade.colormap;
166 timer.glowmod = _nade.glowmod;
167 timer.think = nade_timer_think;
168 timer.nextthink = time;
169 timer.wait = _nade.wait;
173 _nade.effects |= EF_LOWPRECISION;
175 CSQCProjectile(_nade, true, Nades_from(_nade.nade_type).m_projectile[false], true);
178 void napalm_damage(float dist, float damage, float edgedamage, float burntime)
187 RandomSelection_Init();
188 for(e = WarpZone_FindRadius(self.origin, dist, true); e; e = e.chain)
189 if(e.takedamage == DAMAGE_AIM)
190 if(self.realowner != e || autocvar_g_nades_napalm_selfdamage)
191 if(!IS_PLAYER(e) || !self.realowner || DIFF_TEAM(e, self))
195 p.x += e.mins.x + random() * (e.maxs.x - e.mins.x);
196 p.y += e.mins.y + random() * (e.maxs.y - e.mins.y);
197 p.z += e.mins.z + random() * (e.maxs.z - e.mins.z);
198 d = vlen(WarpZone_UnTransformOrigin(e, self.origin) - p);
201 e.fireball_impactvec = p;
202 RandomSelection_Add(e, 0, string_null, 1 / (1 + d), !Fire_IsBurning(e));
205 if(RandomSelection_chosen_ent)
207 d = vlen(WarpZone_UnTransformOrigin(RandomSelection_chosen_ent, self.origin) - RandomSelection_chosen_ent.fireball_impactvec);
208 d = damage + (edgedamage - damage) * (d / dist);
209 Fire_AddDamage(RandomSelection_chosen_ent, self.realowner, d * burntime, burntime, self.projectiledeathtype | HITTYPE_BOUNCE);
210 //trailparticles(self, particleeffectnum(EFFECT_FIREBALL_LASER), self.origin, RandomSelection_chosen_ent.fireball_impactvec);
211 Send_Effect(EFFECT_FIREBALL_LASER, self.origin, RandomSelection_chosen_ent.fireball_impactvec - self.origin, 1);
216 void napalm_ball_think()
218 if(round_handler_IsActive())
219 if(!round_handler_IsRoundStarted())
225 if(time > self.pushltime)
231 vector midpoint = ((self.absmin + self.absmax) * 0.5);
232 if(pointcontents(midpoint) == CONTENT_WATER)
234 self.velocity = self.velocity * 0.5;
236 if(pointcontents(midpoint + '0 0 16') == CONTENT_WATER)
237 { self.velocity_z = 200; }
240 self.angles = vectoangles(self.velocity);
242 napalm_damage(autocvar_g_nades_napalm_ball_radius,autocvar_g_nades_napalm_ball_damage,
243 autocvar_g_nades_napalm_ball_damage,autocvar_g_nades_napalm_burntime);
245 self.nextthink = time + 0.1;
249 void nade_napalm_ball()
254 spamsound(self, CH_SHOTS, SND(FIREBALL_FIRE), VOL_BASE, ATTEN_NORM);
257 proj.owner = self.owner;
258 proj.realowner = self.realowner;
259 proj.team = self.owner.team;
260 proj.bot_dodge = true;
261 proj.bot_dodgerating = autocvar_g_nades_napalm_ball_damage;
262 proj.movetype = MOVETYPE_BOUNCE;
263 proj.projectiledeathtype = DEATH_NADE_NAPALM.m_id;
264 PROJECTILE_MAKETRIGGER(proj);
265 setmodel(proj, MDL_Null);
266 proj.scale = 1;//0.5;
267 setsize(proj, '-4 -4 -4', '4 4 4');
268 setorigin(proj, self.origin);
269 proj.think = napalm_ball_think;
270 proj.nextthink = time;
271 proj.damageforcescale = autocvar_g_nades_napalm_ball_damageforcescale;
272 proj.effects = EF_LOWPRECISION | EF_FLAME;
274 kick.x =(random() - 0.5) * 2 * autocvar_g_nades_napalm_ball_spread;
275 kick.y = (random() - 0.5) * 2 * autocvar_g_nades_napalm_ball_spread;
276 kick.z = (random()/2+0.5) * autocvar_g_nades_napalm_ball_spread;
277 proj.velocity = kick;
279 proj.pushltime = time + autocvar_g_nades_napalm_ball_lifetime;
281 proj.angles = vectoangles(proj.velocity);
282 proj.flags = FL_PROJECTILE;
283 proj.missile_flags = MIF_SPLASH | MIF_PROXY | MIF_ARC;
285 //CSQCProjectile(proj, true, PROJECTILE_NAPALM_FIRE, true);
289 void napalm_fountain_think()
292 if(round_handler_IsActive())
293 if(!round_handler_IsRoundStarted())
299 if(time >= self.ltime)
305 vector midpoint = ((self.absmin + self.absmax) * 0.5);
306 if(pointcontents(midpoint) == CONTENT_WATER)
308 self.velocity = self.velocity * 0.5;
310 if(pointcontents(midpoint + '0 0 16') == CONTENT_WATER)
311 { self.velocity_z = 200; }
313 UpdateCSQCProjectile(self);
316 napalm_damage(autocvar_g_nades_napalm_fountain_radius, autocvar_g_nades_napalm_fountain_damage,
317 autocvar_g_nades_napalm_fountain_edgedamage, autocvar_g_nades_napalm_burntime);
319 self.nextthink = time + 0.1;
320 if(time >= self.nade_special_time)
322 self.nade_special_time = time + autocvar_g_nades_napalm_fountain_delay;
327 void nade_napalm_boom()
331 for (c = 0; c < autocvar_g_nades_napalm_ball_count; c++)
336 fountain.owner = self.owner;
337 fountain.realowner = self.realowner;
338 fountain.origin = self.origin;
339 setorigin(fountain, fountain.origin);
340 fountain.think = napalm_fountain_think;
341 fountain.nextthink = time;
342 fountain.ltime = time + autocvar_g_nades_napalm_fountain_lifetime;
343 fountain.pushltime = fountain.ltime;
344 fountain.team = self.team;
345 fountain.movetype = MOVETYPE_TOSS;
346 fountain.projectiledeathtype = DEATH_NADE_NAPALM.m_id;
347 fountain.bot_dodge = true;
348 fountain.bot_dodgerating = autocvar_g_nades_napalm_fountain_damage;
349 fountain.nade_special_time = time;
350 setsize(fountain, '-16 -16 -16', '16 16 16');
351 CSQCProjectile(fountain, true, PROJECTILE_NAPALM_FOUNTAIN, true);
354 void nade_ice_freeze(entity freezefield, entity frost_target, float freeze_time)
356 frost_target.frozen_by = freezefield.realowner;
357 Send_Effect(EFFECT_ELECTRO_IMPACT, frost_target.origin, '0 0 0', 1);
358 Freeze(frost_target, 1/freeze_time, 3, false);
360 Drop_Special_Items(frost_target);
363 void nade_ice_think()
366 if(round_handler_IsActive())
367 if(!round_handler_IsRoundStarted())
373 if(time >= self.ltime)
375 if ( autocvar_g_nades_ice_explode )
377 entity expef = EFFECT_NADE_EXPLODE(self.realowner.team);
378 Send_Effect(expef, self.origin + '0 0 1', '0 0 0', 1);
379 sound(self, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
381 RadiusDamage(self, self.realowner, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage,
382 autocvar_g_nades_nade_radius, self, world, autocvar_g_nades_nade_force, self.projectiledeathtype, self.enemy);
383 Damage_DamageInfo(self.origin, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage,
384 autocvar_g_nades_nade_radius, '1 1 1' * autocvar_g_nades_nade_force, self.projectiledeathtype, 0, self);
391 self.nextthink = time+0.1;
396 randomr = exp(-5*randomr*randomr)*autocvar_g_nades_nade_radius;
398 randomw = random()*M_PI*2;
400 randomp.x = randomr*cos(randomw);
401 randomp.y = randomr*sin(randomw);
403 Send_Effect(EFFECT_ELECTRO_MUZZLEFLASH, self.origin + randomp, '0 0 0', 1);
405 if(time >= self.nade_special_time)
407 self.nade_special_time = time+0.7;
409 Send_Effect(EFFECT_ELECTRO_IMPACT, self.origin, '0 0 0', 1);
410 Send_Effect(EFFECT_ICEFIELD, self.origin, '0 0 0', 1);
414 float current_freeze_time = self.ltime - time - 0.1;
417 for(e = findradius(self.origin, autocvar_g_nades_nade_radius); e; e = e.chain)
419 if(!autocvar_g_nades_ice_teamcheck || (DIFF_TEAM(e, self.realowner) || e == self.realowner))
420 if(e.takedamage && !IS_DEAD(e))
422 if(!e.revival_time || ((time - e.revival_time) >= 1.5))
424 if(current_freeze_time > 0)
425 nade_ice_freeze(self, e, current_freeze_time);
432 fountain.owner = self.owner;
433 fountain.realowner = self.realowner;
434 fountain.origin = self.origin;
435 setorigin(fountain, fountain.origin);
436 fountain.think = nade_ice_think;
437 fountain.nextthink = time;
438 fountain.ltime = time + autocvar_g_nades_ice_freeze_time;
439 fountain.pushltime = fountain.wait = fountain.ltime;
440 fountain.team = self.team;
441 fountain.movetype = MOVETYPE_TOSS;
442 fountain.projectiledeathtype = DEATH_NADE_ICE.m_id;
443 fountain.bot_dodge = false;
444 setsize(fountain, '-16 -16 -16', '16 16 16');
445 fountain.nade_special_time = time+0.3;
446 fountain.angles = self.angles;
448 if ( autocvar_g_nades_ice_explode )
450 setmodel(fountain, MDL_PROJECTILE_GRENADE);
451 entity timer = new(nade_timer);
452 setmodel(timer, MDL_NADE_TIMER);
453 setattachment(timer, fountain, "");
454 timer.colormap = self.colormap;
455 timer.glowmod = self.glowmod;
456 timer.think = nade_timer_think;
457 timer.nextthink = time;
458 timer.wait = fountain.ltime;
459 timer.owner = fountain;
463 setmodel(fountain, MDL_Null);
466 void nade_translocate_boom()
468 if(self.realowner.vehicle)
471 vector locout = self.origin + '0 0 1' * (1 - self.realowner.mins.z - 24);
472 tracebox(locout, self.realowner.mins, self.realowner.maxs, locout, MOVE_NOMONSTERS, self.realowner);
473 locout = trace_endpos;
475 makevectors(self.realowner.angles);
477 MUTATOR_CALLHOOK(PortalTeleport, self.realowner);
479 TeleportPlayer(self, self.realowner, locout, self.realowner.angles, v_forward * vlen(self.realowner.velocity), '0 0 0', '0 0 0', TELEPORT_FLAGS_TELEPORTER);
482 void nade_spawn_boom()
484 entity spawnloc = spawn();
485 setorigin(spawnloc, self.origin);
486 setsize(spawnloc, self.realowner.mins, self.realowner.maxs);
487 spawnloc.movetype = MOVETYPE_NONE;
488 spawnloc.solid = SOLID_NOT;
489 spawnloc.drawonlytoclient = self.realowner;
490 spawnloc.effects = EF_STARDUST;
491 spawnloc.cnt = autocvar_g_nades_spawn_count;
493 if(self.realowner.nade_spawnloc)
495 remove(self.realowner.nade_spawnloc);
496 self.realowner.nade_spawnloc = world;
499 self.realowner.nade_spawnloc = spawnloc;
502 void nade_heal_think()
504 if(time >= self.ltime)
510 self.nextthink = time;
512 if(time >= self.nade_special_time)
514 self.nade_special_time = time+0.25;
515 self.nade_show_particles = 1;
518 self.nade_show_particles = 0;
521 void nade_heal_touch()
525 if(IS_PLAYER(other) || IS_MONSTER(other))
527 if(!STAT(FROZEN, other))
529 health_factor = autocvar_g_nades_heal_rate*frametime/2;
530 if ( other != self.realowner )
532 if ( SAME_TEAM(other,self) )
533 health_factor *= autocvar_g_nades_heal_friend;
535 health_factor *= autocvar_g_nades_heal_foe;
537 if ( health_factor > 0 )
539 maxhealth = (IS_MONSTER(other)) ? other.max_health : g_pickup_healthmega_max;
540 if ( other.health < maxhealth )
542 if ( self.nade_show_particles )
543 Send_Effect(EFFECT_HEALING, other.origin, '0 0 0', 1);
544 other.health = min(other.health+health_factor, maxhealth);
546 other.pauserothealth_finished = max(other.pauserothealth_finished, time + autocvar_g_balance_pause_health_rot);
548 else if ( health_factor < 0 )
550 Damage(other,self,self.realowner,-health_factor,DEATH_NADE_HEAL.m_id,other.origin,'0 0 0');
555 if ( IS_REAL_CLIENT(other) || IS_VEHICLE(other) )
557 entity show_red = (IS_VEHICLE(other)) ? other.owner : other;
558 show_red.stat_healing_orb = time+0.1;
559 show_red.stat_healing_orb_alpha = 0.75 * (self.ltime - time) / self.healer_lifetime;
563 void nade_heal_boom()
567 healer.owner = self.owner;
568 healer.realowner = self.realowner;
569 setorigin(healer, self.origin);
570 healer.healer_lifetime = autocvar_g_nades_heal_time; // save the cvar
571 healer.ltime = time + healer.healer_lifetime;
572 healer.team = self.realowner.team;
573 healer.bot_dodge = false;
574 healer.solid = SOLID_TRIGGER;
575 healer.touch = nade_heal_touch;
577 setmodel(healer, MDL_NADE_HEAL);
578 healer.healer_radius = autocvar_g_nades_nade_radius;
579 vector size = '1 1 1' * healer.healer_radius / 2;
580 setsize(healer,-size,size);
582 Net_LinkEntity(healer, true, 0, healer_send);
584 healer.think = nade_heal_think;
585 healer.nextthink = time;
586 healer.SendFlags |= 1;
589 void nade_monster_boom()
591 entity e = spawnmonster(self.pokenade_type, 0, self.realowner, self.realowner, self.origin, false, false, 1);
593 if(autocvar_g_nades_pokenade_monster_lifetime > 0)
594 e.monster_lifetime = time + autocvar_g_nades_pokenade_monster_lifetime;
595 e.monster_skill = MONSTER_SKILL_INSANE;
601 bool nade_blast = true;
603 switch ( Nades_from(self.nade_type) )
605 case NADE_TYPE_NAPALM:
606 nade_blast = autocvar_g_nades_napalm_blast;
607 expef = EFFECT_EXPLOSION_MEDIUM;
611 expef = EFFECT_ELECTRO_COMBO; // hookbomb_explode electro_combo bigplasma_impact
613 case NADE_TYPE_TRANSLOCATE:
616 case NADE_TYPE_MONSTER:
617 case NADE_TYPE_SPAWN:
619 switch(self.realowner.team)
621 case NUM_TEAM_1: expef = EFFECT_SPAWN_RED; break;
622 case NUM_TEAM_2: expef = EFFECT_SPAWN_BLUE; break;
623 case NUM_TEAM_3: expef = EFFECT_SPAWN_YELLOW; break;
624 case NUM_TEAM_4: expef = EFFECT_SPAWN_PINK; break;
625 default: expef = EFFECT_SPAWN_NEUTRAL; break;
630 expef = EFFECT_SPAWN_RED;
634 case NADE_TYPE_NORMAL:
635 expef = EFFECT_NADE_EXPLODE(self.realowner.team);
640 Send_Effect(expef, findbetterlocation(self.origin, 8), '0 0 0', 1);
642 sound(self, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, ATTEN_NORM);
643 sound(self, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
645 self.event_damage = func_null; // prevent somehow calling damage in the next call
649 RadiusDamage(self, self.realowner, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage,
650 autocvar_g_nades_nade_radius, self, world, autocvar_g_nades_nade_force, self.projectiledeathtype, self.enemy);
651 Damage_DamageInfo(self.origin, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage, autocvar_g_nades_nade_radius, '1 1 1' * autocvar_g_nades_nade_force, self.projectiledeathtype, 0, self);
655 switch ( Nades_from(self.nade_type) )
657 case NADE_TYPE_NAPALM: nade_napalm_boom(); break;
658 case NADE_TYPE_ICE: nade_ice_boom(); break;
659 case NADE_TYPE_TRANSLOCATE: nade_translocate_boom(); break;
660 case NADE_TYPE_SPAWN: nade_spawn_boom(); break;
661 case NADE_TYPE_HEAL: nade_heal_boom(); break;
662 case NADE_TYPE_MONSTER: nade_monster_boom(); break;
665 FOREACH_ENTITY_ENT(aiment, self,
667 if(it.classname == "grapplinghook")
668 RemoveGrapplingHook(it.realowner);
674 void spawn_held_nade(entity player, entity nowner, float ntime, int ntype, string pntype);
675 void nade_pickup(entity this, entity thenade)
677 spawn_held_nade(this, thenade.realowner, autocvar_g_nades_pickup_time, thenade.nade_type, thenade.pokenade_type);
679 // set refire so player can't even
680 this.nade_refire = time + autocvar_g_nades_nade_refire;
684 this.nade.nade_time_primed = thenade.nade_time_primed;
690 UpdateCSQCProjectile(self);
692 if(other == self.realowner)
693 return; // no self impacts
695 if(autocvar_g_nades_pickup)
696 if(time >= self.spawnshieldtime)
697 if(!other.nade && self.health == self.max_health) // no boosted shot pickups, thank you very much
698 if(IS_REAL_CLIENT(other) && IS_PLAYER(other))
700 nade_pickup(other, self);
701 sound(self, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, 0.5 *(ATTEN_LARGE + ATTEN_MAX));
705 /*float is_weapclip = 0;
706 if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NODRAW)
707 if (!(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NONSOLID))
708 if (!(trace_dphitcontents & DPCONTENTS_OPAQUE))
710 if(ITEM_TOUCH_NEEDKILL()) // || is_weapclip)
712 FOREACH_ENTITY_ENT(aiment, self,
714 if(it.classname == "grapplinghook")
715 RemoveGrapplingHook(it.realowner);
723 //setsize(self, '-2 -2 -2', '2 2 2');
724 //UpdateCSQCProjectile(self);
725 if(self.health == self.max_health)
727 spamsound(self, CH_SHOTS, SND(GRENADE_BOUNCE_RANDOM()), VOL_BASE, ATTEN_NORM);
737 sound(self, CH_SHOTS_SINGLE, SND_NADE_BEEP, VOL_BASE, 0.5 *(ATTEN_LARGE + ATTEN_MAX));
738 self.think = nade_boom;
739 self.nextthink = max(self.wait, time);
742 void nade_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
744 if(ITEM_DAMAGE_NEEDKILL(deathtype))
746 this.takedamage = DAMAGE_NO;
747 WITH(entity, self, this, nade_boom());
751 if(this.nade_type == NADE_TYPE_TRANSLOCATE.m_id || this.nade_type == NADE_TYPE_SPAWN.m_id)
754 if (MUTATOR_CALLHOOK(Nade_Damage, DEATH_WEAPONOF(deathtype), force, damage)) {}
755 else if(DEATH_ISWEAPON(deathtype, WEP_BLASTER))
760 else if(DEATH_ISWEAPON(deathtype, WEP_VAPORIZER) && (deathtype & HITTYPE_SECONDARY))
762 force *= 0.5; // too much
765 else if(DEATH_ISWEAPON(deathtype, WEP_VORTEX) || DEATH_ISWEAPON(deathtype, WEP_VAPORIZER))
768 damage = this.max_health * 0.55;
770 else if(DEATH_ISWEAPON(deathtype, WEP_MACHINEGUN))
771 damage = this.max_health * 0.1;
772 else if(DEATH_ISWEAPON(deathtype, WEP_SHOCKWAVE) || DEATH_ISWEAPON(deathtype, WEP_SHOTGUN)) // WEAPONTODO
774 if(deathtype & HITTYPE_SECONDARY)
776 damage = this.max_health * 0.1;
780 damage = this.max_health * 1.15;
783 this.velocity += force;
784 UpdateCSQCProjectile(this);
786 if(damage <= 0 || ((IS_ONGROUND(this)) && IS_PLAYER(attacker)))
789 if(this.health == this.max_health)
791 sound(this, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, 0.5 *(ATTEN_LARGE + ATTEN_MAX));
792 this.nextthink = max(time + autocvar_g_nades_nade_lifetime, time);
793 this.think = nade_beep;
796 this.health -= damage;
798 if ( this.nade_type != NADE_TYPE_HEAL.m_id || IS_PLAYER(attacker) )
799 this.realowner = attacker;
802 WITH(entity, self, this, W_PrepareExplosionByDamage(attacker, nade_boom));
804 nade_burn_spawn(this);
807 void toss_nade(entity e, bool set_owner, vector _velocity, float _time)
812 entity _nade = e.nade;
818 makevectors(e.v_angle);
820 W_SetupShot(e, false, false, "", CH_WEAPON_A, 0);
822 Kill_Notification(NOTIF_ONE_ONLY, e, MSG_CENTER_CPID, CPID_NADES);
824 vector offset = (v_forward * autocvar_g_nades_throw_offset.x)
825 + (v_right * autocvar_g_nades_throw_offset.y)
826 + (v_up * autocvar_g_nades_throw_offset.z);
827 if(autocvar_g_nades_throw_offset == '0 0 0')
830 setorigin(_nade, w_shotorg + offset + (v_right * 25) * -1);
831 //setmodel(_nade, MDL_PROJECTILE_NADE);
832 //setattachment(_nade, world, "");
833 PROJECTILE_MAKETRIGGER(_nade);
834 if(STAT(NADES_SMALL, e))
835 setsize(_nade, '-8 -8 -8', '8 8 8');
837 setsize(_nade, '-16 -16 -16', '16 16 16');
838 _nade.movetype = MOVETYPE_BOUNCE;
840 tracebox(_nade.origin, _nade.mins, _nade.maxs, _nade.origin, false, _nade);
841 if (trace_startsolid)
842 setorigin(_nade, e.origin);
844 if(self.v_angle.x >= 70 && self.v_angle.x <= 110 && self.BUTTON_CROUCH)
845 _nade.velocity = '0 0 100';
846 else if(autocvar_g_nades_nade_newton_style == 1)
847 _nade.velocity = e.velocity + _velocity;
848 else if(autocvar_g_nades_nade_newton_style == 2)
849 _nade.velocity = _velocity;
851 _nade.velocity = W_CalculateProjectileVelocity(e.velocity, _velocity, true);
856 _nade.touch = nade_touch;
857 _nade.spawnshieldtime = time + 0.1; // prevent instantly picking up again
858 _nade.health = autocvar_g_nades_nade_health;
859 _nade.max_health = _nade.health;
860 _nade.takedamage = DAMAGE_AIM;
861 _nade.event_damage = nade_damage;
862 _nade.customizeentityforclient = func_null;
863 _nade.exteriormodeltoclient = world;
864 _nade.traileffectnum = 0;
865 _nade.teleportable = true;
866 _nade.pushable = true;
868 _nade.missile_flags = MIF_SPLASH | MIF_ARC;
869 _nade.damagedbycontents = true;
870 _nade.angles = vectoangles(_nade.velocity);
871 _nade.flags = FL_PROJECTILE;
872 _nade.projectiledeathtype = DEATH_NADE.m_id;
873 _nade.toss_time = time;
874 _nade.solid = SOLID_CORPSE; //((_nade.nade_type == NADE_TYPE_TRANSLOCATE) ? SOLID_CORPSE : SOLID_BBOX);
876 if(_nade.nade_type == NADE_TYPE_TRANSLOCATE.m_id || _nade.nade_type == NADE_TYPE_SPAWN.m_id)
877 _nade.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
879 _nade.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY;
885 _nade.think = nade_boom;
886 _nade.nextthink = _time;
889 e.nade_refire = time + autocvar_g_nades_nade_refire;
893 void nades_GiveBonus(entity player, float score)
895 if (autocvar_g_nades)
896 if (autocvar_g_nades_bonus)
897 if (IS_REAL_CLIENT(player))
898 if (IS_PLAYER(player) && player.bonus_nades < autocvar_g_nades_bonus_max)
899 if (STAT(FROZEN, player) == 0)
900 if (!IS_DEAD(player))
902 if ( player.bonus_nade_score < 1 )
903 player.bonus_nade_score += score/autocvar_g_nades_bonus_score_max;
905 if ( player.bonus_nade_score >= 1 )
907 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_NADE_BONUS);
908 play2(player, SND(KH_ALARM));
909 player.bonus_nades++;
910 player.bonus_nade_score -= 1;
915 /** Remove all bonus nades from a player */
916 void nades_RemoveBonus(entity player)
918 player.bonus_nades = player.bonus_nade_score = 0;
921 MUTATOR_HOOKFUNCTION(nades, PutClientInServer)
923 nades_RemoveBonus(self);
926 float nade_customize()
928 //if(IS_SPEC(other)) { return false; }
929 if(other == self.exteriormodeltoclient || (IS_SPEC(other) && other.enemy == self.exteriormodeltoclient))
931 // somewhat hide the model, but keep the glow
933 if(self.traileffectnum)
934 self.traileffectnum = 0;
939 //self.effects = EF_ADDITIVE | EF_FULLBRIGHT | EF_LOWPRECISION;
940 if(!self.traileffectnum)
941 self.traileffectnum = _particleeffectnum(Nade_TrailEffect(Nades_from(self.nade_type).m_projectile[false], self.team).eent_eff_name);
948 void spawn_held_nade(entity player, entity nowner, float ntime, int ntype, string pntype)
950 entity n = new(nade), fn = new(fake_nade);
952 n.nade_type = bound(1, ntype, Nades_COUNT);
953 n.pokenade_type = pntype;
955 setmodel(n, MDL_PROJECTILE_NADE);
956 //setattachment(n, player, "bip01 l hand");
957 n.exteriormodeltoclient = player;
958 n.customizeentityforclient = nade_customize;
959 n.traileffectnum = _particleeffectnum(Nade_TrailEffect(Nades_from(n.nade_type).m_projectile[false], player.team).eent_eff_name);
960 n.colormod = Nades_from(n.nade_type).m_color;
961 n.realowner = nowner;
962 n.colormap = player.colormap;
963 n.glowmod = player.glowmod;
964 n.wait = time + max(0, ntime);
965 n.nade_time_primed = time;
967 n.nextthink = max(n.wait - 3, time);
968 n.projectiledeathtype = DEATH_NADE.m_id;
970 setmodel(fn, MDL_NADE_VIEW);
971 .entity weaponentity = weaponentities[0]; // TODO: unhardcode
972 setattachment(fn, player.(weaponentity), "");
973 fn.realowner = fn.owner = player;
974 fn.colormod = Nades_from(n.nade_type).m_color;
975 fn.colormap = player.colormap;
976 fn.glowmod = player.glowmod;
977 fn.think = SUB_Remove_self;
978 fn.nextthink = n.wait;
981 player.fake_nade = fn;
986 if(autocvar_g_nades_bonus_only)
987 if(!self.bonus_nades)
988 return; // only allow bonus nades
994 remove(self.fake_nade);
997 string pntype = self.pokenade_type;
999 if(self.items & ITEM_Strength.m_itemid && autocvar_g_nades_bonus_onstrength)
1000 ntype = self.nade_type;
1001 else if (self.bonus_nades >= 1)
1003 ntype = self.nade_type;
1004 pntype = self.pokenade_type;
1005 self.bonus_nades -= 1;
1009 ntype = ((autocvar_g_nades_client_select) ? self.cvar_cl_nade_type : autocvar_g_nades_nade_type);
1010 pntype = ((autocvar_g_nades_client_select) ? self.cvar_cl_pokenade_type : autocvar_g_nades_pokenade_monster_type);
1013 spawn_held_nade(self, self, autocvar_g_nades_nade_lifetime, ntype, pntype);
1016 float CanThrowNade()
1027 if (!autocvar_g_nades)
1028 return false; // allow turning them off mid match
1030 if(forbidWeaponUse(self))
1033 if (!IS_PLAYER(self))
1039 .bool nade_altbutton;
1041 void nades_CheckThrow()
1046 entity held_nade = self.nade;
1049 self.nade_altbutton = true;
1050 if(time > self.nade_refire)
1052 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_NADE_THROW);
1054 self.nade_refire = time + autocvar_g_nades_nade_refire;
1059 self.nade_altbutton = false;
1060 if (time >= held_nade.nade_time_primed + 1) {
1061 makevectors(self.v_angle);
1062 float _force = time - held_nade.nade_time_primed;
1063 _force /= autocvar_g_nades_nade_lifetime;
1064 _force = autocvar_g_nades_nade_minforce + (_force * (autocvar_g_nades_nade_maxforce - autocvar_g_nades_nade_minforce));
1065 toss_nade(self, true, (v_forward * 0.75 + v_up * 0.2 + v_right * 0.05) * _force, 0);
1070 void nades_Clear(entity player)
1073 remove(player.nade);
1074 if(player.fake_nade)
1075 remove(player.fake_nade);
1077 player.nade = player.fake_nade = world;
1078 player.nade_timer = 0;
1081 MUTATOR_HOOKFUNCTION(nades, VehicleEnter)
1084 toss_nade(vh_player, true, '0 0 100', max(vh_player.nade.wait, time + 0.05));
1089 CLASS(NadeOffhand, OffhandWeapon)
1090 METHOD(NadeOffhand, offhand_think, void(NadeOffhand this, entity player, bool key_pressed))
1092 entity held_nade = player.nade;
1095 player.nade_timer = bound(0, (time - held_nade.nade_time_primed) / autocvar_g_nades_nade_lifetime, 1);
1096 // LOG_TRACEF("%d %d\n", player.nade_timer, time - held_nade.nade_time_primed);
1097 makevectors(player.angles);
1098 held_nade.velocity = player.velocity;
1099 setorigin(held_nade, player.origin + player.view_ofs + v_forward * 8 + v_right * -8 + v_up * 0);
1100 held_nade.angles_y = player.angles.y;
1102 if (time + 0.1 >= held_nade.wait)
1103 toss_nade(player, false, '0 0 0', time + 0.05);
1106 if (!CanThrowNade()) return;
1107 if (!(time > player.nade_refire)) return;
1111 held_nade = player.nade;
1113 } else if (time >= held_nade.nade_time_primed + 1) {
1115 makevectors(player.v_angle);
1116 float _force = time - held_nade.nade_time_primed;
1117 _force /= autocvar_g_nades_nade_lifetime;
1118 _force = autocvar_g_nades_nade_minforce + (_force * (autocvar_g_nades_nade_maxforce - autocvar_g_nades_nade_minforce));
1119 toss_nade(player, false, (v_forward * 0.7 + v_up * 0.2 + v_right * 0.1) * _force, 0);
1123 ENDCLASS(NadeOffhand)
1124 NadeOffhand OFFHAND_NADE; STATIC_INIT(OFFHAND_NADE) { OFFHAND_NADE = NEW(NadeOffhand); }
1126 MUTATOR_HOOKFUNCTION(nades, ForbidThrowCurrentWeapon, CBC_ORDER_LAST)
1128 if (self.offhand != OFFHAND_NADE || (self.weapons & WEPSET(HOOK)) || autocvar_g_nades_override_dropweapon) {
1135 MUTATOR_HOOKFUNCTION(nades, PlayerPreThink)
1137 if (!IS_PLAYER(self)) { return false; }
1139 if (self.nade && (self.offhand != OFFHAND_NADE || (self.weapons & WEPSET(HOOK)))) OFFHAND_NADE.offhand_think(OFFHAND_NADE, self, self.nade_altbutton);
1143 if ( autocvar_g_nades_bonus && autocvar_g_nades )
1146 float key_count = 0;
1147 FOR_EACH_KH_KEY(key) if(key.owner == self) { ++key_count; }
1150 if(self.flagcarried || self.ballcarried) // this player is important
1151 time_score = autocvar_g_nades_bonus_score_time_flagcarrier;
1153 time_score = autocvar_g_nades_bonus_score_time;
1156 time_score = autocvar_g_nades_bonus_score_time_flagcarrier * key_count; // multiply by the number of keys the player is holding
1158 if(autocvar_g_nades_bonus_client_select)
1160 self.nade_type = self.cvar_cl_nade_type;
1161 self.pokenade_type = self.cvar_cl_pokenade_type;
1165 self.nade_type = autocvar_g_nades_bonus_type;
1166 self.pokenade_type = autocvar_g_nades_pokenade_monster_type;
1169 self.nade_type = bound(1, self.nade_type, Nades_COUNT);
1171 if(self.bonus_nade_score >= 0 && autocvar_g_nades_bonus_score_max)
1172 nades_GiveBonus(self, time_score / autocvar_g_nades_bonus_score_max);
1176 self.bonus_nades = self.bonus_nade_score = 0;
1182 if(self.freezetag_frozen_timeout > 0 && time >= self.freezetag_frozen_timeout)
1186 vector revive_extra_size = '1 1 1' * autocvar_g_freezetag_revive_extra_size;
1188 FOREACH_CLIENT(IS_PLAYER(it) && it != self, LAMBDA(
1190 if(STAT(FROZEN, it) == 0)
1191 if(SAME_TEAM(it, self))
1192 if(boxesoverlap(self.absmin - revive_extra_size, self.absmax + revive_extra_size, it.absmin, it.absmax))
1196 if(STAT(FROZEN, self) == 1)
1203 if(n && STAT(FROZEN, self) == 3) // OK, there is at least one teammate reviving us
1205 self.revive_progress = bound(0, self.revive_progress + frametime * max(1/60, autocvar_g_freezetag_revive_speed), 1);
1206 self.health = max(1, self.revive_progress * start_health);
1208 if(self.revive_progress >= 1)
1212 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_FREEZETAG_REVIVED, o.netname);
1213 Send_Notification(NOTIF_ONE, o, MSG_CENTER, CENTER_FREEZETAG_REVIVE, self.netname);
1216 FOREACH_CLIENT(IS_PLAYER(it) && it.reviving, LAMBDA(
1217 other.revive_progress = self.revive_progress;
1218 other.reviving = false;
1225 MUTATOR_HOOKFUNCTION(nades, PlayerSpawn)
1227 if(autocvar_g_nades_spawn)
1228 self.nade_refire = time + autocvar_g_spawnshieldtime;
1230 self.nade_refire = time + autocvar_g_nades_nade_refire;
1232 if(autocvar_g_nades_bonus_client_select)
1233 self.nade_type = self.cvar_cl_nade_type;
1235 self.nade_timer = 0;
1237 if (!self.offhand) self.offhand = OFFHAND_NADE;
1239 if(self.nade_spawnloc)
1241 setorigin(self, self.nade_spawnloc.origin);
1242 self.nade_spawnloc.cnt -= 1;
1244 if(self.nade_spawnloc.cnt <= 0)
1246 remove(self.nade_spawnloc);
1247 self.nade_spawnloc = world;
1254 MUTATOR_HOOKFUNCTION(nades, PlayerDies, CBC_ORDER_LAST)
1256 if(frag_target.nade)
1257 if(!STAT(FROZEN, frag_target) || !autocvar_g_freezetag_revive_nade)
1258 toss_nade(frag_target, true, '0 0 100', max(frag_target.nade.wait, time + 0.05));
1260 float killcount_bonus = ((frag_attacker.killcount >= 1) ? bound(0, autocvar_g_nades_bonus_score_minor * frag_attacker.killcount, autocvar_g_nades_bonus_score_medium) : autocvar_g_nades_bonus_score_minor);
1262 if(IS_PLAYER(frag_attacker))
1264 if (SAME_TEAM(frag_attacker, frag_target) || frag_attacker == frag_target)
1265 nades_RemoveBonus(frag_attacker);
1266 else if(frag_target.flagcarried)
1267 nades_GiveBonus(frag_attacker, autocvar_g_nades_bonus_score_medium);
1268 else if(autocvar_g_nades_bonus_score_spree && frag_attacker.killcount > 1)
1270 #define SPREE_ITEM(counta,countb,center,normal,gentle) \
1271 case counta: { nades_GiveBonus(frag_attacker, autocvar_g_nades_bonus_score_spree); break; }
1272 switch(frag_attacker.killcount)
1275 default: nades_GiveBonus(frag_attacker, autocvar_g_nades_bonus_score_minor); break;
1280 nades_GiveBonus(frag_attacker, killcount_bonus);
1283 nades_RemoveBonus(frag_target);
1288 MUTATOR_HOOKFUNCTION(nades, PlayerDamage_Calculate)
1290 if(STAT(FROZEN, frag_target))
1291 if(autocvar_g_freezetag_revive_nade)
1292 if(frag_attacker == frag_target)
1293 if(frag_deathtype == DEATH_NADE.m_id)
1294 if(time - frag_inflictor.toss_time <= 0.1)
1296 Unfreeze(frag_target);
1297 frag_target.health = autocvar_g_freezetag_revive_nade_health;
1298 Send_Effect(EFFECT_ICEORGLASS, frag_target.origin, '0 0 0', 3);
1300 frag_force = '0 0 0';
1301 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_FREEZETAG_REVIVED_NADE, frag_target.netname);
1302 Send_Notification(NOTIF_ONE, frag_target, MSG_CENTER, CENTER_FREEZETAG_REVIVE_SELF);
1308 MUTATOR_HOOKFUNCTION(nades, MonsterDies)
1310 if(IS_PLAYER(frag_attacker))
1311 if(DIFF_TEAM(frag_attacker, frag_target))
1312 if(!(frag_target.spawnflags & MONSTERFLAG_SPAWNED))
1313 nades_GiveBonus(frag_attacker, autocvar_g_nades_bonus_score_minor);
1318 MUTATOR_HOOKFUNCTION(nades, DropSpecialItems)
1320 if(frag_target.nade)
1321 toss_nade(frag_target, true, '0 0 0', time + 0.05);
1326 bool nades_RemovePlayer()
1329 nades_RemoveBonus(self);
1333 MUTATOR_HOOKFUNCTION(nades, MakePlayerObserver) { nades_RemovePlayer(); }
1334 MUTATOR_HOOKFUNCTION(nades, ClientDisconnect) { nades_RemovePlayer(); }
1335 MUTATOR_HOOKFUNCTION(nades, reset_map_global) { nades_RemovePlayer(); }
1337 MUTATOR_HOOKFUNCTION(nades, SpectateCopy)
1339 self.nade_timer = other.nade_timer;
1340 self.nade_type = other.nade_type;
1341 self.pokenade_type = other.pokenade_type;
1342 self.bonus_nades = other.bonus_nades;
1343 self.bonus_nade_score = other.bonus_nade_score;
1344 self.stat_healing_orb = other.stat_healing_orb;
1345 self.stat_healing_orb_alpha = other.stat_healing_orb_alpha;
1349 MUTATOR_HOOKFUNCTION(nades, GetCvars)
1351 GetCvars_handleFloat(get_cvars_s, get_cvars_f, cvar_cl_nade_type, "cl_nade_type");
1352 GetCvars_handleString(get_cvars_s, get_cvars_f, cvar_cl_pokenade_type, "cl_pokenade_type");
1357 MUTATOR_HOOKFUNCTION(nades, BuildMutatorsString)
1359 ret_string = strcat(ret_string, ":Nades");
1363 MUTATOR_HOOKFUNCTION(nades, BuildMutatorsPrettyString)
1365 ret_string = strcat(ret_string, ", Nades");
1369 MUTATOR_HOOKFUNCTION(nades, BuildGameplayTipsString)
1371 ret_string = strcat(ret_string, "\n\n^3nades^8 are enabled, press 'g' to use them\n");