data/qcsrc/server/cl_weapons.qc

   1 // switch between weapons
   2 void W_SwitchWeapon(float imp)
   3 {
   4         if (self.weapon != imp)
   5         if (client_hasweapon(self, imp, TRUE, TRUE))
   6                 W_SwitchWeapon_Force(self, imp);
   7 };
   8
   9 float W_GetCycleWeapon(entity pl, string weaponorder, float dir, float imp, float complain)
  10 {
  11         float n, i, weaponwant, first_valid, prev_valid, switchtonext, switchtolast;
  12         n = tokenize(weaponorder);
  13         switchtonext = switchtolast = 0;
  14         first_valid = prev_valid = 0;
  15
  16         if(dir == 0)
  17                 switchtonext = 1;
  18
  19         for(i = 0; i < n; ++i)
  20         {
  21                 weaponwant = stof(argv(i));
  22
  23                 if(imp)
  24                         if((get_weaponinfo(weaponwant)).impulse != imp)
  25                                 continue;
  26
  27                 if(client_hasweapon(pl, weaponwant, TRUE, FALSE))
  28                 {
  29                         if(switchtonext)
  30                                 return weaponwant;
  31                         if(!first_valid)
  32                                 first_valid = weaponwant;
  33                         if(weaponwant == pl.switchweapon)
  34                         {
  35                                 if(dir >= 0)
  36                                         switchtonext = 1;
  37                                 else if(prev_valid)
  38                                         return prev_valid;
  39                                 else
  40                                         switchtolast = 1;
  41                         }
  42                         prev_valid = weaponwant;
  43                 }
  44         }
  45         if(first_valid)
  46         {
  47                 if(switchtolast)
  48                         return prev_valid;
  49                 else
  50                         return first_valid;
  51         }
  52         // complain
  53         if(complain)
  54         {
  55                 for(i = 0; i < n; ++i)
  56                 {
  57                         weaponwant = stof(argv(i));
  58                         if(imp)
  59                                 if((get_weaponinfo(weaponwant)).impulse != imp)
  60                                         continue;
  61                         client_hasweapon(pl, weaponwant, TRUE, TRUE);
  62                 }
  63         }
  64         return 0;
  65 }
  66
  67 void W_CycleWeapon(string weaponorder, float dir)
  68 {
  69         float w;
  70         w = W_GetCycleWeapon(self, weaponorder, dir, 0, 1);
  71         if(w > 0)
  72                 W_SwitchWeapon(w);
  73 }
  74
  75 void W_NextWeaponOnImpulse(float imp)
  76 {
  77         float w;
  78         w = W_GetCycleWeapon(self, self.cvar_cl_weaponpriority, +1, imp, 1);
  79         if(w > 0)
  80                 W_SwitchWeapon(w);
  81 }
  82
  83 // next weapon
  84 void W_NextWeapon()
  85 {
  86         W_CycleWeapon(self.cvar_cl_weaponpriority, -1);
  87 }
  88
  89 // prev weapon
  90 void W_PreviousWeapon()
  91 {
  92         W_CycleWeapon(self.cvar_cl_weaponpriority, +1);
  93 }
  94
  95 string W_FixWeaponOrder(string order, float complete)
  96 {
  97         string neworder;
  98         float i, n, w;
  99
 100         n = tokenize(order);
 101         for(i = 0; i < n; ++i)
 102         {
 103                 w = stof(argv(i));
 104                 if(w >= WEP_FIRST && w <= WEP_LAST && w == floor(w))
 105                         neworder = strcat(neworder, ftos(w), " ");
 106         }
 107
 108         if(complete)
 109         {
 110                 n = tokenize(neworder);
 111                 for(w = WEP_FIRST; w <= WEP_LAST; ++w)
 112                 {
 113                         for(i = 0; i < n; ++i)
 114                                 if(stof(argv(i)) == w)
 115                                         break;
 116                         if(i == n) // not found
 117                                 neworder = strcat(ftos(w), " ", neworder);
 118                 }
 119         }
 120
 121         return substring(neworder, 0, strlen(neworder) - 1);
 122 }
 123
 124 string W_FixWeaponOrder_AllowIncomplete(string order)
 125 {
 126         return W_FixWeaponOrder(order, 0);
 127 }
 128
 129 string W_FixWeaponOrder_ForceComplete(string order)
 130 {
 131         return W_FixWeaponOrder(order, 1);
 132 }
 133
 134 float w_getbestweapon(entity e)
 135 {
 136         return W_GetCycleWeapon(e, e.cvar_cl_weaponpriority, 0, 0, 0);
 137 };
 138
 139 // generic weapons table
 140 // TODO should they be macros instead?
 141 float weapon_action(float wpn, float wrequest)
 142 {
 143         return (get_weaponinfo(wpn)).weapon_func(wrequest);
 144 };
 145
 146 string W_Name(float weaponid)
 147 {
 148         return (get_weaponinfo(weaponid)).message;
 149 }
 150
 151 float W_WeaponBit(float wpn)
 152 {
 153         return (get_weaponinfo(wpn)).weapons;
 154 }
 155
 156 float W_AmmoItemCode(float wpn)
 157 {
 158         return (get_weaponinfo(wpn)).items;
 159 }
 160
 161 // think function for tossed weapons
 162 void thrown_wep_think()
 163 {
 164         self.solid = SOLID_TRIGGER;
 165         self.owner = world;
 166         SUB_SetFade(self, time + 20, 1);
 167         setorigin(self, self.origin);
 168 };
 169
 170 // toss current weapon
 171 void W_ThrowWeapon(vector velo, vector delta, float doreduce)
 172 {
 173         local float w, ammo, wb, wa;
 174         local entity wep, e;
 175         local .float ammofield;
 176
 177         w = self.weapon;
 178         if (w == 0)
 179                 return; // just in case
 180         if (w == WEP_LASER)
 181                 return;
 182         if (g_rocketarena)
 183                 return;
 184         if (g_lms)
 185                 return;
 186         if (g_nixnex)
 187                 return;
 188         if (!cvar("g_pickup_items"))
 189                 return;
 190
 191         e = self;
 192         wep = spawn();
 193         self = wep;
 194
 195         setorigin(wep, e.origin + delta);
 196         makevectors(e.angles);
 197         wep.classname = "droppedweapon";
 198         wep.velocity = velo; // e.velocity * 0.5 + v_forward * 750;
 199         SUB_SetFade(wep, time + 20, 1);
 200
 201         wa = W_AmmoItemCode(w);
 202         if(wa == IT_SUPERWEAPON || wa == 0)
 203         {
 204                 wb = W_WeaponBit(w);
 205                 if(!(e.weapons & wb))
 206                 {
 207                         remove(wep);
 208                         goto leave;
 209                 }
 210                 Item_SpawnByWeaponCode(w);
 211                 if(startitem_failed)
 212                         goto leave;
 213                 if(e.weapons & wb)
 214                         if(e.health >= 1)
 215                                 sprint(e, strcat("You dropped the ^2", wep.netname, "\n"));
 216         }
 217         else
 218         {
 219                 ammofield = Item_CounterField(wa);
 220                 wb = W_WeaponBit(w);
 221                 if(!(e.weapons & wb))
 222                 {
 223                         remove(wep);
 224                         goto leave;
 225                 }
 226                 Item_SpawnByWeaponCode(w);
 227                 if(startitem_failed)
 228                         goto leave;
 229                 if(doreduce)
 230                 {
 231                         ammo = min(e.ammofield, wep.ammofield);
 232                         wep.ammofield = ammo;
 233                         e.ammofield -= ammo;
 234                 }
 235                 if(e.weapons & wb)
 236                         if(e.health >= 1)
 237                                 sprint(e, strcat("You dropped the ^2", wep.netname, " with ", ftos(wep.ammofield), " ammo", "\n"));
 238         }
 239
 240         wep.owner = e;
 241         setorigin(wep, wep.origin);
 242         wep.nextthink = time + 0.5;
 243         wep.think = thrown_wep_think;
 244         wep.classname = "droppedweapon";
 245         wep.flags = wep.flags | FL_TOSSED;
 246         e.weapons = e.weapons - (e.weapons & wb);
 247         wep.colormap = e.colormap;
 248         W_SwitchWeapon_Force(e, w_getbestweapon(e));
 249
 250 :leave
 251         self = e;
 252 };
 253
 254 // Bringed back weapon frame
 255 void W_WeaponFrame()
 256 {
 257         if((arena_roundbased && time < warmup) || ((time < restart_countdown) && !cvar("sv_ready_restart_after_countdown")))
 258                 return;
 259
 260         if (!self.weaponentity || self.health < 1)
 261                 return; // Dead player can't use weapons and injure impulse commands
 262
 263         if(!self.switchweapon)
 264         {
 265                 self.weapon = 0;
 266                 self.weaponentity.state = WS_CLEAR;
 267                 return;
 268         }
 269
 270         makevectors(self.v_angle);
 271
 272         // Change weapon
 273         if (self.weapon != self.switchweapon)
 274         {
 275                 if (self.weaponentity.state == WS_CLEAR)
 276                 {
 277                         player_setanim(self.anim_draw, FALSE, TRUE, TRUE);
 278                         self.weaponentity.state = WS_RAISE;
 279                         weapon_action(self.switchweapon, WR_SETUP);
 280                         // VorteX: add player model weapon select frame here
 281                         // setcustomframe(PlayerWeaponRaise);
 282                         weapon_thinkf(WFRAME_IDLE, cvar("g_balance_weaponswitchdelay"), w_ready);
 283                         weapon_boblayer1(PLAYER_WEAPONSELECTION_SPEED, '0 0 0');
 284                 }
 285                 else if (self.weaponentity.state == WS_READY)
 286                 {
 287 #ifndef INDEPENDENT_ATTACK_FINISHED
 288                         if(ATTACK_FINISHED(self) <= time + frametime * 0.5)
 289                         {
 290 #endif
 291                         sound (self, CHAN_WEAPON, "weapons/weapon_switch.wav", VOL_BASE, ATTN_NORM);
 292                         self.weaponentity.state = WS_DROP;
 293                         // set up weapon switch think in the future, and start drop anim
 294                         weapon_thinkf(WFRAME_IDLE, cvar("g_balance_weaponswitchdelay"), w_clear);
 295                         weapon_boblayer1(PLAYER_WEAPONSELECTION_SPEED, PLAYER_WEAPONSELECTION_RANGE);
 296 #ifndef INDEPENDENT_ATTACK_FINISHED
 297                         }
 298 #endif
 299                 }
 300         }
 301
 302         float wb;
 303         wb = W_WeaponBit(self.weapon);
 304
 305         // call the think code which may fire the weapon
 306         // and do so multiple times to resolve framerate dependency issues if the
 307         // server framerate is very low and the weapon fire rate very high
 308         local float c;
 309         c = 0;
 310         while (c < 5)
 311         {
 312                 c = c + 1;
 313                 if(wb && self.weapons & wb == 0)
 314                 {
 315                         W_SwitchWeapon_Force(self, w_getbestweapon(self));
 316                         wb = 0;
 317                 }
 318                 if(wb)
 319                         weapon_action(self.weapon, WR_THINK);
 320                 if (time + frametime * 0.5 >= self.weapon_nextthink)
 321                         self.weapon_think();
 322         }
 323
 324         // don't let attack_finished fall behind when not firing (must be after weapon_setup calls!)
 325         //if (ATTACK_FINISHED(self) < time)
 326         //      ATTACK_FINISHED(self) = time;
 327
 328         //if (self.weapon_nextthink < time)
 329         //      self.weapon_nextthink = time;
 330
 331         // update currentammo incase it has changed
 332         if (self.items & IT_CELLS)
 333                 self.currentammo = self.ammo_cells;
 334         else if (self.items & IT_ROCKETS)
 335                 self.currentammo = self.ammo_rockets;
 336         else if (self.items & IT_NAILS)
 337                 self.currentammo = self.ammo_nails;
 338         else if (self.items & IT_SHELLS)
 339                 self.currentammo = self.ammo_shells;
 340         else
 341                 self.currentammo = 1;
 342
 343 };
 344
 345 float nixnex_weapon;
 346 float nixnex_nextchange;
 347 float nixnex_nextweapon;
 348 .float nixnex_lastchange_id;
 349 .float nixnex_lastinfotime;
 350 .float nixnex_nextincr;
 351
 352 void Nixnex_ChooseNextWeapon()
 353 {
 354         float numberof, id;
 355         numberof = WEP_LAST - WEP_FIRST; // all but the current one
 356         if(g_nixnex_with_laser)
 357                 numberof = numberof - 1;
 358         id = WEP_FIRST + ceil(random() * numberof) - 1;
 359
 360         if(g_nixnex_with_laser) // skip the laser if needed
 361                 id = id + 1;
 362
 363         if(id >= nixnex_weapon) // skip the current weapon
 364                 id = id + 1;
 365
 366         if(id < WEP_FIRST) // can't happen, but to be sure...
 367         {
 368                 dprint("Won't happen (id < WEP_FIRST)\n");
 369                 id = WEP_FIRST;
 370         }
 371         if(id > WEP_LAST) // either
 372         {
 373                 dprint("Won't happen (id > WEP_LAST)\n");
 374                 id = WEP_LAST;
 375         }
 376
 377         nixnex_nextweapon = id;
 378 }
 379
 380 void Nixnex_GiveCurrentWeapon()
 381 {
 382         float dt;
 383         if(g_nixnex)
 384         {
 385                 if(!nixnex_nextweapon)
 386                         Nixnex_ChooseNextWeapon();
 387
 388                 dt = ceil(nixnex_nextchange - time);
 389
 390                 if(dt <= 0)
 391                 {
 392                         nixnex_weapon = nixnex_nextweapon;
 393                         nixnex_nextweapon = 0;
 394                         nixnex_nextchange = time + cvar("g_balance_nixnex_roundtime");
 395                         //weapon_action(nixnex_weapon, WR_PRECACHE); // forget it, too slow
 396                 }
 397
 398                 if(nixnex_nextchange != self.nixnex_lastchange_id) // this shall only be called once per round!
 399                 {
 400                         self.nixnex_lastchange_id = nixnex_nextchange;
 401                         if (cvar("g_use_ammunition"))
 402                         {
 403                                 self.ammo_shells = cvar("g_balance_nixnex_ammo_shells");
 404                                 self.ammo_nails = cvar("g_balance_nixnex_ammo_nails");
 405                                 self.ammo_rockets = cvar("g_balance_nixnex_ammo_rockets");
 406                                 self.ammo_cells = cvar("g_balance_nixnex_ammo_cells");
 407                         }
 408                         else
 409                         {
 410                                 self.ammo_shells = cvar("g_pickup_shells_max");
 411                                 self.ammo_nails = cvar("g_pickup_nails_max");
 412                                 self.ammo_rockets = cvar("g_pickup_rockets_max");
 413                                 self.ammo_cells = cvar("g_pickup_cells_max");
 414                         }
 415                         self.nixnex_nextincr = time + cvar("g_balance_nixnex_incrtime");
 416                         if(dt >= 1 && dt <= 5)
 417                                 self.nixnex_lastinfotime = -42;
 418                         else
 419                                 centerprint(self, strcat("\n\n^2Active weapon: ^3", W_Name(nixnex_weapon), "\n"));
 420                 }
 421                 if(self.nixnex_lastinfotime != dt)
 422                 {
 423                         self.nixnex_lastinfotime = dt; // initial value 0 should count as "not seen"
 424                         if(dt >= 1 && dt <= 5)
 425                                 centerprint(self, strcat("^3", ftos(dt), "^2 seconds until weapon change...\n\nNext weapon: ^3", W_Name(nixnex_nextweapon), "\n"));
 426                 }
 427
 428                 if(cvar("g_use_ammunition") && time > self.nixnex_nextincr)
 429                 {
 430                         self.ammo_shells = self.ammo_shells + cvar("g_balance_nixnex_ammoincr_shells");
 431                         self.ammo_nails = self.ammo_nails + cvar("g_balance_nixnex_ammoincr_nails");
 432                         self.ammo_rockets = self.ammo_rockets + cvar("g_balance_nixnex_ammoincr_rockets");
 433                         self.ammo_cells = self.ammo_cells + cvar("g_balance_nixnex_ammoincr_cells");
 434                         self.nixnex_nextincr = time + cvar("g_balance_nixnex_incrtime");
 435                 }
 436
 437                 self.weapons = 0;
 438                 if(g_nixnex_with_laser)
 439                         self.weapons = self.weapons | WEPBIT_LASER;
 440                 self.weapons = self.weapons | W_WeaponBit(nixnex_weapon);
 441
 442                 if(self.switchweapon != nixnex_weapon)
 443                         if(!client_hasweapon(self, self.switchweapon, TRUE, FALSE))
 444                                 if(client_hasweapon(self, nixnex_weapon, TRUE, FALSE))
 445                                         W_SwitchWeapon(nixnex_weapon);
 446         }
 447 }
 448
 449 void RegisterWeapons()
 450 {
 451         // %weaponaddpoint
 452         register_weapon(WEP_LASER,            w_laser,     0,              1, 1, "laser",   "laser",           "Laser");
 453         register_weapon(WEP_SHOTGUN,          w_shotgun,   IT_SHELLS,      2, 1, "shotgun", "shotgun",         "Shotgun");
 454         register_weapon(WEP_UZI,              w_uzi,       IT_NAILS,       3, 1, "uzi",     "uzi",             "Machine Gun");
 455         register_weapon(WEP_GRENADE_LAUNCHER, w_glauncher, IT_ROCKETS,     4, 1, "gl",      "grenadelauncher", "Mortar");
 456         register_weapon(WEP_ELECTRO,          w_electro,   IT_CELLS,       5, 1, "electro", "electro",         "Electro");
 457         register_weapon(WEP_CRYLINK,          w_crylink,   IT_CELLS,       6, 1, "crylink", "crylink",         "Crylink");
 458         register_weapon(WEP_NEX,              w_nex,       IT_CELLS,       7, 1, "nex",     "nex",             "Nex");
 459         register_weapon(WEP_HAGAR,            w_hagar,     IT_ROCKETS,     8, 1, "hagar",   "hagar",           "Hagar");
 460         register_weapon(WEP_ROCKET_LAUNCHER,  w_rlauncher, IT_ROCKETS,     9, 1, "rl",      "rocketlauncher",  "Rocket Launcher");
 461         register_weapon(WEP_PORTO,            w_porto,     IT_SUPERWEAPON, 1, 0, "porto" ,  "porto",           "Port-O-Launch");
 462         register_weapon(WEP_MINSTANEX,        w_minstanex, IT_CELLS,       7, 0, "nex",     "minstanex",       "MinstaNex");
 463 }