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