qcsrc/server/t_items.qc

   1 #define ISF_SETUP 0xFFFFFF
   2 #define ISF_LOCATION 2
   3 #define ISF_STATUS   4
   4 #define ISF_MODEL    8
   5 #define ISF_RESPAWN  16 // for item watch
   6 #define ISF_FLAGS   32
   7
   8 #ifdef CSQC
   9 // FIXME: Move this to ../common/constants.qh?
  10 float   FL_FLY                                  = 1;
  11 float   FL_SWIM                                 = 2;
  12 float   FL_CLIENT                               = 8;
  13 float   FL_INWATER                              = 16;
  14 float   FL_MONSTER                              = 32;
  15 float   FL_GODMODE                              = 64;
  16 float   FL_NOTARGET                             = 128;
  17 float   FL_ITEM                                 = 256;
  18 float   FL_ONGROUND                             = 512;
  19 float   FL_PARTIALGROUND                        = 1024;
  20 float   FL_WATERJUMP                            = 2048;
  21 float   FL_JUMPRELEASED                         = 4096;
  22 float   FL_WEAPON                               = 8192;
  23 float   FL_POWERUP                              = 16384;
  24 float   FL_PROJECTILE                           = 32768;
  25 float   FL_TOSSED                               = 65536;
  26 float   FL_NO_WEAPON_STAY       = 131072;
  27 float   FL_SPAWNING       = 262144;
  28 /////
  29
  30 .float lastupdate;
  31 .vector colormod;
  32 void ItemDraw()
  33 {
  34     float _delta = time - self.lastupdate;
  35     self.lastupdate = time;
  36     if(_delta >= 0.1)
  37         return;
  38
  39     if(self.solid == SOLID_TRIGGER)
  40     {
  41         self.alpha = 0.5;
  42         self.colormod = '-1 -1 -1';
  43     }
  44     else
  45     {
  46         self.alpha = 1;
  47         self.colormod = '1 1 1';
  48     }
  49
  50     if(self.flags & FL_WEAPON)
  51     {
  52         self.angles += '0 180 0' * _delta;
  53         setorigin(self, '0 0 16' + self.oldorigin + '0 0 8' * sin(time * 2));
  54     }
  55 }
  56
  57 void ItemDrawSimple()
  58 {
  59
  60 }
  61
  62 void ItemRead(float _IsNew)
  63 {
  64     float sf = ReadByte();
  65     float _taken = (self.solid == SOLID_TRIGGER) ? TRUE: FALSE;
  66
  67     if(sf & ISF_LOCATION)
  68     {
  69         self.origin_x = ReadCoord();
  70         self.origin_y = ReadCoord();
  71         self.origin_z = ReadCoord();
  72         setorigin(self, self.origin);
  73         self.oldorigin = self.origin;
  74     }
  75
  76     if(sf & ISF_STATUS)
  77     {
  78         _taken = ReadByte();
  79         if(_taken)
  80             self.solid = SOLID_NOT;
  81         else
  82             self.solid = SOLID_TRIGGER;
  83     }
  84
  85     if(sf & ISF_MODEL) // handle simple itens here
  86     {
  87         if(self.mdl)
  88             strunzone(self.mdl);
  89         else
  90         {
  91             self.draw      = ItemDraw;
  92             self.drawmask = MASK_NORMAL;
  93             self.movetype  = MOVETYPE_NOCLIP;
  94         }
  95
  96         self.mdl = strzone(ReadString());
  97         setmodel(self, self.mdl);
  98     }
  99
 100     if(sf & ISF_FLAGS)
 101         self.flags = ReadCoord();
 102 }
 103 #endif
 104
 105 #ifdef SVQC
 106 float ItemSend(entity to, float sf)
 107 {
 108         WriteByte(MSG_ENTITY, ENT_CLIENT_ITEM);
 109
 110         WriteByte(MSG_ENTITY, sf);
 111
 112         //WriteByte(MSG_ENTITY, self.cnt);
 113     if(sf & ISF_LOCATION)
 114     {
 115         WriteCoord(MSG_ENTITY, self.origin_x);
 116         WriteCoord(MSG_ENTITY, self.origin_y);
 117         WriteCoord(MSG_ENTITY, self.origin_z);
 118     }
 119
 120     if(sf & ISF_STATUS)
 121         WriteByte(MSG_ENTITY, (self.solid == SOLID_TRIGGER) ? TRUE: FALSE);
 122
 123     if(sf & ISF_MODEL)
 124         WriteString(MSG_ENTITY, self.mdl);
 125
 126     if(sf & ISF_FLAGS)
 127         WriteCoord(MSG_ENTITY, self.flags);
 128
 129     return TRUE;
 130 }
 131
 132
 133 float have_pickup_item(void)
 134 {
 135         // minstagib: only allow filtered items
 136         if(g_minstagib)
 137                 if(self.classname != "minstagib")
 138                         return FALSE;
 139
 140         if(self.flags & FL_POWERUP)
 141         {
 142                 if(autocvar_g_powerups > 0)
 143                         return TRUE;
 144                 if(autocvar_g_powerups == 0)
 145                         return FALSE;
 146                 if(g_lms)
 147                         return FALSE;
 148                 if(g_ca)
 149                         return FALSE;
 150                 if(g_arena)
 151                         return FALSE;
 152         }
 153         else
 154         {
 155                 if(autocvar_g_pickup_items > 0)
 156                         return TRUE;
 157                 if(autocvar_g_pickup_items == 0)
 158                         return FALSE;
 159                 if(g_lms)
 160                         return FALSE;
 161                 if(g_ca)
 162                         return FALSE;
 163                 if(g_weaponarena)
 164                         if((self.weapons & WEPBIT_ALL) || (self.items & IT_AMMO))
 165                                 return FALSE;
 166         }
 167         return TRUE;
 168 }
 169
 170 #define ITEM_RESPAWN_TICKS 10
 171
 172 #define ITEM_RESPAWNTIME(i)         ((i).respawntime + crandom() * (i).respawntimejitter)
 173         // range: respawntime - respawntimejitter .. respawntime + respawntimejitter
 174 #define ITEM_RESPAWNTIME_INITIAL(i) (ITEM_RESPAWN_TICKS + random() * ((i).respawntime + (i).respawntimejitter - ITEM_RESPAWN_TICKS))
 175         // range: 10 .. respawntime + respawntimejitter
 176
 177 floatfield Item_CounterField(float it)
 178 {
 179         switch(it)
 180         {
 181                 case IT_SHELLS:      return ammo_shells;
 182                 case IT_NAILS:       return ammo_nails;
 183                 case IT_ROCKETS:     return ammo_rockets;
 184                 case IT_CELLS:       return ammo_cells;
 185                 case IT_FUEL:        return ammo_fuel;
 186                 case IT_5HP:         return health;
 187                 case IT_25HP:        return health;
 188                 case IT_HEALTH:      return health;
 189                 case IT_ARMOR_SHARD: return armorvalue;
 190                 case IT_ARMOR:       return armorvalue;
 191                 // add more things here (health, armor)
 192                 default:             error("requested item has no counter field");
 193         }
 194 }
 195
 196 string Item_CounterFieldName(float it)
 197 {
 198         switch(it)
 199         {
 200                 case IT_SHELLS:      return "shells";
 201                 case IT_NAILS:       return "nails";
 202                 case IT_ROCKETS:     return "rockets";
 203                 case IT_CELLS:       return "cells";
 204                 case IT_FUEL:        return "fuel";
 205
 206                 // add more things here (health, armor)
 207                 default:             error("requested item has no counter field name");
 208         }
 209 }
 210
 211 .float max_armorvalue;
 212 .float pickup_anyway;
 213
 214 float Item_Customize()
 215 {
 216         if(self.spawnshieldtime)
 217                 return TRUE;
 218         if(self.weapons != (self.weapons & other.weapons))
 219         {
 220                 self.colormod = '0 0 0';
 221                 self.glowmod = self.colormod;
 222                 self.alpha = 0.5 + 0.5 * g_ghost_items; // halfway more alpha
 223                 return TRUE;
 224         }
 225         else
 226         {
 227                 if(g_ghost_items)
 228                 {
 229                         self.colormod = stov(autocvar_g_ghost_items_color);
 230                         self.glowmod = self.colormod;
 231                         self.alpha = g_ghost_items;
 232                         return TRUE;
 233                 }
 234                 else
 235                         return FALSE;
 236         }
 237 }
 238
 239 void Item_Show (entity e, float mode)
 240 {
 241         e.effects &~= EF_ADDITIVE | EF_STARDUST | EF_FULLBRIGHT | EF_NODEPTHTEST;
 242         if (mode > 0)
 243         {
 244                 // make the item look normal, and be touchable
 245                 e.model = e.mdl;
 246                 e.solid = SOLID_TRIGGER;
 247                 e.colormod = '0 0 0';
 248                 self.glowmod = self.colormod;
 249                 e.alpha = 0;
 250                 //e.customizeentityforclient = func_null;
 251
 252                 e.spawnshieldtime = 1;
 253         }
 254         else if (mode < 0)
 255         {
 256                 // hide the item completely
 257                 e.model = string_null;
 258                 e.solid = SOLID_NOT;
 259                 e.colormod = '0 0 0';
 260                 self.glowmod = self.colormod;
 261                 e.alpha = 0;
 262                 //e.customizeentityforclient = func_null;
 263
 264                 e.spawnshieldtime = 1;
 265         }
 266         else if((e.flags & FL_WEAPON) && !(e.flags & FL_NO_WEAPON_STAY) && g_weapon_stay)
 267         {
 268                 // make the item translucent and not touchable
 269                 e.model = e.mdl;
 270                 e.solid = SOLID_TRIGGER; // can STILL be picked up!
 271                 e.colormod = '0 0 0';
 272                 self.glowmod = self.colormod;
 273                 e.effects |= EF_STARDUST;
 274                 //e.customizeentityforclient = Item_Customize;
 275
 276                 e.spawnshieldtime = 0; // field indicates whether picking it up may give you anything other than the weapon
 277         }
 278         else if(g_ghost_items)
 279         {
 280                 // make the item translucent and not touchable
 281                 e.model = e.mdl;
 282                 e.solid = SOLID_NOT;
 283                 e.colormod = stov(autocvar_g_ghost_items_color);
 284                 e.glowmod = e.colormod;
 285                 e.alpha = g_ghost_items;
 286                 //e.customizeentityforclient = func_null;
 287
 288                 e.spawnshieldtime = 1;
 289         }
 290         else
 291         {
 292                 // hide the item completely
 293                 e.model = string_null;
 294                 e.solid = SOLID_NOT;
 295                 e.colormod = '0 0 0';
 296                 e.glowmod = e.colormod;
 297                 e.alpha = 0;
 298                 //e.customizeentityforclient = func_null;
 299
 300                 e.spawnshieldtime = 1;
 301         }
 302
 303         if (e.items & (IT_STRENGTH | IT_INVINCIBLE))
 304                 e.effects |= EF_ADDITIVE | EF_FULLBRIGHT;
 305         if (autocvar_g_nodepthtestitems)
 306                 e.effects |= EF_NODEPTHTEST;
 307         if (autocvar_g_fullbrightitems)
 308                 e.effects |= EF_FULLBRIGHT;
 309
 310         // relink entity (because solid may have changed)
 311         setorigin(e, e.origin);
 312     self.SendFlags |= ISF_STATUS;
 313
 314 }
 315
 316 void Item_Respawn (void)
 317 {
 318         Item_Show(self, 1);
 319         if(!g_minstagib && self.items == IT_STRENGTH)
 320                 sound (self, CH_TRIGGER, "misc/strength_respawn.wav", VOL_BASE, ATTN_NORM);     // play respawn sound
 321         else if(!g_minstagib && self.items == IT_INVINCIBLE)
 322                 sound (self, CH_TRIGGER, "misc/shield_respawn.wav", VOL_BASE, ATTN_NORM);       // play respawn sound
 323         else
 324                 sound (self, CH_TRIGGER, "misc/itemrespawn.wav", VOL_BASE, ATTN_NORM);  // play respawn sound
 325         setorigin (self, self.origin);
 326
 327         //pointparticles(particleeffectnum("item_respawn"), self.origin + self.mins_z * '0 0 1' + '0 0 48', '0 0 0', 1);
 328         pointparticles(particleeffectnum("item_respawn"), self.origin + 0.5 * (self.mins + self.maxs), '0 0 0', 1);
 329 }
 330
 331 void Item_RespawnCountdown (void)
 332 {
 333         if(self.count >= ITEM_RESPAWN_TICKS)
 334         {
 335                 if(self.waypointsprite_attached)
 336                         WaypointSprite_Kill(self.waypointsprite_attached);
 337                 Item_Respawn();
 338         }
 339         else
 340         {
 341                 self.nextthink = time + 1;
 342                 self.count += 1;
 343                 if(self.count == 1)
 344                 {
 345                         string name;
 346                         vector rgb;
 347                         name = string_null;
 348                         if(g_minstagib)
 349                         {
 350                                 switch(self.items)
 351                                 {
 352                                         case IT_STRENGTH:   name = "item-invis"; rgb = '0 0 1'; break;
 353                                         case IT_NAILS:      name = "item-extralife"; rgb = '1 0 0'; break;
 354                                         case IT_INVINCIBLE: name = "item-speed"; rgb = '1 0 1'; break;
 355                                 }
 356                         }
 357                         else
 358                         {
 359                                 switch(self.items)
 360                                 {
 361                                         case IT_STRENGTH:   name = "item-strength"; rgb = '0 0 1'; break;
 362                                         case IT_INVINCIBLE: name = "item-shield"; rgb = '1 0 1'; break;
 363                                 }
 364                         }
 365                         switch(self.items)
 366                         {
 367                                 case IT_FUEL_REGEN:     name = "item-fuelregen"; rgb = '1 0.5 0'; break;
 368                                 case IT_JETPACK:        name = "item-jetpack"; rgb = '0.5 0.5 0.5'; break;
 369                         }
 370                         if(self.flags & FL_WEAPON)
 371                         {
 372                                 entity wi = get_weaponinfo(self.weapon);
 373                                 if(wi)
 374                                 {
 375                                         name = wi.model2;
 376                                         rgb = '1 0 0';
 377                                 }
 378                         }
 379                         if(!name)
 380                         {
 381                                 print("Unknown powerup-marked item is wanting to respawn\n");
 382                                 localcmd(sprintf("prvm_edict server %d\n", num_for_edict(self)));
 383                         }
 384                         if(name)
 385                         {
 386                                 WaypointSprite_Spawn(name, 0, 0, self, '0 0 64', world, 0, self, waypointsprite_attached, TRUE, RADARICON_POWERUP, rgb);
 387                                 if(self.waypointsprite_attached)
 388                                         WaypointSprite_UpdateBuildFinished(self.waypointsprite_attached, time + ITEM_RESPAWN_TICKS);
 389                         }
 390                 }
 391                 sound (self, CH_TRIGGER, "misc/itemrespawncountdown.wav", VOL_BASE, ATTN_NORM); // play respawn sound
 392                 if(self.waypointsprite_attached)
 393                 {
 394                         WaypointSprite_Ping(self.waypointsprite_attached);
 395                         //WaypointSprite_UpdateHealth(self.waypointsprite_attached, self.count);
 396                 }
 397         }
 398 }
 399
 400 void Item_ScheduleRespawnIn(entity e, float t)
 401 {
 402         if((e.flags & FL_POWERUP) || (e.weapons & WEPBIT_SUPERWEAPONS))
 403         {
 404                 e.think = Item_RespawnCountdown;
 405                 e.nextthink = time + max(0, t - ITEM_RESPAWN_TICKS);
 406                 e.count = 0;
 407         }
 408         else
 409         {
 410                 e.think = Item_Respawn;
 411                 e.nextthink = time + t;
 412         }
 413 }
 414
 415 void Item_ScheduleRespawn(entity e)
 416 {
 417         if(e.respawntime > 0)
 418         {
 419                 Item_Show(e, 0);
 420                 Item_ScheduleRespawnIn(e, ITEM_RESPAWNTIME(e));
 421         }
 422         else // if respawntime is -1, this item does not respawn
 423                 Item_Show(e, -1);
 424 }
 425
 426 void Item_ScheduleInitialRespawn(entity e)
 427 {
 428         Item_Show(e, 0);
 429         Item_ScheduleRespawnIn(e, game_starttime - time + ITEM_RESPAWNTIME_INITIAL(e));
 430 }
 431
 432 float ITEM_MODE_NONE = 0;
 433 float ITEM_MODE_HEALTH = 1;
 434 float ITEM_MODE_ARMOR = 2;
 435 float ITEM_MODE_FUEL = 3;
 436 float Item_GiveAmmoTo(entity item, entity player, .float ammofield, float ammomax, float mode)
 437 {
 438         if (!item.ammofield)
 439                 return FALSE;
 440
 441         if (item.spawnshieldtime)
 442         {
 443                 if ((player.ammofield < ammomax) || item.pickup_anyway)
 444                 {
 445                         player.ammofield = bound(player.ammofield, ammomax, player.ammofield + item.ammofield);
 446                         goto YEAH;
 447                 }
 448         }
 449         else if(g_weapon_stay == 2)
 450         {
 451                 float mi = min(item.ammofield, ammomax);
 452                 if (player.ammofield < mi)
 453                 {
 454                         player.ammofield = mi;
 455                         goto YEAH;
 456                 }
 457         }
 458
 459         return FALSE;
 460
 461 :YEAH
 462         switch(mode)
 463         {
 464                 case ITEM_MODE_FUEL:
 465                         player.pauserotfuel_finished = max(player.pauserotfuel_finished, time + autocvar_g_balance_pause_fuel_rot);
 466                         break;
 467                 case ITEM_MODE_HEALTH:
 468                         player.pauserothealth_finished = max(player.pauserothealth_finished, time + autocvar_g_balance_pause_health_rot);
 469                         break;
 470                 case ITEM_MODE_ARMOR:
 471                         player.pauserotarmor_finished = max(player.pauserotarmor_finished, time + autocvar_g_balance_pause_armor_rot);
 472                         break;
 473                 default:
 474                         break;
 475         }
 476         return TRUE;
 477 }
 478
 479 float Item_GiveTo(entity item, entity player)
 480 {
 481         float _switchweapon;
 482         float pickedup;
 483         float it;
 484         float i;
 485         entity e;
 486
 487         // if nothing happens to player, just return without taking the item
 488         pickedup = FALSE;
 489         _switchweapon = FALSE;
 490
 491         if (g_minstagib)
 492         {
 493                 float prevcells = player.ammo_cells;
 494
 495                 pickedup |= Item_GiveAmmoTo(item, player, ammo_fuel, g_pickup_fuel_max, ITEM_MODE_FUEL);
 496                 pickedup |= Item_GiveAmmoTo(item, player, ammo_cells, 999, ITEM_MODE_NONE);
 497
 498                 if(player.ammo_cells > prevcells)
 499                 {
 500                         _switchweapon = TRUE;
 501
 502                         // play some cool sounds ;)
 503                         if (clienttype(player) == CLIENTTYPE_REAL)
 504                         {
 505                                 if(player.health <= 5)
 506                                         AnnounceTo(player, "lastsecond");
 507                                 else if(player.health < 50)
 508                                         AnnounceTo(player, "narrowly");
 509                         }
 510                         // sound not available
 511                         // else if(item.items == IT_CELLS)
 512                         //      AnnounceTo(player, "ammo");
 513
 514                         if (item.weapons & WEPBIT_MINSTANEX)
 515                                 W_GiveWeapon (player, WEP_MINSTANEX, item.netname);
 516                         player.health = 100;
 517                 }
 518
 519                 if((it = (item.items - (item.items & player.items)) & IT_PICKUPMASK))
 520                 {
 521                         pickedup = TRUE;
 522                         player.items |= it;
 523                         sprint (player, strcat("You got the ^2", item.netname, "\n"));
 524                 }
 525
 526                 // extralife powerup
 527                 if (item.max_health)
 528                 {
 529                         pickedup = TRUE;
 530                         // sound not available
 531                         // AnnounceTo(player, "_lives");
 532                         player.armorvalue = bound(player.armorvalue, 999, player.armorvalue + autocvar_g_minstagib_extralives);
 533                         sprint(player, "^3You picked up some extra lives\n");
 534                 }
 535
 536                 // invis powerup
 537                 if (item.strength_finished)
 538                 {
 539                         pickedup = TRUE;
 540                         // sound not available
 541                         // AnnounceTo(player, "invisible");
 542                         player.strength_finished = max(player.strength_finished, time) + autocvar_g_balance_powerup_strength_time;
 543                 }
 544
 545                 // speed powerup
 546                 if (item.invincible_finished)
 547                 {
 548                         pickedup = TRUE;
 549                         // sound not available
 550                         // AnnounceTo(player, "speed");
 551                         player.invincible_finished = max(player.invincible_finished, time) + autocvar_g_balance_powerup_strength_time;
 552                 }
 553         }
 554         else
 555         {
 556                 // in case the player has autoswitch enabled do the following:
 557                 // if the player is using their best weapon before items are given, they
 558                 // probably want to switch to an even better weapon after items are given
 559                 if (player.autoswitch)
 560                 if (player.switchweapon == w_getbestweapon(player))
 561                         _switchweapon = TRUE;
 562
 563                 if not(player.weapons & W_WeaponBit(player.switchweapon))
 564                         _switchweapon = TRUE;
 565
 566                 pickedup |= Item_GiveAmmoTo(item, player, ammo_fuel, g_pickup_fuel_max, ITEM_MODE_FUEL);
 567                 pickedup |= Item_GiveAmmoTo(item, player, ammo_shells, g_pickup_shells_max, ITEM_MODE_NONE);
 568                 pickedup |= Item_GiveAmmoTo(item, player, ammo_nails, g_pickup_nails_max, ITEM_MODE_NONE);
 569                 pickedup |= Item_GiveAmmoTo(item, player, ammo_rockets, g_pickup_rockets_max, ITEM_MODE_NONE);
 570                 pickedup |= Item_GiveAmmoTo(item, player, ammo_cells, g_pickup_cells_max, ITEM_MODE_NONE);
 571                 pickedup |= Item_GiveAmmoTo(item, player, health, item.max_health, ITEM_MODE_HEALTH);
 572                 pickedup |= Item_GiveAmmoTo(item, player, armorvalue, item.max_armorvalue, ITEM_MODE_ARMOR);
 573
 574                 if (item.flags & FL_WEAPON)
 575                 if ((it = item.weapons - (item.weapons & player.weapons)) || (item.spawnshieldtime && self.pickup_anyway))
 576                 {
 577                         pickedup = TRUE;
 578                         for(i = WEP_FIRST; i <= WEP_LAST; ++i)
 579                         {
 580                                 e = get_weaponinfo(i);
 581                                 if(it & e.weapons)
 582                                         W_GiveWeapon (player, e.weapon, item.netname);
 583                         }
 584                 }
 585
 586                 if((it = (item.items - (item.items & player.items)) & IT_PICKUPMASK))
 587                 {
 588                         pickedup = TRUE;
 589                         player.items |= it;
 590                         sprint (player, strcat("You got the ^2", item.netname, "\n"));
 591                 }
 592
 593                 if (item.strength_finished)
 594                 {
 595                         pickedup = TRUE;
 596                         player.strength_finished = max(player.strength_finished, time) + item.strength_finished;
 597                 }
 598                 if (item.invincible_finished)
 599                 {
 600                         pickedup = TRUE;
 601                         player.invincible_finished = max(player.invincible_finished, time) + item.invincible_finished;
 602                 }
 603                 if (item.superweapons_finished)
 604                 {
 605                         pickedup = TRUE;
 606                         player.superweapons_finished = max(player.superweapons_finished, time) + item.superweapons_finished;
 607                 }
 608         }
 609
 610 :skip
 611         // always eat teamed entities
 612         if(item.team)
 613                 pickedup = TRUE;
 614
 615         if (!pickedup)
 616                 return 0;
 617
 618         if (_switchweapon)
 619                 if (player.switchweapon != w_getbestweapon(player))
 620                         W_SwitchWeapon_Force(player, w_getbestweapon(player));
 621     self.SendFlags |= ISF_STATUS;
 622         return 1;
 623 }
 624
 625 void Item_Touch (void)
 626 {
 627         entity e, head;
 628
 629         // remove the item if it's currnetly in a NODROP brush or hits a NOIMPACT surface (such as sky)
 630         if (((trace_dpstartcontents | trace_dphitcontents) & DPCONTENTS_NODROP) || (trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT))
 631         {
 632                 remove(self);
 633                 return;
 634         }
 635         if (other.classname != "player")
 636                 return;
 637         if (other.deadflag)
 638                 return;
 639         if (self.solid != SOLID_TRIGGER)
 640                 return;
 641         if (self.owner == other)
 642                 return;
 643
 644         if (self.classname == "droppedweapon")
 645         {
 646                 self.strength_finished = max(0, self.strength_finished - time);
 647                 self.invincible_finished = max(0, self.invincible_finished - time);
 648                 self.superweapons_finished = max(0, self.superweapons_finished - time);
 649         }
 650
 651         if(!Item_GiveTo(self, other))
 652         {
 653                 if (self.classname == "droppedweapon")
 654                 {
 655                         // undo what we did above
 656                         self.strength_finished += time;
 657                         self.invincible_finished += time;
 658                         self.superweapons_finished += time;
 659                 }
 660                 return;
 661         }
 662
 663         other.last_pickup = time;
 664
 665         pointparticles(particleeffectnum("item_pickup"), self.origin, '0 0 0', 1);
 666         sound (other, CH_TRIGGER, self.item_pickupsound, VOL_BASE, ATTN_NORM);
 667
 668         if (self.classname == "droppedweapon")
 669                 remove (self);
 670         else if not(self.spawnshieldtime)
 671                 return;
 672         else
 673         {
 674                 if(self.team)
 675                 {
 676                         RandomSelection_Init();
 677                         for(head = world; (head = findfloat(head, team, self.team)); )
 678                         {
 679                                 if(head.flags & FL_ITEM)
 680                                 {
 681                                         Item_Show(head, -1);
 682                                         RandomSelection_Add(head, 0, string_null, head.cnt, 0);
 683                                 }
 684                         }
 685                         e = RandomSelection_chosen_ent;
 686                         self.SendFlags |= ISF_MODEL;
 687                 }
 688                 else
 689                         e = self;
 690                 Item_ScheduleRespawn(e);
 691         }
 692 }
 693
 694 void Item_Reset()
 695 {
 696         Item_Show(self, !self.state);
 697         setorigin (self, self.origin);
 698
 699         if(self.classname != "droppedweapon")
 700         {
 701                 self.think = SUB_Null;
 702                 self.nextthink = 0;
 703
 704                 if(self.waypointsprite_attached)
 705                         WaypointSprite_Kill(self.waypointsprite_attached);
 706
 707                 if((self.flags & FL_POWERUP) | (self.weapons & WEPBIT_SUPERWEAPONS)) // do not spawn powerups initially!
 708                         Item_ScheduleInitialRespawn(self);
 709         }
 710 }
 711
 712 void Item_FindTeam()
 713 {
 714         entity head, e;
 715
 716         if(self.effects & EF_NODRAW)
 717         {
 718                 // marker for item team search
 719                 dprint("Initializing item team ", ftos(self.team), "\n");
 720                 RandomSelection_Init();
 721                 for(head = world; (head = findfloat(head, team, self.team)); ) if(head.flags & FL_ITEM)
 722                         RandomSelection_Add(head, 0, string_null, head.cnt, 0);
 723                 e = RandomSelection_chosen_ent;
 724                 e.state = 0;
 725                 Item_Show(e, 1);
 726
 727                 for(head = world; (head = findfloat(head, team, self.team)); ) if(head.flags & FL_ITEM)
 728                 {
 729                         if(head != e)
 730                         {
 731                                 // make it a non-spawned item
 732                                 Item_Show(head, -1);
 733                                 head.state = 1; // state 1 = initially hidden item
 734                         }
 735                         head.effects &~= EF_NODRAW;
 736                 }
 737
 738                 Item_Reset();
 739         }
 740 }
 741
 742 // Savage: used for item garbage-collection
 743 // TODO: perhaps nice special effect?
 744 void RemoveItem(void)
 745 {
 746         remove(self);
 747 }
 748
 749 // pickup evaluation functions
 750 // these functions decide how desirable an item is to the bots
 751
 752 float generic_pickupevalfunc(entity player, entity item) {return item.bot_pickupbasevalue;}
 753
 754 float weapon_pickupevalfunc(entity player, entity item)
 755 {
 756         float c, i, j, position;
 757
 758         // See if I have it already
 759         if(player.weapons & item.weapons == item.weapons)
 760         {
 761                 // If I can pick it up
 762                 if(!item.spawnshieldtime)
 763                         c = 0;
 764                 else if(player.ammo_cells || player.ammo_shells || player.ammo_nails || player.ammo_rockets)
 765                 {
 766                         // Skilled bots will grab more
 767                         c = bound(0, skill / 10, 1) * 0.5;
 768                 }
 769                 else
 770                         c = 0;
 771         }
 772         else
 773                 c = 1;
 774
 775         // If custom weapon priorities for bots is enabled rate most wanted weapons higher
 776         if( bot_custom_weapon && c )
 777         {
 778                 for(i = WEP_FIRST; i <= WEP_LAST ; ++i)
 779                 {
 780                         // Find weapon
 781                         if( (get_weaponinfo(i)).weapons & item.weapons  != item.weapons )
 782                                 continue;
 783
 784                         // Find the highest position on any range
 785                         position = -1;
 786                         for(j = 0; j < WEP_LAST ; ++j){
 787                                 if(
 788                                                 bot_weapons_far[j] == i ||
 789                                                 bot_weapons_mid[j] == i ||
 790                                                 bot_weapons_close[j] == i
 791                                   )
 792                                 {
 793                                         position = j;
 794                                         break;
 795                                 }
 796                         }
 797
 798                         // Rate it
 799                         if (position >= 0 )
 800                         {
 801                                 position = WEP_LAST - position;
 802                                 // item.bot_pickupbasevalue is overwritten here
 803                                 return (BOT_PICKUP_RATING_LOW + ( (BOT_PICKUP_RATING_HIGH - BOT_PICKUP_RATING_LOW) * (position / WEP_LAST ))) * c;
 804                         }
 805                 }
 806         }
 807
 808         return item.bot_pickupbasevalue * c;
 809 }
 810
 811 float commodity_pickupevalfunc(entity player, entity item)
 812 {
 813         float c, i, need_shells, need_nails, need_rockets, need_cells, need_fuel;
 814         entity wi;
 815         c = 0;
 816
 817         // Detect needed ammo
 818         for(i = WEP_FIRST; i <= WEP_LAST ; ++i)
 819         {
 820                 wi = get_weaponinfo(i);
 821
 822                 if not(wi.weapons & player.weapons)
 823                         continue;
 824
 825                 if(wi.items & IT_SHELLS)
 826                         need_shells = TRUE;
 827                 else if(wi.items & IT_NAILS)
 828                         need_nails = TRUE;
 829                 else if(wi.items & IT_ROCKETS)
 830                         need_rockets = TRUE;
 831                 else if(wi.items & IT_CELLS)
 832                         need_cells = TRUE;
 833                 else if(wi.items & IT_FUEL)
 834                         need_cells = TRUE;
 835         }
 836
 837         // TODO: figure out if the player even has the weapon this ammo is for?
 838         // may not affect strategy much though...
 839         // find out how much more ammo/armor/health the player can hold
 840         if (need_shells)
 841         if (item.ammo_shells)
 842         if (player.ammo_shells < g_pickup_shells_max)
 843                 c = c + max(0, 1 - player.ammo_shells / g_pickup_shells_max);
 844         if (need_nails)
 845         if (item.ammo_nails)
 846         if (player.ammo_nails < g_pickup_nails_max)
 847                 c = c + max(0, 1 - player.ammo_nails / g_pickup_nails_max);
 848         if (need_rockets)
 849         if (item.ammo_rockets)
 850         if (player.ammo_rockets < g_pickup_rockets_max)
 851                 c = c + max(0, 1 - player.ammo_rockets / g_pickup_rockets_max);
 852         if (need_cells)
 853         if (item.ammo_cells)
 854         if (player.ammo_cells < g_pickup_cells_max)
 855                 c = c + max(0, 1 - player.ammo_cells / g_pickup_cells_max);
 856         if (need_fuel)
 857         if (item.ammo_fuel)
 858         if (player.ammo_fuel < g_pickup_fuel_max)
 859                 c = c + max(0, 1 - player.ammo_fuel / g_pickup_fuel_max);
 860         if (item.armorvalue)
 861         if (player.armorvalue < item.max_armorvalue)
 862                 c = c + max(0, 1 - player.armorvalue / item.max_armorvalue);
 863         if (item.health)
 864         if (player.health < item.max_health)
 865                 c = c + max(0, 1 - player.health / item.max_health);
 866
 867         return item.bot_pickupbasevalue * c;
 868 }
 869
 870
 871 .float is_item;
 872 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)
 873 {
 874         startitem_failed = FALSE;
 875
 876         self.items = itemid;
 877         self.weapons = weaponid;
 878         self.flags = FL_ITEM | itemflags;
 879
 880         // is it a dropped weapon?
 881         if (self.classname == "droppedweapon")
 882         {
 883                 self.reset = SUB_Remove;
 884                 // it's a dropped weapon
 885                 self.movetype = MOVETYPE_TOSS;
 886
 887                 // Savage: remove thrown items after a certain period of time ("garbage collection")
 888                 self.think = RemoveItem;
 889                 self.nextthink = time + 20;
 890
 891                 if(self.strength_finished || self.invincible_finished || self.superweapons_finished)
 892                 /*
 893                 if(self.items == 0)
 894                 if(self.weapons == (self.weapons & WEPBIT_SUPERWEAPONS)) // only superweapons
 895                 if(self.ammo_nails == 0)
 896                 if(self.ammo_cells == 0)
 897                 if(self.ammo_rockets == 0)
 898                 if(self.ammo_shells == 0)
 899                 if(self.ammo_fuel == 0)
 900                 if(self.health == 0)
 901                 if(self.armorvalue == 0)
 902                 */
 903                 {
 904                         // if item is worthless after a timer, have it expire then
 905                         self.nextthink = max(self.strength_finished, self.invincible_finished, self.superweapons_finished);
 906                 }
 907
 908                 // don't drop if in a NODROP zone (such as lava)
 909                 traceline(self.origin, self.origin, MOVE_NORMAL, self);
 910                 if (trace_dpstartcontents & DPCONTENTS_NODROP)
 911                 {
 912                         startitem_failed = TRUE;
 913                         remove(self);
 914                         return;
 915                 }
 916         }
 917         else
 918         {
 919                 if(MUTATOR_CALLHOOK(FilterItem)) // error means we do not want the item
 920                 {
 921                         startitem_failed = TRUE;
 922                         remove(self);
 923                         return;
 924                 }
 925
 926                 if(!have_pickup_item())
 927                 {
 928                         startitem_failed = TRUE;
 929                         remove (self);
 930                         return;
 931                 }
 932
 933                 if(self.model != "")
 934                         itemmodel = self.model;
 935                 if(self.item_pickupsound != "")
 936                         pickupsound = self.item_pickupsound;
 937
 938                 self.reset = Item_Reset;
 939                 // it's a level item
 940                 if(self.spawnflags & 1)
 941                         self.noalign = 1;
 942                 if (self.noalign)
 943                         self.movetype = MOVETYPE_NONE;
 944                 else
 945                         self.movetype = MOVETYPE_TOSS;
 946                 // do item filtering according to game mode and other things
 947                 if (!self.noalign)
 948                 {
 949                         // first nudge it off the floor a little bit to avoid math errors
 950                         setorigin(self, self.origin + '0 0 1');
 951                         // set item size before we spawn a spawnfunc_waypoint
 952                         if((itemflags & FL_POWERUP) || self.health || self.armorvalue)
 953                                 setsize (self, '-16 -16 0', '16 16 48');
 954                         else
 955                                 setsize (self, '-16 -16 0', '16 16 32');
 956                         // note droptofloor returns FALSE if stuck/or would fall too far
 957                         droptofloor();
 958                         waypoint_spawnforitem(self);
 959                 }
 960
 961                 /*
 962                  * can't do it that way, as it would break maps
 963                  * TODO make a target_give like entity another way, that perhaps has
 964                  * the weapon name in a key
 965                 if(self.targetname)
 966                 {
 967                         // target_give not yet supported; maybe later
 968                         print("removed targeted ", self.classname, "\n");
 969                         startitem_failed = TRUE;
 970                         remove (self);
 971                         return;
 972                 }
 973                 */
 974
 975                 if(autocvar_spawn_debug >= 2)
 976                 {
 977                         entity otheritem;
 978                         for(otheritem = findradius(self.origin, 3); otheritem; otheritem = otheritem.chain)
 979                         {
 980                                 if(otheritem.is_item)
 981                                 {
 982                                         dprint("XXX Found duplicated item: ", itemname, vtos(self.origin));
 983                                         dprint(" vs ", otheritem.netname, vtos(otheritem.origin), "\n");
 984                                         error("Mapper sucks.");
 985                                 }
 986                         }
 987                         self.is_item = TRUE;
 988                 }
 989
 990                 weaponsInMap |= weaponid;
 991
 992                 precache_model (itemmodel);
 993                 precache_sound (pickupsound);
 994
 995                 precache_sound ("misc/itemrespawncountdown.wav");
 996                 if(!g_minstagib && itemid == IT_STRENGTH)
 997                         precache_sound ("misc/strength_respawn.wav");
 998                 else if(!g_minstagib && itemid == IT_INVINCIBLE)
 999                         precache_sound ("misc/shield_respawn.wav");
1000                 else
1001                         precache_sound ("misc/itemrespawn.wav");
1002
1003                 if((itemflags & (FL_POWERUP | FL_WEAPON)) || (itemid & (IT_HEALTH | IT_ARMOR | IT_KEY1 | IT_KEY2)))
1004                         self.target = "###item###"; // for finding the nearest item using find()
1005         }
1006
1007         self.bot_pickup = TRUE;
1008         self.bot_pickupevalfunc = pickupevalfunc;
1009         self.bot_pickupbasevalue = pickupbasevalue;
1010         self.mdl = itemmodel;
1011         self.item_pickupsound = pickupsound;
1012         if(self.weapons)
1013                 self.weapon = WEP_FIRST + log2of(lowestbit(self.weapons));
1014         else
1015                 self.weapon = 0;
1016         // let mappers override respawntime
1017         if(!self.respawntime) // both set
1018         {
1019                 self.respawntime = defaultrespawntime;
1020                 self.respawntimejitter = defaultrespawntimejitter;
1021         }
1022         self.netname = itemname;
1023         self.touch = Item_Touch;
1024         setmodel (self, self.mdl); // precision set below
1025         self.effects |= EF_LOWPRECISION;
1026         if((itemflags & FL_POWERUP) || self.health || self.armorvalue)
1027                 setsize (self, '-16 -16 0', '16 16 48');
1028         else
1029                 setsize (self, '-16 -16 0', '16 16 32');
1030         if(itemflags & FL_WEAPON)
1031                 self.modelflags |= MF_ROTATE;
1032
1033         if (self.classname != "droppedweapon") // if dropped, colormap is already set up nicely
1034         if (itemflags & FL_WEAPON)
1035         {
1036                 // neutral team color for pickup weapons
1037                 self.colormap = 1024; // color shirt=0 pants=0 grey
1038         }
1039
1040         self.state = 0;
1041         if(self.team)
1042         {
1043                 if(!self.cnt)
1044                         self.cnt = 1; // item probability weight
1045                 self.effects = self.effects | EF_NODRAW; // marker for item team search
1046                 InitializeEntity(self, Item_FindTeam, INITPRIO_FINDTARGET);
1047         }
1048         else
1049                 Item_Reset();
1050
1051     if(self.classname == "droppedweapon")
1052         return;
1053
1054     //self.SendFlags = 0xFFFFFF;
1055     if(cvar("g_csqc_items"))
1056         Net_LinkEntity(self, FALSE, 0, ItemSend);
1057
1058 }
1059
1060 /* replace items in minstagib
1061  * IT_STRENGTH   = invisibility
1062  * IT_NAILS      = extra lives
1063  * IT_INVINCIBLE = speed
1064  */
1065 void minstagib_items (float itemid)
1066 {
1067         float rnd;
1068         self.classname = "minstagib";
1069
1070         // replace rocket launchers and nex guns with ammo cells
1071         if (itemid == IT_CELLS)
1072         {
1073                 self.ammo_cells = autocvar_g_minstagib_ammo_drop;
1074                 StartItem ("models/items/a_cells.md3",
1075                         "misc/itempickup.wav", 45, 0,
1076                         "MinstaNex Ammo", IT_CELLS, 0, 0, generic_pickupevalfunc, 100);
1077                 return;
1078         }
1079
1080         // randomize
1081         rnd = random() * 3;
1082         if (rnd <= 1)
1083                 itemid = IT_STRENGTH;
1084         else if (rnd <= 2)
1085                 itemid = IT_NAILS;
1086         else
1087                 itemid = IT_INVINCIBLE;
1088
1089         // replace with invis
1090         if (itemid == IT_STRENGTH)
1091         {
1092                 if(!self.strength_finished)
1093                         self.strength_finished = autocvar_g_balance_powerup_strength_time;
1094                 StartItem ("models/items/g_strength.md3",
1095                         "misc/powerup.wav", g_pickup_respawntime_powerup, g_pickup_respawntimejitter_powerup,
1096                         "Invisibility", IT_STRENGTH, 0, FL_POWERUP, generic_pickupevalfunc, BOT_PICKUP_RATING_MID);
1097         }
1098         // replace with extra lives
1099         if (itemid == IT_NAILS)
1100         {
1101                 self.max_health = 1;
1102                 StartItem ("models/items/g_h100.md3",
1103                         "misc/megahealth.wav", g_pickup_respawntime_powerup, g_pickup_respawntimejitter_powerup,
1104                         "Extralife", IT_NAILS, 0, FL_POWERUP, generic_pickupevalfunc, BOT_PICKUP_RATING_HIGH);
1105         }
1106         // replace with speed
1107         if (itemid == IT_INVINCIBLE)
1108         {
1109                 if(!self.invincible_finished)
1110                         self.invincible_finished = autocvar_g_balance_powerup_invincible_time;
1111                 StartItem ("models/items/g_invincible.md3",
1112                         "misc/powerup_shield.wav", g_pickup_respawntime_powerup, g_pickup_respawntimejitter_powerup,
1113                         "Speed", IT_INVINCIBLE, 0, FL_POWERUP, generic_pickupevalfunc, BOT_PICKUP_RATING_MID);
1114         }
1115 }
1116
1117 float minst_no_auto_cells;
1118 void minst_remove_item (void) {
1119         if(minst_no_auto_cells)
1120                 remove(self);
1121 }
1122
1123 float weaponswapping;
1124 float internalteam;
1125
1126 void weapon_defaultspawnfunc(float wpn)
1127 {
1128         entity e;
1129         float t;
1130         var .float ammofield;
1131         string s;
1132         entity oldself;
1133         float i, j;
1134         float f;
1135
1136         if(self.classname != "droppedweapon" && self.classname != "replacedweapon")
1137         {
1138                 e = get_weaponinfo(wpn);
1139                 s = cvar_string(strcat("g_weaponreplace_", e.netname));
1140                 if(s == "0")
1141                 {
1142                         remove(self);
1143                         startitem_failed = TRUE;
1144                         return;
1145                 }
1146                 t = tokenize_console(s);
1147                 if(t >= 2)
1148                 {
1149                         self.team = --internalteam;
1150                         oldself = self;
1151                         for(i = 1; i < t; ++i)
1152                         {
1153                                 s = argv(i);
1154                                 for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1155                                 {
1156                                         e = get_weaponinfo(j);
1157                                         if(e.netname == s)
1158                                         {
1159                                                 self = spawn();
1160                                                 copyentity(oldself, self);
1161                                                 self.classname = "replacedweapon";
1162                                                 weapon_defaultspawnfunc(j);
1163                                                 break;
1164                                         }
1165                                 }
1166                                 if(j > WEP_LAST)
1167                                 {
1168                                         print("The weapon replace list for ", oldself.classname, " contains an unknown weapon ", s, ". Skipped.\n");
1169                                 }
1170                         }
1171                         self = oldself;
1172                 }
1173                 if(t >= 1)
1174                 {
1175                         s = argv(0);
1176                         wpn = 0;
1177                         for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1178                         {
1179                                 e = get_weaponinfo(j);
1180                                 if(e.netname == s)
1181                                 {
1182                                         wpn = j;
1183                                         break;
1184                                 }
1185                         }
1186                         if(j > WEP_LAST)
1187                         {
1188                                 print("The weapon replace list for ", self.classname, " contains an unknown weapon ", s, ". Skipped.\n");
1189                         }
1190                 }
1191                 if(wpn == 0)
1192                 {
1193                         remove(self);
1194                         startitem_failed = TRUE;
1195                         return;
1196                 }
1197         }
1198
1199         e = get_weaponinfo(wpn);
1200
1201         if(!self.respawntime)
1202         {
1203                 if(e.weapons & WEPBIT_SUPERWEAPONS)
1204                 {
1205                         self.respawntime = g_pickup_respawntime_superweapon;
1206                         self.respawntimejitter = g_pickup_respawntimejitter_superweapon;
1207                 }
1208                 else
1209                 {
1210                         self.respawntime = g_pickup_respawntime_weapon;
1211                         self.respawntimejitter = g_pickup_respawntimejitter_weapon;
1212                 }
1213         }
1214
1215         if(e.weapons & WEPBIT_SUPERWEAPONS)
1216                 if(!self.superweapons_finished)
1217                         self.superweapons_finished = autocvar_g_balance_superweapons_time;
1218
1219         if(e.items)
1220         {
1221                 for(i = 0, j = 1; i < 24; ++i, j *= 2)
1222                 {
1223                         if(e.items & j)
1224                         {
1225                                 ammofield = Item_CounterField(j);
1226                                 if(!self.ammofield)
1227                                         self.ammofield = cvar(strcat("g_pickup_", Item_CounterFieldName(j), "_weapon"));
1228                         }
1229                 }
1230         }
1231
1232         // pickup anyway
1233         if(g_pickup_weapons_anyway)
1234                 self.pickup_anyway = TRUE;
1235
1236         f = FL_WEAPON;
1237
1238         // no weapon-stay on superweapons
1239         if(e.weapons & WEPBIT_SUPERWEAPONS)
1240                 f |= FL_NO_WEAPON_STAY;
1241
1242         // weapon stay isn't supported for teamed weapons
1243         if(self.team)
1244                 f |= FL_NO_WEAPON_STAY;
1245
1246         // stupid minstagib hack, don't ask
1247         if(g_minstagib)
1248                 if(self.ammo_cells)
1249                         self.ammo_cells = autocvar_g_minstagib_ammo_drop;
1250
1251         StartItem(e.model, "weapons/weaponpickup.wav", self.respawntime, self.respawntimejitter, e.message, 0, e.weapons, f, weapon_pickupevalfunc, e.bot_pickupbasevalue);
1252         if (self.modelindex) // don't precache if self was removed
1253                 weapon_action(e.weapon, WR_PRECACHE);
1254 }
1255
1256 void spawnfunc_weapon_shotgun (void);
1257 void spawnfunc_weapon_uzi (void) {
1258         if(autocvar_sv_q3acompat_machineshotgunswap)
1259         if(self.classname != "droppedweapon")
1260         {
1261                 weapon_defaultspawnfunc(WEP_SHOTGUN);
1262                 return;
1263         }
1264         weapon_defaultspawnfunc(WEP_UZI);
1265 }
1266
1267 void spawnfunc_weapon_shotgun (void) {
1268         if(autocvar_sv_q3acompat_machineshotgunswap)
1269         if(self.classname != "droppedweapon")
1270         {
1271                 weapon_defaultspawnfunc(WEP_UZI);
1272                 return;
1273         }
1274         weapon_defaultspawnfunc(WEP_SHOTGUN);
1275 }
1276
1277 void spawnfunc_weapon_nex (void)
1278 {
1279         if (g_minstagib)
1280         {
1281                 minstagib_items(IT_CELLS);
1282                 self.think = minst_remove_item;
1283                 self.nextthink = time;
1284                 return;
1285         }
1286         weapon_defaultspawnfunc(WEP_NEX);
1287 }
1288
1289 void spawnfunc_weapon_minstanex (void)
1290 {
1291         if (g_minstagib)
1292         {
1293                 minstagib_items(IT_CELLS);
1294                 self.think = minst_remove_item;
1295                 self.nextthink = time;
1296                 return;
1297         }
1298         weapon_defaultspawnfunc(WEP_MINSTANEX);
1299 }
1300
1301 void spawnfunc_weapon_rocketlauncher (void)
1302 {
1303         if (g_minstagib)
1304         {
1305                 minstagib_items(IT_CELLS); // replace rocketlauncher with cells
1306                 self.think = minst_remove_item;
1307                 self.nextthink = time;
1308                 return;
1309         }
1310         weapon_defaultspawnfunc(WEP_ROCKET_LAUNCHER);
1311 }
1312
1313 void spawnfunc_item_rockets (void) {
1314         if(!self.ammo_rockets)
1315                 self.ammo_rockets = g_pickup_rockets;
1316         if(!self.pickup_anyway)
1317                 self.pickup_anyway = g_pickup_ammo_anyway;
1318         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);
1319 }
1320
1321 void spawnfunc_item_shells (void);
1322 void spawnfunc_item_bullets (void) {
1323         if(!weaponswapping)
1324         if(autocvar_sv_q3acompat_machineshotgunswap)
1325         if(self.classname != "droppedweapon")
1326         {
1327                 weaponswapping = TRUE;
1328                 spawnfunc_item_shells();
1329                 weaponswapping = FALSE;
1330                 return;
1331         }
1332
1333         if(!self.ammo_nails)
1334                 self.ammo_nails = g_pickup_nails;
1335         if(!self.pickup_anyway)
1336                 self.pickup_anyway = g_pickup_ammo_anyway;
1337         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);
1338 }
1339
1340 void spawnfunc_item_cells (void) {
1341         if(!self.ammo_cells)
1342                 self.ammo_cells = g_pickup_cells;
1343         if(!self.pickup_anyway)
1344                 self.pickup_anyway = g_pickup_ammo_anyway;
1345         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);
1346 }
1347
1348 void spawnfunc_item_shells (void) {
1349         if(!weaponswapping)
1350         if(autocvar_sv_q3acompat_machineshotgunswap)
1351         if(self.classname != "droppedweapon")
1352         {
1353                 weaponswapping = TRUE;
1354                 spawnfunc_item_bullets();
1355                 weaponswapping = FALSE;
1356                 return;
1357         }
1358
1359         if(!self.ammo_shells)
1360                 self.ammo_shells = g_pickup_shells;
1361         if(!self.pickup_anyway)
1362                 self.pickup_anyway = g_pickup_ammo_anyway;
1363         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);
1364 }
1365
1366 void spawnfunc_item_armor_small (void) {
1367         if(!self.armorvalue)
1368                 self.armorvalue = g_pickup_armorsmall;
1369         if(!self.max_armorvalue)
1370                 self.max_armorvalue = g_pickup_armorsmall_max;
1371         if(!self.pickup_anyway)
1372                 self.pickup_anyway = g_pickup_armorsmall_anyway;
1373         StartItem ("models/items/item_armor_small.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);
1374 }
1375
1376 void spawnfunc_item_armor_medium (void) {
1377         if(!self.armorvalue)
1378                 self.armorvalue = g_pickup_armormedium;
1379         if(!self.max_armorvalue)
1380                 self.max_armorvalue = g_pickup_armormedium_max;
1381         if(!self.pickup_anyway)
1382                 self.pickup_anyway = g_pickup_armormedium_anyway;
1383         StartItem ("models/items/item_armor_medium.md3", "misc/armor10.wav", g_pickup_respawntime_medium, g_pickup_respawntimejitter_medium, "25 Armor", IT_ARMOR, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_MID);
1384 }
1385
1386 void spawnfunc_item_armor_big (void) {
1387         if(!self.armorvalue)
1388                 self.armorvalue = g_pickup_armorbig;
1389         if(!self.max_armorvalue)
1390                 self.max_armorvalue = g_pickup_armorbig_max;
1391         if(!self.pickup_anyway)
1392                 self.pickup_anyway = g_pickup_armorbig_anyway;
1393         StartItem ("models/items/item_armor_big.md3", "misc/armor17_5.wav", g_pickup_respawntime_long, g_pickup_respawntimejitter_long, "50 Armor", IT_ARMOR, 0, 0, commodity_pickupevalfunc, 20000);
1394 }
1395
1396 void spawnfunc_item_armor_large (void) {
1397         if(!self.armorvalue)
1398                 self.armorvalue = g_pickup_armorlarge;
1399         if(!self.max_armorvalue)
1400                 self.max_armorvalue = g_pickup_armorlarge_max;
1401         if(!self.pickup_anyway)
1402                 self.pickup_anyway = g_pickup_armorlarge_anyway;
1403         StartItem ("models/items/item_armor_large.md3", "misc/armor25.wav", g_pickup_respawntime_long, g_pickup_respawntimejitter_long, "100 Armor", IT_ARMOR, 0, 0, commodity_pickupevalfunc, BOT_PICKUP_RATING_HIGH);
1404 }
1405
1406 void spawnfunc_item_health_small (void) {
1407         if(!self.max_health)
1408                 self.max_health = g_pickup_healthsmall_max;
1409         if(!self.health)
1410                 self.health = g_pickup_healthsmall;
1411         if(!self.pickup_anyway)
1412                 self.pickup_anyway = g_pickup_healthsmall_anyway;
1413         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);
1414 }
1415
1416 void spawnfunc_item_health_medium (void) {
1417         if(!self.max_health)
1418                 self.max_health = g_pickup_healthmedium_max;
1419         if(!self.health)
1420                 self.health = g_pickup_healthmedium;
1421         if(!self.pickup_anyway)
1422                 self.pickup_anyway = g_pickup_healthmedium_anyway;
1423         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);
1424 }
1425
1426 void spawnfunc_item_health_large (void) {
1427         if(!self.max_health)
1428                 self.max_health = g_pickup_healthlarge_max;
1429         if(!self.health)
1430                 self.health = g_pickup_healthlarge;
1431         if(!self.pickup_anyway)
1432                 self.pickup_anyway = g_pickup_healthlarge_anyway;
1433         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);
1434 }
1435
1436 void spawnfunc_item_health_mega (void) {
1437         if(g_minstagib) {
1438                 minstagib_items(IT_NAILS);
1439         } else {
1440                 if(!self.max_health)
1441                         self.max_health = g_pickup_healthmega_max;
1442                 if(!self.health)
1443                         self.health = g_pickup_healthmega;
1444                 if(!self.pickup_anyway)
1445                         self.pickup_anyway = g_pickup_healthmega_anyway;
1446                 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);
1447         }
1448 }
1449
1450 // support old misnamed entities
1451 void spawnfunc_item_armor1() { spawnfunc_item_armor_small(); }  // FIXME: in Quake this is green armor, in Xonotic maps it is an armor shard
1452 void spawnfunc_item_armor25() { spawnfunc_item_armor_large(); }
1453 void spawnfunc_item_health1() { spawnfunc_item_health_small(); }
1454 void spawnfunc_item_health25() { spawnfunc_item_health_medium(); }
1455 void spawnfunc_item_health100() { spawnfunc_item_health_mega(); }
1456
1457 void spawnfunc_item_strength (void) {
1458         if(g_minstagib) {
1459                 minstagib_items(IT_STRENGTH);
1460         } else {
1461                 precache_sound("weapons/strength_fire.wav");
1462                 if(!self.strength_finished)
1463                         self.strength_finished = autocvar_g_balance_powerup_strength_time;
1464                 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);
1465         }
1466 }
1467
1468 void spawnfunc_item_invincible (void) {
1469         if(g_minstagib) {
1470                 minstagib_items(IT_INVINCIBLE);
1471         } else {
1472                 if(!self.invincible_finished)
1473                         self.invincible_finished = autocvar_g_balance_powerup_invincible_time;
1474                 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);
1475         }
1476 }
1477
1478 void spawnfunc_item_minst_cells (void) {
1479         if (g_minstagib)
1480         {
1481                 minst_no_auto_cells = 1;
1482                 minstagib_items(IT_CELLS);
1483         }
1484         else
1485                 remove(self);
1486 }
1487
1488 // compatibility:
1489 void spawnfunc_item_quad (void) {self.classname = "item_strength";spawnfunc_item_strength();}
1490
1491 float GiveItems(entity e, float beginarg, float endarg);
1492 void target_items_use (void)
1493 {
1494         if(activator.classname == "droppedweapon")
1495         {
1496                 EXACTTRIGGER_TOUCH;
1497                 remove(activator);
1498                 return;
1499         }
1500
1501         if(activator.classname != "player")
1502                 return;
1503         if(activator.deadflag != DEAD_NO)
1504                 return;
1505         EXACTTRIGGER_TOUCH;
1506
1507         entity e;
1508         for(e = world; (e = find(e, classname, "droppedweapon")); )
1509                 if(e.enemy == activator)
1510                         remove(e);
1511
1512         if(GiveItems(activator, 0, tokenize_console(self.netname)))
1513                 centerprint(activator, self.message);
1514 }
1515
1516 void spawnfunc_target_items (void)
1517 {
1518         float n, i, j;
1519         entity e;
1520
1521         self.use = target_items_use;
1522         if(!self.strength_finished)
1523                 self.strength_finished = autocvar_g_balance_powerup_strength_time;
1524         if(!self.invincible_finished)
1525                 self.invincible_finished = autocvar_g_balance_powerup_invincible_time;
1526         if(!self.superweapons_finished)
1527                 self.superweapons_finished = autocvar_g_balance_superweapons_time;
1528
1529         precache_sound("misc/itempickup.wav");
1530         precache_sound("misc/megahealth.wav");
1531         precache_sound("misc/armor25.wav");
1532         precache_sound("misc/powerup.wav");
1533         precache_sound("misc/poweroff.wav");
1534         precache_sound("weapons/weaponpickup.wav");
1535
1536         n = tokenize_console(self.netname);
1537         if(argv(0) == "give")
1538         {
1539                 self.netname = substring(self.netname, argv_start_index(1), argv_end_index(-1) - argv_start_index(1));
1540         }
1541         else
1542         {
1543                 for(i = 0; i < n; ++i)
1544                 {
1545                         if     (argv(i) == "unlimited_ammo")         self.items |= IT_UNLIMITED_AMMO;
1546                         else if(argv(i) == "unlimited_weapon_ammo")  self.items |= IT_UNLIMITED_WEAPON_AMMO;
1547                         else if(argv(i) == "unlimited_superweapons") self.items |= IT_UNLIMITED_SUPERWEAPONS;
1548                         else if(argv(i) == "strength")               self.items |= IT_STRENGTH;
1549                         else if(argv(i) == "invincible")             self.items |= IT_INVINCIBLE;
1550                         else if(argv(i) == "superweapons")           self.items |= IT_SUPERWEAPON;
1551                         else if(argv(i) == "jetpack")                self.items |= IT_JETPACK;
1552                         else if(argv(i) == "fuel_regen")             self.items |= IT_FUEL_REGEN;
1553                         else
1554                         for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1555                         {
1556                                 e = get_weaponinfo(j);
1557                                 if(argv(i) == e.netname)
1558                                 {
1559                                         self.weapons |= e.weapons;
1560                                         if(self.spawnflags == 0 || self.spawnflags == 2)
1561                                                 weapon_action(e.weapon, WR_PRECACHE);
1562                                         break;
1563                                 }
1564                         }
1565                         if(j > WEP_LAST)
1566                                 print("target_items: invalid item ", argv(i), "\n");
1567                 }
1568
1569                 string itemprefix, valueprefix;
1570                 if(self.spawnflags == 0)
1571                 {
1572                         itemprefix = "";
1573                         valueprefix = "";
1574                 }
1575                 else if(self.spawnflags == 1)
1576                 {
1577                         itemprefix = "max ";
1578                         valueprefix = "max ";
1579                 }
1580                 else if(self.spawnflags == 2)
1581                 {
1582                         itemprefix = "min ";
1583                         valueprefix = "min ";
1584                 }
1585                 else if(self.spawnflags == 4)
1586                 {
1587                         itemprefix = "minus ";
1588                         valueprefix = "max ";
1589                 }
1590                 else
1591                         error("invalid spawnflags");
1592
1593                 self.netname = "";
1594                 self.netname = sprintf("%s %s%d %s", self.netname, itemprefix, !!(self.items & IT_UNLIMITED_WEAPON_AMMO), "unlimited_weapon_ammo");
1595                 self.netname = sprintf("%s %s%d %s", self.netname, itemprefix, !!(self.items & IT_UNLIMITED_SUPERWEAPONS), "unlimited_superweapons");
1596                 self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, self.strength_finished * !!(self.items & IT_STRENGTH), "strength");
1597                 self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, self.invincible_finished * !!(self.items & IT_INVINCIBLE), "invincible");
1598                 self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, self.superweapons_finished * !!(self.items & IT_SUPERWEAPON), "superweapons");
1599                 self.netname = sprintf("%s %s%d %s", self.netname, itemprefix, !!(self.items & IT_JETPACK), "jetpack");
1600                 self.netname = sprintf("%s %s%d %s", self.netname, itemprefix, !!(self.items & IT_FUEL_REGEN), "fuel_regen");
1601                 if(self.ammo_shells != 0) self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, max(0, self.ammo_shells), "shells");
1602                 if(self.ammo_nails != 0) self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, max(0, self.ammo_nails), "nails");
1603                 if(self.ammo_rockets != 0) self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, max(0, self.ammo_rockets), "rockets");
1604                 if(self.ammo_cells != 0) self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, max(0, self.ammo_cells), "cells");
1605                 if(self.ammo_fuel != 0) self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, max(0, self.ammo_fuel), "fuel");
1606                 if(self.health != 0) self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, max(0, self.health), "health");
1607                 if(self.armorvalue != 0) self.netname = sprintf("%s %s%d %s", self.netname, valueprefix, max(0, self.health), "armor");
1608                 for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1609                 {
1610                         e = get_weaponinfo(j);
1611                         if(e.weapons)
1612                                 self.netname = sprintf("%s %s%d %s", self.netname, itemprefix, !!(self.weapons & e.weapons), e.netname);
1613                 }
1614         }
1615         self.netname = strzone(self.netname);
1616         //print(self.netname, "\n");
1617
1618         n = tokenize_console(self.netname);
1619         for(i = 0; i < n; ++i)
1620         {
1621                 for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1622                 {
1623                         e = get_weaponinfo(j);
1624                         if(argv(i) == e.netname)
1625                         {
1626                                 weapon_action(e.weapon, WR_PRECACHE);
1627                                 break;
1628                         }
1629                 }
1630         }
1631 }
1632
1633 void spawnfunc_item_fuel(void)
1634 {
1635         if(!self.ammo_fuel)
1636                 self.ammo_fuel = g_pickup_fuel;
1637         if(!self.pickup_anyway)
1638                 self.pickup_anyway = g_pickup_ammo_anyway;
1639         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);
1640 }
1641
1642 void spawnfunc_item_fuel_regen(void)
1643 {
1644         if(start_items & IT_FUEL_REGEN)
1645         {
1646                 spawnfunc_item_fuel();
1647                 return;
1648         }
1649         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);
1650 }
1651
1652 void spawnfunc_item_jetpack(void)
1653 {
1654         if(g_grappling_hook)
1655                 return; // sorry, but these two can't coexist (same button); spawn fuel instead
1656         if(!self.ammo_fuel)
1657                 self.ammo_fuel = g_pickup_fuel_jetpack;
1658         if(start_items & IT_JETPACK)
1659         {
1660                 spawnfunc_item_fuel();
1661                 return;
1662         }
1663         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);
1664 }
1665
1666
1667 #define OP_SET 0
1668 #define OP_MIN 1
1669 #define OP_MAX 2
1670 #define OP_PLUS 3
1671 #define OP_MINUS 4
1672
1673 float GiveBit(entity e, .float fld, float bit, float op, float val)
1674 {
1675         float v0, v1;
1676         v0 = (e.fld & bit);
1677         switch(op)
1678         {
1679                 case OP_SET:
1680                         if(val > 0)
1681                                 e.fld |= bit;
1682                         else
1683                                 e.fld &~= bit;
1684                         break;
1685                 case OP_MIN:
1686                 case OP_PLUS:
1687                         if(val > 0)
1688                                 e.fld |= bit;
1689                         break;
1690                 case OP_MAX:
1691                         if(val <= 0)
1692                                 e.fld &~= bit;
1693                         break;
1694                 case OP_MINUS:
1695                         if(val > 0)
1696                                 e.fld &~= bit;
1697                         break;
1698         }
1699         v1 = (e.fld & bit);
1700         return (v0 != v1);
1701 }
1702
1703 float GiveValue(entity e, .float fld, float op, float val)
1704 {
1705         float v0, v1;
1706         v0 = e.fld;
1707         switch(op)
1708         {
1709                 case OP_SET:
1710                         e.fld = val;
1711                         break;
1712                 case OP_MIN:
1713                         e.fld = max(e.fld, val); // min 100 cells = at least 100 cells
1714                         break;
1715                 case OP_MAX:
1716                         e.fld = min(e.fld, val);
1717                         break;
1718                 case OP_PLUS:
1719                         e.fld += val;
1720                         break;
1721                 case OP_MINUS:
1722                         e.fld -= val;
1723                         break;
1724         }
1725         v1 = e.fld;
1726         return (v0 != v1);
1727 }
1728
1729 void GiveSound(entity e, float v0, float v1, float t, string snd_incr, string snd_decr)
1730 {
1731         if(v1 == v0)
1732                 return;
1733         if(v1 <= v0 - t)
1734         {
1735                 if(snd_decr != "")
1736                         sound (e, CH_TRIGGER, snd_decr, VOL_BASE, ATTN_NORM);
1737         }
1738         else if(v0 >= v0 + t)
1739         {
1740                 if(snd_incr != "")
1741                         sound (e, CH_TRIGGER, snd_incr, VOL_BASE, ATTN_NORM);
1742         }
1743 }
1744
1745 void GiveRot(entity e, float v0, float v1, .float rotfield, float rottime, .float regenfield, float regentime)
1746 {
1747         if(v0 < v1)
1748                 e.rotfield = max(e.rotfield, time + rottime);
1749         else if(v0 > v1)
1750                 e.regenfield = max(e.regenfield, time + regentime);
1751 }
1752
1753 #define PREGIVE(e,f) float save_##f; save_##f = (e).f
1754 #define POSTGIVE_BIT(e,f,b,snd_incr,snd_decr) GiveSound((e), save_##f & (b), (e).f & (b), 0, snd_incr, snd_decr)
1755 #define POSTGIVE_VALUE(e,f,t,snd_incr,snd_decr) GiveSound((e), save_##f, (e).f, t, snd_incr, snd_decr)
1756 #define POSTGIVE_VALUE_ROT(e,f,t,rotfield,rottime,regenfield,regentime,snd_incr,snd_decr) GiveRot((e), save_##f, (e).f, rotfield, rottime, regenfield, regentime); GiveSound((e), save_##f, (e).f, t, snd_incr, snd_decr)
1757
1758 float GiveItems(entity e, float beginarg, float endarg)
1759 {
1760         float got, i, j, val, op;
1761         float _switchweapon;
1762         entity wi;
1763         string cmd;
1764
1765         val = 999;
1766         op = OP_SET;
1767
1768         got = 0;
1769
1770         _switchweapon = FALSE;
1771         if (e.autoswitch)
1772                 if (e.switchweapon == w_getbestweapon(e))
1773                         _switchweapon = TRUE;
1774
1775         e.strength_finished = max(0, e.strength_finished - time);
1776         e.invincible_finished = max(0, e.invincible_finished - time);
1777         e.superweapons_finished = max(0, e.superweapons_finished - time);
1778
1779         PREGIVE(e, items);
1780         PREGIVE(e, weapons);
1781         PREGIVE(e, strength_finished);
1782         PREGIVE(e, invincible_finished);
1783         PREGIVE(e, superweapons_finished);
1784         PREGIVE(e, ammo_nails);
1785         PREGIVE(e, ammo_cells);
1786         PREGIVE(e, ammo_shells);
1787         PREGIVE(e, ammo_rockets);
1788         PREGIVE(e, ammo_fuel);
1789         PREGIVE(e, armorvalue);
1790         PREGIVE(e, health);
1791
1792         for(i = beginarg; i < endarg; ++i)
1793         {
1794                 cmd = argv(i);
1795
1796                 if(cmd == "0" || stof(cmd))
1797                 {
1798                         val = stof(cmd);
1799                         continue;
1800                 }
1801                 switch(cmd)
1802                 {
1803                         case "no":
1804                                 op = OP_MAX;
1805                                 val = 0;
1806                                 continue;
1807                         case "max":
1808                                 op = OP_MAX;
1809                                 continue;
1810                         case "min":
1811                                 op = OP_MIN;
1812                                 continue;
1813                         case "plus":
1814                                 op = OP_PLUS;
1815                                 continue;
1816                         case "minus":
1817                                 op = OP_MINUS;
1818                                 continue;
1819                         case "ALL":
1820                                 got += GiveBit(e, items, IT_FUEL_REGEN, op, val);
1821                                 got += GiveValue(e, strength_finished, op, val);
1822                                 got += GiveValue(e, invincible_finished, op, val);
1823                                 got += GiveValue(e, superweapons_finished, op, val);
1824                                 got += GiveBit(e, items, IT_UNLIMITED_AMMO, op, val);
1825                         case "all":
1826                                 got += GiveBit(e, items, IT_JETPACK, op, val);
1827                                 got += GiveValue(e, health, op, val);
1828                                 got += GiveValue(e, armorvalue, op, val);
1829                         case "allweapons":
1830                                 for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1831                                 {
1832                                         wi = get_weaponinfo(j);
1833                                         if(wi.weapons)
1834                                                 got += GiveBit(e, weapons, wi.weapons, op, val);
1835                                 }
1836                         case "allammo":
1837                                 got += GiveValue(e, ammo_cells, op, val);
1838                                 got += GiveValue(e, ammo_shells, op, val);
1839                                 got += GiveValue(e, ammo_nails, op, val);
1840                                 got += GiveValue(e, ammo_rockets, op, val);
1841                                 got += GiveValue(e, ammo_fuel, op, val);
1842                                 break;
1843                         case "unlimited_ammo":
1844                                 got += GiveBit(e, items, IT_UNLIMITED_AMMO, op, val);
1845                                 break;
1846                         case "unlimited_weapon_ammo":
1847                                 got += GiveBit(e, items, IT_UNLIMITED_WEAPON_AMMO, op, val);
1848                                 break;
1849                         case "unlimited_superweapons":
1850                                 got += GiveBit(e, items, IT_UNLIMITED_SUPERWEAPONS, op, val);
1851                                 break;
1852                         case "jetpack":
1853                                 got += GiveBit(e, items, IT_JETPACK, op, val);
1854                                 break;
1855                         case "fuel_regen":
1856                                 got += GiveBit(e, items, IT_FUEL_REGEN, op, val);
1857                                 break;
1858                         case "strength":
1859                                 got += GiveValue(e, strength_finished, op, val);
1860                                 break;
1861                         case "invincible":
1862                                 got += GiveValue(e, invincible_finished, op, val);
1863                                 break;
1864                         case "superweapons":
1865                                 got += GiveValue(e, superweapons_finished, op, val);
1866                                 break;
1867                         case "cells":
1868                                 got += GiveValue(e, ammo_cells, op, val);
1869                                 break;
1870                         case "shells":
1871                                 got += GiveValue(e, ammo_shells, op, val);
1872                                 break;
1873                         case "nails":
1874                         case "bullets":
1875                                 got += GiveValue(e, ammo_nails, op, val);
1876                                 break;
1877                         case "rockets":
1878                                 got += GiveValue(e, ammo_rockets, op, val);
1879                                 break;
1880                         case "health":
1881                                 got += GiveValue(e, health, op, val);
1882                                 break;
1883                         case "armor":
1884                                 got += GiveValue(e, armorvalue, op, val);
1885                                 break;
1886                         case "fuel":
1887                                 got += GiveValue(e, ammo_fuel, op, val);
1888                                 break;
1889                         default:
1890                                 for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1891                                 {
1892                                         wi = get_weaponinfo(j);
1893                                         if(cmd == wi.netname)
1894                                         {
1895                                                 got += GiveBit(e, weapons, wi.weapons, op, val);
1896                                                 break;
1897                                         }
1898                                 }
1899                                 if(j > WEP_LAST)
1900                                         print("give: invalid item ", cmd, "\n");
1901                                 break;
1902                 }
1903                 val = 999;
1904                 op = OP_SET;
1905         }
1906
1907         POSTGIVE_BIT(e, items, IT_FUEL_REGEN, "misc/itempickup.wav", string_null);
1908         POSTGIVE_BIT(e, items, IT_UNLIMITED_SUPERWEAPONS, "misc/powerup.wav", "misc/poweroff.wav");
1909         POSTGIVE_BIT(e, items, IT_UNLIMITED_WEAPON_AMMO, "misc/powerup.wav", "misc/poweroff.wav");
1910         POSTGIVE_BIT(e, items, IT_JETPACK, "misc/itempickup.wav", string_null);
1911         for(j = WEP_FIRST; j <= WEP_LAST; ++j)
1912         {
1913                 wi = get_weaponinfo(j);
1914                 if(wi.weapons)
1915                 {
1916                         POSTGIVE_BIT(e, weapons, wi.weapons, "weapons/weaponpickup.wav", string_null);
1917                         if not(save_weapons & wi.weapons)
1918                                 if(e.weapons & wi.weapons)
1919                                         weapon_action(wi.weapon, WR_PRECACHE);
1920                 }
1921         }
1922         POSTGIVE_VALUE(e, strength_finished, 1, "misc/powerup.wav", "misc/poweroff.wav");
1923         POSTGIVE_VALUE(e, invincible_finished, 1, "misc/powerup_shield.wav", "misc/poweroff.wav");
1924         POSTGIVE_VALUE(e, ammo_nails, 0, "misc/itempickup.wav", string_null);
1925         POSTGIVE_VALUE(e, ammo_cells, 0, "misc/itempickup.wav", string_null);
1926         POSTGIVE_VALUE(e, ammo_shells, 0, "misc/itempickup.wav", string_null);
1927         POSTGIVE_VALUE(e, ammo_rockets, 0, "misc/itempickup.wav", string_null);
1928         POSTGIVE_VALUE_ROT(e, ammo_fuel, 1, pauserotfuel_finished, autocvar_g_balance_pause_fuel_rot, pauseregen_finished, autocvar_g_balance_pause_fuel_regen, "misc/itempickup.wav", string_null);
1929         POSTGIVE_VALUE_ROT(e, armorvalue, 1, pauserotarmor_finished, autocvar_g_balance_pause_armor_rot, pauseregen_finished, autocvar_g_balance_pause_health_regen, "misc/armor25.wav", string_null);
1930         POSTGIVE_VALUE_ROT(e, health, 1, pauserothealth_finished, autocvar_g_balance_pause_health_rot, pauseregen_finished, autocvar_g_balance_pause_health_regen, "misc/megahealth.wav", string_null);
1931
1932         if(e.superweapons_finished <= 0)
1933                 if(self.weapons & WEPBIT_SUPERWEAPONS)
1934                         e.superweapons_finished = autocvar_g_balance_superweapons_time;
1935
1936         if (g_minstagib)
1937         {
1938                 e.health = bound(0, e.health, 100);
1939                 e.armorvalue = bound(0, e.armorvalue, 999);
1940         }
1941
1942         if(e.strength_finished <= 0)
1943                 e.strength_finished = 0;
1944         else
1945                 e.strength_finished += time;
1946         if(e.invincible_finished <= 0)
1947                 e.invincible_finished = 0;
1948         else
1949                 e.invincible_finished += time;
1950         if(e.superweapons_finished <= 0)
1951                 e.superweapons_finished = 0;
1952         else
1953                 e.superweapons_finished += time;
1954
1955         if not(e.weapons & W_WeaponBit(e.switchweapon))
1956                 _switchweapon = TRUE;
1957         if(_switchweapon)
1958                 W_SwitchWeapon_Force(e, w_getbestweapon(e));
1959
1960         return got;
1961 }
1962 #endif