Random start weapons: Merged URS2.
authorLyberta <lyberta@lyberta.net>
Mon, 28 Aug 2017 19:14:49 +0000 (22:14 +0300)
committerLyberta <lyberta@lyberta.net>
Mon, 28 Aug 2017 19:14:49 +0000 (22:14 +0300)
1  2 
qcsrc/common/t_items.qc
qcsrc/common/t_items.qh
qcsrc/server/client.qc

diff --combined qcsrc/common/t_items.qc
@@@ -682,229 -682,6 +682,86 @@@ void Item_ScheduleInitialRespawn(entit
        Item_ScheduleRespawnIn(e, max(0, game_starttime - time) + ((e.respawntimestart) ? e.respawntimestart : ITEM_RESPAWNTIME_INITIAL(e)));
  }
  
- int GetResourceType(.float resource_property)
- {
-       switch (resource_property)
-       {
-               case health: { return RESOURCE_HEALTH; }
-               case armorvalue: { return RESOURCE_ARMOR; }
-               case ammo_shells: { return RESOURCE_SHELLS; }
-               case ammo_nails: { return RESOURCE_BULLETS; }
-               case ammo_rockets: { return RESOURCE_ROCKETS; }
-               case ammo_cells: { return RESOURCE_CELLS; }
-               case ammo_plasma: { return RESOURCE_PLASMA; }
-               case ammo_fuel: { return RESOURCE_FUEL; }
-       }
-       error("GetResourceType: Invalid property.");
-       return 0;
- }
- .float GetResourceProperty(int resource_type)
- {
-       switch (resource_type)
-       {
-               case RESOURCE_HEALTH: { return health; }
-               case RESOURCE_ARMOR: { return armorvalue; }
-               case RESOURCE_SHELLS: { return ammo_shells; }
-               case RESOURCE_BULLETS: { return ammo_nails; }
-               case RESOURCE_ROCKETS: { return ammo_rockets; }
-               case RESOURCE_CELLS: { return ammo_cells; }
-               case RESOURCE_PLASMA: { return ammo_plasma; }
-               case RESOURCE_FUEL: { return ammo_fuel; }
-       }
-       error("GetResourceProperty: Invalid resource type.");
-       return health;
- }
- float GetResourceLimit(entity e, int resource_type)
- {
-       float limit;
-       switch (resource_type)
-       {
-               case RESOURCE_HEALTH:
-               {
-                       limit = autocvar_g_balance_health_limit;
-                       break;
-               }
-               case RESOURCE_ARMOR:
-               {
-                       limit = autocvar_g_balance_armor_limit;
-                       break;
-               }
-               case RESOURCE_SHELLS:
-               {
-                       limit = g_pickup_shells_max;
-                       break;
-               }
-               case RESOURCE_BULLETS:
-               {
-                       limit = g_pickup_nails_max;
-                       break;
-               }
-               case RESOURCE_ROCKETS:
-               {
-                       limit = g_pickup_rockets_max;
-                       break;
-               }
-               case RESOURCE_CELLS:
-               {
-                       limit = g_pickup_cells_max;
-                       break;
-               }
-               case RESOURCE_PLASMA:
-               {
-                       limit = g_pickup_plasma_max;
-                       break;
-               }
-               case RESOURCE_FUEL:
-               {
-                       limit = autocvar_g_balance_fuel_limit;
-                       break;
-               }
-               default:
-               {
-                       error("GetResourceLimit: Invalid resource type.");
-                       return 0;
-               }
-       }
-       MUTATOR_CALLHOOK(GetResourceLimit, e, resource_type, limit);
-       limit = M_ARGV(2, float);
-       if (limit > RESOURCE_AMOUNT_HARD_LIMIT)
-       {
-               limit = RESOURCE_AMOUNT_HARD_LIMIT;
-       }
-       return limit;
- }
- void GiveResource(entity receiver, int resource_type, float amount)
- {
-       if (amount == 0)
-       {
-               return;
-       }
-       bool forbid = MUTATOR_CALLHOOK(GiveResource, receiver, resource_type,
-               amount);
-       if (forbid)
-       {
-               return;
-       }
-       resource_type = M_ARGV(1, int);
-       amount = M_ARGV(2, float);
-       .float resource_property = GetResourceProperty(resource_type);
-       float max_amount = GetResourceLimit(receiver, resource_type);
-       receiver.(resource_property) = bound(receiver.(resource_property),
-               receiver.(resource_property) + amount, max_amount);
-       switch (resource_type)
-       {
-               case RESOURCE_HEALTH:
-               {
-                       receiver.pauserothealth_finished =
-                               max(receiver.pauserothealth_finished, time +
-                               autocvar_g_balance_pause_health_rot);
-                       return;
-               }
-               case RESOURCE_ARMOR:
-               {
-                       receiver.pauserotarmor_finished =
-                               max(receiver.pauserotarmor_finished, time +
-                               autocvar_g_balance_pause_armor_rot);
-                       return;
-               }
-               case RESOURCE_FUEL:
-               {
-                       receiver.pauserotfuel_finished = max(receiver.pauserotfuel_finished,
-                               time + autocvar_g_balance_pause_fuel_rot);
-                       return;
-               }
-       }
- }
- void GiveResourceViaProperty(entity receiver, .float resource_property,
-       float amount)
- {
-       GiveResource(receiver, GetResourceType(resource_property), amount);
- }
 +void GiveRandomWeapons(entity receiver, int num_weapons, string weapon_names,
 +      float shells, float bullets, float rockets, float cells, float plasma)
 +{
 +      if (num_weapons == 0)
 +      {
 +              return;
 +      }
 +      int num_potential_weapons = tokenize_console(weapon_names);
 +      for (int i = 0; i < num_weapons; ++i)
 +      {
 +              RandomSelection_Init();
 +              for (int j = 0; j < num_potential_weapons; ++j)
 +              {
 +                      string weapon = argv(j);
 +                      FOREACH(Weapons, it != WEP_Null,
 +                      {
 +                              // Finding a weapon which player doesn't have.
 +                              if (!(receiver.weapons & it.m_wepset) && (it.netname == weapon))
 +                              {
 +                                      RandomSelection_AddEnt(it, 1, 1);
 +                                      break;
 +                              }
 +                      });
 +              }
 +              if (RandomSelection_chosen_ent == NULL)
 +              {
 +                      return;
 +              }
 +              receiver.weapons |= RandomSelection_chosen_ent.m_wepset;
 +              switch (RandomSelection_chosen_ent.ammo_field)
 +              {
 +                      case (ammo_shells):
 +                      {
 +                              if (receiver.ammo_shells != 0)
 +                              {
 +                                      break;
 +                              }
 +                              GiveResource(receiver, RESOURCE_SHELLS, shells);
 +                              break;
 +                      }
 +                      case (ammo_nails):
 +                      {
 +                              if (receiver.ammo_nails != 0)
 +                              {
 +                                      break;
 +                              }
 +                              GiveResource(receiver, RESOURCE_BULLETS, bullets);
 +                              break;
 +                      }
 +                      case (ammo_rockets):
 +                      {
 +                              if (receiver.ammo_rockets != 0)
 +                              {
 +                                      break;
 +                              }
 +                              GiveResource(receiver, RESOURCE_ROCKETS, rockets);
 +                              break;
 +                      }
 +                      case (ammo_cells):
 +                      {
 +                              if (receiver.ammo_cells != 0)
 +                              {
 +                                      break;
 +                              }
 +                              GiveResource(receiver, RESOURCE_CELLS, cells);
 +                              break;
 +                      }
 +                      case (ammo_plasma):
 +                      {
 +                              if (receiver.ammo_plasma != 0)
 +                              {
 +                                      break;
 +                              }
 +                              GiveResource(receiver, RESOURCE_PLASMA, plasma);
 +                              break;
 +                      }
 +              }
 +      }
 +}
 +
  float Item_GiveAmmoTo(entity item, entity player, .float ammotype, float ammomax)
  {
        if (!item.(ammotype))
                        {
                                amount = ammomax - player.(ammotype);
                        }
-                       GiveResourceViaProperty(player, ammotype, amount);
+                       GiveResource(player, GetResourceType(ammotype), amount);
                        return true;
                }
        }
                float mi = min(item.(ammotype), ammomax);
                if (player.(ammotype) < mi)
                {
-                       GiveResourceViaProperty(player, ammotype, mi - player.(ammotype));
+                       GiveResource(player, GetResourceType(ammotype), mi -
+                               player.(ammotype));
                }
                return true;
        }
diff --combined qcsrc/common/t_items.qh
@@@ -4,22 -4,6 +4,6 @@@
  #include <server/defs.qh>
  #endif
  
- /// \brief Unconditional maximum amount of resources the player can have.
- const int RESOURCE_AMOUNT_HARD_LIMIT = 999;
- /// \brief Describes the available resource types.
- enum
- {
-       RESOURCE_HEALTH, ///< Health.
-       RESOURCE_ARMOR, ///< Armor.
-       RESOURCE_SHELLS, ///< Shells (used by shotgun).
-       RESOURCE_BULLETS, ///< Bullets (used by machinegun and rifle)
-       RESOURCE_ROCKETS, ///< Rockets (used by mortar, hagar, devastator, etc).
-       RESOURCE_CELLS, ///< Cells (used by electro, crylink, vortex, etc)
-       RESOURCE_PLASMA, ///< Plasma (unused).
-       RESOURCE_FUEL ///< Fuel (used by jetpack).
- };
  const int AMMO_COUNT = 4; // amount of ammo types to show in the inventory panel
  
  // item networking
@@@ -100,50 -84,6 +84,19 @@@ void Item_ScheduleRespawn(entity e)
  
  void Item_ScheduleInitialRespawn(entity e);
  
- /// \brief Converts resource entity property to resource type.
- /// \param[in] resource_property Resource entity property to convert.
- /// \return Resource type (a RESOURCE_* constant).
- int GetResourceType(.float resource_property);
- /// \brief Converts resource type (a RESOURCE_* constant) to entity property.
- /// \param[in] resource_type Type of the resource.
- /// \return Entity proprty for that resource.
- .float GetResourceProperty(int resource_type);
- /// \brief Returns the maximum amount of the given resource.
- /// \param[in] e Entity to check.
- /// \param[in] resource_type Type of the resource (a RESOURCE_* constant).
- /// \return Maximum amount of the given resource.
- float GetResourceLimit(entity e, int resource_type);
- /// \brief Gives player a resource such as health, armor or ammo.
- /// \param[in,out] receiver Entity to give resource to.
- /// \param[in] resource_type Type of the resource (a RESOURCE_* constant).
- /// \param[in] amount Amount of resource to give.
- /// \return No return.
- void GiveResource(entity receiver, int resource_type, float amount);
- /// \brief Gives player a resource such as health, armor or ammo.
- /// \param[in,out] e Entity to give resource to.
- /// \param[in] resource_property Entity property of the resource.
- /// \param[in] amount Amount of resource to give.
- /// \return No return.
- void GiveResourceViaProperty(entity receiver, .float resource_property,
-       float amount);
 +/// \brief Give several random weapons and ammo to the entity.
 +/// \param[in,out] receiver Entity to give weapons to.
 +/// \param[in] num_weapons Number of weapons to give.
 +/// \param[in] weapon_names Names of weapons to give separated by spaces.
 +/// \param[in] shells Amount of shells to give with shell-based weapon.
 +/// \param[in] bullets Amount of bullets to give with bullet-based weapon.
 +/// \param[in] rockets Amount of rockets to give with rocket-based weapon.
 +/// \param[in] cells Amount of cells to give with cell-based weapon.
 +/// \param[in] plasma Amount of plasma to give with plasma-based weapon.
 +/// \return No return.
 +void GiveRandomWeapons(entity receiver, int num_weapons, string weapon_names,
 +      float shells, float bullets, float rockets, float cells, float plasma);
 +
  float Item_GiveAmmoTo(entity item, entity player, .float ammotype, float ammomax);
  
  float Item_GiveTo(entity item, entity player);
diff --combined qcsrc/server/client.qc
@@@ -12,6 -12,7 +12,7 @@@
  #include "teamplay.qh"
  #include "playerdemo.qh"
  #include "spawnpoints.qh"
+ #include "resources.qh"
  #include "g_damage.qh"
  #include "g_hook.qh"
  #include "command/common.qh"
@@@ -544,10 -545,6 +545,10 @@@ void PutPlayerInServer(entity this
                this.health = start_health;
                this.armorvalue = start_armorvalue;
                this.weapons = start_weapons;
 +              GiveRandomWeapons(this, random_start_weapons_count,
 +                      cvar_string("g_random_start_weapons"), random_start_shells,
 +                      random_start_bullets, random_start_rockets, random_start_cells,
 +                      random_start_plasma);
        }
        SetSpectatee_status(this, 0);