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