data/qcsrc/server/t_items.qc

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