qcsrc/server/resources.qc

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