208948f2866e8637f36766ccc3368cc905479a61
[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(entity actor, float fr, float t, void(Weapon thiswep, entity actor, 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, entity actor, bool fire1, bool fire2)
438 {
439         if (actor.weapon != -1)
440         {
441                 actor.weapon = 0;
442                 actor.switchingweapon = 0;
443         }
444         if (actor.weaponentity)
445         {
446                 actor.weaponentity.state = WS_CLEAR;
447                 actor.weaponentity.effects = 0;
448         }
449 }
450
451 void w_ready(Weapon thiswep, entity actor, bool fire1, bool fire2)
452 {
453         if (actor.weaponentity)
454                 actor.weaponentity.state = WS_READY;
455         weapon_thinkf(actor, WFRAME_IDLE, 1000000, w_ready);
456 }
457
458 .float prevdryfire;
459 .float prevwarntime;
460 bool weapon_prepareattack_checkammo(entity actor, float secondary)
461 {
462         Weapon w = get_weaponinfo(actor.weapon);
463         if (!(actor.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(actor.weapon == WEP_MINE_LAYER.m_id)
469                 for(mine = world; (mine = find(mine, classname, "mine")); ) if(mine.owner == actor)
470                         return false;
471
472                 if(actor.weapon == WEP_SHOTGUN.m_id)
473                 if(!secondary && WEP_CVAR(shotgun, secondary) == 1)
474                         return false; // no clicking, just allow
475
476                 if(actor.weapon == actor.switchweapon && time - actor.prevdryfire > 1) // only play once BEFORE starting to switch weapons
477                 {
478                         sound (actor, CH_WEAPON_A, SND_DRYFIRE, VOL_BASE, ATTEN_NORM);
479                         actor.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 - actor.prevwarntime > 1)
485                         {
486                                 Send_Notification(
487                                         NOTIF_ONE,
488                                         actor,
489                                         MSG_MULTI,
490                                         ITEM_WEAPON_PRIMORSEC,
491                                         actor.weapon,
492                                         secondary,
493                                         (1 - secondary)
494                                 );
495                         }
496                         actor.prevwarntime = time;
497                 }
498                 else // this weapon is totally unable to fire, switch to another one
499                 {
500                         W_SwitchToOtherWeapon(actor);
501                 }
502
503                 return false;
504         }
505         return true;
506 }
507 .float race_penalty;
508 bool weapon_prepareattack_check(entity actor, bool secondary, float attacktime)
509 {
510         if(!weapon_prepareattack_checkammo(actor, 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 < actor.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(actor.switchweapon != actor.weapon)
524                 return false;
525
526         if(attacktime >= 0)
527         {
528                 // don't fire if previous attack is not finished
529                 if (ATTACK_FINISHED(actor) > time + actor.weapon_frametime * 0.5)
530                         return false;
531                 // don't fire while changing weapon
532                 if (actor.weaponentity.state != WS_READY)
533                         return false;
534         }
535         return true;
536 }
537 void weapon_prepareattack_do(entity actor, bool secondary, float attacktime)
538 {
539         actor.weaponentity.state = WS_INUSE;
540
541         actor.spawnshieldtime = min(actor.spawnshieldtime, time); // kill spawn shield when you fire
542
543         // if the weapon hasn't been firing continuously, reset the timer
544         if(attacktime >= 0)
545         {
546                 if (ATTACK_FINISHED(actor) < time - actor.weapon_frametime * 1.5)
547                 {
548                         ATTACK_FINISHED(actor) = time;
549                         //dprint("resetting attack finished to ", ftos(time), "\n");
550                 }
551                 ATTACK_FINISHED(actor) = ATTACK_FINISHED(actor) + attacktime * W_WeaponRateFactor();
552         }
553         actor.bulletcounter += 1;
554         //dprint("attack finished ", ftos(ATTACK_FINISHED(actor)), "\n");
555 }
556 bool weapon_prepareattack(entity actor, bool secondary, float attacktime)
557 {
558         if (weapon_prepareattack_check(actor, secondary, attacktime)) {
559                 weapon_prepareattack_do(actor, secondary, attacktime);
560                 return true;
561         }
562         return false;
563 }
564
565 void weapon_thinkf(entity actor, float fr, float t, void(Weapon thiswep, entity actor, bool fire1, bool fire2) func)
566 {
567         vector a;
568         vector of, or, ou;
569         float restartanim;
570
571         if(fr == WFRAME_DONTCHANGE)
572         {
573                 fr = actor.weaponentity.wframe;
574                 restartanim = false;
575         }
576         else if (fr == WFRAME_IDLE)
577                 restartanim = false;
578         else
579                 restartanim = true;
580
581         of = v_forward;
582         or = v_right;
583         ou = v_up;
584
585         if (actor.weaponentity)
586         {
587                 actor.weaponentity.wframe = fr;
588                 a = '0 0 0';
589                 if (fr == WFRAME_IDLE)
590                         a = actor.weaponentity.anim_idle;
591                 else if (fr == WFRAME_FIRE1)
592                         a = actor.weaponentity.anim_fire1;
593                 else if (fr == WFRAME_FIRE2)
594                         a = actor.weaponentity.anim_fire2;
595                 else // if (fr == WFRAME_RELOAD)
596                         a = actor.weaponentity.anim_reload;
597                 a.z *= g_weaponratefactor;
598                 setanim(actor.weaponentity, a, restartanim == false, restartanim, restartanim);
599         }
600
601         v_forward = of;
602         v_right = or;
603         v_up = ou;
604
605         if(actor.weapon_think == w_ready && func != w_ready && actor.weaponentity.state == WS_RAISE)
606         {
607                 backtrace("Tried to override initial weapon think function - should this really happen?");
608         }
609
610         t *= W_WeaponRateFactor();
611
612         // VorteX: haste can be added here
613         if (actor.weapon_think == w_ready)
614         {
615                 actor.weapon_nextthink = time;
616                 //dprint("started firing at ", ftos(time), "\n");
617         }
618         if (actor.weapon_nextthink < time - actor.weapon_frametime * 1.5 || actor.weapon_nextthink > time + actor.weapon_frametime * 1.5)
619         {
620                 actor.weapon_nextthink = time;
621                 //dprint("reset weapon animation timer at ", ftos(time), "\n");
622         }
623         actor.weapon_nextthink = actor.weapon_nextthink + t;
624         actor.weapon_think = func;
625         //dprint("next ", ftos(actor.weapon_nextthink), "\n");
626
627         if((fr == WFRAME_FIRE1 || fr == WFRAME_FIRE2) && t)
628         {
629                 if((actor.weapon == WEP_SHOCKWAVE.m_id || actor.weapon == WEP_SHOTGUN.m_id) && fr == WFRAME_FIRE2)
630                         animdecide_setaction(actor, ANIMACTION_MELEE, restartanim);
631                 else
632                         animdecide_setaction(actor, ANIMACTION_SHOOT, restartanim);
633         }
634         else
635         {
636                 if(actor.anim_upper_action == ANIMACTION_SHOOT || actor.anim_upper_action == ANIMACTION_MELEE)
637                         actor.anim_upper_action = 0;
638         }
639 }
640
641 float forbidWeaponUse(entity player)
642 {
643         if(time < game_starttime && !autocvar_sv_ready_restart_after_countdown)
644                 return 1;
645         if(round_handler_IsActive() && !round_handler_IsRoundStarted())
646                 return 1;
647         if(player.player_blocked)
648                 return 1;
649         if(player.frozen)
650                 return 1;
651         if(player.weapon_blocked)
652                 return 1;
653         return 0;
654 }
655
656 void W_WeaponFrame(entity actor)
657 {
658         vector fo, ri, up;
659
660         if (frametime)
661                 actor.weapon_frametime = frametime;
662
663         if (!actor.weaponentity || actor.health < 1)
664                 return; // Dead player can't use weapons and injure impulse commands
665
666         if(forbidWeaponUse(actor))
667         if(actor.weaponentity.state != WS_CLEAR)
668         {
669                 Weapon wpn = get_weaponinfo(actor.weapon);
670                 w_ready(wpn, actor, actor.BUTTON_ATCK, actor.BUTTON_ATCK2);
671                 return;
672         }
673
674         if(!actor.switchweapon)
675         {
676                 actor.weapon = 0;
677                 actor.switchingweapon = 0;
678                 actor.weaponentity.state = WS_CLEAR;
679                 actor.weaponname = "";
680                 //actor.items &= ~IT_AMMO;
681                 return;
682         }
683
684         makevectors(actor.v_angle);
685         fo = v_forward; // save them in case the weapon think functions change it
686         ri = v_right;
687         up = v_up;
688
689         // Change weapon
690         if (actor.weapon != actor.switchweapon)
691         {
692                 if (actor.weaponentity.state == WS_CLEAR)
693                 {
694                         // end switching!
695                         actor.switchingweapon = actor.switchweapon;
696                         entity newwep = get_weaponinfo(actor.switchweapon);
697
698                         // the two weapon entities will notice this has changed and update their models
699                         actor.weapon = actor.switchweapon;
700                         actor.weaponname = newwep.mdl;
701                         actor.bulletcounter = 0;
702                         actor.ammo_field = newwep.ammo_field;
703                         Weapon w = get_weaponinfo(actor.switchweapon);
704                         w.wr_setup(w);
705                         actor.weaponentity.state = WS_RAISE;
706
707                         // set our clip load to the load of the weapon we switched to, if it's reloadable
708                         if(newwep.spawnflags & WEP_FLAG_RELOADABLE && newwep.reloading_ammo) // prevent accessing undefined cvars
709                         {
710                                 actor.clip_load = actor.(weapon_load[actor.switchweapon]);
711                                 actor.clip_size = newwep.reloading_ammo;
712                         }
713                         else
714                                 actor.clip_load = actor.clip_size = 0;
715
716                         weapon_thinkf(actor, WFRAME_IDLE, newwep.switchdelay_raise, w_ready);
717                 }
718                 else if (actor.weaponentity.state == WS_DROP)
719                 {
720                         // in dropping phase we can switch at any time
721                         actor.switchingweapon = actor.switchweapon;
722                 }
723                 else if (actor.weaponentity.state == WS_READY)
724                 {
725                         // start switching!
726                         actor.switchingweapon = actor.switchweapon;
727                         entity oldwep = get_weaponinfo(actor.weapon);
728
729                         // set up weapon switch think in the future, and start drop anim
730                         #ifndef INDEPENDENT_ATTACK_FINISHED
731                         if(ATTACK_FINISHED(actor) <= time + actor.weapon_frametime * 0.5)
732                         {
733                         #endif
734                                 sound(actor, CH_WEAPON_SINGLE, SND_WEAPON_SWITCH, VOL_BASE, ATTN_NORM);
735                                 actor.weaponentity.state = WS_DROP;
736                                 weapon_thinkf(actor, WFRAME_DONTCHANGE, oldwep.switchdelay_drop, w_clear);
737                         #ifndef INDEPENDENT_ATTACK_FINISHED
738                         }
739                         #endif
740                 }
741         }
742
743         // LordHavoc: network timing test code
744         //if (actor.button0)
745         //      print(ftos(frametime), " ", ftos(time), " >= ", ftos(ATTACK_FINISHED(actor)), " >= ", ftos(actor.weapon_nextthink), "\n");
746
747         float w;
748         w = actor.weapon;
749
750         // call the think code which may fire the weapon
751         // and do so multiple times to resolve framerate dependency issues if the
752         // server framerate is very low and the weapon fire rate very high
753         float c;
754         c = 0;
755         while (c < W_TICSPERFRAME)
756         {
757                 c = c + 1;
758                 if(w && !(actor.weapons & WepSet_FromWeapon(w)))
759                 {
760                         if(actor.weapon == actor.switchweapon)
761                                 W_SwitchWeapon_Force(actor, w_getbestweapon(actor));
762                         w = 0;
763                 }
764
765                 v_forward = fo;
766                 v_right = ri;
767                 v_up = up;
768
769                 {
770                         bool key_pressed = actor.BUTTON_HOOK;
771                 Weapon wpn = actor.offhand;
772                 if (wpn.offhand_think) wpn.offhand_think(wpn, actor, key_pressed);
773         }
774
775                 if (w) {
776                         Weapon e = get_weaponinfo(actor.weapon);
777                         e.wr_think(e, actor, actor.BUTTON_ATCK, actor.BUTTON_ATCK2);
778                 } else {
779                         Weapon w = get_weaponinfo(actor.weapon);
780                         w.wr_gonethink(w);
781                 }
782
783                 if (time + actor.weapon_frametime * 0.5 >= actor.weapon_nextthink)
784                 {
785                         if(actor.weapon_think)
786                         {
787                                 v_forward = fo;
788                                 v_right = ri;
789                                 v_up = up;
790                                 Weapon wpn = get_weaponinfo(actor.weapon);
791                                 actor.weapon_think(wpn, actor, actor.BUTTON_ATCK, actor.BUTTON_ATCK2);
792                         }
793                         else
794                                 bprint("\{1}^1ERROR: undefined weapon think function for ", actor.netname, "\n");
795                 }
796         }
797 }
798
799 void W_AttachToShotorg(entity actor, entity flash, vector offset)
800 {
801         entity xflash;
802         flash.owner = actor;
803         flash.angles_z = random() * 360;
804
805         if(gettagindex(actor.weaponentity, "shot"))
806                 setattachment(flash, actor.weaponentity, "shot");
807         else
808                 setattachment(flash, actor.weaponentity, "tag_shot");
809         setorigin(flash, offset);
810
811         xflash = spawn();
812         copyentity(flash, xflash);
813
814         flash.viewmodelforclient = actor;
815
816         if(actor.weaponentity.oldorigin.x > 0)
817         {
818                 setattachment(xflash, actor.exteriorweaponentity, "");
819                 setorigin(xflash, actor.weaponentity.oldorigin + offset);
820         }
821         else
822         {
823                 if(gettagindex(actor.exteriorweaponentity, "shot"))
824                         setattachment(xflash, actor.exteriorweaponentity, "shot");
825                 else
826                         setattachment(xflash, actor.exteriorweaponentity, "tag_shot");
827                 setorigin(xflash, offset);
828         }
829 }
830
831 void W_DecreaseAmmo(Weapon wep, entity actor, float ammo_use)
832 {
833
834         if(cvar("g_overkill"))
835         if(actor.ok_use_ammocharge)
836         {
837                 ok_DecreaseCharge(actor, actor.weapon);
838                 return; // TODO
839         }
840
841         if((actor.items & IT_UNLIMITED_WEAPON_AMMO) && !wep.reloading_ammo)
842                 return;
843
844         // if this weapon is reloadable, decrease its load. Else decrease the player's ammo
845         if(wep.reloading_ammo)
846         {
847                 actor.clip_load -= ammo_use;
848                 actor.(weapon_load[actor.weapon]) = actor.clip_load;
849         }
850         else if(wep.ammo_field != ammo_none)
851         {
852                 actor.(wep.ammo_field) -= ammo_use;
853                 if(actor.(wep.ammo_field) < 0)
854                 {
855                         backtrace(sprintf(
856                                 "W_DecreaseAmmo(%.2f): '%s' subtracted too much %s from '%s', resulting with '%.2f' left... "
857                                 "Please notify Samual immediately with a copy of this backtrace!\n",
858                                 ammo_use,
859                                 wep.netname,
860                                 GetAmmoPicture(wep.ammo_field),
861                                 actor.netname,
862                                 actor.(wep.ammo_field)
863                         ));
864                 }
865         }
866 }
867
868 // weapon reloading code
869
870 .float reload_ammo_amount, reload_ammo_min, reload_time;
871 .float reload_complain;
872 .string reload_sound;
873
874 void W_ReloadedAndReady(Weapon thiswep, entity actor, bool fire1, bool fire2)
875 {
876         // finish the reloading process, and do the ammo transfer
877
878         actor.clip_load = actor.old_clip_load; // restore the ammo counter, in case we still had ammo in the weapon before reloading
879
880         // if the gun uses no ammo, max out weapon load, else decrease ammo as we increase weapon load
881         if(!actor.reload_ammo_min || actor.items & IT_UNLIMITED_WEAPON_AMMO || actor.ammo_field == ammo_none)
882                 actor.clip_load = actor.reload_ammo_amount;
883         else
884         {
885                 // make sure we don't add more ammo than we have
886                 float load = min(actor.reload_ammo_amount - actor.clip_load, actor.(actor.ammo_field));
887         actor.clip_load += load;
888         actor.(actor.ammo_field) -= load;
889         }
890         actor.(weapon_load[actor.weapon]) = actor.clip_load;
891
892         // do not set ATTACK_FINISHED in reload code any more. This causes annoying delays if eg: You start reloading a weapon,
893         // then quickly switch to another weapon and back. Reloading is canceled, but the reload delay is still there,
894         // so your weapon is disabled for a few seconds without reason
895
896         //ATTACK_FINISHED(actor) -= actor.reload_time - 1;
897
898         Weapon wpn = get_weaponinfo(actor.weapon);
899         w_ready(wpn, actor, actor.BUTTON_ATCK, actor.BUTTON_ATCK2);
900 }
901
902 void W_Reload(entity actor, float sent_ammo_min, string sent_sound)
903 {
904         // set global values to work with
905         entity e;
906         e = get_weaponinfo(actor.weapon);
907
908         if(cvar("g_overkill"))
909         if(actor.ok_use_ammocharge)
910                 return; // TODO
911
912         actor.reload_ammo_min = sent_ammo_min;
913         actor.reload_ammo_amount = e.reloading_ammo;
914         actor.reload_time = e.reloading_time;
915         actor.reload_sound = sent_sound;
916
917         // don't reload weapons that don't have the RELOADABLE flag
918         if (!(e.spawnflags & WEP_FLAG_RELOADABLE))
919         {
920                 LOG_TRACE("Warning: Attempted to reload a weapon that does not have the WEP_FLAG_RELOADABLE flag. Fix your code!\n");
921                 return;
922         }
923
924         // return if reloading is disabled for this weapon
925         if(!actor.reload_ammo_amount)
926                 return;
927
928         // our weapon is fully loaded, no need to reload
929         if (actor.clip_load >= actor.reload_ammo_amount)
930                 return;
931
932         // no ammo, so nothing to load
933         if(actor.ammo_field != ammo_none)
934         if(!actor.(actor.ammo_field) && actor.reload_ammo_min)
935         if (!(actor.items & IT_UNLIMITED_WEAPON_AMMO))
936         {
937                 if(IS_REAL_CLIENT(actor) && actor.reload_complain < time)
938                 {
939                         play2(actor, SND(UNAVAILABLE));
940                         sprint(actor, strcat("You don't have enough ammo to reload the ^2", WEP_NAME(actor.weapon), "\n"));
941                         actor.reload_complain = time + 1;
942                 }
943                 // switch away if the amount of ammo is not enough to keep using this weapon
944                 Weapon w = get_weaponinfo(actor.weapon);
945                 if (!(w.wr_checkammo1(w) + w.wr_checkammo2(w)))
946                 {
947                         actor.clip_load = -1; // reload later
948                         W_SwitchToOtherWeapon(actor);
949                 }
950                 return;
951         }
952
953         if (actor.weaponentity)
954         {
955                 if (actor.weaponentity.wframe == WFRAME_RELOAD)
956                         return;
957
958                 // allow switching away while reloading, but this will cause a new reload!
959                 actor.weaponentity.state = WS_READY;
960         }
961
962         // now begin the reloading process
963
964         _sound(actor, CH_WEAPON_SINGLE, actor.reload_sound, VOL_BASE, ATTEN_NORM);
965
966         // do not set ATTACK_FINISHED in reload code any more. This causes annoying delays if eg: You start reloading a weapon,
967         // then quickly switch to another weapon and back. Reloading is canceled, but the reload delay is still there,
968         // so your weapon is disabled for a few seconds without reason
969
970         //ATTACK_FINISHED(actor) = max(time, ATTACK_FINISHED(actor)) + actor.reload_time + 1;
971
972         weapon_thinkf(actor, WFRAME_RELOAD, actor.reload_time, W_ReloadedAndReady);
973
974         if(actor.clip_load < 0)
975                 actor.clip_load = 0;
976         actor.old_clip_load = actor.clip_load;
977         actor.clip_load = actor.(weapon_load[actor.weapon]) = -1;
978 }
979
980 void W_DropEvent(.void(Weapon) event, entity player, float weapon_type, entity weapon_item)
981 {SELFPARAM();
982         setself(player);
983         weapon_dropevent_item = weapon_item;
984         Weapon w = get_weaponinfo(weapon_type);
985         w.event(w);
986         setself(this);
987 }