Weapons: remove WEP_ACTION
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / weapons / weaponsystem.qc
1 #include "weaponsystem.qh"
2 #include "../_all.qh"
3
4 #include "selection.qh"
5
6 #include "../command/common.qh"
7 #include "../mutators/mutators_include.qh"
8 #include "../round_handler.qh"
9 #include "../t_items.qh"
10 #include "../../common/animdecide.qh"
11 #include "../../common/constants.qh"
12 #include "../../common/monsters/all.qh"
13 #include "../../common/notifications.qh"
14 #include "../../common/util.qh"
15 #include "../../common/weapons/all.qh"
16 #include "../../csqcmodellib/sv_model.qh"
17
18 /*
19 ===========================================================================
20
21   CLIENT WEAPONSYSTEM CODE
22   Bring back W_Weaponframe
23
24 ===========================================================================
25 */
26
27 .float weapon_frametime;
28
29 float W_WeaponRateFactor()
30 {
31         float t = 1.0 / g_weaponratefactor;
32
33         MUTATOR_CALLHOOK(WeaponRateFactor, t);
34         t = weapon_rate;
35
36         return t;
37 }
38
39 float W_WeaponSpeedFactor()
40 {
41         float t = 1.0 * g_weaponspeedfactor;
42
43         MUTATOR_CALLHOOK(WeaponSpeedFactor, t);
44         t = ret_float;
45
46         return t;
47 }
48
49
50 void weapon_thinkf(float fr, float t, void(Weapon thiswep, bool fire1, bool fire2) func);
51
52 float CL_Weaponentity_CustomizeEntityForClient()
53 {SELFPARAM();
54         self.viewmodelforclient = self.owner;
55         if(IS_SPEC(other))
56                 if(other.enemy == self.owner)
57                         self.viewmodelforclient = other;
58         return true;
59 }
60
61 /*
62  * supported formats:
63  *
64  * 1. simple animated model, muzzle flash handling on h_ model:
65  *    h_tuba.dpm, h_tuba.dpm.framegroups - invisible model controlling the animation
66  *      tags:
67  *        shot = muzzle end (shot origin, also used for muzzle flashes)
68  *        shell = casings ejection point (must be on the right hand side of the gun)
69  *        weapon = attachment for v_tuba.md3
70  *    v_tuba.md3 - first and third person model
71  *    g_tuba.md3 - pickup model
72  *
73  * 2. simple animated model, muzzle flash handling on v_ model:
74  *    h_tuba.dpm, h_tuba.dpm.framegroups - invisible model controlling the animation
75  *      tags:
76  *        weapon = attachment for v_tuba.md3
77  *    v_tuba.md3 - first and third person model
78  *      tags:
79  *        shot = muzzle end (shot origin, also used for muzzle flashes)
80  *        shell = casings ejection point (must be on the right hand side of the gun)
81  *    g_tuba.md3 - pickup model
82  *
83  * 3. fully animated model, muzzle flash handling on h_ model:
84  *    h_tuba.dpm, h_tuba.dpm.framegroups - animated first person model
85  *      tags:
86  *        shot = muzzle end (shot origin, also used for muzzle flashes)
87  *        shell = casings ejection point (must be on the right hand side of the gun)
88  *        handle = corresponding to the origin of v_tuba.md3 (used for muzzle flashes)
89  *    v_tuba.md3 - third person model
90  *    g_tuba.md3 - pickup model
91  *
92  * 4. fully animated model, muzzle flash handling on v_ model:
93  *    h_tuba.dpm, h_tuba.dpm.framegroups - animated first person model
94  *      tags:
95  *        shot = muzzle end (shot origin)
96  *        shell = casings ejection point (must be on the right hand side of the gun)
97  *    v_tuba.md3 - third person model
98  *      tags:
99  *        shot = muzzle end (for muzzle flashes)
100  *    g_tuba.md3 - pickup model
101  */
102
103 // writes:
104 //   self.origin, self.angles
105 //   self.weaponentity
106 //   self.movedir, self.view_ofs
107 //   attachment stuff
108 //   anim stuff
109 // to free:
110 //   call again with ""
111 //   remove the ent
112 void CL_WeaponEntity_SetModel(string name)
113 {SELFPARAM();
114         float v_shot_idx;
115         if (name != "")
116         {
117                 // if there is a child entity, hide it until we're sure we use it
118                 if (self.weaponentity)
119                         self.weaponentity.model = "";
120                 _setmodel(self, W_Model(strcat("v_", name, ".md3")));
121                 v_shot_idx = gettagindex(self, "shot"); // used later
122                 if(!v_shot_idx)
123                         v_shot_idx = gettagindex(self, "tag_shot");
124
125                 _setmodel(self, W_Model(strcat("h_", name, ".iqm")));
126                 // preset some defaults that work great for renamed zym files (which don't need an animinfo)
127                 self.anim_fire1  = animfixfps(self, '0 1 0.01', '0 0 0');
128                 self.anim_fire2  = animfixfps(self, '1 1 0.01', '0 0 0');
129                 self.anim_idle   = animfixfps(self, '2 1 0.01', '0 0 0');
130                 self.anim_reload = animfixfps(self, '3 1 0.01', '0 0 0');
131
132                 // if we have a "weapon" tag, let's attach the v_ model to it ("invisible hand" style model)
133                 // if we don't, this is a "real" animated model
134                 if(gettagindex(self, "weapon"))
135                 {
136                         if (!self.weaponentity)
137                                 self.weaponentity = spawn();
138                         _setmodel(self.weaponentity, W_Model(strcat("v_", name, ".md3")));
139                         setattachment(self.weaponentity, self, "weapon");
140                 }
141                 else if(gettagindex(self, "tag_weapon"))
142                 {
143                         if (!self.weaponentity)
144                                 self.weaponentity = spawn();
145                         _setmodel(self.weaponentity, W_Model(strcat("v_", name, ".md3")));
146                         setattachment(self.weaponentity, self, "tag_weapon");
147                 }
148                 else
149                 {
150                         if(self.weaponentity)
151                                 remove(self.weaponentity);
152                         self.weaponentity = world;
153                 }
154
155                 setorigin(self,'0 0 0');
156                 self.angles = '0 0 0';
157                 self.frame = 0;
158                 self.viewmodelforclient = world;
159
160                 float idx;
161
162                 if(v_shot_idx) // v_ model attached to invisible h_ model
163                 {
164                         self.movedir = gettaginfo(self.weaponentity, v_shot_idx);
165                 }
166                 else
167                 {
168                         idx = gettagindex(self, "shot");
169                         if(!idx)
170                                 idx = gettagindex(self, "tag_shot");
171                         if(idx)
172                                 self.movedir = gettaginfo(self, idx);
173                         else
174                         {
175                                 LOG_INFO("WARNING: weapon model ", self.model, " does not support the 'shot' tag, will display shots TOTALLY wrong\n");
176                                 self.movedir = '0 0 0';
177                         }
178                 }
179
180                 if(self.weaponentity) // v_ model attached to invisible h_ model
181                 {
182                         idx = gettagindex(self.weaponentity, "shell");
183                         if(!idx)
184                                 idx = gettagindex(self.weaponentity, "tag_shell");
185                         if(idx)
186                                 self.spawnorigin = gettaginfo(self.weaponentity, idx);
187                 }
188                 else
189                         idx = 0;
190                 if(!idx)
191                 {
192                         idx = gettagindex(self, "shell");
193                         if(!idx)
194                                 idx = gettagindex(self, "tag_shell");
195                         if(idx)
196                                 self.spawnorigin = gettaginfo(self, idx);
197                         else
198                         {
199                                 LOG_INFO("WARNING: weapon model ", self.model, " does not support the 'shell' tag, will display casings wrong\n");
200                                 self.spawnorigin = self.movedir;
201                         }
202                 }
203
204                 if(v_shot_idx)
205                 {
206                         self.oldorigin = '0 0 0'; // use regular attachment
207                 }
208                 else
209                 {
210                         if(self.weaponentity)
211                         {
212                                 idx = gettagindex(self, "weapon");
213                                 if(!idx)
214                                         idx = gettagindex(self, "tag_weapon");
215                         }
216                         else
217                         {
218                                 idx = gettagindex(self, "handle");
219                                 if(!idx)
220                                         idx = gettagindex(self, "tag_handle");
221                         }
222                         if(idx)
223                         {
224                                 self.oldorigin = self.movedir - gettaginfo(self, idx);
225                         }
226                         else
227                         {
228                                 LOG_INFO("WARNING: weapon model ", self.model, " does not support the 'handle' tag and neither does the v_ model support the 'shot' tag, will display muzzle flashes TOTALLY wrong\n");
229                                 self.oldorigin = '0 0 0'; // there is no way to recover from this
230                         }
231                 }
232
233                 self.viewmodelforclient = self.owner;
234         }
235         else
236         {
237                 self.model = "";
238                 if(self.weaponentity)
239                         remove(self.weaponentity);
240                 self.weaponentity = world;
241                 self.movedir = '0 0 0';
242                 self.spawnorigin = '0 0 0';
243                 self.oldorigin = '0 0 0';
244                 self.anim_fire1  = '0 1 0.01';
245                 self.anim_fire2  = '0 1 0.01';
246                 self.anim_idle   = '0 1 0.01';
247                 self.anim_reload = '0 1 0.01';
248         }
249
250         self.view_ofs = '0 0 0';
251
252         if(self.movedir.x >= 0)
253         {
254                 vector v0;
255                 v0 = self.movedir;
256                 self.movedir = shotorg_adjust(v0, false, false);
257                 self.view_ofs = shotorg_adjust(v0, false, true) - v0;
258         }
259         self.owner.stat_shotorg = compressShotOrigin(self.movedir);
260         self.movedir = decompressShotOrigin(self.owner.stat_shotorg); // make them match perfectly
261
262         self.spawnorigin += self.view_ofs; // offset the casings origin by the same amount
263
264         // check if an instant weapon switch occurred
265         setorigin(self, self.view_ofs);
266         // reset animstate now
267         self.wframe = WFRAME_IDLE;
268         setanim(self, self.anim_idle, true, false, true);
269 }
270
271 vector CL_Weapon_GetShotOrg(float wpn)
272 {SELFPARAM();
273         entity wi = get_weaponinfo(wpn);
274         setself(spawn());
275         CL_WeaponEntity_SetModel(wi.mdl);
276         vector ret = self.movedir;
277         CL_WeaponEntity_SetModel("");
278         remove(self);
279         setself(this);
280         return ret;
281 }
282
283 void CL_Weaponentity_Think()
284 {SELFPARAM();
285         int tb;
286         self.nextthink = time;
287         if (intermission_running)
288                 self.frame = self.anim_idle.x;
289         if (self.owner.weaponentity != self)
290         {
291                 if (self.weaponentity)
292                         remove(self.weaponentity);
293                 remove(self);
294                 return;
295         }
296         if (self.owner.deadflag != DEAD_NO)
297         {
298                 self.model = "";
299                 if (self.weaponentity)
300                         self.weaponentity.model = "";
301                 return;
302         }
303         if (self.weaponname != self.owner.weaponname || self.dmg != self.owner.modelindex || self.deadflag != self.owner.deadflag)
304         {
305                 self.weaponname = self.owner.weaponname;
306                 self.dmg = self.owner.modelindex;
307                 self.deadflag = self.owner.deadflag;
308
309                 CL_WeaponEntity_SetModel(self.owner.weaponname);
310         }
311
312         tb = (self.effects & (EF_TELEPORT_BIT | EF_RESTARTANIM_BIT));
313         self.effects = self.owner.effects & EFMASK_CHEAP;
314         self.effects &= ~EF_LOWPRECISION;
315         self.effects &= ~EF_FULLBRIGHT; // can mask team color, so get rid of it
316         self.effects &= ~EF_TELEPORT_BIT;
317         self.effects &= ~EF_RESTARTANIM_BIT;
318         self.effects |= tb;
319
320         if(self.owner.alpha == default_player_alpha)
321                 self.alpha = default_weapon_alpha;
322         else if(self.owner.alpha != 0)
323                 self.alpha = self.owner.alpha;
324         else
325                 self.alpha = 1;
326
327         self.glowmod = self.owner.weaponentity_glowmod;
328         self.colormap = self.owner.colormap;
329         if (self.weaponentity)
330         {
331                 self.weaponentity.effects = self.effects;
332                 self.weaponentity.alpha = self.alpha;
333                 self.weaponentity.colormap = self.colormap;
334                 self.weaponentity.glowmod = self.glowmod;
335         }
336
337         self.angles = '0 0 0';
338
339         float f = (self.owner.weapon_nextthink - time);
340         if (self.state == WS_RAISE && !intermission_running)
341         {
342                 entity newwep = get_weaponinfo(self.owner.switchweapon);
343                 f = f * g_weaponratefactor / max(f, newwep.switchdelay_raise);
344                 self.angles_x = -90 * f * f;
345         }
346         else if (self.state == WS_DROP && !intermission_running)
347         {
348                 entity oldwep = get_weaponinfo(self.owner.weapon);
349                 f = 1 - f * g_weaponratefactor / max(f, oldwep.switchdelay_drop);
350                 self.angles_x = -90 * f * f;
351         }
352         else if (self.state == WS_CLEAR)
353         {
354                 f = 1;
355                 self.angles_x = -90 * f * f;
356         }
357 }
358
359 void CL_ExteriorWeaponentity_Think()
360 {SELFPARAM();
361         float tag_found;
362         self.nextthink = time;
363         if (self.owner.exteriorweaponentity != self)
364         {
365                 remove(self);
366                 return;
367         }
368         if (self.owner.deadflag != DEAD_NO)
369         {
370                 self.model = "";
371                 return;
372         }
373         if (self.weaponname != self.owner.weaponname || self.dmg != self.owner.modelindex || self.deadflag != self.owner.deadflag)
374         {
375                 self.weaponname = self.owner.weaponname;
376                 self.dmg = self.owner.modelindex;
377                 self.deadflag = self.owner.deadflag;
378                 if (self.owner.weaponname != "")
379                         _setmodel(self, W_Model(strcat("v_", self.owner.weaponname, ".md3")));
380                 else
381                         self.model = "";
382
383                 if((tag_found = gettagindex(self.owner, "tag_weapon")))
384                 {
385                         self.tag_index = tag_found;
386                         self.tag_entity = self.owner;
387                 }
388                 else
389                         setattachment(self, self.owner, "bip01 r hand");
390         }
391         self.effects = self.owner.effects;
392         self.effects |= EF_LOWPRECISION;
393         self.effects = self.effects & EFMASK_CHEAP; // eat performance
394         if(self.owner.alpha == default_player_alpha)
395                 self.alpha = default_weapon_alpha;
396         else if(self.owner.alpha != 0)
397                 self.alpha = self.owner.alpha;
398         else
399                 self.alpha = 1;
400
401         self.glowmod = self.owner.weaponentity_glowmod;
402         self.colormap = self.owner.colormap;
403
404         CSQCMODEL_AUTOUPDATE(self);
405 }
406
407 // spawning weaponentity for client
408 void CL_SpawnWeaponentity(entity e)
409 {
410         entity view = e.weaponentity = spawn();
411         view.classname = "weaponentity";
412         view.solid = SOLID_NOT;
413         view.owner = e;
414         setmodel(view, MDL_Null); // precision set when changed
415         setorigin(view, '0 0 0');
416         view.angles = '0 0 0';
417         view.viewmodelforclient = e;
418         view.flags = 0;
419         view.think = CL_Weaponentity_Think;
420         view.customizeentityforclient = CL_Weaponentity_CustomizeEntityForClient;
421         view.nextthink = time;
422
423         entity exterior = e.exteriorweaponentity = spawn();
424         exterior.classname = "exteriorweaponentity";
425         exterior.solid = SOLID_NOT;
426         exterior.exteriorweaponentity = exterior;
427         exterior.owner = e;
428         setorigin(exterior, '0 0 0');
429         exterior.angles = '0 0 0';
430         exterior.think = CL_ExteriorWeaponentity_Think;
431         exterior.nextthink = time;
432
433         CSQCMODEL_AUTOINIT(exterior);
434 }
435
436 // Weapon subs
437 void w_clear(Weapon thiswep, bool fire1, bool fire2)
438 {SELFPARAM();
439         if (self.weapon != -1)
440         {
441                 self.weapon = 0;
442                 self.switchingweapon = 0;
443         }
444         if (self.weaponentity)
445         {
446                 self.weaponentity.state = WS_CLEAR;
447                 self.weaponentity.effects = 0;
448         }
449 }
450
451 void w_ready(Weapon thiswep, bool fire1, bool fire2)
452 {SELFPARAM();
453         if (self.weaponentity)
454                 self.weaponentity.state = WS_READY;
455         weapon_thinkf(WFRAME_IDLE, 1000000, w_ready);
456 }
457
458 .float prevdryfire;
459 .float prevwarntime;
460 float weapon_prepareattack_checkammo(float secondary)
461 {SELFPARAM();
462         Weapon w = get_weaponinfo(self.weapon);
463         if (!(self.items & IT_UNLIMITED_WEAPON_AMMO))
464         if (!w.(secondary ? wr_checkammo2 : wr_checkammo1)(w))
465         {
466                 // always keep the Mine Layer if we placed mines, so that we can detonate them
467                 entity mine;
468                 if(self.weapon == WEP_MINE_LAYER.m_id)
469                 for(mine = world; (mine = find(mine, classname, "mine")); ) if(mine.owner == self)
470                         return false;
471
472                 if(self.weapon == WEP_SHOTGUN.m_id)
473                 if(!secondary && WEP_CVAR(shotgun, secondary) == 1)
474                         return false; // no clicking, just allow
475
476                 if(self.weapon == self.switchweapon && time - self.prevdryfire > 1) // only play once BEFORE starting to switch weapons
477                 {
478                         sound (self, CH_WEAPON_A, SND_DRYFIRE, VOL_BASE, ATTEN_NORM);
479                         self.prevdryfire = time;
480                 }
481
482                 if(w.(secondary ? wr_checkammo1 : wr_checkammo2)(w)) // check if the other firing mode has enough ammo
483                 {
484                         if(time - self.prevwarntime > 1)
485                         {
486                                 Send_Notification(
487                                         NOTIF_ONE,
488                                         self,
489                                         MSG_MULTI,
490                                         ITEM_WEAPON_PRIMORSEC,
491                                         self.weapon,
492                                         secondary,
493                                         (1 - secondary)
494                                 );
495                         }
496                         self.prevwarntime = time;
497                 }
498                 else // this weapon is totally unable to fire, switch to another one
499                 {
500                         W_SwitchToOtherWeapon(self);
501                 }
502
503                 return false;
504         }
505         return true;
506 }
507 .float race_penalty;
508 float weapon_prepareattack_check(float secondary, float attacktime)
509 {SELFPARAM();
510         if(!weapon_prepareattack_checkammo(secondary))
511                 return false;
512
513         //if sv_ready_restart_after_countdown is set, don't allow the player to shoot
514         //if all players readied up and the countdown is running
515         if(time < game_starttime || time < self.race_penalty) {
516                 return false;
517         }
518
519         if (timeout_status == TIMEOUT_ACTIVE) //don't allow the player to shoot while game is paused
520                 return false;
521
522         // do not even think about shooting if switching
523         if(self.switchweapon != self.weapon)
524                 return false;
525
526         if(attacktime >= 0)
527         {
528                 // don't fire if previous attack is not finished
529                 if (ATTACK_FINISHED(self) > time + self.weapon_frametime * 0.5)
530                         return false;
531                 // don't fire while changing weapon
532                 if (self.weaponentity.state != WS_READY)
533                         return false;
534         }
535
536         return true;
537 }
538 float weapon_prepareattack_do(float secondary, float attacktime)
539 {SELFPARAM();
540         self.weaponentity.state = WS_INUSE;
541
542         self.spawnshieldtime = min(self.spawnshieldtime, time); // kill spawn shield when you fire
543
544         // if the weapon hasn't been firing continuously, reset the timer
545         if(attacktime >= 0)
546         {
547                 if (ATTACK_FINISHED(self) < time - self.weapon_frametime * 1.5)
548                 {
549                         ATTACK_FINISHED(self) = time;
550                         //dprint("resetting attack finished to ", ftos(time), "\n");
551                 }
552                 ATTACK_FINISHED(self) = ATTACK_FINISHED(self) + attacktime * W_WeaponRateFactor();
553         }
554         self.bulletcounter += 1;
555         //dprint("attack finished ", ftos(ATTACK_FINISHED(self)), "\n");
556         return true;
557 }
558 float weapon_prepareattack(float secondary, float attacktime)
559 {
560         if(weapon_prepareattack_check(secondary, attacktime))
561         {
562                 weapon_prepareattack_do(secondary, attacktime);
563                 return true;
564         }
565         else
566                 return false;
567 }
568
569 void weapon_thinkf(float fr, float t, void(Weapon thiswep, bool fire1, bool fire2) func)
570 {SELFPARAM();
571         vector a;
572         vector of, or, ou;
573         float restartanim;
574
575         if(fr == WFRAME_DONTCHANGE)
576         {
577                 fr = self.weaponentity.wframe;
578                 restartanim = false;
579         }
580         else if (fr == WFRAME_IDLE)
581                 restartanim = false;
582         else
583                 restartanim = true;
584
585         of = v_forward;
586         or = v_right;
587         ou = v_up;
588
589         if (self.weaponentity)
590         {
591                 self.weaponentity.wframe = fr;
592                 a = '0 0 0';
593                 if (fr == WFRAME_IDLE)
594                         a = self.weaponentity.anim_idle;
595                 else if (fr == WFRAME_FIRE1)
596                         a = self.weaponentity.anim_fire1;
597                 else if (fr == WFRAME_FIRE2)
598                         a = self.weaponentity.anim_fire2;
599                 else // if (fr == WFRAME_RELOAD)
600                         a = self.weaponentity.anim_reload;
601                 a.z *= g_weaponratefactor;
602                 setanim(self.weaponentity, a, restartanim == false, restartanim, restartanim);
603         }
604
605         v_forward = of;
606         v_right = or;
607         v_up = ou;
608
609         if(self.weapon_think == w_ready && func != w_ready && self.weaponentity.state == WS_RAISE)
610         {
611                 backtrace("Tried to override initial weapon think function - should this really happen?");
612         }
613
614         t *= W_WeaponRateFactor();
615
616         // VorteX: haste can be added here
617         if (self.weapon_think == w_ready)
618         {
619                 self.weapon_nextthink = time;
620                 //dprint("started firing at ", ftos(time), "\n");
621         }
622         if (self.weapon_nextthink < time - self.weapon_frametime * 1.5 || self.weapon_nextthink > time + self.weapon_frametime * 1.5)
623         {
624                 self.weapon_nextthink = time;
625                 //dprint("reset weapon animation timer at ", ftos(time), "\n");
626         }
627         self.weapon_nextthink = self.weapon_nextthink + t;
628         self.weapon_think = func;
629         //dprint("next ", ftos(self.weapon_nextthink), "\n");
630
631         if((fr == WFRAME_FIRE1 || fr == WFRAME_FIRE2) && t)
632         {
633                 if((self.weapon == WEP_SHOCKWAVE.m_id || self.weapon == WEP_SHOTGUN.m_id) && fr == WFRAME_FIRE2)
634                         animdecide_setaction(self, ANIMACTION_MELEE, restartanim);
635                 else
636                         animdecide_setaction(self, ANIMACTION_SHOOT, restartanim);
637         }
638         else
639         {
640                 if(self.anim_upper_action == ANIMACTION_SHOOT || self.anim_upper_action == ANIMACTION_MELEE)
641                         self.anim_upper_action = 0;
642         }
643 }
644
645 float forbidWeaponUse(entity player)
646 {
647         if(time < game_starttime && !autocvar_sv_ready_restart_after_countdown)
648                 return 1;
649         if(round_handler_IsActive() && !round_handler_IsRoundStarted())
650                 return 1;
651         if(player.player_blocked)
652                 return 1;
653         if(player.frozen)
654                 return 1;
655         if(player.weapon_blocked)
656                 return 1;
657         return 0;
658 }
659
660 void W_WeaponFrame()
661 {SELFPARAM();
662         vector fo, ri, up;
663
664         if (frametime)
665                 self.weapon_frametime = frametime;
666
667         if (!self.weaponentity || self.health < 1)
668                 return; // Dead player can't use weapons and injure impulse commands
669
670         if(forbidWeaponUse(self))
671         if(self.weaponentity.state != WS_CLEAR)
672         {
673                 Weapon wpn = get_weaponinfo(self.weapon);
674                 w_ready(wpn, self.BUTTON_ATCK, self.BUTTON_ATCK2);
675                 return;
676         }
677
678         if(!self.switchweapon)
679         {
680                 self.weapon = 0;
681                 self.switchingweapon = 0;
682                 self.weaponentity.state = WS_CLEAR;
683                 self.weaponname = "";
684                 //self.items &= ~IT_AMMO;
685                 return;
686         }
687
688         makevectors(self.v_angle);
689         fo = v_forward; // save them in case the weapon think functions change it
690         ri = v_right;
691         up = v_up;
692
693         // Change weapon
694         if (self.weapon != self.switchweapon)
695         {
696                 if (self.weaponentity.state == WS_CLEAR)
697                 {
698                         // end switching!
699                         self.switchingweapon = self.switchweapon;
700                         entity newwep = get_weaponinfo(self.switchweapon);
701
702                         // the two weapon entities will notice this has changed and update their models
703                         self.weapon = self.switchweapon;
704                         self.weaponname = newwep.mdl;
705                         self.bulletcounter = 0;
706                         self.ammo_field = newwep.ammo_field;
707                         Weapon w = get_weaponinfo(self.switchweapon);
708                         w.wr_setup(w);
709                         self.weaponentity.state = WS_RAISE;
710
711                         // set our clip load to the load of the weapon we switched to, if it's reloadable
712                         if(newwep.spawnflags & WEP_FLAG_RELOADABLE && newwep.reloading_ammo) // prevent accessing undefined cvars
713                         {
714                                 self.clip_load = self.(weapon_load[self.switchweapon]);
715                                 self.clip_size = newwep.reloading_ammo;
716                         }
717                         else
718                                 self.clip_load = self.clip_size = 0;
719
720                         weapon_thinkf(WFRAME_IDLE, newwep.switchdelay_raise, w_ready);
721                 }
722                 else if (self.weaponentity.state == WS_DROP)
723                 {
724                         // in dropping phase we can switch at any time
725                         self.switchingweapon = self.switchweapon;
726                 }
727                 else if (self.weaponentity.state == WS_READY)
728                 {
729                         // start switching!
730                         self.switchingweapon = self.switchweapon;
731                         entity oldwep = get_weaponinfo(self.weapon);
732
733                         // set up weapon switch think in the future, and start drop anim
734                         #ifndef INDEPENDENT_ATTACK_FINISHED
735                         if(ATTACK_FINISHED(self) <= time + self.weapon_frametime * 0.5)
736                         {
737                         #endif
738                                 sound(self, CH_WEAPON_SINGLE, SND_WEAPON_SWITCH, VOL_BASE, ATTN_NORM);
739                                 self.weaponentity.state = WS_DROP;
740                                 weapon_thinkf(WFRAME_DONTCHANGE, oldwep.switchdelay_drop, w_clear);
741                         #ifndef INDEPENDENT_ATTACK_FINISHED
742                         }
743                         #endif
744                 }
745         }
746
747         // LordHavoc: network timing test code
748         //if (self.button0)
749         //      print(ftos(frametime), " ", ftos(time), " >= ", ftos(ATTACK_FINISHED(self)), " >= ", ftos(self.weapon_nextthink), "\n");
750
751         float w;
752         w = self.weapon;
753
754         // call the think code which may fire the weapon
755         // and do so multiple times to resolve framerate dependency issues if the
756         // server framerate is very low and the weapon fire rate very high
757         float c;
758         c = 0;
759         while (c < W_TICSPERFRAME)
760         {
761                 c = c + 1;
762                 if(w && !(self.weapons & WepSet_FromWeapon(w)))
763                 {
764                         if(self.weapon == self.switchweapon)
765                                 W_SwitchWeapon_Force(self, w_getbestweapon(self));
766                         w = 0;
767                 }
768
769                 v_forward = fo;
770                 v_right = ri;
771                 v_up = up;
772
773                 {
774                         bool key_pressed = self.BUTTON_HOOK;
775                 Weapon wpn = self.offhand;
776                 if (wpn.offhand_think) wpn.offhand_think(wpn, self, key_pressed);
777         }
778
779                 if (w) {
780                         entity e = get_weaponinfo(self.weapon);
781                         if (e.wr_think) e.wr_think(e, self.BUTTON_ATCK, self.BUTTON_ATCK2);
782                 } else {
783                         Weapon w = get_weaponinfo(self.weapon);
784                         w.wr_gonethink(w);
785                 }
786
787                 if (time + self.weapon_frametime * 0.5 >= self.weapon_nextthink)
788                 {
789                         if(self.weapon_think)
790                         {
791                                 v_forward = fo;
792                                 v_right = ri;
793                                 v_up = up;
794                                 Weapon wpn = get_weaponinfo(self.weapon);
795                                 self.weapon_think(wpn, self.BUTTON_ATCK, self.BUTTON_ATCK2);
796                         }
797                         else
798                                 bprint("\{1}^1ERROR: undefined weapon think function for ", self.netname, "\n");
799                 }
800         }
801 }
802
803 void W_AttachToShotorg(entity flash, vector offset)
804 {SELFPARAM();
805         entity xflash;
806         flash.owner = self;
807         flash.angles_z = random() * 360;
808
809         if(gettagindex(self.weaponentity, "shot"))
810                 setattachment(flash, self.weaponentity, "shot");
811         else
812                 setattachment(flash, self.weaponentity, "tag_shot");
813         setorigin(flash, offset);
814
815         xflash = spawn();
816         copyentity(flash, xflash);
817
818         flash.viewmodelforclient = self;
819
820         if(self.weaponentity.oldorigin.x > 0)
821         {
822                 setattachment(xflash, self.exteriorweaponentity, "");
823                 setorigin(xflash, self.weaponentity.oldorigin + offset);
824         }
825         else
826         {
827                 if(gettagindex(self.exteriorweaponentity, "shot"))
828                         setattachment(xflash, self.exteriorweaponentity, "shot");
829                 else
830                         setattachment(xflash, self.exteriorweaponentity, "tag_shot");
831                 setorigin(xflash, offset);
832         }
833 }
834
835 void W_DecreaseAmmo(Weapon wep, float ammo_use)
836 {SELFPARAM();
837
838         if(cvar("g_overkill"))
839         if(self.ok_use_ammocharge)
840         {
841                 ok_DecreaseCharge(self, self.weapon);
842                 return; // TODO
843         }
844
845         if((self.items & IT_UNLIMITED_WEAPON_AMMO) && !wep.reloading_ammo)
846                 return;
847
848         // if this weapon is reloadable, decrease its load. Else decrease the player's ammo
849         if(wep.reloading_ammo)
850         {
851                 self.clip_load -= ammo_use;
852                 self.(weapon_load[self.weapon]) = self.clip_load;
853         }
854         else if(wep.ammo_field != ammo_none)
855         {
856                 self.(wep.ammo_field) -= ammo_use;
857                 if(self.(wep.ammo_field) < 0)
858                 {
859                         backtrace(sprintf(
860                                 "W_DecreaseAmmo(%.2f): '%s' subtracted too much %s from '%s', resulting with '%.2f' left... "
861                                 "Please notify Samual immediately with a copy of this backtrace!\n",
862                                 ammo_use,
863                                 wep.netname,
864                                 GetAmmoPicture(wep.ammo_field),
865                                 self.netname,
866                                 self.(wep.ammo_field)
867                         ));
868                 }
869         }
870 }
871
872 // weapon reloading code
873
874 .float reload_ammo_amount, reload_ammo_min, reload_time;
875 .float reload_complain;
876 .string reload_sound;
877
878 void W_ReloadedAndReady(Weapon thiswep, bool fire1, bool fire2)
879 {SELFPARAM();
880         // finish the reloading process, and do the ammo transfer
881
882         self.clip_load = self.old_clip_load; // restore the ammo counter, in case we still had ammo in the weapon before reloading
883
884         // if the gun uses no ammo, max out weapon load, else decrease ammo as we increase weapon load
885         if(!self.reload_ammo_min || self.items & IT_UNLIMITED_WEAPON_AMMO || self.ammo_field == ammo_none)
886                 self.clip_load = self.reload_ammo_amount;
887         else
888         {
889                 // make sure we don't add more ammo than we have
890                 float load = min(self.reload_ammo_amount - self.clip_load, self.(self.ammo_field));
891         self.clip_load += load;
892         self.(self.ammo_field) -= load;
893         }
894         self.(weapon_load[self.weapon]) = self.clip_load;
895
896         // do not set ATTACK_FINISHED in reload code any more. This causes annoying delays if eg: You start reloading a weapon,
897         // then quickly switch to another weapon and back. Reloading is canceled, but the reload delay is still there,
898         // so your weapon is disabled for a few seconds without reason
899
900         //ATTACK_FINISHED(self) -= self.reload_time - 1;
901
902         Weapon wpn = get_weaponinfo(self.weapon);
903         w_ready(wpn, self.BUTTON_ATCK, self.BUTTON_ATCK2);
904 }
905
906 void W_Reload(float sent_ammo_min, string sent_sound)
907 {SELFPARAM();
908         // set global values to work with
909         entity e;
910         e = get_weaponinfo(self.weapon);
911
912         if(cvar("g_overkill"))
913         if(self.ok_use_ammocharge)
914                 return; // TODO
915
916         self.reload_ammo_min = sent_ammo_min;
917         self.reload_ammo_amount = e.reloading_ammo;
918         self.reload_time = e.reloading_time;
919         self.reload_sound = sent_sound;
920
921         // don't reload weapons that don't have the RELOADABLE flag
922         if (!(e.spawnflags & WEP_FLAG_RELOADABLE))
923         {
924                 LOG_TRACE("Warning: Attempted to reload a weapon that does not have the WEP_FLAG_RELOADABLE flag. Fix your code!\n");
925                 return;
926         }
927
928         // return if reloading is disabled for this weapon
929         if(!self.reload_ammo_amount)
930                 return;
931
932         // our weapon is fully loaded, no need to reload
933         if (self.clip_load >= self.reload_ammo_amount)
934                 return;
935
936         // no ammo, so nothing to load
937         if(self.ammo_field != ammo_none)
938         if(!self.(self.ammo_field) && self.reload_ammo_min)
939         if (!(self.items & IT_UNLIMITED_WEAPON_AMMO))
940         {
941                 if(IS_REAL_CLIENT(self) && self.reload_complain < time)
942                 {
943                         play2(self, SND(UNAVAILABLE));
944                         sprint(self, strcat("You don't have enough ammo to reload the ^2", WEP_NAME(self.weapon), "\n"));
945                         self.reload_complain = time + 1;
946                 }
947                 // switch away if the amount of ammo is not enough to keep using this weapon
948                 Weapon w = get_weaponinfo(self.weapon);
949                 if (!(w.wr_checkammo1(w) + w.wr_checkammo2(w)))
950                 {
951                         self.clip_load = -1; // reload later
952                         W_SwitchToOtherWeapon(self);
953                 }
954                 return;
955         }
956
957         if (self.weaponentity)
958         {
959                 if (self.weaponentity.wframe == WFRAME_RELOAD)
960                         return;
961
962                 // allow switching away while reloading, but this will cause a new reload!
963                 self.weaponentity.state = WS_READY;
964         }
965
966         // now begin the reloading process
967
968         _sound(self, CH_WEAPON_SINGLE, self.reload_sound, VOL_BASE, ATTEN_NORM);
969
970         // do not set ATTACK_FINISHED in reload code any more. This causes annoying delays if eg: You start reloading a weapon,
971         // then quickly switch to another weapon and back. Reloading is canceled, but the reload delay is still there,
972         // so your weapon is disabled for a few seconds without reason
973
974         //ATTACK_FINISHED(self) = max(time, ATTACK_FINISHED(self)) + self.reload_time + 1;
975
976         weapon_thinkf(WFRAME_RELOAD, self.reload_time, W_ReloadedAndReady);
977
978         if(self.clip_load < 0)
979                 self.clip_load = 0;
980         self.old_clip_load = self.clip_load;
981         self.clip_load = self.(weapon_load[self.weapon]) = -1;
982 }
983
984 void W_DropEvent(.bool(Weapon) event, entity player, float weapon_type, entity weapon_item)
985 {SELFPARAM();
986         setself(player);
987         weapon_dropevent_item = weapon_item;
988         Weapon w = get_weaponinfo(weapon_type);
989         w.event(w);
990         setself(this);
991 }