data/qcsrc/server/g_subs.qc

   1 void SUB_Null() {};
   2
   3 void(vector destangle, float tspeed, void() func) SUB_CalcAngleMove;
   4 void()  SUB_CalcMoveDone;
   5 void() SUB_CalcAngleMoveDone;
   6 //void() SUB_UseTargets;
   7 void() SUB_Remove;
   8
   9 void spawnfunc_info_null (void)
  10 {
  11         remove(self);
  12         // if anything breaks, tell the mapper to fix his map! info_null is meant to remove itself immediately.
  13 }
  14
  15 /*
  16 ==================
  17 SUB_Remove
  18
  19 Remove self
  20 ==================
  21 */
  22 void SUB_Remove (void)
  23 {
  24         remove (self);
  25 }
  26
  27 /*
  28 ==================
  29 SUB_VanishOrRemove
  30
  31 Makes client invisible or removes non-client
  32 ==================
  33 */
  34 void SUB_VanishOrRemove (entity ent)
  35 {
  36         if (ent.flags & FL_CLIENT)
  37         {
  38                 // vanish
  39                 ent.model = "";
  40                 ent.effects = 0;
  41                 ent.glow_size = 0;
  42                 ent.pflags = 0;
  43         }
  44         else
  45         {
  46                 // remove
  47                 remove (ent);
  48         }
  49 }
  50
  51 void SUB_SetFade_Think (void)
  52 {
  53         self.think = SUB_SetFade_Think;
  54         self.nextthink = self.fade_time;
  55         self.alpha = 1 - (time - self.fade_time) * self.fade_rate;
  56         if (self.alpha < 0.01)
  57                 SUB_VanishOrRemove(self);
  58         self.alpha = bound(0.01, self.alpha, 1);
  59 }
  60
  61 /*
  62 ==================
  63 SUB_SetFade
  64
  65 Fade 'ent' out when time >= 'when'
  66 ==================
  67 */
  68 void SUB_SetFade (entity ent, float when, float fadetime)
  69 {
  70         //if (ent.flags & FL_CLIENT) // && ent.deadflag != DEAD_NO)
  71         //      return;
  72         //ent.alpha = 1;
  73         ent.fade_rate = 1/fadetime;
  74         ent.fade_time = when;
  75         ent.think = SUB_SetFade_Think;
  76         ent.nextthink = when;
  77 }
  78
  79 /*
  80 =============
  81 SUB_CalcMove
  82
  83 calculate self.velocity and self.nextthink to reach dest from
  84 self.origin traveling at speed
  85 ===============
  86 */
  87 void SUB_CalcMoveDone (void)
  88 {
  89         // After moving, set origin to exact final destination
  90
  91         setorigin (self, self.finaldest);
  92         self.velocity = '0 0 0';
  93         self.nextthink = -1;
  94         if (self.think1)
  95                 self.think1 ();
  96 }
  97
  98 void SUB_CalcMove (vector tdest, float tspeed, void() func)
  99 {
 100         vector  delta;
 101         float   traveltime;
 102
 103         if (!tspeed)
 104                 objerror ("No speed is defined!");
 105
 106         self.think1 = func;
 107         self.finaldest = tdest;
 108         self.think = SUB_CalcMoveDone;
 109
 110         if (tdest == self.origin)
 111         {
 112                 self.velocity = '0 0 0';
 113                 self.nextthink = self.ltime + 0.1;
 114                 return;
 115         }
 116
 117         delta = tdest - self.origin;
 118         traveltime = vlen (delta) / tspeed;
 119
 120         if (traveltime < 0.1)
 121         {
 122                 self.velocity = '0 0 0';
 123                 self.nextthink = self.ltime + 0.1;
 124                 return;
 125         }
 126
 127         self.velocity = delta * (1/traveltime); // QuakeC doesn't allow vector/float division
 128
 129         self.nextthink = self.ltime + traveltime;
 130 }
 131
 132 void SUB_CalcMoveEnt (entity ent, vector tdest, float tspeed, void() func)
 133 {
 134         entity  oldself;
 135
 136         oldself = self;
 137         self = ent;
 138
 139         SUB_CalcMove (tdest, tspeed, func);
 140
 141         self = oldself;
 142 }
 143
 144 /*
 145 =============
 146 SUB_CalcAngleMove
 147
 148 calculate self.avelocity and self.nextthink to reach destangle from
 149 self.angles rotating
 150
 151 The calling function should make sure self.think is valid
 152 ===============
 153 */
 154 void SUB_CalcAngleMoveDone (void)
 155 {
 156         // After rotating, set angle to exact final angle
 157         self.angles = self.finalangle;
 158         self.avelocity = '0 0 0';
 159         self.nextthink = -1;
 160         if (self.think1)
 161                 self.think1 ();
 162 }
 163
 164 void SUB_CalcAngleMove (vector destangle, float tspeed, void() func)
 165 {
 166         vector  delta;
 167         float   traveltime;
 168
 169         if (!tspeed)
 170                 objerror ("No speed is defined!");
 171
 172         delta = destangle - self.angles;
 173         traveltime = vlen (delta) / tspeed;
 174
 175         self.avelocity = delta * (1 / traveltime);
 176
 177         self.think1 = func;
 178         self.finalangle = destangle;
 179
 180         self.think = SUB_CalcAngleMoveDone;
 181         self.nextthink = self.ltime + traveltime;
 182 }
 183
 184 void SUB_CalcAngleMoveEnt (entity ent, vector destangle, float tspeed, void() func)
 185 {
 186         entity  oldself;
 187
 188         oldself = self;
 189         self = ent;
 190
 191         SUB_CalcAngleMove (destangle, tspeed, func);
 192
 193         self = oldself;
 194 }
 195
 196 /*
 197 ==================
 198 main
 199
 200 unused but required by the engine
 201 ==================
 202 */
 203 void main (void)
 204 {
 205
 206 }
 207
 208 // Misc
 209
 210 /*
 211 ==================
 212 traceline_antilag
 213
 214 A version of traceline that must be used by SOLID_SLIDEBOX things that want to hit SOLID_CORPSE things with a trace attack
 215 Additionally it moves players back into the past before the trace and restores them afterward.
 216 ==================
 217 */
 218 void traceline_antilag (entity source, vector v1, vector v2, float nomonst, entity forent, float lag)
 219 {
 220         local entity player;
 221         local float oldsolid;
 222
 223         // check whether antilagged traces are enabled
 224         if (lag < 0.001)
 225                 lag = 0;
 226         if (clienttype(forent) != CLIENTTYPE_REAL)
 227                 lag = 0; // only antilag for clients
 228         if (lag)
 229         if (cvar("g_antilag") != 2)
 230                 lag = 0;
 231
 232         // change shooter to SOLID_BBOX so the shot can hit corpses
 233         oldsolid = source.solid;
 234         source.solid = SOLID_BBOX;
 235
 236         if (lag)
 237         {
 238                 // take players back into the past
 239                 player = player_list;
 240                 while (player)
 241                 {
 242                         antilag_takeback(player, time - lag);
 243                         player = player.nextplayer;
 244                 }
 245         }
 246
 247         // do the trace
 248         traceline (v1, v2, nomonst, forent);
 249
 250         // restore players to current positions
 251         if (lag)
 252         {
 253                 player = player_list;
 254                 while (player)
 255                 {
 256                         antilag_restore(player);
 257                         player = player.nextplayer;
 258                 }
 259         }
 260
 261         // restore shooter solid type
 262         source.solid = oldsolid;
 263 }
 264
 265 /*
 266 ==================
 267 findbetterlocation
 268
 269 Returns a point at least 12 units away from walls
 270 (useful for explosion animations, although the blast is performed where it really happened)
 271 Ripped from DPMod
 272 ==================
 273 */
 274 vector findbetterlocation (vector org, float mindist)
 275 {
 276         vector  loc;
 277         vector vec;
 278         float c;
 279
 280         vec = mindist * '1 0 0';
 281         c = 0;
 282         while (c < 6)
 283         {
 284                 traceline (org, org + vec, TRUE, world);
 285                 vec = vec * -1;
 286                 if (trace_fraction < 1)
 287                 {
 288                         loc = trace_endpos;
 289                         traceline (loc, loc + vec, TRUE, world);
 290                         if (trace_fraction >= 1)
 291                                 org = loc + vec;
 292                 }
 293                 if (c & 1)
 294                 {
 295                         vec_z = vec_y;
 296                         vec_y = vec_x;
 297                         vec_x = vec_z;
 298                 }
 299                 c = c + 1;
 300         }
 301
 302         return org;
 303 }
 304
 305 /*
 306 ==================
 307 crandom
 308
 309 Returns a random number between -1.0 and 1.0
 310 ==================
 311 */
 312 float crandom (void)
 313 {
 314         return 2 * (random () - 0.5);
 315 }
 316
 317 /*
 318 ==================
 319 Angc used for animations
 320 ==================
 321 */
 322
 323
 324 float angc (float a1, float a2)
 325 {
 326         float   a;
 327
 328         while (a1 > 180)
 329                 a1 = a1 - 360;
 330         while (a1 < -179)
 331                 a1 = a1 + 360;
 332
 333         while (a2 > 180)
 334                 a2 = a2 - 360;
 335         while (a2 < -179)
 336                 a2 = a2 + 360;
 337
 338         a = a1 - a2;
 339         while (a > 180)
 340                 a = a - 360;
 341         while (a < -179)
 342                 a = a + 360;
 343
 344         return a;
 345 }
 346
 347
 348 /*
 349 ================
 350 InitTrigger
 351 ================
 352 */
 353
 354 void SetMovedir()
 355 {
 356         if (self.movedir != '0 0 0')
 357                 self.movedir = normalize(self.movedir);
 358         else
 359         {
 360                 if (self.angles == '0 -1 0')
 361                         self.movedir = '0 0 1';
 362                 else if (self.angles == '0 -2 0')
 363                         self.movedir = '0 0 -1';
 364                 else
 365                 {
 366                         makevectors (self.angles);
 367                         self.movedir = v_forward;
 368                 }
 369         }
 370
 371         self.angles = '0 0 0';
 372 };
 373
 374 void InitTrigger()
 375 {
 376 // trigger angles are used for one-way touches.  An angle of 0 is assumed
 377 // to mean no restrictions, so use a yaw of 360 instead.
 378         if (self.movedir == '0 0 0')
 379         if (self.angles != '0 0 0')
 380                 SetMovedir ();
 381         self.solid = SOLID_TRIGGER;
 382         setmodel (self, self.model);    // set size and link into world, no precision needed
 383         self.movetype = MOVETYPE_NONE;
 384         self.modelindex = 0;
 385         self.model = "";
 386 };
 387
 388 void InitSolidBSPTrigger()
 389 {
 390 // trigger angles are used for one-way touches.  An angle of 0 is assumed
 391 // to mean no restrictions, so use a yaw of 360 instead.
 392         if (self.movedir == '0 0 0')
 393         if (self.angles != '0 0 0')
 394                 SetMovedir ();
 395         self.solid = SOLID_BSP;
 396         setmodel (self, self.model);    // set size and link into world, no precision needed
 397         self.movetype = MOVETYPE_PUSH;
 398 //      self.modelindex = 0;
 399         self.model = "";
 400 };