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 void GiveResource(entity receiver, int resource_type, float amount)
  66 {
  67         if (amount == 0)
  68         {
  69                 return;
  70         }
  71         bool forbid = MUTATOR_CALLHOOK(GiveResource, receiver, resource_type,
  72                 amount);
  73         if (forbid)
  74         {
  75                 return;
  76         }
  77         resource_type = M_ARGV(1, int);
  78         amount = M_ARGV(2, float);
  79         .float resource_property = GetResourceProperty(resource_type);
  80         float max_amount = GetResourceLimit(receiver, resource_type);
  81         receiver.(resource_property) = bound(receiver.(resource_property),
  82                 receiver.(resource_property) + amount, max_amount);
  83         switch (resource_type)
  84         {
  85                 case RESOURCE_HEALTH:
  86                 {
  87                         receiver.pauserothealth_finished =
  88                                 max(receiver.pauserothealth_finished, time +
  89                                 autocvar_g_balance_pause_health_rot);
  90                         return;
  91                 }
  92                 case RESOURCE_ARMOR:
  93                 {
  94                         receiver.pauserotarmor_finished =
  95                                 max(receiver.pauserotarmor_finished, time +
  96                                 autocvar_g_balance_pause_armor_rot);
  97                         return;
  98                 }
  99                 case RESOURCE_FUEL:
 100                 {
 101                         receiver.pauserotfuel_finished = max(receiver.pauserotfuel_finished,
 102                                 time + autocvar_g_balance_pause_fuel_rot);
 103                         return;
 104                 }
 105         }
 106 }
 107
 108 int GetResourceType(.float resource_property)
 109 {
 110         switch (resource_property)
 111         {
 112                 case health: { return RESOURCE_HEALTH; }
 113                 case armorvalue: { return RESOURCE_ARMOR; }
 114                 case ammo_shells: { return RESOURCE_SHELLS; }
 115                 case ammo_nails: { return RESOURCE_BULLETS; }
 116                 case ammo_rockets: { return RESOURCE_ROCKETS; }
 117                 case ammo_cells: { return RESOURCE_CELLS; }
 118                 case ammo_plasma: { return RESOURCE_PLASMA; }
 119                 case ammo_fuel: { return RESOURCE_FUEL; }
 120         }
 121         error("GetResourceType: Invalid property.");
 122         return 0;
 123 }
 124
 125 .float GetResourceProperty(int resource_type)
 126 {
 127         switch (resource_type)
 128         {
 129                 case RESOURCE_HEALTH: { return health; }
 130                 case RESOURCE_ARMOR: { return armorvalue; }
 131                 case RESOURCE_SHELLS: { return ammo_shells; }
 132                 case RESOURCE_BULLETS: { return ammo_nails; }
 133                 case RESOURCE_ROCKETS: { return ammo_rockets; }
 134                 case RESOURCE_CELLS: { return ammo_cells; }
 135                 case RESOURCE_PLASMA: { return ammo_plasma; }
 136                 case RESOURCE_FUEL: { return ammo_fuel; }
 137         }
 138         error("GetResourceProperty: Invalid resource type.");
 139         return health;
 140 }