a6a683389eaf30e85f0afdc878fb86d9bad7b957
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / w_seeker.qc
1 #ifdef REGISTER_WEAPON
2 REGISTER_WEAPON(SEEKER, w_seeker, IT_ROCKETS, 8, WEP_FLAG_MUTATORBLOCKED | WEP_FLAG_RELOADABLE | WEP_TYPE_SPLASH, BOT_PICKUP_RATING_MID, "seeker", "seeker", _("T.A.G. Seeker"))
3 #else
4 #ifdef SVQC
5 //.float proxytime; = autoswitch
6 //.float tl; = wait
7 .entity tag_target, wps_tag_tracker;
8 .float tag_time;
9
10 // ============================
11 // Begin: Missile functions, these are general functions to be manipulated by other code
12 // ============================
13 void Seeker_Missile_Explode ()
14 {
15         self.event_damage = SUB_Null;
16         RadiusDamage (self, self.realowner, autocvar_g_balance_seeker_missile_damage, autocvar_g_balance_seeker_missile_edgedamage, autocvar_g_balance_seeker_missile_radius, world, world, autocvar_g_balance_seeker_missile_force, self.projectiledeathtype, other);
17
18         remove (self);
19 }
20
21 void Seeker_Missile_Touch()
22 {
23         PROJECTILE_TOUCH;
24
25         Seeker_Missile_Explode();
26 }
27
28 void Seeker_Missile_Think()
29 {
30         entity e;
31         vector desireddir, olddir, newdir, eorg;
32         float turnrate;
33         float dist;
34         float spd;
35
36         if (time > self.cnt)
37         {
38                 self.projectiledeathtype |= HITTYPE_SPLASH;
39                 Seeker_Missile_Explode();
40         }
41
42         spd = vlen(self.velocity);
43         spd = bound(
44                 spd - autocvar_g_balance_seeker_missile_decel * frametime,
45                 autocvar_g_balance_seeker_missile_speed_max,
46                 spd + autocvar_g_balance_seeker_missile_accel * frametime
47         );
48
49         if (self.enemy != world)
50                 if (self.enemy.takedamage != DAMAGE_AIM || self.enemy.deadflag != DEAD_NO)
51                         self.enemy = world;
52
53         if (self.enemy != world)
54         {
55                 e               = self.enemy;
56                 eorg            = 0.5 * (e.absmin + e.absmax);
57                 turnrate        = autocvar_g_balance_seeker_missile_turnrate; // how fast to turn
58                 desireddir      = normalize(eorg - self.origin);
59                 olddir          = normalize(self.velocity); // get my current direction
60                 dist            = vlen(eorg - self.origin);
61
62                 // Do evasive maneuvers for world objects? ( this should be a cpu hog. :P )
63                 if (autocvar_g_balance_seeker_missile_smart && (dist > autocvar_g_balance_seeker_missile_smart_mindist))
64                 {
65                         // Is it a better idea (shorter distance) to trace to the target itself?
66                         if ( vlen(self.origin + olddir * self.wait) < dist)
67                                 traceline(self.origin, self.origin + olddir * self.wait, FALSE, self);
68                         else
69                                 traceline(self.origin, eorg, FALSE, self);
70
71                         // Setup adaptive tracelength
72                         self.wait = bound(autocvar_g_balance_seeker_missile_smart_trace_min, vlen(self.origin - trace_endpos), self.wait = autocvar_g_balance_seeker_missile_smart_trace_max);
73
74                         // Calc how important it is that we turn and add this to the desierd (enemy) dir.
75                         desireddir  = normalize(((trace_plane_normal * (1 - trace_fraction)) + (desireddir * trace_fraction)) * 0.5);
76                 }
77                 
78                 newdir = normalize(olddir + desireddir * turnrate); // take the average of the 2 directions; not the best method but simple & easy
79                 self.velocity = newdir * spd; // make me fly in the new direction at my flight speed
80         }
81         else
82                 dist = 0;
83
84         // Proxy
85         if (autocvar_g_balance_seeker_missile_proxy)
86         {
87                 if ( dist <= autocvar_g_balance_seeker_missile_proxy_maxrange)
88                 {
89                         if (self.autoswitch == 0)
90                         {
91                                 self.autoswitch = time + autocvar_g_balance_seeker_missile_proxy_delay;
92                         }
93                         else
94                         {
95                                 if (self.autoswitch <= time)
96                                 {
97                                         Seeker_Missile_Explode();
98                                         self.autoswitch = 0;
99                                 }
100                         }
101                 }
102                 else
103                 {
104                         if (self.autoswitch != 0)
105                                 self.autoswitch = 0;
106                 }
107         }
108         ///////////////
109
110         if (self.enemy.deadflag != DEAD_NO)
111         {
112                 self.enemy = world;
113                 self.cnt = time + 1 + (random() * 4);
114                 self.nextthink = self.cnt;
115                 return;
116         }
117
118         //self.angles = vectoangles(self.velocity);                     // turn model in the new flight direction
119         self.nextthink = time;// + 0.05; // csqc projectiles
120         UpdateCSQCProjectile(self);
121 }
122
123
124
125 void Seeker_Missile_Damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
126 {
127         if (self.health <= 0)
128                 return;
129                 
130         if (!W_CheckProjectileDamage(inflictor.realowner, self.realowner, deathtype, -1)) // no exceptions
131                 return; // g_projectiles_damage says to halt
132
133         if (self.realowner == attacker)
134                 self.health = self.health - (damage * 0.25);
135         else
136                 self.health = self.health - damage;
137                 
138         if (self.health <= 0)
139                 W_PrepareExplosionByDamage(attacker, Seeker_Missile_Explode);
140 }
141
142 /*
143 void Seeker_Missile_Animate()
144 {
145         self.frame = self.frame +1;
146         self.nextthink = time + 0.05;
147
148         if (self.enemy != world)
149                 if (self.enemy.takedamage != DAMAGE_AIM || self.enemy.deadflag != DEAD_NO)
150                         self.enemy = world;
151
152         if(self.frame == 5)
153         {
154                 self.think           = Seeker_Missile_Think;
155                 self.nextthink       = time;// + cvar("g_balance_seeker_missile_activate_delay"); // cant dealy with csqc projectiles
156
157                 if (autocvar_g_balance_seeker_missile_proxy)
158                         self.movetype    = MOVETYPE_BOUNCEMISSILE;
159                 else
160                         self.movetype    = MOVETYPE_FLYMISSILE;
161         }
162
163         UpdateCSQCProjectile(self);
164 }
165 */
166
167 void Seeker_Fire_Missile(vector f_diff, entity m_target)
168 {
169         entity missile;
170
171         W_DecreaseAmmo(ammo_rockets, autocvar_g_balance_seeker_missile_ammo, autocvar_g_balance_seeker_reload_ammo);
172
173         makevectors(self.v_angle);
174         W_SetupShot_ProjectileSize (self, '-2 -2 -2', '2 2 2', FALSE, 2, "weapons/seeker_fire.wav", CH_WEAPON_A, 0);
175         w_shotorg += f_diff;
176         pointparticles(particleeffectnum("seeker_muzzleflash"), w_shotorg, w_shotdir * 1000, 1);
177
178         //self.detornator         = FALSE;
179
180         missile                 = spawn();
181         missile.owner           = missile.realowner = self;
182         missile.classname       = "seeker_missile";
183         missile.bot_dodge       = TRUE;
184         missile.bot_dodgerating = autocvar_g_balance_seeker_missile_damage;
185
186         missile.think           = Seeker_Missile_Think;
187         missile.touch           = Seeker_Missile_Touch;
188         missile.event_damage    = Seeker_Missile_Damage;
189         missile.nextthink       = time;// + 0.2;// + cvar("g_balance_seeker_missile_activate_delay");
190         missile.cnt             = time + autocvar_g_balance_seeker_missile_lifetime;
191         missile.enemy           = m_target;
192         missile.solid           = SOLID_BBOX;
193         missile.scale           = 2;
194         missile.takedamage      = DAMAGE_YES;
195         missile.health          = autocvar_g_balance_seeker_missile_health;
196         missile.damageforcescale = autocvar_g_balance_seeker_missile_damageforcescale;
197         missile.damagedbycontents = TRUE;
198         //missile.think           = Seeker_Missile_Animate; // csqc projectiles.
199         
200         if (missile.enemy != world)
201                 missile.projectiledeathtype = WEP_SEEKER | HITTYPE_SECONDARY;
202         else 
203                 missile.projectiledeathtype = WEP_SEEKER;
204
205
206         setorigin (missile, w_shotorg);
207         setsize (missile, '-4 -4 -4', '4 4 4');
208         missile.movetype    = MOVETYPE_FLYMISSILE;
209         missile.flags       = FL_PROJECTILE;
210         missile.missile_flags = MIF_SPLASH | MIF_GUIDED_TAG;
211         
212         W_SETUPPROJECTILEVELOCITY_UP(missile, g_balance_seeker_missile);
213
214         missile.angles = vectoangles (missile.velocity);
215
216         CSQCProjectile(missile, FALSE, PROJECTILE_SEEKER, TRUE);
217
218         other = missile; MUTATOR_CALLHOOK(EditProjectile);
219 }
220
221 // ============================
222 // Begin: FLAC, close range attack meant for defeating rockets which are coming at you. 
223 // ============================
224 void Seeker_Flac_Explode ()
225 {
226         self.event_damage = SUB_Null;
227
228         RadiusDamage (self, self.realowner, autocvar_g_balance_seeker_flac_damage, autocvar_g_balance_seeker_flac_edgedamage, autocvar_g_balance_seeker_flac_radius, world, world, autocvar_g_balance_seeker_flac_force, self.projectiledeathtype, other);
229
230         remove (self);
231 }
232
233 void Seeker_Flac_Touch()
234 {
235         PROJECTILE_TOUCH;
236
237         Seeker_Flac_Explode();
238 }
239
240 void Seeker_Fire_Flac()
241 {
242         entity missile;
243         vector f_diff;
244         float c;
245
246         W_DecreaseAmmo(ammo_rockets, autocvar_g_balance_seeker_flac_ammo, autocvar_g_balance_seeker_reload_ammo);
247
248         c = mod(self.bulletcounter, 4);
249         switch(c)
250         {
251                 case 0:
252                         f_diff = '-1.25 -3.75 0';
253                         break;
254                 case 1:
255                         f_diff = '+1.25 -3.75 0';
256                         break;
257                 case 2:
258                         f_diff = '-1.25 +3.75 0';
259                         break;
260                 case 3:
261                 default:
262                         f_diff = '+1.25 +3.75 0';
263                         break;
264         }
265         W_SetupShot_ProjectileSize (self, '-2 -2 -2', '2 2 2', FALSE, 2, "weapons/flac_fire.wav", CH_WEAPON_A, autocvar_g_balance_seeker_flac_damage);
266         w_shotorg += f_diff;
267
268         pointparticles(particleeffectnum("hagar_muzzleflash"), w_shotorg, w_shotdir * 1000, 1);
269
270         missile                                 = spawn ();
271         missile.owner                   = missile.realowner = self;
272         missile.classname               = "missile";
273         missile.bot_dodge               = TRUE;
274         missile.bot_dodgerating = autocvar_g_balance_seeker_flac_damage;
275         missile.touch                   = Seeker_Flac_Explode;
276         missile.use                     = Seeker_Flac_Explode; 
277         missile.think                   = adaptor_think2use_hittype_splash;
278         missile.nextthink               = time + autocvar_g_balance_seeker_flac_lifetime + autocvar_g_balance_seeker_flac_lifetime_rand;
279         missile.solid                   = SOLID_BBOX;
280         missile.movetype                = MOVETYPE_FLY; 
281         missile.projectiledeathtype = WEP_SEEKER;
282         missile.projectiledeathtype = WEP_SEEKER | HITTYPE_SECONDARY;
283         missile.flags                           = FL_PROJECTILE;
284         missile.missile_flags       = MIF_SPLASH; 
285         
286         // csqc projectiles
287         //missile.angles                                = vectoangles (missile.velocity);       
288         //missile.scale = 0.4; // BUG: the model is too big 
289         
290         setorigin (missile, w_shotorg);
291         setsize (missile, '-2 -2 -2', '2 2 2');
292                 
293         W_SETUPPROJECTILEVELOCITY_UP(missile, g_balance_seeker_flac);
294         CSQCProjectile(missile, TRUE, PROJECTILE_FLAC, TRUE);
295
296         other = missile; MUTATOR_CALLHOOK(EditProjectile);
297 }
298
299 // ============================
300 // Begin: Tag and rocket controllers 
301 // ============================
302 entity Seeker_Tagged_Info(entity isowner, entity istarget)
303 {
304         entity tag;
305         for(tag = world; (tag = find(tag, classname, "tag_tracker")); ) 
306                 if ((tag.realowner == isowner) && (tag.tag_target == istarget))
307                         return tag;
308                 
309         return world;
310 }
311
312 void Seeker_Attack()
313 {
314         entity tracker, closest_target;
315         
316         closest_target = world;
317         for(tracker = world; (tracker = find(tracker, classname, "tag_tracker")); ) if (tracker.realowner == self)
318         {
319                 if (closest_target)
320                 {
321                         if (vlen(self.origin - tracker.tag_target.origin) < vlen(self.origin - closest_target.origin))
322                                 closest_target = tracker.tag_target;
323                 }
324                 else 
325                         closest_target = tracker.tag_target;
326         }
327                 
328         traceline(self.origin + self.view_ofs, closest_target.origin, MOVE_NOMONSTERS, self);
329         if ((!closest_target) || ((trace_fraction < 1) && (trace_ent != closest_target)))
330                 closest_target = world;
331         
332         Seeker_Fire_Missile('0 0 0', closest_target);
333 }
334
335 void Seeker_Vollycontroller_Think() // TODO: Merge this with Seeker_Attack
336 {
337         float c;
338         entity oldself,oldenemy;
339         self.cnt = self.cnt - 1;
340
341         if((!(self.realowner.items & IT_UNLIMITED_AMMO) && self.realowner.ammo_rockets < autocvar_g_balance_seeker_missile_ammo) || (self.cnt <= -1) || (self.realowner.deadflag != DEAD_NO) || (self.realowner.switchweapon != WEP_SEEKER))
342         {
343                 remove(self);
344                 return;
345         }
346
347         self.nextthink = time + autocvar_g_balance_seeker_missile_delay * W_WeaponRateFactor();
348         
349         oldself = self;
350         self = self.realowner;
351         
352         oldenemy = self.enemy;
353         self.enemy = oldself.enemy;
354         
355         c = mod(self.cnt, 4);
356         switch(c)
357         {
358                 case 0:
359                         Seeker_Fire_Missile('-1.25 -3.75 0', self.enemy);
360                         break;
361                 case 1:
362                         Seeker_Fire_Missile('+1.25 -3.75 0', self.enemy);
363                         break;
364                 case 2:
365                         Seeker_Fire_Missile('-1.25 +3.75 0', self.enemy);
366                         break;
367                 case 3:
368                 default:
369                         Seeker_Fire_Missile('+1.25 +3.75 0', self.enemy);
370                         break;
371         }
372
373         self.enemy = oldenemy;
374         self = oldself;
375 }
376
377 void Seeker_Tracker_Think() 
378 {
379         // commit suicide if: You die OR target dies OR you switch away from the seeker OR commit suicide if lifetime is up
380         if ((self.realowner.deadflag != DEAD_NO) || (self.tag_target.deadflag != DEAD_NO) || (self.realowner.switchweapon != WEP_SEEKER)
381         || (time > self.tag_time + autocvar_g_balance_seeker_tag_tracker_lifetime))
382         {
383                 if (self)
384                 {
385                         WaypointSprite_Kill(self.tag_target.wps_tag_tracker);
386                         remove(self);
387                 }
388                 return;
389         }
390         
391         // Update the think method information
392         self.nextthink = time;
393 }
394
395 // ============================
396 // Begin: Tag projectile 
397 // ============================
398 void Seeker_Tag_Explode ()
399 {
400         //if(other==self.realowner)
401         //    return;
402         Damage_DamageInfo(self.origin, 0, 0, 0, self.velocity, WEP_SEEKER | HITTYPE_BOUNCE, other.species, self);
403
404         remove (self);
405 }
406
407 void Seeker_Tag_Damage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
408 {
409         if (self.health <= 0)
410                 return;
411         self.health = self.health - damage;
412         if (self.health <= 0)
413                 Seeker_Tag_Explode();
414 }
415
416 void Seeker_Tag_Touch()
417 {
418         vector dir;
419         vector org2;
420         entity e;
421         
422         PROJECTILE_TOUCH;
423
424         dir     = normalize (self.realowner.origin - self.origin);
425         org2    = findbetterlocation (self.origin, 8);
426
427         te_knightspike(org2);
428
429         self.event_damage = SUB_Null;
430         Damage_DamageInfo(self.origin, 0, 0, 0, self.velocity, WEP_SEEKER | HITTYPE_HEADSHOT, other.species, self);
431
432         if (other.takedamage == DAMAGE_AIM && other.deadflag == DEAD_NO)
433         {
434                 // check to see if this person is already tagged by me
435                 entity tag = Seeker_Tagged_Info(self.realowner, other);
436                 
437                 if (tag != world)
438                 {
439                         if (other.wps_tag_tracker && (autocvar_g_balance_seeker_type == 1)) // don't attach another waypointsprite without killing the old one first
440                                 WaypointSprite_Kill(other.wps_tag_tracker);
441                                 
442                         tag.tag_time = time;
443                 }
444                 else
445                 {               
446                         //sprint(self.realowner, strcat("You just tagged ^2", other.netname, "^7 with a tracking device!\n"));
447                         e             = spawn();
448                         e.cnt         = autocvar_g_balance_seeker_missile_count;
449                         e.classname   = "tag_tracker";
450                         e.owner       = self.owner;
451                         e.realowner   = self.realowner;
452                         
453                         if      (autocvar_g_balance_seeker_type == 1)
454                         {
455                                 e.tag_target  = other;
456                                 e.tag_time    = time;
457                                 e.think       = Seeker_Tracker_Think;
458                         }
459                         else 
460                         {
461                                 e.enemy     = other;
462                                 e.think     = Seeker_Vollycontroller_Think;
463                         }
464                         
465                         e.nextthink   = time;
466                 }
467                 
468                 if      (autocvar_g_balance_seeker_type == 1)
469                 {
470                         WaypointSprite_Spawn("tagged-target", autocvar_g_balance_seeker_tag_tracker_lifetime, 0, other, '0 0 64', self.realowner, 0, other, wps_tag_tracker, TRUE, RADARICON_TAGGED, '0.5 1 0');
471                         WaypointSprite_UpdateRule(other.wps_tag_tracker, 0, SPRITERULE_DEFAULT);
472                 }
473         }
474
475         remove(self);
476         return;
477 }
478
479 void Seeker_Fire_Tag()
480 {
481         entity missile;
482         W_DecreaseAmmo(ammo_rockets, autocvar_g_balance_seeker_tag_ammo, autocvar_g_balance_seeker_reload_ammo);
483
484         W_SetupShot_ProjectileSize (self, '-2 -2 -2', '2 2 2', FALSE, 2, "weapons/tag_fire.wav", CH_WEAPON_A, autocvar_g_balance_seeker_missile_damage * autocvar_g_balance_seeker_missile_count);
485
486         missile                 = spawn();
487         missile.owner           = missile.realowner = self;
488         missile.classname       = "seeker_tag";
489         missile.bot_dodge       = TRUE;
490         missile.bot_dodgerating = 50;
491         missile.touch           = Seeker_Tag_Touch;
492         missile.think           = SUB_Remove;
493         missile.nextthink       = time + autocvar_g_balance_seeker_tag_lifetime;
494         missile.movetype        = MOVETYPE_FLY;
495         missile.solid           = SOLID_BBOX;
496
497         missile.takedamage       = DAMAGE_YES;
498         missile.event_damage    = Seeker_Tag_Explode;
499         missile.health          = autocvar_g_balance_seeker_tag_health;
500         missile.damageforcescale = autocvar_g_balance_seeker_tag_damageforcescale;
501
502         setorigin (missile, w_shotorg);
503         setsize (missile, '-2 -2 -2', '2 2 2');
504
505         missile.flags       = FL_PROJECTILE;
506         //missile.missile_flags = MIF_..?; 
507
508         missile.movetype    = MOVETYPE_FLY;
509         W_SETUPPROJECTILEVELOCITY(missile, g_balance_seeker_tag);
510         missile.angles = vectoangles (missile.velocity);
511
512         CSQCProjectile(missile, TRUE, PROJECTILE_TAG, FALSE); // has sound
513
514         other = missile; MUTATOR_CALLHOOK(EditProjectile);
515 }
516
517 // ============================
518 // Begin: Genereal weapon functions
519 // ============================
520 void spawnfunc_weapon_seeker (void)
521 {
522         weapon_defaultspawnfunc(WEP_SEEKER);
523 }
524
525 float w_seeker(float req)
526 {
527         float ammo_amount;
528
529         if (req == WR_AIM)
530         {
531                 if (autocvar_g_balance_seeker_type == 1) 
532                         if (Seeker_Tagged_Info(self, self.enemy) != world)
533                                 self.BUTTON_ATCK = bot_aim(autocvar_g_balance_seeker_missile_speed_max, 0, autocvar_g_balance_seeker_missile_lifetime, FALSE);
534                         else
535                                 self.BUTTON_ATCK2 = bot_aim(autocvar_g_balance_seeker_tag_speed, 0, autocvar_g_balance_seeker_tag_lifetime, FALSE);
536                 else
537                         self.BUTTON_ATCK = bot_aim(autocvar_g_balance_seeker_tag_speed, 0, autocvar_g_balance_seeker_tag_lifetime, FALSE);
538         }
539         else if (req == WR_THINK)
540         {
541                 if(autocvar_g_balance_seeker_reload_ammo && self.clip_load < min(autocvar_g_balance_seeker_missile_ammo, autocvar_g_balance_seeker_tag_ammo)) // forced reload
542                         weapon_action(self.weapon, WR_RELOAD);
543                         
544                 else if (self.BUTTON_ATCK)
545                 {
546                         if (autocvar_g_balance_seeker_type == 1) 
547                         {
548                                 if (weapon_prepareattack(0, autocvar_g_balance_seeker_missile_refire))
549                                 {
550                                         Seeker_Attack();
551                                         weapon_thinkf(WFRAME_FIRE2, autocvar_g_balance_seeker_missile_animtime, w_ready);
552                                 }
553                         }
554                         else 
555                         {
556                                 if (weapon_prepareattack(0, autocvar_g_balance_seeker_tag_refire))
557                                 {
558                                         Seeker_Fire_Tag();
559                                         weapon_thinkf(WFRAME_FIRE2, autocvar_g_balance_seeker_tag_animtime, w_ready);
560                                 }
561                         }
562                 }
563
564                 else if (self.BUTTON_ATCK2)
565                 {
566                         if (autocvar_g_balance_seeker_type == 1) 
567                         {
568                                 if (weapon_prepareattack(0, autocvar_g_balance_seeker_tag_refire))
569                                 {
570                                         Seeker_Fire_Tag();
571                                         weapon_thinkf(WFRAME_FIRE2, autocvar_g_balance_seeker_tag_animtime, w_ready);
572                                 }
573                         }
574                         else 
575                         {
576                                 if (weapon_prepareattack(0, autocvar_g_balance_seeker_flac_refire))
577                                 {
578                                         Seeker_Fire_Flac();
579                                         weapon_thinkf(WFRAME_FIRE2, autocvar_g_balance_seeker_flac_animtime, w_ready);
580                                 }
581                         }
582                 }
583         }
584         else if (req == WR_PRECACHE)
585         {
586                 precache_model ("models/weapons/g_seeker.md3");
587                 precache_model ("models/weapons/v_seeker.md3");
588                 precache_model ("models/weapons/h_seeker.iqm");
589                 precache_sound ("weapons/tag_fire.wav");
590                 precache_sound ("weapons/flac_fire.wav");
591                 precache_sound ("weapons/seeker_fire.wav");
592                 //precache_sound ("weapons/reload.wav"); // until weapons have individual reload sounds, precache the reload sound somewhere else
593         }
594         else if (req == WR_SETUP)
595         {
596                 weapon_setup(WEP_SEEKER);
597                 self.current_ammo = ammo_rockets;
598         }
599         else if (req == WR_CHECKAMMO1)
600         {
601                 ammo_amount = self.ammo_rockets >= autocvar_g_balance_seeker_missile_ammo;
602                 ammo_amount += self.(weapon_load[WEP_SEEKER]) >= autocvar_g_balance_seeker_missile_ammo;
603                 return ammo_amount;
604         }
605         else if (req == WR_CHECKAMMO2)
606         {
607                 ammo_amount = self.ammo_rockets >= autocvar_g_balance_seeker_tag_ammo;
608                 ammo_amount += self.(weapon_load[WEP_SEEKER]) >= autocvar_g_balance_seeker_tag_ammo;
609                 return ammo_amount;
610         }
611         else if (req == WR_RELOAD)
612         {
613                 W_Reload(min(autocvar_g_balance_seeker_missile_ammo, autocvar_g_balance_seeker_tag_ammo), autocvar_g_balance_seeker_reload_ammo, autocvar_g_balance_seeker_reload_time, "weapons/reload.wav");
614         }
615         return TRUE;
616 }
617 #endif
618 #ifdef CSQC
619 float w_seeker(float req)
620 {
621         if(req == WR_IMPACTEFFECT)
622         {
623                 vector org2;
624                 org2 = w_org + w_backoff * 6;
625                 if(w_deathtype & HITTYPE_BOUNCE)
626                 {
627                         pointparticles(particleeffectnum("hagar_explode"), org2, '0 0 0', 1);
628                         if(!w_issilent)
629                         {
630                                 if (w_random<0.15)
631                                         sound(self, CH_SHOTS, "weapons/tagexp1.wav", 1, ATTN_NORM);
632                                 else if (w_random<0.7)
633                                         sound(self, CH_SHOTS, "weapons/tagexp2.wav", 1, ATTN_NORM);
634                                 else
635                                         sound(self, CH_SHOTS, "weapons/tagexp3.wav", 1, ATTN_NORM);
636                         }
637                 }
638                 else if(w_deathtype & HITTYPE_HEADSHOT)
639                 {
640                         if(!w_issilent)
641                                 sound(self, CH_SHOTS, "weapons/tag_impact.wav", 1, ATTN_NORM);
642                 }
643                 else
644                 {
645                         pointparticles(particleeffectnum("hagar_explode"), org2, '0 0 0', 1);
646                         if(!w_issilent)
647                         {
648                                 if (w_random<0.15)
649                                         sound(self, CH_SHOTS, "weapons/seekerexp1.wav", 1, ATTN_NORM);
650                                 else if (w_random<0.7)
651                                         sound(self, CH_SHOTS, "weapons/seekerexp2.wav", 1, ATTN_NORM);
652                                 else
653                                         sound(self, CH_SHOTS, "weapons/seekerexp3.wav", 1, ATTN_NORM);
654                         }
655                 }
656         }
657         else if(req == WR_PRECACHE)
658         {
659                 precache_sound("weapons/seekerexp1.wav");
660                 precache_sound("weapons/seekerexp2.wav");
661                 precache_sound("weapons/seekerexp3.wav");
662                 precache_sound("weapons/tagexp1.wav");
663                 precache_sound("weapons/tagexp2.wav");
664                 precache_sound("weapons/tagexp3.wav");
665                 precache_sound("weapons/tag_impact.wav");
666         }
667         else if (req == WR_SUICIDEMESSAGE)
668                 w_deathtypestring = _("%s played with tiny seeker rockets");
669         else if (req == WR_KILLMESSAGE)
670         {
671                 if(w_deathtype & HITTYPE_SECONDARY)
672                         w_deathtypestring = _("%s was tagged with a seeker by %s");
673                 else
674                         w_deathtypestring = _("%s was pummeled with seeker rockets by %s");
675         }
676         return TRUE;
677 }
678 #endif
679 #endif