qcsrc/server/resources.qc

   1 #include "resources.qh"
   2
   3 /// \file
   4 /// \brief Source file that contains implementation of the resource system.
   5 /// \author Lyberta
   6 /// \copyright GNU GPLv2 or any later version.
   7
   8 #include "autocvars.qh"
   9 #include "miscfunctions.qh"
  10
  11 float GetResourceLimit(entity e, int resource_type)
  12 {
  13         float limit;
  14         switch (resource_type)
  15         {
  16                 case RESOURCE_HEALTH:
  17                 {
  18                         limit = autocvar_g_balance_health_limit;
  19                         break;
  20                 }
  21                 case RESOURCE_ARMOR:
  22                 {
  23                         limit = autocvar_g_balance_armor_limit;
  24                         break;
  25                 }
  26                 case RESOURCE_SHELLS:
  27                 {
  28                         limit = g_pickup_shells_max;
  29                         break;
  30                 }
  31                 case RESOURCE_BULLETS:
  32                 {
  33                         limit = g_pickup_nails_max;
  34                         break;
  35                 }
  36                 case RESOURCE_ROCKETS:
  37                 {
  38                         limit = g_pickup_rockets_max;
  39                         break;
  40                 }
  41                 case RESOURCE_CELLS:
  42                 {
  43                         limit = g_pickup_cells_max;
  44                         break;
  45                 }
  46                 case RESOURCE_PLASMA:
  47                 {
  48                         limit = g_pickup_plasma_max;
  49                         break;
  50                 }
  51                 case RESOURCE_FUEL:
  52                 {
  53                         limit = autocvar_g_balance_fuel_limit;
  54                         break;
  55                 }
  56                 default:
  57                 {
  58                         error("GetResourceLimit: Invalid resource type.");
  59                         return 0;
  60                 }
  61         }
  62         MUTATOR_CALLHOOK(GetResourceLimit, e, resource_type, limit);
  63         limit = M_ARGV(2, float);
  64         if (limit > RESOURCE_AMOUNT_HARD_LIMIT)
  65         {
  66                 limit = RESOURCE_AMOUNT_HARD_LIMIT;
  67         }
  68         return limit;
  69 }
  70
  71 float GetResourceAmount(entity e, int resource_type)
  72 {
  73         .float resource_field = GetResourceField(resource_type);
  74         return e.(resource_field);
  75 }
  76
  77 void SetResourceAmount(entity e, int resource_type, float amount)
  78 {
  79         bool forbid = MUTATOR_CALLHOOK(SetResourceAmount, e, resource_type, amount);
  80         if (forbid)
  81         {
  82                 return;
  83         }
  84         resource_type = M_ARGV(1, int);
  85         amount = M_ARGV(2, float);
  86         .float resource_field = GetResourceField(resource_type);
  87         if (e.(resource_field) == amount)
  88         {
  89                 return;
  90         }
  91         float max_amount = GetResourceLimit(e, resource_type);
  92         if (amount > max_amount)
  93         {
  94                 amount = max_amount;
  95         }
  96         e.(resource_field) = amount;
  97         MUTATOR_CALLHOOK(ResourceAmountChanged, e, resource_type, amount);
  98 }
  99
 100 void GiveResource(entity receiver, int resource_type, float amount)
 101 {
 102         if (amount == 0)
 103         {
 104                 return;
 105         }
 106         bool forbid = MUTATOR_CALLHOOK(GiveResource, receiver, resource_type,
 107                 amount);
 108         if (forbid)
 109         {
 110                 return;
 111         }
 112         resource_type = M_ARGV(1, int);
 113         amount = M_ARGV(2, float);
 114         if (amount <= 0)
 115         {
 116                 return;
 117         }
 118         SetResourceAmount(receiver, resource_type,
 119                 GetResourceAmount(receiver, resource_type) + amount);
 120         switch (resource_type)
 121         {
 122                 case RESOURCE_HEALTH:
 123                 {
 124                         receiver.pauserothealth_finished =
 125                                 max(receiver.pauserothealth_finished, time +
 126                                 autocvar_g_balance_pause_health_rot);
 127                         return;
 128                 }
 129                 case RESOURCE_ARMOR:
 130                 {
 131                         receiver.pauserotarmor_finished =
 132                                 max(receiver.pauserotarmor_finished, time +
 133                                 autocvar_g_balance_pause_armor_rot);
 134                         return;
 135                 }
 136                 case RESOURCE_FUEL:
 137                 {
 138                         receiver.pauserotfuel_finished = max(receiver.pauserotfuel_finished,
 139                                 time + autocvar_g_balance_pause_fuel_rot);
 140                         return;
 141                 }
 142         }
 143 }
 144
 145 void GiveResourceWithLimit(entity receiver, int resource_type, float amount,
 146         float limit)
 147 {
 148         if (amount == 0)
 149         {
 150                 return;
 151         }
 152         bool forbid = MUTATOR_CALLHOOK(GiveResourceWithLimit, receiver,
 153                 resource_type, amount, limit);
 154         if (forbid)
 155         {
 156                 return;
 157         }
 158         resource_type = M_ARGV(1, int);
 159         amount = M_ARGV(2, float);
 160         limit = M_ARGV(3, float);
 161         if (amount == 0)
 162         {
 163                 return;
 164         }
 165         float current_amount = GetResourceAmount(receiver, resource_type);
 166         if (current_amount + amount > limit)
 167         {
 168                 amount = limit - current_amount;
 169         }
 170         GiveResource(receiver, resource_type, amount);
 171 }
 172
 173 int GetResourceType(.float resource_field)
 174 {
 175         switch (resource_field)
 176         {
 177                 case health: { return RESOURCE_HEALTH; }
 178                 case armorvalue: { return RESOURCE_ARMOR; }
 179                 case ammo_shells: { return RESOURCE_SHELLS; }
 180                 case ammo_nails: { return RESOURCE_BULLETS; }
 181                 case ammo_rockets: { return RESOURCE_ROCKETS; }
 182                 case ammo_cells: { return RESOURCE_CELLS; }
 183                 case ammo_plasma: { return RESOURCE_PLASMA; }
 184                 case ammo_fuel: { return RESOURCE_FUEL; }
 185         }
 186         error("GetResourceType: Invalid field.");
 187         return 0;
 188 }
 189
 190 .float GetResourceField(int resource_type)
 191 {
 192         switch (resource_type)
 193         {
 194                 case RESOURCE_HEALTH: { return health; }
 195                 case RESOURCE_ARMOR: { return armorvalue; }
 196                 case RESOURCE_SHELLS: { return ammo_shells; }
 197                 case RESOURCE_BULLETS: { return ammo_nails; }
 198                 case RESOURCE_ROCKETS: { return ammo_rockets; }
 199                 case RESOURCE_CELLS: { return ammo_cells; }
 200                 case RESOURCE_PLASMA: { return ammo_plasma; }
 201                 case RESOURCE_FUEL: { return ammo_fuel; }
 202         }
 203         error("GetResourceField: Invalid resource type.");
 204         return health;
 205 }