Remove SELFPARAM() from .think and .touch
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / weapons / weaponsystem.qc
1 #include "weaponsystem.qh"
2
3 #include "selection.qh"
4
5 #include "../command/common.qh"
6 #include "../mutators/all.qh"
7 #include "../round_handler.qh"
8 #include <common/t_items.qh>
9 #include <common/animdecide.qh>
10 #include <common/constants.qh>
11 #include <common/monsters/all.qh>
12 #include <common/notifications/all.qh>
13 #include <common/util.qh>
14 #include <common/weapons/all.qh>
15 #include <common/state.qh>
16 #include <lib/csqcmodel/sv_model.qh>
17
18 .int state;
19
20 .float weapon_frametime;
21
22 float W_WeaponRateFactor()
23 {
24         float t = 1.0 / g_weaponratefactor;
25
26         MUTATOR_CALLHOOK(WeaponRateFactor, t);
27         t = weapon_rate;
28
29         return t;
30 }
31
32 float W_WeaponSpeedFactor()
33 {
34         float t = 1.0 * g_weaponspeedfactor;
35
36         MUTATOR_CALLHOOK(WeaponSpeedFactor, t);
37         t = ret_float;
38
39         return t;
40 }
41
42
43 bool CL_Weaponentity_CustomizeEntityForClient()
44 {
45         SELFPARAM();
46         this.viewmodelforclient = this.owner;
47         if (IS_SPEC(other) && other.enemy == this.owner) this.viewmodelforclient = other;
48         return true;
49 }
50
51 vector CL_Weapon_GetShotOrg(int wpn)
52 {
53         entity wi = Weapons_from(wpn);
54         entity e = spawn();
55         CL_WeaponEntity_SetModel(e, wi.mdl, false);
56         vector ret = e.movedir;
57         CL_WeaponEntity_SetModel(e, "", false);
58         remove(e);
59         return ret;
60 }
61
62 ..entity weaponentity_fld;
63 .float m_alpha;
64
65 void CL_Weaponentity_Think(entity this)
66 {
67         this.nextthink = time;
68         if (intermission_running) this.frame = this.anim_idle.x;
69         .entity weaponentity = this.weaponentity_fld;
70         if (this.owner.(weaponentity) != this)
71         {
72                 // owner has new gun; remove self
73                 if (this.weaponchild) remove(this.weaponchild);
74                 remove(this);
75                 return;
76         }
77         if (IS_DEAD(this.owner))
78         {
79                 // owner died; disappear
80                 this.model = "";
81                 if (this.weaponchild) this.weaponchild.model = "";
82                 return;
83         }
84         if (this.weaponname != this.owner.weaponname
85             || this.dmg != this.owner.modelindex
86             || this.deadflag != this.owner.deadflag)
87         {
88                 // owner changed weapons; update appearance
89                 this.weaponname = this.owner.weaponname;
90                 this.dmg = this.owner.modelindex;
91                 this.deadflag = this.owner.deadflag;
92
93                 CL_WeaponEntity_SetModel(this, this.owner.weaponname, true);
94         }
95
96         this.alpha = -1;  // TODO: don't render this entity at all
97
98         if (this.owner.alpha == default_player_alpha) this.m_alpha = default_weapon_alpha;
99         else if (this.owner.alpha != 0) this.m_alpha = this.owner.alpha;
100         else this.m_alpha  = 1;
101
102         if (this.weaponchild)
103         {
104                 this.weaponchild.alpha = this.alpha;
105                 this.weaponchild.effects = this.effects;
106         }
107 }
108
109 void CL_ExteriorWeaponentity_Think(entity this)
110 {
111         this.nextthink = time;
112         if (this.owner.exteriorweaponentity != this)
113         {
114                 remove(this);
115                 return;
116         }
117         if (IS_DEAD(this.owner))
118         {
119                 this.model = "";
120                 return;
121         }
122         if (this.weaponname != this.owner.weaponname || this.dmg != this.owner.modelindex
123             || this.deadflag != this.owner.deadflag)
124         {
125                 this.weaponname = this.owner.weaponname;
126                 this.dmg = this.owner.modelindex;
127                 this.deadflag = this.owner.deadflag;
128                 if (this.owner.weaponname != "")
129                 {
130                         _setmodel(this, W_Model(strcat("v_", this.owner.weaponname, ".md3")));
131                         setsize(this, '0 0 0', '0 0 0');
132                 }
133                 else this.model = "";
134
135                 int tag_found;
136                 if ((tag_found = gettagindex(this.owner, "tag_weapon")))
137                 {
138                         this.tag_index = tag_found;
139                         this.tag_entity = this.owner;
140                 }
141                 else
142                 {
143                         setattachment(this, this.owner, "bip01 r hand");
144                 }
145         }
146         this.effects = this.owner.effects;
147         this.effects |= EF_LOWPRECISION;
148         this.effects = this.effects & EFMASK_CHEAP;  // eat performance
149         if (this.owner.alpha == default_player_alpha) this.alpha = default_weapon_alpha;
150         else if (this.owner.alpha != 0) this.alpha = this.owner.alpha;
151         else this.alpha = 1;
152
153     Weapon wep = PS(this.owner).m_weapon;
154         if (wep) this.glowmod = weaponentity_glowmod(wep, this.owner.clientcolors);
155         this.colormap = this.owner.colormap;
156
157         CSQCMODEL_AUTOUPDATE(this);
158 }
159
160 // spawning weaponentity for client
161 void CL_SpawnWeaponentity(entity actor, .entity weaponentity)
162 {
163         entity view = actor.(weaponentity) = new(weaponentity);
164         view.solid = SOLID_NOT;
165         view.owner = actor;
166         setmodel(view, MDL_Null);  // precision set when changed
167         setorigin(view, '0 0 0');
168         view.weaponentity_fld = weaponentity;
169         setthink(view, CL_Weaponentity_Think);
170         view.nextthink = time;
171         view.viewmodelforclient = actor;
172         view.customizeentityforclient = CL_Weaponentity_CustomizeEntityForClient;
173
174         if (weaponentity == weaponentities[0])
175         {
176                 entity exterior = actor.exteriorweaponentity = new(exteriorweaponentity);
177                 exterior.solid = SOLID_NOT;
178                 exterior.owner = actor;
179                 setorigin(exterior, '0 0 0');
180                 setthink(exterior, CL_ExteriorWeaponentity_Think);
181                 exterior.nextthink = time;
182
183                 CSQCMODEL_AUTOINIT(exterior);
184         }
185 }
186
187 // Weapon subs
188 void w_clear(Weapon thiswep, entity actor, .entity weaponentity, int fire)
189 {
190         PS(actor).m_weapon = WEP_Null;
191         PS(actor).m_switchingweapon = WEP_Null;
192         entity this = actor.(weaponentity);
193         if (this)
194         {
195                 this.state = WS_CLEAR;
196                 this.effects = 0;
197         }
198 }
199
200 void w_ready(Weapon thiswep, entity actor, .entity weaponentity, int fire)
201 {
202         entity this = actor.(weaponentity);
203         if (this) this.state = WS_READY;
204         weapon_thinkf(actor, weaponentity, WFRAME_IDLE, 1000000, w_ready);
205 }
206
207 .float prevdryfire;
208 .float prevwarntime;
209 bool weapon_prepareattack_checkammo(Weapon thiswep, entity actor, bool secondary)
210 {
211         if ((actor.items & IT_UNLIMITED_WEAPON_AMMO)) return true;
212         bool ammo = false;
213         if (secondary) ammo = thiswep.wr_checkammo2(thiswep, actor);
214         else ammo = thiswep.wr_checkammo1(thiswep, actor);
215         if (ammo) return true;
216         // always keep the Mine Layer if we placed mines, so that we can detonate them
217         if (thiswep == WEP_MINE_LAYER)
218                 for (entity mine; (mine = find(mine, classname, "mine")); )
219                         if (mine.owner == actor) return false;
220
221         if (thiswep == WEP_SHOTGUN)
222                 if (!secondary && WEP_CVAR(shotgun, secondary) == 1) return false;           // no clicking, just allow
223
224         if (thiswep == PS(actor).m_switchweapon && time - actor.prevdryfire > 1) // only play once BEFORE starting to switch weapons
225         {
226                 sound(actor, CH_WEAPON_A, SND_DRYFIRE, VOL_BASE, ATTEN_NORM);
227                 actor.prevdryfire = time;
228         }
229
230         // check if the other firing mode has enough ammo
231         bool ammo_other = false;
232         if (secondary) ammo_other = thiswep.wr_checkammo1(thiswep, actor);
233         else ammo_other = thiswep.wr_checkammo2(thiswep, actor);
234         if (ammo_other)
235         {
236                 if (time - actor.prevwarntime > 1)
237                 {
238                         Send_Notification(
239                                 NOTIF_ONE,
240                                 actor,
241                                 MSG_MULTI,
242                                 ITEM_WEAPON_PRIMORSEC,
243                                 thiswep.m_id,
244                                 secondary,
245                                 (1 - secondary)
246                                          );
247                 }
248                 actor.prevwarntime = time;
249         }
250         else  // this weapon is totally unable to fire, switch to another one
251         {
252                 W_SwitchToOtherWeapon(actor);
253         }
254
255         return false;
256 }
257
258 .float race_penalty;
259 bool weapon_prepareattack_check(Weapon thiswep, entity actor, .entity weaponentity, bool secondary, float attacktime)
260 {
261         if (actor.weaponentity == NULL) return true;
262         if (!weapon_prepareattack_checkammo(thiswep, actor, secondary)) return false;
263
264         // if sv_ready_restart_after_countdown is set, don't allow the player to shoot
265         // if all players readied up and the countdown is running
266         if (time < game_starttime || time < actor.race_penalty) return false;
267
268         if (timeout_status == TIMEOUT_ACTIVE)  // don't allow the player to shoot while game is paused
269                 return false;
270
271         // do not even think about shooting if switching
272         if (PS(actor).m_switchweapon != PS(actor).m_weapon) return false;
273
274         if (attacktime >= 0)
275         {
276                 int slot = weaponslot(weaponentity);
277                 // don't fire if previous attack is not finished
278                 if (ATTACK_FINISHED(actor, slot) > time + actor.weapon_frametime * 0.5) return false;
279                 entity this = actor.(weaponentity);
280                 // don't fire while changing weapon
281                 if (this.state != WS_READY) return false;
282         }
283         return true;
284 }
285
286 void weapon_prepareattack_do(entity actor, .entity weaponentity, bool secondary, float attacktime)
287 {
288         entity this = actor.(weaponentity);
289         if (this == NULL) return;
290         this.state = WS_INUSE;
291
292         actor.spawnshieldtime = min(actor.spawnshieldtime, time);  // kill spawn shield when you fire
293
294         // if the weapon hasn't been firing continuously, reset the timer
295         if (attacktime >= 0)
296         {
297                 int slot = weaponslot(weaponentity);
298                 if (ATTACK_FINISHED(actor, slot) < time - actor.weapon_frametime * 1.5)
299                 {
300                         ATTACK_FINISHED(actor, slot) = time;
301                         // dprint("resetting attack finished to ", ftos(time), "\n");
302                 }
303                 ATTACK_FINISHED(actor, slot) = ATTACK_FINISHED(actor, slot) + attacktime * W_WeaponRateFactor();
304         }
305         actor.bulletcounter += 1;
306         // dprint("attack finished ", ftos(ATTACK_FINISHED(actor, slot)), "\n");
307 }
308
309 bool weapon_prepareattack(Weapon thiswep, entity actor, .entity weaponentity, bool secondary, float attacktime)
310 {
311         if (weapon_prepareattack_check(thiswep, actor, weaponentity, secondary, attacktime))
312         {
313                 weapon_prepareattack_do(actor, weaponentity, secondary, attacktime);
314                 return true;
315         }
316         return false;
317 }
318
319 void wframe_send(entity actor, entity weaponentity, vector a, bool restartanim);
320
321 /**
322  * @param t defer thinking until time + t
323  * @param func next think function
324  */
325 void weapon_thinkf(entity actor, .entity weaponentity, WFRAME fr, float t, void(Weapon thiswep, entity actor,
326         .entity weaponentity, int fire) func)
327 {
328         entity this = actor.(weaponentity);
329         if (this == NULL) return;
330         bool restartanim;
331         if (fr == WFRAME_DONTCHANGE)
332         {
333                 fr = this.wframe;
334                 restartanim = false;
335         }
336         else
337         {
338                 restartanim = fr != WFRAME_IDLE;
339         }
340
341         vector of = v_forward;
342         vector or = v_right;
343         vector ou = v_up;
344
345         vector a = '0 0 0';
346     this.wframe = fr;
347     if (fr == WFRAME_IDLE) a = this.anim_idle;
348     else if (fr == WFRAME_FIRE1) a = this.anim_fire1;
349     else if (fr == WFRAME_FIRE2) a = this.anim_fire2;
350     else  // if (fr == WFRAME_RELOAD)
351         a = this.anim_reload;
352     a.z *= g_weaponratefactor;
353
354         v_forward = of;
355         v_right = or;
356         v_up = ou;
357
358         if (this.weapon_think == w_ready && func != w_ready && this.state == WS_RAISE) backtrace(
359                         "Tried to override initial weapon think function - should this really happen?");
360
361         t *= W_WeaponRateFactor();
362
363         // VorteX: haste can be added here
364         if (this.weapon_think == w_ready)
365         {
366                 this.weapon_nextthink = time;
367                 // dprint("started firing at ", ftos(time), "\n");
368         }
369         if (this.weapon_nextthink < time - actor.weapon_frametime * 1.5
370             || this.weapon_nextthink > time + actor.weapon_frametime * 1.5)
371         {
372                 this.weapon_nextthink = time;
373                 // dprint("reset weapon animation timer at ", ftos(time), "\n");
374         }
375         this.weapon_nextthink += t;
376         if (weaponentity == weaponentities[0]) STAT(WEAPON_NEXTTHINK, actor) = this.weapon_nextthink;
377         this.weapon_think = func;
378         // dprint("next ", ftos(this.weapon_nextthink), "\n");
379
380         if (this)
381         {
382                 FOREACH_CLIENT(true, LAMBDA(
383                         if(it == actor || (IS_SPEC(it) && it.enemy == actor))
384                                 wframe_send(it, this, a, restartanim);
385                 ));
386         }
387
388         if ((fr == WFRAME_FIRE1 || fr == WFRAME_FIRE2) && t)
389         {
390                 int act = (fr == WFRAME_FIRE2 && (PS(actor).m_weapon == WEP_SHOCKWAVE || PS(actor).m_weapon == WEP_SHOTGUN))
391                         ? ANIMACTION_MELEE
392                         : ANIMACTION_SHOOT
393                         ;
394                 animdecide_setaction(actor, act, restartanim);
395         }
396         else if (actor.anim_upper_action == ANIMACTION_SHOOT || actor.anim_upper_action == ANIMACTION_MELEE)
397         {
398                 actor.anim_upper_action = 0;
399         }
400 }
401
402 bool forbidWeaponUse(entity player)
403 {
404         if (time < game_starttime && !autocvar_sv_ready_restart_after_countdown) return true;
405         if (round_handler_IsActive() && !round_handler_IsRoundStarted()) return true;
406         if (player.player_blocked) return true;
407         if (STAT(FROZEN, player)) return true;
408         if (player.weapon_blocked) return true;
409         return false;
410 }
411
412 .bool hook_switchweapon;
413
414 void W_WeaponFrame(Player actor)
415 {
416     TC(Player, actor);
417     TC(PlayerState, PS(actor));
418         .entity weaponentity = weaponentities[0];  // TODO: unhardcode
419         entity this = actor.(weaponentity);
420         if (frametime) actor.weapon_frametime = frametime;
421
422         if (!this || actor.health < 1) return;  // Dead player can't use weapons and injure impulse commands
423
424
425         if (forbidWeaponUse(actor))
426         {
427                 if (actor.(weaponentity).state != WS_CLEAR)
428                 {
429                         Weapon wpn = PS(actor).m_weapon;
430                         w_ready(wpn, actor, weaponentity, PHYS_INPUT_BUTTON_ATCK(actor) | (PHYS_INPUT_BUTTON_ATCK2(actor) << 1));
431                         return;
432                 }
433         }
434
435         if (PS(actor).m_switchweapon == WEP_Null)
436         {
437                 PS(actor).m_weapon = WEP_Null;
438                 PS(actor).m_switchingweapon = WEP_Null;
439                 this.state = WS_CLEAR;
440                 actor.weaponname = "";
441                 // actor.items &= ~IT_AMMO;
442                 return;
443         }
444
445         makevectors(actor.v_angle);
446         vector fo = v_forward;  // save them in case the weapon think functions change it
447         vector ri = v_right;
448         vector up = v_up;
449
450         // Change weapon
451         if (PS(actor).m_weapon != PS(actor).m_switchweapon)
452         {
453                 switch (this.state)
454                 {
455                         default:
456                                 LOG_WARNINGF("unhandled weaponentity (%i) state for player (%i): %d\n", this, actor, this.state);
457                                 break;
458                         case WS_INUSE:
459                         case WS_RAISE:
460                                 break;
461                         case WS_CLEAR:
462                         {
463                                 // end switching!
464                                 Weapon newwep = PS(actor).m_switchweapon;
465                                 PS(actor).m_switchingweapon = newwep;
466
467                                 // the two weapon entities will notice this has changed and update their models
468                                 PS(actor).m_weapon = newwep;
469                                 actor.weaponname = newwep.mdl;
470                                 actor.bulletcounter = 0;
471                                 actor.ammo_field = newwep.ammo_field;
472                                 newwep.wr_setup(newwep);
473                                 this.state = WS_RAISE;
474
475                                 // set our clip load to the load of the weapon we switched to, if it's reloadable
476                                 if ((newwep.spawnflags & WEP_FLAG_RELOADABLE) && newwep.reloading_ammo)  // prevent accessing undefined cvars
477                                 {
478                                         actor.clip_load = actor.(weapon_load[PS(actor).m_switchweapon.m_id]);
479                                         actor.clip_size = newwep.reloading_ammo;
480                                 }
481                                 else
482                                 {
483                                         actor.clip_load = actor.clip_size = 0;
484                                 }
485
486                                 weapon_thinkf(actor, weaponentity, WFRAME_IDLE, newwep.switchdelay_raise, w_ready);
487                                 break;
488                         }
489                         case WS_DROP:
490                         {
491                                 // in dropping phase we can switch at any time
492                                 PS(actor).m_switchingweapon = PS(actor).m_switchweapon;
493                                 break;
494                         }
495                         case WS_READY:
496                         {
497                                 // start switching!
498                                 PS(actor).m_switchingweapon = PS(actor).m_switchweapon;
499                                 entity oldwep = PS(actor).m_weapon;
500
501                                 // set up weapon switch think in the future, and start drop anim
502                                 if (INDEPENDENT_ATTACK_FINISHED || ATTACK_FINISHED(actor, weaponslot(weaponentity)) <= time + actor.weapon_frametime * 0.5)
503                                 {
504                                         sound(actor, CH_WEAPON_SINGLE, SND_WEAPON_SWITCH, VOL_BASE, ATTN_NORM);
505                                         this.state = WS_DROP;
506                                         weapon_thinkf(actor, weaponentity, WFRAME_DONTCHANGE, oldwep.switchdelay_drop, w_clear);
507                                 }
508                                 break;
509                         }
510                 }
511         }
512
513         // LordHavoc: network timing test code
514         // if (actor.button0)
515         //      print(ftos(frametime), " ", ftos(time), " >= ", ftos(ATTACK_FINISHED(actor, slot)), " >= ", ftos(this.weapon_nextthink), "\n");
516
517         Weapon w = PS(actor).m_weapon;
518
519         // call the think code which may fire the weapon
520         // and do so multiple times to resolve framerate dependency issues if the
521         // server framerate is very low and the weapon fire rate very high
522         for (int c = 0; c < W_TICSPERFRAME; ++c)
523         {
524                 if (w != WEP_Null && !(actor.weapons & WepSet_FromWeapon(w)))
525                 {
526                         if (PS(actor).m_weapon == PS(actor).m_switchweapon) W_SwitchWeapon_Force(actor, w_getbestweapon(actor));
527                         w = WEP_Null;
528                 }
529
530                 v_forward = fo;
531                 v_right = ri;
532                 v_up = up;
533
534                 bool block_weapon = false;
535                 {
536                         bool key_pressed = PHYS_INPUT_BUTTON_HOOK(actor) && !actor.vehicle;
537                         Weapon off = actor.offhand;
538                         if (off && !(actor.weapons & WEPSET(HOOK)))
539                         {
540                                 if (off.offhand_think) off.offhand_think(off, actor, key_pressed);
541                         }
542                         else
543                         {
544                                 if (key_pressed && PS(actor).m_switchweapon != WEP_HOOK && !actor.hook_switchweapon)
545                                         W_SwitchWeapon(actor, WEP_HOOK);
546                                 actor.hook_switchweapon = key_pressed;
547                                 Weapon h = WEP_HOOK;
548                                 block_weapon = (PS(actor).m_weapon == h && (PHYS_INPUT_BUTTON_ATCK(actor) || key_pressed));
549                                 h.wr_think(h, actor, weaponentity, block_weapon ? 1 : 0);
550                         }
551                 }
552
553                 v_forward = fo;
554                 v_right = ri;
555                 v_up = up;
556
557                 if (!block_weapon)
558                 {
559             Weapon e = PS(actor).m_weapon;
560             TC(Weapon, e);
561                         if (w != WEP_Null)
562                         {
563                                 e.wr_think(e, actor, weaponentity, PHYS_INPUT_BUTTON_ATCK(actor) | (PHYS_INPUT_BUTTON_ATCK2(actor) << 1));
564                         }
565                         else if (e)
566                         {
567                                 e.wr_gonethink(e);
568                         }
569                 }
570
571                 if (time + actor.weapon_frametime * 0.5 >= this.weapon_nextthink)
572                 {
573                         if (this.weapon_think)
574                         {
575                                 v_forward = fo;
576                                 v_right = ri;
577                                 v_up = up;
578                                 Weapon wpn = PS(actor).m_weapon;
579                                 this.weapon_think(wpn, actor, weaponentity,
580                                         PHYS_INPUT_BUTTON_ATCK(actor) | (PHYS_INPUT_BUTTON_ATCK2(actor) << 1));
581                         }
582                         else
583                         {
584                                 bprint("\{1}^1ERROR: undefined weapon think function for ", actor.netname, "\n");
585                         }
586                 }
587         }
588 }
589
590 void W_AttachToShotorg(entity actor, entity flash, vector offset)
591 {
592         .entity weaponentity = weaponentities[0];
593         flash.owner = actor;
594         flash.angles_z = random() * 360;
595
596         entity view = actor.(weaponentity);
597         entity exterior = actor.exteriorweaponentity;
598
599         if (gettagindex(view, "shot")) setattachment(flash, view, "shot");
600         else setattachment(flash, view, "tag_shot");
601         setorigin(flash, offset);
602
603         entity xflash = spawn();
604         copyentity(flash, xflash);
605
606         flash.viewmodelforclient = actor;
607
608         if (view.oldorigin.x > 0)
609         {
610                 setattachment(xflash, exterior, "");
611                 setorigin(xflash, view.oldorigin + offset);
612         }
613         else
614         {
615                 if (gettagindex(exterior, "shot")) setattachment(xflash, exterior, "shot");
616                 else setattachment(xflash, exterior, "tag_shot");
617                 setorigin(xflash, offset);
618         }
619 }
620
621 void W_DecreaseAmmo(Weapon wep, entity actor, float ammo_use)
622 {
623         if (MUTATOR_CALLHOOK(W_DecreaseAmmo, actor)) return;
624
625         if ((actor.items & IT_UNLIMITED_WEAPON_AMMO) && !wep.reloading_ammo) return;
626
627         // if this weapon is reloadable, decrease its load. Else decrease the player's ammo
628         if (wep.reloading_ammo)
629         {
630                 actor.clip_load -= ammo_use;
631                 actor.(weapon_load[PS(actor).m_weapon.m_id]) = actor.clip_load;
632         }
633         else if (wep.ammo_field != ammo_none)
634         {
635                 actor.(wep.ammo_field) -= ammo_use;
636                 if (actor.(wep.ammo_field) < 0)
637                 {
638                         backtrace(sprintf(
639                                 "W_DecreaseAmmo(%.2f): '%s' subtracted too much %s from '%s', resulting with '%.2f' left... "
640                                 "Please notify Samual immediately with a copy of this backtrace!\n",
641                                 ammo_use,
642                                 wep.netname,
643                                 GetAmmoPicture(wep.ammo_field),
644                                 actor.netname,
645                                 actor.(wep.ammo_field)
646                                              ));
647                 }
648         }
649 }
650
651 // weapon reloading code
652
653 .float reload_ammo_amount, reload_ammo_min, reload_time;
654 .float reload_complain;
655 .string reload_sound;
656
657 void W_ReloadedAndReady(Weapon thiswep, entity actor, .entity weaponentity, int fire)
658 {
659         // finish the reloading process, and do the ammo transfer
660
661         actor.clip_load = actor.old_clip_load;  // restore the ammo counter, in case we still had ammo in the weapon before reloading
662
663         // if the gun uses no ammo, max out weapon load, else decrease ammo as we increase weapon load
664         if (!actor.reload_ammo_min || actor.items & IT_UNLIMITED_WEAPON_AMMO || actor.ammo_field == ammo_none)
665         {
666                 actor.clip_load = actor.reload_ammo_amount;
667         }
668         else
669         {
670                 // make sure we don't add more ammo than we have
671                 float load = min(actor.reload_ammo_amount - actor.clip_load, actor.(actor.ammo_field));
672                 actor.clip_load += load;
673                 actor.(actor.ammo_field) -= load;
674         }
675         actor.(weapon_load[PS(actor).m_weapon.m_id]) = actor.clip_load;
676
677         // do not set ATTACK_FINISHED in reload code any more. This causes annoying delays if eg: You start reloading a weapon,
678         // then quickly switch to another weapon and back. Reloading is canceled, but the reload delay is still there,
679         // so your weapon is disabled for a few seconds without reason
680
681         // ATTACK_FINISHED(actor, slot) -= actor.reload_time - 1;
682
683         Weapon wpn = Weapons_from(PS(actor).m_weapon.m_id);
684         w_ready(wpn, actor, weaponentity, PHYS_INPUT_BUTTON_ATCK(actor) | (PHYS_INPUT_BUTTON_ATCK2(actor) << 1));
685 }
686
687 void W_Reload(entity actor, float sent_ammo_min, Sound sent_sound)
688 {
689     TC(Sound, sent_sound);
690         .entity weaponentity = weaponentities[0];
691         // set global values to work with
692         Weapon e = PS(actor).m_weapon;
693
694         if (MUTATOR_CALLHOOK(W_Reload, actor)) return;
695
696         actor.reload_ammo_min = sent_ammo_min;
697         actor.reload_ammo_amount = e.reloading_ammo;
698         actor.reload_time = e.reloading_time;
699         if (actor.reload_sound) strunzone(actor.reload_sound);
700         actor.reload_sound = strzone(Sound_fixpath(sent_sound));
701
702         // don't reload weapons that don't have the RELOADABLE flag
703         if (!(e.spawnflags & WEP_FLAG_RELOADABLE))
704         {
705                 LOG_TRACE(
706                         "Warning: Attempted to reload a weapon that does not have the WEP_FLAG_RELOADABLE flag. Fix your code!\n");
707                 return;
708         }
709
710         // return if reloading is disabled for this weapon
711         if (!actor.reload_ammo_amount) return;
712
713         // our weapon is fully loaded, no need to reload
714         if (actor.clip_load >= actor.reload_ammo_amount) return;
715
716         // no ammo, so nothing to load
717         if (actor.ammo_field != ammo_none)
718         {
719                 if (!actor.(actor.ammo_field) && actor.reload_ammo_min)
720                 {
721                         if (!(actor.items & IT_UNLIMITED_WEAPON_AMMO))
722                         {
723                                 if (IS_REAL_CLIENT(actor) && actor.reload_complain < time)
724                                 {
725                                         play2(actor, SND(UNAVAILABLE));
726                                         sprint(actor, strcat("You don't have enough ammo to reload the ^2", PS(actor).m_weapon.m_name, "\n"));
727                                         actor.reload_complain = time + 1;
728                                 }
729                                 // switch away if the amount of ammo is not enough to keep using this weapon
730                                 Weapon w = PS(actor).m_weapon;
731                                 if (!(w.wr_checkammo1(w, actor) + w.wr_checkammo2(w, actor)))
732                                 {
733                                         actor.clip_load = -1;  // reload later
734                                         W_SwitchToOtherWeapon(actor);
735                                 }
736                                 return;
737                         }
738                 }
739         }
740
741         entity this = actor.(weaponentity);
742         if (this)
743         {
744                 if (this.wframe == WFRAME_RELOAD) return;
745
746                 // allow switching away while reloading, but this will cause a new reload!
747                 this.state = WS_READY;
748         }
749
750         // now begin the reloading process
751
752         _sound(actor, CH_WEAPON_SINGLE, actor.reload_sound, VOL_BASE, ATTEN_NORM);
753
754         // do not set ATTACK_FINISHED in reload code any more. This causes annoying delays if eg: You start reloading a weapon,
755         // then quickly switch to another weapon and back. Reloading is canceled, but the reload delay is still there,
756         // so your weapon is disabled for a few seconds without reason
757
758         // ATTACK_FINISHED(actor, slot) = max(time, ATTACK_FINISHED(actor, slot)) + actor.reload_time + 1;
759
760         weapon_thinkf(actor, weaponentity, WFRAME_RELOAD, actor.reload_time, W_ReloadedAndReady);
761
762         if (actor.clip_load < 0) actor.clip_load = 0;
763         actor.old_clip_load = actor.clip_load;
764         actor.clip_load = actor.(weapon_load[PS(actor).m_weapon.m_id]) = -1;
765 }
766
767 void W_DropEvent(.void(Weapon) event, entity player, float weapon_type, entity weapon_item)
768 {
769         Weapon w = Weapons_from(weapon_type);
770         weapon_dropevent_item = weapon_item;
771         WITHSELF(player, w.event(w));
772 }