data/qcsrc/server/t_items.qc

   1 floatfield Item_CounterField(float it)
   2 {
   3         switch(it)
   4         {
   5                 case IT_SHELLS:      return ammo_shells;
   6                 case IT_NAILS:       return ammo_nails;
   7                 case IT_ROCKETS:     return ammo_rockets;
   8                 case IT_CELLS:       return ammo_cells;
   9                 case IT_5HP:         return health;
  10                 case IT_25HP:        return health;
  11                 case IT_HEALTH:      return health;
  12                 case IT_ARMOR_SHARD: return armorvalue;
  13                 case IT_ARMOR:       return armorvalue;
  14                 // add more things here (health, armor)
  15                 default:             error("requested item has no counter field");
  16         }
  17 }
  18
  19 string Item_CounterFieldName(float it)
  20 {
  21         switch(it)
  22         {
  23                 case IT_SHELLS:      return "shells";
  24                 case IT_NAILS:       return "nails";
  25                 case IT_ROCKETS:     return "rockets";
  26                 case IT_CELLS:       return "cells";
  27
  28                 // add more things here (health, armor)
  29                 default:             error("requested item has no counter field name");
  30         }
  31 }
  32
  33 .float max_armorvalue;
  34
  35 void Item_Respawn (void)
  36 {
  37         self.model = self.mdl;          // restore original model
  38         self.solid = SOLID_TRIGGER;     // allow it to be touched again
  39         sound (self, CHAN_TRIGGER, "misc/itemrespawn.wav", VOL_BASE, ATTN_NORM);        // play respawn sound
  40         setorigin (self, self.origin);
  41
  42         //pointparticles(particleeffectnum("item_respawn"), self.origin + self.mins_z * '0 0 1' + '0 0 48', '0 0 0', 1);
  43         pointparticles(particleeffectnum("item_respawn"), self.origin + 0.5 * (self.mins + self.maxs), '0 0 0', 1);
  44 }
  45
  46 float Item_GiveTo(entity item, entity player)
  47 {
  48         float _switchweapon;
  49         float pickedup;
  50         float it;
  51         float i;
  52         entity e;
  53
  54         // if nothing happens to player, just return without taking the item
  55         pickedup = FALSE;
  56         _switchweapon = FALSE;
  57
  58         if (g_minstagib)
  59         {
  60                 _switchweapon = TRUE;
  61                 if (item.ammo_cells)
  62                 {
  63                         pickedup = TRUE;
  64                         // play some cool sounds ;)
  65                         centerprint(player, "\n");
  66                         if(player.health <= 5)
  67                                 announce(player, "announcer/robotic/lastsecond.wav");
  68                         else if(player.health < 50)
  69                                 announce(player, "announcer/robotic/narrowly.wav");
  70                         // sound not available
  71                         // else if(item.items == IT_CELLS)
  72                         //      play2(player, "announce/robotic/ammo.wav");
  73
  74                         if (item.weapons & WEPBIT_MINSTANEX)
  75                                 W_GiveWeapon (player, WEP_MINSTANEX, "Nex");
  76                         if (item.ammo_cells)
  77                                 player.ammo_cells = min (player.ammo_cells + cvar("g_minstagib_ammo_drop"), 999);
  78                         player.health = 100;
  79                 }
  80
  81                 // extralife powerup
  82                 if (item.max_health)
  83                 {
  84                         pickedup = TRUE;
  85                         // sound not available
  86                         // play2(player, "announce/robotic/extra.ogg\nplay2 announce/robotic/_lives.wav");
  87                         player.armorvalue = player.armorvalue + cvar("g_minstagib_extralives");
  88                         sprint(player, "^3You picked up some extra lives\n");
  89                 }
  90
  91                 // invis powerup
  92                 if (item.strength_finished)
  93                 {
  94                         pickedup = TRUE;
  95                         // sound not available
  96                         // play2(player, "announce/robotic/invisible.wav");
  97                         player.strength_finished = max(player.strength_finished, time) + cvar("g_balance_powerup_strength_time");
  98                 }
  99
 100                 // speed powerup
 101                 if (item.invincible_finished)
 102                 {
 103                         pickedup = TRUE;
 104                         // sound not available
 105                         // play2(player, "announce/robotic/speed.wav");
 106                         player.invincible_finished = max(player.invincible_finished, time) + cvar("g_balance_powerup_strength_time");
 107                 }
 108         }
 109         else
 110         {
 111                 if (g_weapon_stay == 1)
 112                 if not(item.flags & FL_NO_WEAPON_STAY)
 113                 if (item.flags & FL_WEAPON)
 114                 {
 115                         if(item.classname == "droppedweapon")
 116                         {
 117                                 if (player.weapons & item.weapons)      // don't let players stack ammo by tossing weapons
 118                                         goto skip;
 119                         }
 120                         else
 121                         {
 122                                 if (player.weapons & item.weapons)
 123                                         goto skip;
 124                         }
 125                 }
 126
 127                 // in case the player has autoswitch enabled do the following:
 128                 // if the player is using their best weapon before items are given, they
 129                 // probably want to switch to an even better weapon after items are given
 130                 if (player.autoswitch)
 131                 if (player.switchweapon == w_getbestweapon(player))
 132                         _switchweapon = TRUE;
 133
 134                 if not(player.weapons & W_WeaponBit(player.switchweapon))
 135                         _switchweapon = TRUE;
 136
 137                 if (item.ammo_shells)
 138                 if (player.ammo_shells < g_pickup_shells_max)
 139                 {
 140                         pickedup = TRUE;
 141                         player.ammo_shells = min (player.ammo_shells + item.ammo_shells, g_pickup_shells_max);
 142                 }
 143                 if (item.ammo_nails)
 144                 if (player.ammo_nails < g_pickup_nails_max)
 145                 {
 146                         pickedup = TRUE;
 147                         player.ammo_nails = min (player.ammo_nails + item.ammo_nails, g_pickup_nails_max);
 148                 }
 149                 if (item.ammo_rockets)
 150                 if (player.ammo_rockets < g_pickup_rockets_max)
 151                 {
 152                         pickedup = TRUE;
 153                         player.ammo_rockets = min (player.ammo_rockets + item.ammo_rockets, g_pickup_rockets_max);
 154                 }
 155                 if (item.ammo_cells)
 156                 if (player.ammo_cells < g_pickup_cells_max)
 157                 {
 158                         pickedup = TRUE;
 159                         player.ammo_cells = min (player.ammo_cells + item.ammo_cells, g_pickup_cells_max);
 160                 }
 161
 162                 if (item.flags & FL_WEAPON)
 163                 if ((it = item.weapons - (item.weapons & player.weapons)))
 164                 {
 165                         pickedup = TRUE;
 166                         for(i = WEP_FIRST; i <= WEP_LAST; ++i)
 167                         {
 168                                 e = get_weaponinfo(i);
 169                                 if(it & e.weapons)
 170                                         W_GiveWeapon (player, e.weapon, item.netname);
 171                         }
 172                 }
 173
 174                 if (item.strength_finished)
 175                 {
 176                         pickedup = TRUE;
 177                         player.strength_finished = max(player.strength_finished, time) + cvar("g_balance_powerup_strength_time");
 178                 }
 179                 if (item.invincible_finished)
 180                 {
 181                         pickedup = TRUE;
 182                         player.invincible_finished = max(player.invincible_finished, time) + cvar("g_balance_powerup_invincible_time");
 183                 }
 184                 //if (item.speed_finished)
 185                 //{
 186                 //      pickedup = TRUE;
 187                 //      player.speed_finished = max(player.speed_finished, time) + cvar("g_balance_powerup_speed_time");
 188                 //}
 189                 //if (item.slowmo_finished)
 190                 //{
 191                 //      pickedup = TRUE;
 192                 //      player.slowmo_finished = max(player.slowmo_finished, time) + (cvar("g_balance_powerup_slowmo_time") * cvar("g_balance_powerup_slowmo_speed"));
 193                 //}
 194
 195                 if (item.health)
 196                 if (player.health < item.max_health)
 197                 {
 198                         pickedup = TRUE;
 199                         player.health = min(player.health + item.health, item.max_health);
 200                         player.pauserothealth_finished = max(player.pauserothealth_finished, time + cvar("g_balance_pause_health_rot"));
 201                 }
 202                 if (item.armorvalue)
 203                 if (player.armorvalue < item.max_armorvalue)
 204                 {
 205                         pickedup = TRUE;
 206                         player.armorvalue = min(player.armorvalue + item.armorvalue, item.max_armorvalue);
 207                         player.pauserotarmor_finished = max(player.pauserotarmor_finished, time + cvar("g_balance_pause_armor_rot"));
 208                 }
 209         }
 210
 211 :skip
 212         // always eat teamed entities
 213         if(item.team)
 214                 pickedup = TRUE;
 215
 216         if (!pickedup)
 217                 return 0;
 218
 219         sound (player, CHAN_AUTO, item.item_pickupsound, VOL_BASE, ATTN_NORM);
 220         if (_switchweapon)
 221                 W_SwitchWeapon_Force(player, w_getbestweapon(player));
 222
 223         return 1;
 224 }
 225
 226 void Item_Touch (void)
 227 {
 228         entity e, head;
 229
 230         // remove the item if it's currnetly in a NODROP brush or hits a NOIMPACT surface (such as sky)
 231         if (((trace_dpstartcontents | trace_dphitcontents) & DPCONTENTS_NODROP) || (trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT))
 232         {
 233                 remove(self);
 234                 return;
 235         }
 236         if (other.classname != "player")
 237                 return;
 238         if (other.deadflag)
 239                 return;
 240         if (self.solid != SOLID_TRIGGER)
 241                 return;
 242         if (self.owner == other)
 243                 return;
 244
 245         if(!Item_GiveTo(self, other))
 246                 return;
 247
 248         if (self.classname == "droppedweapon")
 249                 remove (self);
 250         else if((self.flags & FL_WEAPON) && !(self.flags & FL_NO_WEAPON_STAY) && g_weapon_stay)
 251                 return;
 252         else
 253         {
 254                 self.solid = SOLID_NOT;
 255                 self.model = string_null;
 256                 if(self.team)
 257                 {
 258                         RandomSelection_Init();
 259                         for(head = world; (head = findfloat(head, team, self.team)); ) if(head.flags & FL_ITEM)
 260                                 RandomSelection_Add(head, 0, head.cnt, 0);
 261                         e = RandomSelection_chosen_ent;
 262                 }
 263                 else
 264                         e = self;
 265                 e.nextthink = time + self.respawntime;
 266                 e.think = Item_Respawn;
 267         }
 268 }
 269
 270 void Item_FindTeam()
 271 {
 272         entity head, e;
 273
 274         if(self.effects & EF_NODRAW)
 275         {
 276                 // marker for item team search
 277                 dprint("Initializing item team ", ftos(self.team), "\n");
 278                 RandomSelection_Init();
 279                 for(head = world; (head = findfloat(head, team, self.team)); ) if(head.flags & FL_ITEM)
 280                         RandomSelection_Add(head, 0, head.cnt, 0);
 281                 e = RandomSelection_chosen_ent;
 282                 e.state = 0;
 283
 284                 for(head = world; (head = findfloat(head, team, self.team)); ) if(head.flags & FL_ITEM)
 285                 {
 286                         if(head != e)
 287                         {
 288                                 // make it a non-spawned item
 289                                 head.solid = SOLID_NOT;
 290                                 head.model = string_null;
 291                                 head.state = 1; // state 1 = initially hidden item
 292                         }
 293                         head.effects = head.effects - (head.effects & EF_NODRAW);
 294                 }
 295         }
 296 }
 297
 298 void Item_Reset()
 299 {
 300         if(self.state == 1)
 301         {
 302                 self.model = string_null;
 303                 self.solid = SOLID_NOT;
 304         }
 305         else
 306         {
 307                 self.model = self.mdl;
 308                 self.solid = SOLID_TRIGGER;
 309         }
 310         setorigin (self, self.origin);
 311         self.think = SUB_Null;
 312         self.nextthink = 0;
 313 }
 314
 315 // Savage: used for item garbage-collection
 316 // TODO: perhaps nice special effect?
 317 void RemoveItem(void)
 318 {
 319         remove(self);
 320 }
 321
 322 // pickup evaluation functions
 323 // these functions decide how desirable an item is to the bots
 324
 325 float generic_pickupevalfunc(entity player, entity item) {return item.bot_pickupbasevalue;};
 326
 327 float weapon_pickupevalfunc(entity player, entity item)
 328 {
 329         // if we already have the weapon, rate it 1/5th normal value
 330         if ((player.weapons & item.weapons) == item.weapons)
 331                 return item.bot_pickupbasevalue * 0.2;
 332         return item.bot_pickupbasevalue;
 333 };
 334
 335 float commodity_pickupevalfunc(entity player, entity item)
 336 {
 337         float c;
 338         c = 0;
 339         // TODO: figure out if the player even has the weapon this ammo is for?
 340         // may not affect strategy much though...
 341         // find out how much more ammo/armor/health the player can hold
 342         if (item.ammo_shells)
 343         if (player.ammo_shells < g_pickup_shells_max)
 344                 c = c + max(0, 1 - player.ammo_shells / g_pickup_shells_max);
 345         if (item.ammo_nails)
 346         if (player.ammo_nails < g_pickup_nails_max)
 347                 c = c + max(0, 1 - player.ammo_nails / g_pickup_nails_max);
 348         if (item.ammo_rockets)
 349         if (player.ammo_rockets < g_pickup_rockets_max)
 350                 c = c + max(0, 1 - player.ammo_rockets / g_pickup_rockets_max);
 351         if (item.ammo_cells)
 352         if (player.ammo_cells < g_pickup_cells_max)
 353                 c = c + max(0, 1 - player.ammo_cells / g_pickup_cells_max);
 354         if (item.armorvalue)
 355         if (player.armorvalue < item.max_armorvalue)
 356                 c = c + max(0, 1 - player.armorvalue / item.max_armorvalue);
 357         if (item.health)
 358         if (player.health < item.max_health)
 359                 c = c + max(0, 1 - player.health / item.max_health);
 360
 361         return item.bot_pickupbasevalue * c;
 362 };
 363
 364
 365 .float is_item;
 366 void StartItem (string itemmodel, string pickupsound, float defaultrespawntime, string itemname, float itemid, float weaponid, float itemflags, float(entity player, entity item) pickupevalfunc, float pickupbasevalue)
 367 {
 368         startitem_failed = FALSE;
 369
 370         // is it a dropped weapon?
 371         if (self.classname == "droppedweapon")
 372         {
 373                 self.reset = SUB_Remove;
 374                 // it's a dropped weapon
 375                 self.movetype = MOVETYPE_TOSS;
 376                 self.solid = SOLID_TRIGGER;
 377                 // Savage: remove thrown items after a certain period of time ("garbage collection")
 378                 self.think = RemoveItem;
 379                 self.nextthink = time + 60;
 380                 // don't drop if in a NODROP zone (such as lava)
 381                 traceline(self.origin, self.origin, MOVE_NORMAL, self);
 382                 if (trace_dpstartcontents & DPCONTENTS_NODROP)
 383                 {
 384                         startitem_failed = TRUE;
 385                         remove(self);
 386                         return;
 387                 }
 388         }
 389         else
 390         {
 391                 self.reset = Item_Reset;
 392                 // it's a level item
 393                 if(self.spawnflags & 1)
 394                         self.noalign = 1;
 395                 if (self.noalign)
 396                         self.movetype = MOVETYPE_NONE;
 397                 else
 398                         self.movetype = MOVETYPE_TOSS;
 399                 self.solid = SOLID_TRIGGER;
 400                 // do item filtering according to game mode and other things
 401                 if (!self.noalign)
 402                 {
 403                         // first nudge it off the floor a little bit to avoid math errors
 404                         setorigin(self, self.origin + '0 0 1');
 405                         // set item size before we spawn a spawnfunc_waypoint
 406                         if((itemflags & FL_POWERUP) || self.health || self.armorvalue)
 407                                 setsize (self, '-16 -16 0', '16 16 48');
 408                         else
 409                                 setsize (self, '-16 -16 0', '16 16 32');
 410                         // note droptofloor returns FALSE if stuck/or would fall too far
 411                         droptofloor();
 412                         waypoint_spawnforitem(self);
 413                 }
 414
 415                 if(teams_matter)
 416                 {
 417                         if(self.notteam)
 418                         {
 419                                 print("removed non-teamplay ", self.classname, "\n");
 420                                 startitem_failed = TRUE;
 421                                 remove (self);
 422                                 return;
 423                         }
 424                 }
 425                 else
 426                 {
 427                         if(self.notfree)
 428                         {
 429                                 print("removed non-FFA ", self.classname, "\n");
 430                                 startitem_failed = TRUE;
 431                                 remove (self);
 432                                 return;
 433                         }
 434                 }
 435
 436                 if(self.notq3a)
 437                 {
 438                         // We aren't TA or something like that, so we keep the Q3A entities
 439                         print("removed non-Q3A ", self.classname, "\n");
 440                         startitem_failed = TRUE;
 441                         remove (self);
 442                         return;
 443                 }
 444
 445                 /*
 446                  * can't do it that way, as it would break maps
 447                  * TODO make a target_give like entity another way, that perhaps has
 448                  * the weapon name in a key
 449                 if(self.targetname)
 450                 {
 451                         // target_give not yet supported; maybe later
 452                         print("removed targeted ", self.classname, "\n");
 453                         startitem_failed = TRUE;
 454                         remove (self);
 455                         return;
 456                 }
 457                 */
 458
 459                 if(cvar("spawn_debug") >= 2)
 460                 {
 461                         entity otheritem;
 462                         for(otheritem = findradius(self.origin, 3); otheritem; otheritem = otheritem.chain)
 463                         {
 464                                 if(otheritem.is_item)
 465                                 {
 466                                         dprint("XXX Found duplicated item: ", itemname, vtos(self.origin));
 467                                         dprint(" vs ", otheritem.netname, vtos(otheritem.origin), "\n");
 468                                         error("Mapper sucks.");
 469                                 }
 470                         }
 471                         self.is_item = TRUE;
 472                 }
 473
 474                 weaponsInMap |= weaponid;
 475
 476                 if(g_lms)
 477                 {
 478                         startitem_failed = TRUE;
 479                         remove(self);
 480                         return;
 481                 }
 482                 else if (g_weaponarena && ((weaponid & WEPBIT_ALL) || (itemid & IT_AMMO)))
 483                 {
 484                         startitem_failed = TRUE;
 485                         remove(self);
 486                         return;
 487                 }
 488                 else if (g_minstagib)
 489                 {
 490                         // don't remove dropped items and powerups
 491                         if (self.classname != "minstagib")
 492                         {
 493                                 startitem_failed = TRUE;
 494                                 remove (self);
 495                                 return;
 496                         }
 497                 }
 498                 else if ((!cvar("g_pickup_items") || g_nixnex) && itemid != IT_STRENGTH && itemid != IT_INVINCIBLE && itemid != IT_HEALTH)
 499                 {
 500                         startitem_failed = TRUE;
 501                         remove (self);
 502                         return;
 503                 }
 504
 505                 precache_model (itemmodel);
 506                 precache_sound (pickupsound);
 507                 precache_sound ("misc/itemrespawn.wav");
 508
 509                 if((itemid & (IT_STRENGTH | IT_INVINCIBLE | IT_HEALTH | IT_ARMOR | IT_KEY1 | IT_KEY2)) || (weaponid & WEPBIT_ALL))
 510                         self.target = "###item###"; // for finding the nearest item using find()
 511         }
 512
 513         self.bot_pickup = TRUE;
 514         self.bot_pickupevalfunc = pickupevalfunc;
 515         self.bot_pickupbasevalue = pickupbasevalue;
 516         self.mdl = itemmodel;
 517         self.item_pickupsound = pickupsound;
 518         // let mappers override respawntime
 519         if (!self.respawntime)
 520                 self.respawntime = defaultrespawntime;
 521         self.netname = itemname;
 522         self.items = itemid;
 523         self.weapons = weaponid;
 524         self.flags = FL_ITEM | itemflags;
 525         self.touch = Item_Touch;
 526         setmodel (self, self.mdl); // precision set below
 527         self.effects |= EF_LOWPRECISION;
 528         if((itemflags & FL_POWERUP) || self.health || self.armorvalue)
 529                 setsize (self, '-16 -16 0', '16 16 48');
 530         else
 531                 setsize (self, '-16 -16 0', '16 16 32');
 532         if(itemflags & FL_WEAPON)
 533                 self.modelflags |= MF_ROTATE;
 534
 535         if (self.classname != "droppedweapon") // if dropped, colormap is already set up nicely
 536         if (itemflags & FL_WEAPON)
 537         {
 538                 // neutral team color for pickup weapons
 539                 self.colormap = 1024; // color shirt=0 pants=0 grey
 540         }
 541
 542         if (cvar("g_fullbrightitems"))
 543                 self.effects = self.effects | EF_FULLBRIGHT;
 544
 545         self.state = 0;
 546         if(self.team)
 547         {
 548                 if(!self.cnt)
 549                         self.cnt = 1; // item probability weight
 550                 self.effects = self.effects | EF_NODRAW; // marker for item team search
 551                 InitializeEntity(self, Item_FindTeam, INITPRIO_FINDTARGET);
 552         }
 553 }
 554
 555 /* replace items in minstagib
 556  * IT_STRENGTH   = invisibility
 557  * IT_NAILS      = extra lives
 558  * IT_INVINCIBLE = speed
 559  */
 560 void minstagib_items (float itemid)
 561 {
 562         // we don't want to replace dropped weapons ;)
 563         if (self.classname == "droppedweapon")
 564         {
 565                 self.ammo_cells = 25;
 566                 StartItem ("models/weapons/g_nex.md3",
 567                         "weapons/weaponpickup.wav", 15,
 568                         "MinstaNex", 0, WEPBIT_MINSTANEX, FL_WEAPON, generic_pickupevalfunc, 1000);
 569                 return;
 570         }
 571
 572         local float rnd;
 573         self.classname = "minstagib";
 574
 575         // replace rocket launchers and nex guns with ammo cells
 576         if (itemid == IT_CELLS)
 577         {
 578                 self.ammo_cells = 1;
 579                 StartItem ("models/items/a_cells.md3",
 580                         "misc/itempickup.wav", 45,
 581                         "Nex Ammo", IT_CELLS, 0, 0, generic_pickupevalfunc, 100);
 582                 return;
 583         }
 584
 585         // randomize
 586         rnd = random() * 3;
 587         if (rnd <= 1)
 588                 itemid = IT_STRENGTH;
 589         else if (rnd <= 2)
 590                 itemid = IT_NAILS;
 591         else
 592                 itemid = IT_INVINCIBLE;
 593
 594         // replace with invis
 595         if (itemid == IT_STRENGTH)
 596         {
 597                 self.effects = EF_ADDITIVE;
 598                 self.strength_finished = 30;
 599                 StartItem ("models/items/g_strength.md3",
 600                         "misc/powerup.wav", g_pickup_respawntime_powerup,
 601                         "Invisibility", IT_STRENGTH, 0, FL_POWERUP, generic_pickupevalfunc, BOT_PICKUP_RATING_MID);
 602         }
 603         // replace with extra lives
 604         if (itemid == IT_NAILS)
 605         {
 606                 self.max_health = 1;
 607                 StartItem ("models/items/g_h100.md3",
 608                         "misc/megahealth.wav", g_pickup_respawntime_powerup,
 609                         "Extralife", IT_NAILS, 0, FL_POWERUP, generic_pickupevalfunc, BOT_PICKUP_RATING_HIGH);
 610
 611         }
 612         // replace with speed
 613         if (itemid == IT_INVINCIBLE)
 614         {
 615                 self.effects = EF_ADDITIVE;
 616                 self.invincible_finished = 30;
 617                 StartItem ("models/items/g_invincible.md3",
 618                         "misc/powerup_shield.wav", g_pickup_respawntime_powerup,
 619                         "Speed", IT_INVINCIBLE, 0, FL_POWERUP, generic_pickupevalfunc, BOT_PICKUP_RATING_MID);
 620         }
 621
 622 }
 623
 624 float minst_no_auto_cells;
 625 void minst_remove_item (void) {
 626         if(minst_no_auto_cells)
 627                 remove(self);
 628 }
 629
 630 float weaponswapping;
 631 float internalteam;
 632
 633 void weapon_defaultspawnfunc(float wpn)
 634 {
 635         entity e;
 636         float t;
 637         var .float ammofield;
 638         string s;
 639         entity oldself;
 640         float i, j;
 641
 642         // set the respawntime in advance (so replaced weapons can copy it)
 643         if(!self.respawntime)
 644         {
 645                 e = get_weaponinfo(wpn);
 646                 if(e.items == IT_SUPERWEAPON)
 647                         self.respawntime = g_pickup_respawntime_powerup;
 648                 else
 649                         self.respawntime = g_pickup_respawntime_weapon;
 650         }
 651
 652         if(self.classname != "droppedweapon" && self.classname != "replacedweapon")
 653         {
 654                 e = get_weaponinfo(wpn);
 655                 s = cvar_string(strcat("g_weaponreplace_", e.netname));
 656                 if(s == "0")
 657                 {
 658                         remove(self);
 659                         startitem_failed = TRUE;
 660                         return;
 661                 }
 662                 t = tokenize_sane(s);
 663                 if(t >= 2)
 664                 {
 665                         self.team = --internalteam;
 666                         oldself = self;
 667                         for(i = 1; i < t; ++i)
 668                         {
 669                                 s = argv(i);
 670                                 for(j = WEP_FIRST; j <= WEP_LAST; ++j)
 671                                 {
 672                                         e = get_weaponinfo(j);
 673                                         if(e.netname == s)
 674                                         {
 675                                                 self = spawn();
 676                                                 copyentity(oldself, self);
 677                                                 self.classname = "replacedweapon";
 678                                                 weapon_defaultspawnfunc(j);
 679                                                 break;
 680                                         }
 681                                 }
 682                                 if(j > WEP_LAST)
 683                                 {
 684                                         print("The weapon replace list for ", oldself.classname, " contains an unknown weapon ", s, ". Skipped.\n");
 685                                 }
 686                         }
 687                         self = oldself;
 688                 }
 689                 if(t >= 1)
 690                 {
 691                         s = argv(0);
 692                         wpn = 0;
 693                         for(j = WEP_FIRST; j <= WEP_LAST; ++j)
 694                         {
 695                                 e = get_weaponinfo(j);
 696                                 if(e.netname == s)
 697                                 {
 698                                         wpn = j;
 699                                         break;
 700                                 }
 701                         }
 702                         if(j > WEP_LAST)
 703                         {
 704                                 print("The weapon replace list for ", self.classname, " contains an unknown weapon ", s, ". Skipped.\n");
 705                         }
 706                 }
 707                 if(wpn == 0)
 708                 {
 709                         remove(self);
 710                         startitem_failed = TRUE;
 711                         return;
 712                 }
 713         }
 714
 715         e = get_weaponinfo(wpn);
 716
 717         if(e.items && e.items != IT_SUPERWEAPON)
 718         {
 719                 ammofield = Item_CounterField(e.items);
 720                 if(!self.ammofield)
 721                         self.ammofield = cvar(strcat("g_pickup_", Item_CounterFieldName(e.items)));
 722         }
 723         else
 724         {
 725                 self.flags |= FL_NO_WEAPON_STAY;
 726         }
 727
 728         // weapon stay isn't supported for teamed weapons
 729         if(self.team)
 730                 self.flags |= FL_NO_WEAPON_STAY;
 731
 732         if(g_weapon_stay == 2 && self.classname != "droppedweapon")
 733         {
 734                 self.ammo_shells = 0;
 735                 self.ammo_nails = 0;
 736                 self.ammo_cells = 0;
 737                 self.ammo_rockets = 0;
 738                 // weapon stay 2: don't use ammo on weapon pickups; instead
 739                 // initialize all ammo types to the pickup ammo unless set by g_start_ammo_*
 740         }
 741
 742         StartItem(e.model, "weapons/weaponpickup.wav", self.respawntime, e.message, 0, e.weapons, FL_WEAPON, weapon_pickupevalfunc, e.bot_pickupbasevalue);
 743         if (self.modelindex) // don't precache if self was removed
 744                 weapon_action(e.weapon, WR_PRECACHE);
 745 }
 746
 747 void spawnfunc_weapon_shotgun (void);
 748 void spawnfunc_weapon_uzi (void) {
 749         if(q3acompat_machineshotgunswap)
 750         if(self.classname != "droppedweapon")
 751         {
 752                 weapon_defaultspawnfunc(WEP_SHOTGUN);
 753                 return;
 754         }
 755         weapon_defaultspawnfunc(WEP_UZI);
 756 }
 757
 758 void spawnfunc_weapon_shotgun (void) {
 759         if(q3acompat_machineshotgunswap)
 760         if(self.classname != "droppedweapon")
 761         {
 762                 weapon_defaultspawnfunc(WEP_UZI);
 763                 return;
 764         }
 765         weapon_defaultspawnfunc(WEP_SHOTGUN);
 766 }
 767
 768 void spawnfunc_weapon_nex (void)
 769 {
 770         if (g_minstagib)
 771         {
 772                 minstagib_items(IT_CELLS);
 773                 self.think = minst_remove_item;
 774                 self.nextthink = time;
 775                 return;
 776         }
 777         weapon_defaultspawnfunc(WEP_NEX);
 778 }
 779
 780 void spawnfunc_weapon_minstanex (void)
 781 {
 782         if (g_minstagib)
 783         {
 784                 minstagib_items(IT_CELLS);
 785                 self.think = minst_remove_item;
 786                 self.nextthink = time;
 787                 return;
 788         }
 789         weapon_defaultspawnfunc(WEP_MINSTANEX);
 790 }
 791
 792 void spawnfunc_weapon_rocketlauncher (void)
 793 {
 794         if (g_minstagib)
 795         {
 796                 minstagib_items(IT_CELLS);
 797                 self.think = minst_remove_item;
 798                 self.nextthink = time;
 799                 return;
 800         }
 801         weapon_defaultspawnfunc(WEP_ROCKET_LAUNCHER);
 802 }
 803
 804 void spawnfunc_item_rockets (void) {
 805         if(!self.ammo_rockets)
 806                 self.ammo_rockets = g_pickup_rockets;
 807         StartItem ("models/items/a_rockets.md3", "misc/itempickup.wav", g_pickup_respawntime_ammo, "rockets", IT_ROCKETS, 0, 0, commodity_pickupevalfunc, 3000);
 808 }
 809
 810 void spawnfunc_item_shells (void);
 811 void spawnfunc_item_bullets (void) {
 812         if(!weaponswapping)
 813         if(q3acompat_machineshotgunswap)
 814         if(self.classname != "droppedweapon")
 815         {
 816                 weaponswapping = TRUE;
 817                 spawnfunc_item_shells();
 818                 weaponswapping = FALSE;
 819                 return;
 820         }
 821
 822         if(!self.ammo_nails)
 823                 self.ammo_nails = g_pickup_nails;
 824         StartItem ("models/items/a_bullets.mdl", "misc/itempickup.wav", g_pickup_respawntime_ammo, "bullets", IT_NAILS, 0, 0, commodity_pickupevalfunc, 2000);
 825 }
 826
 827 void spawnfunc_item_cells (void) {
 828         if(!self.ammo_cells)
 829                 self.ammo_cells = g_pickup_cells;
 830         StartItem ("models/items/a_cells.md3", "misc/itempickup.wav", g_pickup_respawntime_ammo, "cells", IT_CELLS, 0, 0, commodity_pickupevalfunc, 2000);
 831 }
 832
 833 void spawnfunc_item_shells (void) {
 834         if(!weaponswapping)
 835         if(q3acompat_machineshotgunswap)
 836         if(self.classname != "droppedweapon")
 837         {
 838                 weaponswapping = TRUE;
 839                 spawnfunc_item_bullets();
 840                 weaponswapping = FALSE;
 841                 return;
 842         }
 843
 844         if(!self.ammo_shells)
 845                 self.ammo_shells = g_pickup_shells;
 846         StartItem ("models/items/a_shells.md3", "misc/itempickup.wav", g_pickup_respawntime_ammo, "shells", IT_SHELLS, 0, 0, commodity_pickupevalfunc, 500);
 847 }
 848
 849 void spawnfunc_item_armor_small (void) {
 850         if(!self.armorvalue)
 851                 self.armorvalue = g_pickup_armorsmall;
 852         if(!self.max_armorvalue)
 853                 self.max_armorvalue = g_pickup_armorsmall_max;
 854         StartItem ("models/items/g_a1.md3", "misc/armor1.wav", g_pickup_respawntime_short, "5 Armor", IT_ARMOR_SHARD, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_LOW);
 855 }
 856
 857 void spawnfunc_item_armor_medium (void) {
 858         if(!self.armorvalue)
 859                 self.armorvalue = g_pickup_armormedium;
 860         if(!self.max_armorvalue)
 861                 self.max_armorvalue = g_pickup_armormedium_max;
 862         StartItem ("models/items/g_armormedium.md3", "misc/armor10.wav", g_pickup_respawntime_medium, "25 Armor", IT_ARMOR, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_MID);
 863 }
 864
 865 void spawnfunc_item_armor_big (void) {
 866         if(!self.armorvalue)
 867                 self.armorvalue = g_pickup_armorbig;
 868         if(!self.max_armorvalue)
 869                 self.max_armorvalue = g_pickup_armorbig_max;
 870         StartItem ("models/items/g_a50.md3", "misc/armor17_5.wav", g_pickup_respawntime_long, "50 Armor", IT_ARMOR, 0, 0, commodity_pickupevalfunc, 20000);
 871 }
 872
 873 void spawnfunc_item_armor_large (void) {
 874         if(!self.armorvalue)
 875                 self.armorvalue = g_pickup_armorlarge;
 876         if(!self.max_armorvalue)
 877                 self.max_armorvalue = g_pickup_armorlarge_max;
 878         StartItem ("models/items/g_a25.md3", "misc/armor25.wav", g_pickup_respawntime_long, "100 Armor", IT_ARMOR, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_HIGH);
 879 }
 880
 881 void spawnfunc_item_health_small (void) {
 882         if(!self.max_health)
 883                 self.max_health = g_pickup_healthsmall_max;
 884         if(!self.health)
 885                 self.health = g_pickup_healthsmall;
 886         StartItem ("models/items/g_h1.md3", "misc/minihealth.wav", g_pickup_respawntime_short, "5 Health", IT_5HP, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_LOW);
 887 }
 888
 889 void spawnfunc_item_health_medium (void) {
 890         if(!self.max_health)
 891                 self.max_health = g_pickup_healthmedium_max;
 892         if(!self.health)
 893                 self.health = g_pickup_healthmedium;
 894         StartItem ("models/items/g_h25.md3", "misc/mediumhealth.wav", g_pickup_respawntime_short, "25 Health", IT_25HP, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_MID);
 895 }
 896
 897 void spawnfunc_item_health_large (void) {
 898         if(!self.max_health)
 899                 self.max_health = g_pickup_healthlarge_max;
 900         if(!self.health)
 901                 self.health = g_pickup_healthlarge;
 902         StartItem ("models/items/g_h50.md3", "misc/mediumhealth.wav", g_pickup_respawntime_medium, "50 Health", IT_25HP, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_MID);
 903 }
 904
 905 void spawnfunc_item_health_mega (void) {
 906         if(!cvar("g_powerup_superhealth"))
 907                 return;
 908
 909         if(g_arena && !cvar("g_arena_powerups"))
 910                 return;
 911
 912         if(g_minstagib) {
 913                 minstagib_items(IT_NAILS);
 914         } else {
 915                 if(!self.max_health)
 916                         self.max_health = g_pickup_healthmega_max;
 917                 if(!self.health)
 918                         self.health = g_pickup_healthmega;
 919                 StartItem ("models/items/g_h100.md3", "misc/megahealth.wav", g_pickup_respawntime_long, "100 Health", IT_HEALTH, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_HIGH);
 920         }
 921 }
 922
 923 // support old misnamed entities
 924 void spawnfunc_item_armor1() { spawnfunc_item_armor_small(); }  // FIXME: in Quake this is green armor, in Nexuiz maps it is an armor shard
 925 void spawnfunc_item_armor25() { spawnfunc_item_armor_large(); }
 926 void spawnfunc_item_health1() { spawnfunc_item_health_small(); }
 927 void spawnfunc_item_health25() { spawnfunc_item_health_medium(); }
 928 void spawnfunc_item_health100() { spawnfunc_item_health_mega(); }
 929
 930 void spawnfunc_item_strength (void) {
 931         if(!cvar("g_powerup_strength"))
 932                 return;
 933
 934         if(g_arena && !cvar("g_arena_powerups"))
 935                 return;
 936
 937         if(g_minstagib) {
 938                 minstagib_items(IT_STRENGTH);
 939         } else {
 940                 precache_sound("weapons/strength_fire.wav");
 941                 self.strength_finished = 30;
 942                 self.effects = EF_ADDITIVE;
 943                 StartItem ("models/items/g_strength.md3", "misc/powerup.wav", g_pickup_respawntime_powerup, "Strength Powerup", IT_STRENGTH, 0, FL_POWERUP, generic_pickupevalfunc, 100000);
 944         }
 945 }
 946
 947 void spawnfunc_item_invincible (void) {
 948         if(!cvar("g_powerup_shield"))
 949                 return;
 950
 951         if(g_arena && !cvar("g_arena_powerups"))
 952                 return;
 953
 954         if(g_minstagib) {
 955                 minstagib_items(IT_INVINCIBLE);
 956         } else {
 957                 self.invincible_finished = 30;
 958                 self.effects = EF_ADDITIVE;
 959                 StartItem ("models/items/g_invincible.md3", "misc/powerup_shield.wav", g_pickup_respawntime_powerup, "Invulnerability", IT_INVINCIBLE, 0, FL_POWERUP, generic_pickupevalfunc, 100000);
 960         }
 961 }
 962
 963 void spawnfunc_item_minst_cells (void) {
 964         if (g_minstagib)
 965         {
 966                 minst_no_auto_cells = 1;
 967                 minstagib_items(IT_CELLS);
 968         }
 969         else
 970                 remove(self);
 971 }
 972
 973 // compatibility:
 974 void spawnfunc_item_quad (void) {self.classname = "item_strength";spawnfunc_item_strength();}
 975
 976 void spawnfunc_misc_models (void)
 977 {
 978         // exists as alias name for 2.4.2 compat
 979         SetBrushEntityModel();
 980 }
 981
 982 void spawnfunc_func_static (void)
 983 {
 984         // exists as alias name for having it with brushes
 985         SetBrushEntityModel();
 986 }
 987
 988 void func_wall_use (void)
 989 {
 990         if(teams_matter)
 991         {
 992                 if(activator.team)
 993                         self.colormap = (activator.team - 1) * 0x11;
 994                 else
 995                         self.colormap = 0x00;
 996         }
 997         else
 998                 self.colormap = floor(random() * 256);
 999         self.colormap |= 1024; // RENDER_COLORMAPPED
1000 }
1001
1002 void spawnfunc_func_wall (void)
1003 {
1004         SetBrushEntityModel();
1005         if(!self.solid)
1006                 self.solid = SOLID_BSP;
1007         self.use = func_wall_use;
1008 }
1009
1010 void spawnfunc_func_illusionary (void)
1011 {
1012         SetBrushEntityModel();
1013         self.use = func_wall_use;
1014 }
1015
1016 void gamemodel_drop()
1017 {
1018         if(self.spawnflags & 3 == 1) // ALIGN_ORIGIN
1019         {
1020                 traceline(self.origin, self.origin - '0 0 4096', MOVE_NOMONSTERS, self);
1021                 setorigin(self, trace_endpos);
1022         }
1023         else if(self.spawnflags & 3 == 2) // ALIGN_BOTTOM
1024         {
1025                 tracebox(self.origin, self.mins, self.maxs, self.origin - '0 0 4096', MOVE_NOMONSTERS, self);
1026                 setorigin(self, trace_endpos);
1027         }
1028         else if(self.spawnflags & 3 == 3) // ALIGN_ORIGIN | ALIGN_BOTTOM
1029         {
1030                 traceline(self.origin, self.origin - '0 0 4096', MOVE_NOMONSTERS, self);
1031                 setorigin(self, trace_endpos - '0 0 1' * self.mins_z);
1032         }
1033 }
1034
1035 .float modelscale;
1036 void spawnfunc_misc_gamemodel (void)
1037 {
1038         if(!self.scale)
1039                 self.scale = self.modelscale;
1040         SetBrushEntityModel();
1041         self.use = func_wall_use;
1042
1043         InitializeEntity(self, gamemodel_drop, INITPRIO_DROPTOFLOOR);
1044 }
1045
1046 float target_item_func_set(float a, float b)
1047 {
1048         if(b == 0)
1049                 return a;
1050         else if(b < 0)
1051                 return 0;
1052         else
1053                 return b;
1054 }
1055
1056 float target_item_func_min(float a, float b)
1057 {
1058         if(b == 0)
1059                 return a;
1060         else if(b < 0)
1061                 return 0;
1062         else
1063                 return min(a, b);
1064 }
1065
1066 float target_item_func_max(float a, float b)
1067 {
1068         return max(a, b);
1069 }
1070
1071 float target_item_func_bitset(float a, float b)
1072 {
1073         return b;
1074 }
1075
1076 float target_item_func_and(float a, float b)
1077 {
1078         return a & b;
1079 }
1080
1081 float target_item_func_itembitset(float a, float b)
1082 {
1083         return (a - (a & (IT_UNLIMITED_WEAPON_AMMO | IT_STRENGTH | IT_INVINCIBLE))) | b;
1084 }
1085
1086 float target_item_func_itemand(float a, float b)
1087 {
1088         return (a - (a & (IT_UNLIMITED_WEAPON_AMMO | IT_STRENGTH | IT_INVINCIBLE))) | (a & b);
1089 }
1090
1091 float target_item_func_or(float a, float b)
1092 {
1093         return a | b;
1094 }
1095
1096 float target_item_func_andnot(float a, float b)
1097 {
1098         return a - (a & b);
1099 }
1100
1101 float target_item_changed;
1102 void target_item_change(float binary, .float field, float(float a, float b) func, string sound_increase, string sound_decrease)
1103 {
1104         float n, d;
1105         n = func(activator.field, self.field);
1106
1107         if(binary)
1108         {
1109                 d = n & activator.field;
1110                 if(d != n) // bits added?
1111                         d = +1;
1112                 else if(d != activator.field) // bits removed?
1113                         d = -1;
1114                 else
1115                         d = 0;
1116         }
1117         else
1118                 d = n - activator.field;
1119
1120         if(d < 0)
1121         {
1122                 if(sound_decrease != "")
1123                         sound (activator, CHAN_AUTO, sound_decrease, VOL_BASE, ATTN_NORM);
1124                 target_item_changed = 1;
1125         }
1126         else if(d > 0)
1127         {
1128                 if(sound_increase != "")
1129                         sound (activator, CHAN_AUTO, sound_increase, VOL_BASE, ATTN_NORM);
1130                 target_item_changed = 1;
1131         }
1132         activator.field = n;
1133 }
1134
1135 void target_items_use (void)
1136 {
1137         float h0, a0;
1138         if(activator.classname != "player")
1139                 return;
1140         if(activator.deadflag != DEAD_NO)
1141                 return;
1142         EXACTTRIGGER_TOUCH;
1143
1144         entity e;
1145         for(e = world; (e = find(e, classname, "droppedweapon")); )
1146                 if(e.enemy == activator)
1147                         remove(e);
1148
1149         float _switchweapon;
1150         _switchweapon = FALSE;
1151         if (activator.autoswitch)
1152                 if (activator.switchweapon == w_getbestweapon(activator))
1153                         _switchweapon = TRUE;
1154
1155         a0 = activator.armorvalue;
1156         h0 = activator.health;
1157         target_item_changed = 0;
1158
1159         if(self.spawnflags == 0) // SET
1160         {
1161                 target_item_change(0, ammo_shells, target_item_func_set, "misc/itempickup.wav", "");
1162                 target_item_change(0, ammo_nails, target_item_func_set, "misc/itempickup.wav", "");
1163                 target_item_change(0, ammo_rockets, target_item_func_set, "misc/itempickup.wav", "");
1164                 target_item_change(0, ammo_cells, target_item_func_set, "misc/itempickup.wav", "");
1165                 target_item_change(0, health, target_item_func_set, "misc/megahealth.wav", "");
1166                 target_item_change(0, armorvalue, target_item_func_set, "misc/armor25.wav", "");
1167                 target_item_change(1, items, target_item_func_itembitset, "misc/powerup.wav", "");
1168                 target_item_change(1, weapons, target_item_func_bitset, "weapons/weaponpickup.wav", "");
1169
1170                 if((self.items & activator.items) & IT_STRENGTH)
1171                         activator.strength_finished = time + self.strength_finished;
1172                 if((self.items & activator.items) & IT_INVINCIBLE)
1173                         activator.invincible_finished = time + self.invincible_finished;
1174         }
1175         else if(self.spawnflags == 1) // AND/MIN
1176         {
1177                 target_item_change(0, ammo_shells, target_item_func_min, "misc/itempickup.wav", "");
1178                 target_item_change(0, ammo_nails, target_item_func_min, "misc/itempickup.wav", "");
1179                 target_item_change(0, ammo_rockets, target_item_func_min, "misc/itempickup.wav", "");
1180                 target_item_change(0, ammo_cells, target_item_func_min, "misc/itempickup.wav", "");
1181                 target_item_change(0, health, target_item_func_min, "misc/megahealth.wav", "");
1182                 target_item_change(0, armorvalue, target_item_func_min, "misc/armor25.wav", "");
1183                 target_item_change(1, items, target_item_func_itemand, "misc/powerup.wav", "");
1184                 target_item_change(1, weapons, target_item_func_and, "weapons/weaponpickup.wav", "");
1185
1186                 if((self.items & activator.items) & IT_STRENGTH)
1187                         activator.strength_finished = min(activator.strength_finished, time + self.strength_finished);
1188                 if((self.items & activator.items) & IT_INVINCIBLE)
1189                         activator.invincible_finished = min(activator.invincible_finished, time + self.invincible_finished);
1190         }
1191         else if(self.spawnflags == 2) // OR/MAX
1192         {
1193                 target_item_change(0, ammo_shells, target_item_func_max, "misc/itempickup.wav", "");
1194                 target_item_change(0, ammo_nails, target_item_func_max, "misc/itempickup.wav", "");
1195                 target_item_change(0, ammo_rockets, target_item_func_max, "misc/itempickup.wav", "");
1196                 target_item_change(0, ammo_cells, target_item_func_max, "misc/itempickup.wav", "");
1197                 target_item_change(0, health, target_item_func_max, "misc/megahealth.wav", "");
1198                 target_item_change(0, armorvalue, target_item_func_max, "misc/armor25.wav", "");
1199                 target_item_change(1, items, target_item_func_or, "misc/powerup.wav", "");
1200                 target_item_change(1, weapons, target_item_func_or, "weapons/weaponpickup.wav", "");
1201
1202                 if((self.items & activator.items) & IT_STRENGTH)
1203                         activator.strength_finished = max(activator.strength_finished, time + self.strength_finished);
1204                 if((self.items & activator.items) & IT_INVINCIBLE)
1205                         activator.invincible_finished = max(activator.invincible_finished, time + self.invincible_finished);
1206         }
1207         else if(self.spawnflags == 4) // ANDNOT/MIN
1208         {
1209                 target_item_change(0, ammo_shells, target_item_func_min, "misc/itempickup.wav", "");
1210                 target_item_change(0, ammo_nails, target_item_func_min, "misc/itempickup.wav", "");
1211                 target_item_change(0, ammo_rockets, target_item_func_min, "misc/itempickup.wav", "");
1212                 target_item_change(0, ammo_cells, target_item_func_min, "misc/itempickup.wav", "");
1213                 target_item_change(0, health, target_item_func_min, "misc/megahealth.wav", "");
1214                 target_item_change(0, armorvalue, target_item_func_min, "misc/armor25.wav", "");
1215                 target_item_change(1, items, target_item_func_andnot, "misc/powerup.wav", "");
1216                 target_item_change(1, weapons, target_item_func_andnot, "weapons/weaponpickup.wav", "");
1217
1218                 if((self.items & activator.items) & IT_STRENGTH)
1219                         activator.strength_finished = min(activator.strength_finished, time + self.strength_finished);
1220                 if((self.items & activator.items) & IT_INVINCIBLE)
1221                         activator.invincible_finished = min(activator.invincible_finished, time + self.invincible_finished);
1222         }
1223
1224         if not(activator.items & IT_STRENGTH)
1225                 activator.strength_finished = 0;
1226         if not(activator.items & IT_INVINCIBLE)
1227                 activator.invincible_finished = 0;
1228
1229         if(activator.health > h0)
1230                 activator.pauserothealth_finished = max(activator.pauserothealth_finished, time + cvar("g_balance_pause_health_rot"));
1231         else if(activator.health < h0)
1232                 activator.pauseregen_finished = max(activator.pauseregen_finished, time + cvar("g_balance_pause_health_regen"));
1233
1234         if(activator.armorvalue > a0)
1235                 activator.pauserotarmor_finished = max(activator.pauserothealth_finished, time + cvar("g_balance_pause_health_rot"));
1236
1237         if not(activator.weapons & W_WeaponBit(activator.switchweapon))
1238                 _switchweapon = TRUE;
1239         if(_switchweapon)
1240                 W_SwitchWeapon_Force(activator, w_getbestweapon(activator));
1241
1242         if(target_item_changed)
1243                 centerprint(activator, self.message);
1244 }
1245
1246 void spawnfunc_target_items (void)
1247 {
1248         float n, i, j;
1249         entity e;
1250         self.use = target_items_use;
1251         if(!self.strength_finished)
1252                 self.strength_finished = cvar("g_balance_powerup_strength_time");
1253         if(!self.invincible_finished)
1254                 self.invincible_finished = cvar("g_balance_powerup_invincible_time");
1255
1256         precache_sound("misc/itempickup.wav");
1257         precache_sound("misc/itempickup.wav");
1258         precache_sound("misc/itempickup.wav");
1259         precache_sound("misc/itempickup.wav");
1260         precache_sound("misc/megahealth.wav");
1261         precache_sound("misc/armor25.wav");
1262         precache_sound("misc/powerup.wav");
1263         precache_sound("weapons/weaponpickup.wav");
1264
1265         n = tokenize_sane(self.netname);
1266         for(i = 0; i < n; ++i)
1267         {
1268                 if(argv(i) == "unlimited_ammo")         self.items |= IT_UNLIMITED_AMMO;
1269                 if(argv(i) == "unlimited_weapon_ammo")  self.items |= IT_UNLIMITED_WEAPON_AMMO;
1270                 if(argv(i) == "unlimited_superweapons") self.items |= IT_UNLIMITED_SUPERWEAPONS;
1271                 if(argv(i) == "strength")               self.items |= IT_STRENGTH;
1272                 if(argv(i) == "invincible")             self.items |= IT_INVINCIBLE;
1273                 for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1274                 {
1275                         e = get_weaponinfo(j);
1276                         if(argv(i) == e.netname)
1277                         {
1278                                 self.weapons |= e.weapons;
1279                                 if(self.spawnflags == 0 || self.spawnflags == 2)
1280                                         weapon_action(e.weapon, WR_PRECACHE);
1281                         }
1282                 }
1283         }
1284 }