qcsrc/server/resources.qc

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