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