qcsrc/server/antilag.qc

   1 #define ANTILAG_MAX_ORIGINS 64
   2 .vector antilag_origins[ANTILAG_MAX_ORIGINS];
   3 .float antilag_times[ANTILAG_MAX_ORIGINS];
   4 .float antilag_index;
   5 .vector antilag_saved_origin;
   6 .float antilag_takenback;
   7
   8 .float antilag_debug;
   9
  10 void antilag_dummy()
  11 {
  12         self.antilag_times = 0;
  13         self.antilag_origins = '0 0 0';
  14 }
  15
  16 void antilag_record(entity e, float t)
  17 {
  18     if(e.vehicle)
  19         antilag_record(e.vehicle, t);
  20
  21         if(time < e.(antilag_times[e.antilag_index]))
  22                 return;
  23         e.antilag_index = e.antilag_index + 1;
  24         if(e.antilag_index >= ANTILAG_MAX_ORIGINS)
  25                 e.antilag_index = 0;
  26         e.(antilag_times[e.antilag_index]) = t;
  27         e.(antilag_origins[e.antilag_index]) = e.origin;
  28
  29         if(e.antilag_debug)
  30                 te_spark(antilag_takebackorigin(e, t - e.antilag_debug), '0 0 0', 32);
  31
  32 }
  33
  34 // finds the index BEFORE t
  35 float antilag_find(entity e, float t)
  36 {
  37         float i;
  38
  39         for(i = e.antilag_index; i > 0; --i)
  40                 if(e.(antilag_times[i]) >= t)
  41                         if(e.(antilag_times[i - 1]) < t)
  42                                 return i - 1;
  43
  44         if(e.(antilag_times[0]) >= t)
  45                 if(e.(antilag_times[ANTILAG_MAX_ORIGINS - 1]) < t)
  46                         return ANTILAG_MAX_ORIGINS - 1;
  47
  48         for(i = ANTILAG_MAX_ORIGINS - 1; i > e.antilag_index + 1; --i)
  49                 if(e.(antilag_times[i]) >= t)
  50                         if(e.(antilag_times[i - 1]) < t)
  51                                 return i - 1;
  52
  53         // if we get here, t is sandwiched nowhere, so let's assume it's in the present
  54         return -1;
  55 }
  56
  57 vector lerpv(float t0, vector v0, float t1, vector v1, float t)
  58 {
  59         return v0 + (v1 - v0) * ((t - t0) / (t1 - t0));
  60 }
  61
  62 vector antilag_takebackorigin(entity e, float t)
  63 {
  64         float i0, i1;
  65
  66         i0 = antilag_find(e, t);
  67         if(i0 < 0)
  68         {
  69                 // IN THE PRESENT
  70                 if(e.antilag_takenback)
  71                         return e.antilag_saved_origin;
  72                 else
  73                         return e.origin;
  74         }
  75         i1 = i0 + 1;
  76         if(i1 >= ANTILAG_MAX_ORIGINS)
  77                 i1 = 0;
  78
  79         return lerpv(e.(antilag_times[i0]), e.(antilag_origins[i0]), e.(antilag_times[i1]), e.(antilag_origins[i1]), t);
  80 }
  81
  82 vector antilag_takebackavgvelocity(entity e, float t0, float t1)
  83 {
  84         vector o0, o1;
  85
  86         if(t0 >= t1)
  87                 return '0 0 0';
  88         o0 = antilag_takebackorigin(e, t0);
  89         o1 = antilag_takebackorigin(e, t1);
  90         return (o1 - o0) * (1 / (t1 - t0));
  91 }
  92
  93 void antilag_takeback(entity e, float t)
  94 {
  95         if(e.vehicle)
  96                 antilag_takeback(e.vehicle, t);
  97
  98         if(!e.antilag_takenback)
  99                 e.antilag_saved_origin = e.origin;
 100
 101         setorigin(e, antilag_takebackorigin(e, t));
 102         e.antilag_takenback = TRUE;
 103 }
 104
 105 void antilag_restore(entity e)
 106 {
 107         if(e.vehicle)
 108                 antilag_restore(e.vehicle);
 109
 110         if(!e.antilag_takenback)
 111                 return;
 112
 113         setorigin(e, e.antilag_saved_origin);
 114         e.antilag_takenback = FALSE;
 115 }
 116
 117 void antilag_clear(entity e)
 118 {
 119         float i;
 120
 121         antilag_restore(e);
 122         for(i = 0; i < ANTILAG_MAX_ORIGINS; ++i)
 123         {
 124                 e.(antilag_times[i]) = -2342;
 125                 e.(antilag_origins[i]) = self.origin;
 126         }
 127         e.antilag_index = ANTILAG_MAX_ORIGINS - 1; // next one is 0
 128 }