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(float fr, float t, void() func) weapon_thinkf;
  51
  52 float CL_Weaponentity_CustomizeEntityForClient()
  53 {
  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 {
 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, strcat("models/weapons/v_", name, ".md3")); // precision set below
 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, strcat("models/weapons/h_", name, ".iqm")); // precision set below
 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, strcat("models/weapons/v_", name, ".md3")); // precision does not matter
 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, strcat("models/weapons/v_", name, ".md3")); // precision does not matter
 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                                 print("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                                 print("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                                 print("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 {
 273         entity wi, oldself;
 274         vector ret;
 275         wi = get_weaponinfo(wpn);
 276         oldself = self;
 277         self = spawn();
 278         CL_WeaponEntity_SetModel(wi.mdl);
 279         ret = self.movedir;
 280         CL_WeaponEntity_SetModel("");
 281         remove(self);
 282         self = oldself;
 283         return ret;
 284 }
 285
 286 void CL_Weaponentity_Think()
 287 {
 288         int tb;
 289         self.nextthink = time;
 290         if (intermission_running)
 291                 self.frame = self.anim_idle.x;
 292         if (self.owner.weaponentity != self)
 293         {
 294                 if (self.weaponentity)
 295                         remove(self.weaponentity);
 296                 remove(self);
 297                 return;
 298         }
 299         if (self.owner.deadflag != DEAD_NO)
 300         {
 301                 self.model = "";
 302                 if (self.weaponentity)
 303                         self.weaponentity.model = "";
 304                 return;
 305         }
 306         if (self.weaponname != self.owner.weaponname || self.dmg != self.owner.modelindex || self.deadflag != self.owner.deadflag)
 307         {
 308                 self.weaponname = self.owner.weaponname;
 309                 self.dmg = self.owner.modelindex;
 310                 self.deadflag = self.owner.deadflag;
 311
 312                 CL_WeaponEntity_SetModel(self.owner.weaponname);
 313         }
 314
 315         tb = (self.effects & (EF_TELEPORT_BIT | EF_RESTARTANIM_BIT));
 316         self.effects = self.owner.effects & EFMASK_CHEAP;
 317         self.effects &= ~EF_LOWPRECISION;
 318         self.effects &= ~EF_FULLBRIGHT; // can mask team color, so get rid of it
 319         self.effects &= ~EF_TELEPORT_BIT;
 320         self.effects &= ~EF_RESTARTANIM_BIT;
 321         self.effects |= tb;
 322
 323         if(self.owner.alpha == default_player_alpha)
 324                 self.alpha = default_weapon_alpha;
 325         else if(self.owner.alpha != 0)
 326                 self.alpha = self.owner.alpha;
 327         else
 328                 self.alpha = 1;
 329
 330         self.glowmod = self.owner.weaponentity_glowmod;
 331         self.colormap = self.owner.colormap;
 332         if (self.weaponentity)
 333         {
 334                 self.weaponentity.effects = self.effects;
 335                 self.weaponentity.alpha = self.alpha;
 336                 self.weaponentity.colormap = self.colormap;
 337                 self.weaponentity.glowmod = self.glowmod;
 338         }
 339
 340         self.angles = '0 0 0';
 341
 342         float f = (self.owner.weapon_nextthink - time);
 343         if (self.state == WS_RAISE && !intermission_running)
 344         {
 345                 entity newwep = get_weaponinfo(self.owner.switchweapon);
 346                 f = f * g_weaponratefactor / max(f, newwep.switchdelay_raise);
 347                 self.angles_x = -90 * f * f;
 348         }
 349         else if (self.state == WS_DROP && !intermission_running)
 350         {
 351                 entity oldwep = get_weaponinfo(self.owner.weapon);
 352                 f = 1 - f * g_weaponratefactor / max(f, oldwep.switchdelay_drop);
 353                 self.angles_x = -90 * f * f;
 354         }
 355         else if (self.state == WS_CLEAR)
 356         {
 357                 f = 1;
 358                 self.angles_x = -90 * f * f;
 359         }
 360 }
 361
 362 void CL_ExteriorWeaponentity_Think()
 363 {
 364         float tag_found;
 365         self.nextthink = time;
 366         if (self.owner.exteriorweaponentity != self)
 367         {
 368                 remove(self);
 369                 return;
 370         }
 371         if (self.owner.deadflag != DEAD_NO)
 372         {
 373                 self.model = "";
 374                 return;
 375         }
 376         if (self.weaponname != self.owner.weaponname || self.dmg != self.owner.modelindex || self.deadflag != self.owner.deadflag)
 377         {
 378                 self.weaponname = self.owner.weaponname;
 379                 self.dmg = self.owner.modelindex;
 380                 self.deadflag = self.owner.deadflag;
 381                 if (self.owner.weaponname != "")
 382                         setmodel(self, strcat("models/weapons/v_", self.owner.weaponname, ".md3")); // precision set below
 383                 else
 384                         self.model = "";
 385
 386                 if((tag_found = gettagindex(self.owner, "tag_weapon")))
 387                 {
 388                         self.tag_index = tag_found;
 389                         self.tag_entity = self.owner;
 390                 }
 391                 else
 392                         setattachment(self, self.owner, "bip01 r hand");
 393         }
 394         self.effects = self.owner.effects;
 395         self.effects |= EF_LOWPRECISION;
 396         self.effects = self.effects & EFMASK_CHEAP; // eat performance
 397         if(self.owner.alpha == default_player_alpha)
 398                 self.alpha = default_weapon_alpha;
 399         else if(self.owner.alpha != 0)
 400                 self.alpha = self.owner.alpha;
 401         else
 402                 self.alpha = 1;
 403
 404         self.glowmod = self.owner.weaponentity_glowmod;
 405         self.colormap = self.owner.colormap;
 406
 407         CSQCMODEL_AUTOUPDATE();
 408 }
 409
 410 // spawning weaponentity for client
 411 void CL_SpawnWeaponentity()
 412 {
 413         self.weaponentity = spawn();
 414         self.weaponentity.classname = "weaponentity";
 415         self.weaponentity.solid = SOLID_NOT;
 416         self.weaponentity.owner = self;
 417         setmodel(self.weaponentity, ""); // precision set when changed
 418         setorigin(self.weaponentity, '0 0 0');
 419         self.weaponentity.angles = '0 0 0';
 420         self.weaponentity.viewmodelforclient = self;
 421         self.weaponentity.flags = 0;
 422         self.weaponentity.think = CL_Weaponentity_Think;
 423         self.weaponentity.customizeentityforclient = CL_Weaponentity_CustomizeEntityForClient;
 424         self.weaponentity.nextthink = time;
 425
 426         self.exteriorweaponentity = spawn();
 427         self.exteriorweaponentity.classname = "exteriorweaponentity";
 428         self.exteriorweaponentity.solid = SOLID_NOT;
 429         self.exteriorweaponentity.exteriorweaponentity = self.exteriorweaponentity;
 430         self.exteriorweaponentity.owner = self;
 431         setorigin(self.exteriorweaponentity, '0 0 0');
 432         self.exteriorweaponentity.angles = '0 0 0';
 433         self.exteriorweaponentity.think = CL_ExteriorWeaponentity_Think;
 434         self.exteriorweaponentity.nextthink = time;
 435
 436         {
 437                 entity oldself = self;
 438                 self = self.exteriorweaponentity;
 439                 CSQCMODEL_AUTOINIT();
 440                 self = oldself;
 441         }
 442 }
 443
 444 // Weapon subs
 445 void w_clear()
 446 {
 447         if (self.weapon != -1)
 448         {
 449                 self.weapon = 0;
 450                 self.switchingweapon = 0;
 451         }
 452         if (self.weaponentity)
 453         {
 454                 self.weaponentity.state = WS_CLEAR;
 455                 self.weaponentity.effects = 0;
 456         }
 457 }
 458
 459 void w_ready()
 460 {
 461         if (self.weaponentity)
 462                 self.weaponentity.state = WS_READY;
 463         weapon_thinkf(WFRAME_IDLE, 1000000, w_ready);
 464 }
 465
 466 .float prevdryfire;
 467 .float prevwarntime;
 468 float weapon_prepareattack_checkammo(float secondary)
 469 {
 470         if (!(self.items & IT_UNLIMITED_WEAPON_AMMO))
 471         if (!WEP_ACTION(self.weapon, WR_CHECKAMMO1 + secondary))
 472         {
 473                 // always keep the Mine Layer if we placed mines, so that we can detonate them
 474                 entity mine;
 475                 if(self.weapon == WEP_MINE_LAYER)
 476                 for(mine = world; (mine = find(mine, classname, "mine")); ) if(mine.owner == self)
 477                         return false;
 478
 479                 if(self.weapon == WEP_SHOTGUN)
 480                 if(!secondary && WEP_CVAR(shotgun, secondary) == 1)
 481                         return false; // no clicking, just allow
 482
 483                 if(self.weapon == self.switchweapon && time - self.prevdryfire > 1) // only play once BEFORE starting to switch weapons
 484                 {
 485                         sound (self, CH_WEAPON_A, "weapons/dryfire.wav", VOL_BASE, ATTEN_NORM);
 486                         self.prevdryfire = time;
 487                 }
 488
 489                 if(WEP_ACTION(self.weapon, WR_CHECKAMMO2 - secondary)) // check if the other firing mode has enough ammo
 490                 {
 491                         if(time - self.prevwarntime > 1)
 492                         {
 493                                 Send_Notification(
 494                                         NOTIF_ONE,
 495                                         self,
 496                                         MSG_MULTI,
 497                                         ITEM_WEAPON_PRIMORSEC,
 498                                         self.weapon,
 499                                         secondary,
 500                                         (1 - secondary)
 501                                 );
 502                         }
 503                         self.prevwarntime = time;
 504                 }
 505                 else // this weapon is totally unable to fire, switch to another one
 506                 {
 507                         W_SwitchToOtherWeapon(self);
 508                 }
 509
 510                 return false;
 511         }
 512         return true;
 513 }
 514 .float race_penalty;
 515 float weapon_prepareattack_check(float secondary, float attacktime)
 516 {
 517         if(!weapon_prepareattack_checkammo(secondary))
 518                 return false;
 519
 520         //if sv_ready_restart_after_countdown is set, don't allow the player to shoot
 521         //if all players readied up and the countdown is running
 522         if(time < game_starttime || time < self.race_penalty) {
 523                 return false;
 524         }
 525
 526         if (timeout_status == TIMEOUT_ACTIVE) //don't allow the player to shoot while game is paused
 527                 return false;
 528
 529         // do not even think about shooting if switching
 530         if(self.switchweapon != self.weapon)
 531                 return false;
 532
 533         if(attacktime >= 0)
 534         {
 535                 // don't fire if previous attack is not finished
 536                 if (ATTACK_FINISHED(self) > time + self.weapon_frametime * 0.5)
 537                         return false;
 538                 // don't fire while changing weapon
 539                 if (self.weaponentity.state != WS_READY)
 540                         return false;
 541         }
 542
 543         return true;
 544 }
 545 float weapon_prepareattack_do(float secondary, float attacktime)
 546 {
 547         self.weaponentity.state = WS_INUSE;
 548
 549         self.spawnshieldtime = min(self.spawnshieldtime, time); // kill spawn shield when you fire
 550
 551         // if the weapon hasn't been firing continuously, reset the timer
 552         if(attacktime >= 0)
 553         {
 554                 if (ATTACK_FINISHED(self) < time - self.weapon_frametime * 1.5)
 555                 {
 556                         ATTACK_FINISHED(self) = time;
 557                         //dprint("resetting attack finished to ", ftos(time), "\n");
 558                 }
 559                 ATTACK_FINISHED(self) = ATTACK_FINISHED(self) + attacktime * W_WeaponRateFactor();
 560         }
 561         self.bulletcounter += 1;
 562         //dprint("attack finished ", ftos(ATTACK_FINISHED(self)), "\n");
 563         return true;
 564 }
 565 float weapon_prepareattack(float secondary, float attacktime)
 566 {
 567         if(weapon_prepareattack_check(secondary, attacktime))
 568         {
 569                 weapon_prepareattack_do(secondary, attacktime);
 570                 return true;
 571         }
 572         else
 573                 return false;
 574 }
 575
 576 void weapon_thinkf(float fr, float t, void() func)
 577 {
 578         vector a;
 579         vector of, or, ou;
 580         float restartanim;
 581
 582         if(fr == WFRAME_DONTCHANGE)
 583         {
 584                 fr = self.weaponentity.wframe;
 585                 restartanim = false;
 586         }
 587         else if (fr == WFRAME_IDLE)
 588                 restartanim = false;
 589         else
 590                 restartanim = true;
 591
 592         of = v_forward;
 593         or = v_right;
 594         ou = v_up;
 595
 596         if (self.weaponentity)
 597         {
 598                 self.weaponentity.wframe = fr;
 599                 a = '0 0 0';
 600                 if (fr == WFRAME_IDLE)
 601                         a = self.weaponentity.anim_idle;
 602                 else if (fr == WFRAME_FIRE1)
 603                         a = self.weaponentity.anim_fire1;
 604                 else if (fr == WFRAME_FIRE2)
 605                         a = self.weaponentity.anim_fire2;
 606                 else // if (fr == WFRAME_RELOAD)
 607                         a = self.weaponentity.anim_reload;
 608                 a.z *= g_weaponratefactor;
 609                 setanim(self.weaponentity, a, restartanim == false, restartanim, restartanim);
 610         }
 611
 612         v_forward = of;
 613         v_right = or;
 614         v_up = ou;
 615
 616         if(self.weapon_think == w_ready && func != w_ready && self.weaponentity.state == WS_RAISE)
 617         {
 618                 backtrace("Tried to override initial weapon think function - should this really happen?");
 619         }
 620
 621         t *= W_WeaponRateFactor();
 622
 623         // VorteX: haste can be added here
 624         if (self.weapon_think == w_ready)
 625         {
 626                 self.weapon_nextthink = time;
 627                 //dprint("started firing at ", ftos(time), "\n");
 628         }
 629         if (self.weapon_nextthink < time - self.weapon_frametime * 1.5 || self.weapon_nextthink > time + self.weapon_frametime * 1.5)
 630         {
 631                 self.weapon_nextthink = time;
 632                 //dprint("reset weapon animation timer at ", ftos(time), "\n");
 633         }
 634         self.weapon_nextthink = self.weapon_nextthink + t;
 635         self.weapon_think = func;
 636         //dprint("next ", ftos(self.weapon_nextthink), "\n");
 637
 638         if((fr == WFRAME_FIRE1 || fr == WFRAME_FIRE2) && t)
 639         {
 640                 if((self.weapon == WEP_SHOCKWAVE || self.weapon == WEP_SHOTGUN) && fr == WFRAME_FIRE2)
 641                         animdecide_setaction(self, ANIMACTION_MELEE, restartanim);
 642                 else
 643                         animdecide_setaction(self, ANIMACTION_SHOOT, restartanim);
 644         }
 645         else
 646         {
 647                 if(self.anim_upper_action == ANIMACTION_SHOOT || self.anim_upper_action == ANIMACTION_MELEE)
 648                         self.anim_upper_action = 0;
 649         }
 650 }
 651
 652 float forbidWeaponUse()
 653 {
 654         if(time < game_starttime && !autocvar_sv_ready_restart_after_countdown)
 655                 return 1;
 656         if(round_handler_IsActive() && !round_handler_IsRoundStarted())
 657                 return 1;
 658         if(self.player_blocked)
 659                 return 1;
 660         if(self.frozen)
 661                 return 1;
 662         if(self.weapon_blocked)
 663                 return 1;
 664         return 0;
 665 }
 666
 667 void W_WeaponFrame()
 668 {
 669         vector fo, ri, up;
 670
 671         if (frametime)
 672                 self.weapon_frametime = frametime;
 673
 674         if (!self.weaponentity || self.health < 1)
 675                 return; // Dead player can't use weapons and injure impulse commands
 676
 677         if(forbidWeaponUse())
 678         if(self.weaponentity.state != WS_CLEAR)
 679         {
 680                 w_ready();
 681                 return;
 682         }
 683
 684         if(!self.switchweapon)
 685         {
 686                 self.weapon = 0;
 687                 self.switchingweapon = 0;
 688                 self.weaponentity.state = WS_CLEAR;
 689                 self.weaponname = "";
 690                 //self.items &= ~IT_AMMO;
 691                 return;
 692         }
 693
 694         makevectors(self.v_angle);
 695         fo = v_forward; // save them in case the weapon think functions change it
 696         ri = v_right;
 697         up = v_up;
 698
 699         // Change weapon
 700         if (self.weapon != self.switchweapon)
 701         {
 702                 if (self.weaponentity.state == WS_CLEAR)
 703                 {
 704                         // end switching!
 705                         self.switchingweapon = self.switchweapon;
 706                         entity newwep = get_weaponinfo(self.switchweapon);
 707
 708                         // the two weapon entities will notice this has changed and update their models
 709                         self.weapon = self.switchweapon;
 710                         self.weaponname = newwep.mdl;
 711                         self.bulletcounter = 0;
 712                         self.ammo_field = newwep.ammo_field;
 713                         WEP_ACTION(self.switchweapon, WR_SETUP);
 714                         self.weaponentity.state = WS_RAISE;
 715
 716                         // set our clip load to the load of the weapon we switched to, if it's reloadable
 717                         if(newwep.spawnflags & WEP_FLAG_RELOADABLE && newwep.reloading_ammo) // prevent accessing undefined cvars
 718                         {
 719                                 self.clip_load = self.(weapon_load[self.switchweapon]);
 720                                 self.clip_size = newwep.reloading_ammo;
 721                         }
 722                         else
 723                                 self.clip_load = self.clip_size = 0;
 724
 725                         weapon_thinkf(WFRAME_IDLE, newwep.switchdelay_raise, w_ready);
 726                 }
 727                 else if (self.weaponentity.state == WS_DROP)
 728                 {
 729                         // in dropping phase we can switch at any time
 730                         self.switchingweapon = self.switchweapon;
 731                 }
 732                 else if (self.weaponentity.state == WS_READY)
 733                 {
 734                         // start switching!
 735                         self.switchingweapon = self.switchweapon;
 736                         entity oldwep = get_weaponinfo(self.weapon);
 737
 738                         // set up weapon switch think in the future, and start drop anim
 739                         #ifndef INDEPENDENT_ATTACK_FINISHED
 740                         if(ATTACK_FINISHED(self) <= time + self.weapon_frametime * 0.5)
 741                         {
 742                         #endif
 743                                 sound(self, CH_WEAPON_SINGLE, "weapons/weapon_switch.wav", VOL_BASE, ATTN_NORM);
 744                                 self.weaponentity.state = WS_DROP;
 745                                 weapon_thinkf(WFRAME_DONTCHANGE, oldwep.switchdelay_drop, w_clear);
 746                         #ifndef INDEPENDENT_ATTACK_FINISHED
 747                         }
 748                         #endif
 749                 }
 750         }
 751
 752         // LordHavoc: network timing test code
 753         //if (self.button0)
 754         //      print(ftos(frametime), " ", ftos(time), " >= ", ftos(ATTACK_FINISHED(self)), " >= ", ftos(self.weapon_nextthink), "\n");
 755
 756         float w;
 757         w = self.weapon;
 758
 759         // call the think code which may fire the weapon
 760         // and do so multiple times to resolve framerate dependency issues if the
 761         // server framerate is very low and the weapon fire rate very high
 762         float c;
 763         c = 0;
 764         while (c < W_TICSPERFRAME)
 765         {
 766                 c = c + 1;
 767                 if(w && !(self.weapons & WepSet_FromWeapon(w)))
 768                 {
 769                         if(self.weapon == self.switchweapon)
 770                                 W_SwitchWeapon_Force(self, w_getbestweapon(self));
 771                         w = 0;
 772                 }
 773
 774                 v_forward = fo;
 775                 v_right = ri;
 776                 v_up = up;
 777
 778                 if(w)
 779                         WEP_ACTION(self.weapon, WR_THINK);
 780                 else
 781                         WEP_ACTION(self.weapon, WR_GONETHINK);
 782
 783                 if (time + self.weapon_frametime * 0.5 >= self.weapon_nextthink)
 784                 {
 785                         if(self.weapon_think)
 786                         {
 787                                 v_forward = fo;
 788                                 v_right = ri;
 789                                 v_up = up;
 790                                 self.weapon_think();
 791                         }
 792                         else
 793                                 bprint("\{1}^1ERROR: undefined weapon think function for ", self.netname, "\n");
 794                 }
 795         }
 796 }
 797
 798 void W_AttachToShotorg(entity flash, vector offset)
 799 {
 800         entity xflash;
 801         flash.owner = self;
 802         flash.angles_z = random() * 360;
 803
 804         if(gettagindex(self.weaponentity, "shot"))
 805                 setattachment(flash, self.weaponentity, "shot");
 806         else
 807                 setattachment(flash, self.weaponentity, "tag_shot");
 808         setorigin(flash, offset);
 809
 810         xflash = spawn();
 811         copyentity(flash, xflash);
 812
 813         flash.viewmodelforclient = self;
 814
 815         if(self.weaponentity.oldorigin.x > 0)
 816         {
 817                 setattachment(xflash, self.exteriorweaponentity, "");
 818                 setorigin(xflash, self.weaponentity.oldorigin + offset);
 819         }
 820         else
 821         {
 822                 if(gettagindex(self.exteriorweaponentity, "shot"))
 823                         setattachment(xflash, self.exteriorweaponentity, "shot");
 824                 else
 825                         setattachment(xflash, self.exteriorweaponentity, "tag_shot");
 826                 setorigin(xflash, offset);
 827         }
 828 }
 829
 830 void W_DecreaseAmmo(float ammo_use)
 831 {
 832         entity wep = get_weaponinfo(self.weapon);
 833
 834         if(cvar("g_overkill"))
 835         if(self.ok_use_ammocharge)
 836         {
 837                 ok_DecreaseCharge(self, self.weapon);
 838                 return; // TODO
 839         }
 840
 841         if((self.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                 self.clip_load -= ammo_use;
 848                 self.(weapon_load[self.weapon]) = self.clip_load;
 849         }
 850         else if(wep.ammo_field != ammo_none)
 851         {
 852                 self.(wep.ammo_field) -= ammo_use;
 853                 if(self.(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                                 self.netname,
 862                                 self.(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()
 875 {
 876         // finish the reloading process, and do the ammo transfer
 877
 878         self.clip_load = self.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(!self.reload_ammo_min || self.items & IT_UNLIMITED_WEAPON_AMMO || self.ammo_field == ammo_none)
 882                 self.clip_load = self.reload_ammo_amount;
 883         else
 884         {
 885                 // make sure we don't add more ammo than we have
 886                 float load = min(self.reload_ammo_amount - self.clip_load, self.(self.ammo_field));
 887         self.clip_load += load;
 888         self.(self.ammo_field) -= load;
 889         }
 890         self.(weapon_load[self.weapon]) = self.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(self) -= self.reload_time - 1;
 897
 898         w_ready();
 899 }
 900
 901 void W_Reload(float sent_ammo_min, string sent_sound)
 902 {
 903         // set global values to work with
 904         entity e;
 905         e = get_weaponinfo(self.weapon);
 906
 907         if(cvar("g_overkill"))
 908         if(self.ok_use_ammocharge)
 909                 return; // TODO
 910
 911         self.reload_ammo_min = sent_ammo_min;
 912         self.reload_ammo_amount = e.reloading_ammo;
 913         self.reload_time = e.reloading_time;
 914         self.reload_sound = sent_sound;
 915
 916         // don't reload weapons that don't have the RELOADABLE flag
 917         if (!(e.spawnflags & WEP_FLAG_RELOADABLE))
 918         {
 919                 dprint("Warning: Attempted to reload a weapon that does not have the WEP_FLAG_RELOADABLE flag. Fix your code!\n");
 920                 return;
 921         }
 922
 923         // return if reloading is disabled for this weapon
 924         if(!self.reload_ammo_amount)
 925                 return;
 926
 927         // our weapon is fully loaded, no need to reload
 928         if (self.clip_load >= self.reload_ammo_amount)
 929                 return;
 930
 931         // no ammo, so nothing to load
 932         if(self.ammo_field != ammo_none)
 933         if(!self.(self.ammo_field) && self.reload_ammo_min)
 934         if (!(self.items & IT_UNLIMITED_WEAPON_AMMO))
 935         {
 936                 if(IS_REAL_CLIENT(self) && self.reload_complain < time)
 937                 {
 938                         play2(self, "weapons/unavailable.wav");
 939                         sprint(self, strcat("You don't have enough ammo to reload the ^2", WEP_NAME(self.weapon), "\n"));
 940                         self.reload_complain = time + 1;
 941                 }
 942                 // switch away if the amount of ammo is not enough to keep using this weapon
 943                 if (!(WEP_ACTION(self.weapon, WR_CHECKAMMO1) + WEP_ACTION(self.weapon, WR_CHECKAMMO2)))
 944                 {
 945                         self.clip_load = -1; // reload later
 946                         W_SwitchToOtherWeapon(self);
 947                 }
 948                 return;
 949         }
 950
 951         if (self.weaponentity)
 952         {
 953                 if (self.weaponentity.wframe == WFRAME_RELOAD)
 954                         return;
 955
 956                 // allow switching away while reloading, but this will cause a new reload!
 957                 self.weaponentity.state = WS_READY;
 958         }
 959
 960         // now begin the reloading process
 961
 962         sound(self, CH_WEAPON_SINGLE, self.reload_sound, VOL_BASE, ATTEN_NORM);
 963
 964         // do not set ATTACK_FINISHED in reload code any more. This causes annoying delays if eg: You start reloading a weapon,
 965         // then quickly switch to another weapon and back. Reloading is canceled, but the reload delay is still there,
 966         // so your weapon is disabled for a few seconds without reason
 967
 968         //ATTACK_FINISHED(self) = max(time, ATTACK_FINISHED(self)) + self.reload_time + 1;
 969
 970         weapon_thinkf(WFRAME_RELOAD, self.reload_time, W_ReloadedAndReady);
 971
 972         if(self.clip_load < 0)
 973                 self.clip_load = 0;
 974         self.old_clip_load = self.clip_load;
 975         self.clip_load = self.(weapon_load[self.weapon]) = -1;
 976 }
 977
 978 void W_DropEvent(float event, entity player, float weapon_type, entity weapon_item)
 979 {
 980         entity oldself = self;
 981         self = player;
 982         weapon_dropevent_item = weapon_item;
 983         WEP_ACTION(weapon_type, event);
 984         self = oldself;
 985 }