data/qcsrc/server/t_items.qc

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