qcsrc/warpzonelib/common.qc

   1 void WarpZone_Accumulator_Clear(entity acc)
   2 {
   3         acc.warpzone_transform = '0 0 0';
   4         acc.warpzone_shift = '0 0 0';
   5 }
   6 void WarpZone_Accumulator_AddTransform(entity acc, vector t, vector s)
   7 {
   8         vector tr, st;
   9         tr = AnglesTransform_Multiply(t, acc.warpzone_transform);
  10         st = AnglesTransform_Multiply_GetPostShift(t, s, acc.warpzone_transform, acc.warpzone_shift);
  11         acc.warpzone_transform = tr;
  12         acc.warpzone_shift = st;
  13 }
  14 void WarpZone_Accumulator_Add(entity acc, entity wz)
  15 {
  16         WarpZone_Accumulator_AddTransform(acc, wz.warpzone_transform, wz.warpzone_shift);
  17 }
  18 void WarpZone_Accumulator_AddInverseTransform(entity acc, vector t, vector s)
  19 {
  20         vector tt, ss;
  21         tt = AnglesTransform_Invert(t);
  22         ss = AnglesTransform_PrePostShift_GetPostShift(s, tt, '0 0 0');
  23         WarpZone_Accumulator_AddTransform(acc, tt, ss);
  24         // yes, this probably can be done simpler... but this way is "obvious" :)
  25 }
  26 void WarpZone_Accumulator_AddInverse(entity acc, entity wz)
  27 {
  28         WarpZone_Accumulator_AddInverseTransform(acc, wz.warpzone_transform, wz.warpzone_shift);
  29 }
  30
  31 .vector(vector, vector) camera_transform;
  32 float autocvar_cl_warpzone_usetrace = 1;
  33 vector WarpZone_camera_transform(vector org, vector ang)
  34 {
  35         vector vf, vr, vu;
  36         if(self.warpzone_fadestart)
  37                 if(vlen(org - self.origin - 0.5 * (self.mins + self.maxs)) > self.warpzone_fadeend + 400)
  38                         return org;
  39                         // don't transform if zone faded out (plus 400qu safety margin for typical speeds and latencies)
  40                         // unneeded on client, on server this helps a lot
  41         vf = v_forward;
  42         vr = v_right;
  43         vu = v_up;
  44         org = WarpZone_TransformOrigin(self, org);
  45         vf = WarpZone_TransformVelocity(self, vf);
  46         vr = WarpZone_TransformVelocity(self, vr);
  47         vu = WarpZone_TransformVelocity(self, vu);
  48         if(autocvar_cl_warpzone_usetrace)
  49                 traceline(self.warpzone_targetorigin, org, MOVE_NOMONSTERS, world);
  50         else
  51                 trace_endpos = self.warpzone_targetorigin;
  52         v_forward = vf;
  53         v_right = vr;
  54         v_up = vu;
  55         return org;
  56 }
  57
  58 void WarpZone_SetUp(entity e, vector my_org, vector my_ang, vector other_org, vector other_ang)
  59 {
  60         e.warpzone_transform = AnglesTransform_RightDivide(other_ang, AnglesTransform_TurnDirectionFR(my_ang));
  61         e.warpzone_shift = AnglesTransform_PrePostShift_GetPostShift(my_org, e.warpzone_transform, other_org);
  62         e.warpzone_origin = my_org;
  63         e.warpzone_targetorigin = other_org;
  64         e.warpzone_angles = my_ang;
  65         e.warpzone_targetangles = other_ang;
  66         fixedmakevectors(my_ang); e.warpzone_forward = v_forward;
  67         fixedmakevectors(other_ang); e.warpzone_targetforward = v_forward;
  68         e.camera_transform = WarpZone_camera_transform;
  69 }
  70
  71 vector WarpZone_Camera_camera_transform(vector org, vector ang)
  72 {
  73         // a fixed camera view
  74         if(self.warpzone_fadestart)
  75                 if(vlen(org - self.origin - 0.5 * (self.mins + self.maxs)) > self.warpzone_fadeend + 400)
  76                         return org;
  77                         // don't transform if zone faded out (plus 400qu safety margin for typical speeds and latencies)
  78                         // unneeded on client, on server this helps a lot
  79         trace_endpos = self.warpzone_origin;
  80         makevectors(self.warpzone_angles);
  81         return self.warpzone_origin;
  82 }
  83
  84 void WarpZone_Camera_SetUp(entity e, vector my_org, vector my_ang) // we assume that e.oldorigin and e.avelocity point to view origin and direction
  85 {
  86         e.warpzone_origin = my_org;
  87         e.warpzone_angles = my_ang;
  88         e.camera_transform = WarpZone_Camera_camera_transform;
  89 }
  90
  91 .entity enemy;
  92
  93 vector WarpZoneLib_BoxTouchesBrush_mins;
  94 vector WarpZoneLib_BoxTouchesBrush_maxs;
  95 entity WarpZoneLib_BoxTouchesBrush_ent;
  96 entity WarpZoneLib_BoxTouchesBrush_ignore;
  97 float WarpZoneLib_BoxTouchesBrush_Recurse()
  98 {
  99         float s;
 100         entity se;
 101         float f;
 102
 103         tracebox('0 0 0', WarpZoneLib_BoxTouchesBrush_mins, WarpZoneLib_BoxTouchesBrush_maxs, '0 0 0', MOVE_NOMONSTERS, WarpZoneLib_BoxTouchesBrush_ignore);
 104 #ifdef CSQC
 105         if (trace_networkentity)
 106         {
 107                 dprint("hit a network ent, cannot continue WarpZoneLib_BoxTouchesBrush\n");
 108                 // we cannot continue, as a player blocks us...
 109                 // so, abort
 110                 return 0;
 111         }
 112 #endif
 113         if (!trace_ent)
 114                 return 0;
 115         if (trace_ent == WarpZoneLib_BoxTouchesBrush_ent)
 116                 return 1;
 117
 118         se = trace_ent;
 119         s = se.solid;
 120         se.solid = SOLID_NOT;
 121         f = WarpZoneLib_BoxTouchesBrush_Recurse();
 122         se.solid = s;
 123
 124         return f;
 125 }
 126
 127 float WarpZoneLib_BoxTouchesBrush(vector mi, vector ma, entity e, entity ig)
 128 {
 129     float f, s;
 130
 131     if(!e.modelindex || e.warpzone_isboxy)
 132         return 1;
 133
 134     s = e.solid;
 135     e.solid = SOLID_BSP;
 136     WarpZoneLib_BoxTouchesBrush_mins = mi;
 137     WarpZoneLib_BoxTouchesBrush_maxs = ma;
 138     WarpZoneLib_BoxTouchesBrush_ent = e;
 139     WarpZoneLib_BoxTouchesBrush_ignore = ig;
 140     f = WarpZoneLib_BoxTouchesBrush_Recurse();
 141     e.solid = s;
 142
 143     return f;
 144 }
 145
 146 entity WarpZone_Find(vector mi, vector ma)
 147 {
 148         // if we are near any warpzone planes - MOVE AWAY (work around nearclip)
 149         entity e;
 150         if(!warpzone_warpzones_exist)
 151                 return world;
 152         for(e = world; (e = find(e, classname, "trigger_warpzone")); )
 153                 if(WarpZoneLib_BoxTouchesBrush(mi, ma, e, world))
 154                         return e;
 155         return world;
 156 }
 157
 158 void WarpZone_MakeAllSolid()
 159 {
 160         entity e;
 161         if(!warpzone_warpzones_exist)
 162                 return;
 163         for(e = world; (e = find(e, classname, "trigger_warpzone")); )
 164                 e.solid = SOLID_BSP;
 165 }
 166
 167 void WarpZone_MakeAllOther()
 168 {
 169         entity e;
 170         if(!warpzone_warpzones_exist)
 171                 return;
 172         for(e = world; (e = find(e, classname, "trigger_warpzone")); )
 173                 e.solid = SOLID_TRIGGER;
 174 }
 175
 176 void WarpZone_Trace_InitTransform()
 177 {
 178         if(!WarpZone_trace_transform)
 179         {
 180                 WarpZone_trace_transform = spawn();
 181                 WarpZone_trace_transform.classname = "warpzone_trace_transform";
 182         }
 183         WarpZone_Accumulator_Clear(WarpZone_trace_transform);
 184 }
 185 void WarpZone_Trace_AddTransform(entity wz)
 186 {
 187         WarpZone_Accumulator_Add(WarpZone_trace_transform, wz);
 188 }
 189
 190 void WarpZone_TraceBox_ThroughZone(vector org, vector mi, vector ma, vector end, float nomonsters, entity forent, entity zone, WarpZone_trace_callback_t cb)
 191 {
 192         float nomonsters_adjusted;
 193         float frac, sol, i;
 194         float contentshack;
 195         vector o0, e0;
 196         entity wz;
 197         vector vf, vr, vu;
 198
 199         WarpZone_trace_forent = forent;
 200         WarpZone_trace_firstzone = world;
 201         WarpZone_trace_lastzone = world;
 202         WarpZone_Trace_InitTransform();
 203         if(!warpzone_warpzones_exist)
 204         {
 205                 if(nomonsters == MOVE_NOTHING)
 206                 {
 207                         trace_endpos = end;
 208                         trace_fraction = 1;
 209                         if(cb)
 210                                 cb(org, trace_endpos, end);
 211                         return;
 212                 }
 213                 else
 214                 {
 215                         tracebox(org, mi, ma, end, nomonsters, WarpZone_trace_forent);
 216                         if(cb)
 217                                 cb(org, trace_endpos, end);
 218                         return;
 219                 }
 220         }
 221
 222         vf = v_forward;
 223         vr = v_right;
 224         vu = v_up;
 225         o0 = org;
 226         e0 = end;
 227
 228         switch(nomonsters)
 229         {
 230                 case MOVE_WORLDONLY:
 231                 case MOVE_NOTHING:
 232                         nomonsters_adjusted = MOVE_NOMONSTERS;
 233                         break;
 234                 default:
 235                         nomonsters_adjusted = nomonsters;
 236                         break;
 237         }
 238         if((contentshack = (WarpZone_trace_forent.dphitcontentsmask && !(WarpZone_trace_forent.dphitcontentsmask & DPCONTENTS_SOLID))))
 239                 BITSET_ASSIGN(WarpZone_trace_forent.dphitcontentsmask, DPCONTENTS_SOLID);
 240
 241         // if starting in warpzone, first transform
 242         wz = WarpZone_Find(org + mi, org + ma);
 243         if(wz)
 244         {
 245                 WarpZone_trace_firstzone = wz;
 246                 WarpZone_trace_lastzone = wz;
 247                 if(zone && wz != zone)
 248                 {
 249                         // we are in ANOTHER warpzone. This is bad. Make a zero length trace and return.
 250                         sol = 1;
 251                         trace_fraction = 0;
 252                         trace_endpos = org;
 253                         goto fail;
 254                 }
 255                 WarpZone_Trace_AddTransform(wz);
 256                 org = WarpZone_TransformOrigin(wz, org);
 257                 end = WarpZone_TransformOrigin(wz, end);
 258         }
 259         WarpZone_MakeAllSolid();
 260         sol = -1;
 261         frac = 0;
 262         i = 16;
 263         for(0;;)
 264         {
 265                 if(--i < 1)
 266                 {
 267                         dprint("Too many warpzones in sequence, aborting trace.\n");
 268                         trace_ent = world;
 269                         break;
 270                 }
 271                 tracebox(org, mi, ma, end, nomonsters_adjusted, WarpZone_trace_forent);
 272                 if(cb)
 273                         cb(org, trace_endpos, end);
 274                 if(sol < 0)
 275                         sol = trace_startsolid;
 276
 277                 frac = trace_fraction = frac + (1 - frac) * trace_fraction;
 278                 if(trace_fraction >= 1)
 279                         break;
 280                 if(trace_ent.classname != "trigger_warpzone")
 281                 {
 282                         if((nomonsters == MOVE_NOTHING) || ((nomonsters == MOVE_WORLDONLY) && trace_ent) || (contentshack && (trace_dphitcontents & WarpZone_trace_forent.dphitcontentsmask) == DPCONTENTS_SOLID))
 283                         {
 284                                 // continue the trace, ignoring this hit (we only care for warpzones)
 285                                 org = trace_endpos + normalize(end - org);
 286                                 continue;
 287                                 // we cannot do an inverted trace here, as we do care for further warpzones inside that "solid" to be found
 288                                 // otherwise, players could block entrances that way
 289                         }
 290                         break;
 291                 }
 292                 if(trace_ent == wz)
 293                 {
 294                         // FIXME can this check be removed? Do we really need it?
 295                         dprint("I transformed into the same zone again, wtf, aborting the trace\n");
 296                         trace_ent = world;
 297                         break;
 298                 }
 299                 wz = trace_ent;
 300                 if(!WarpZone_trace_firstzone)
 301                         WarpZone_trace_firstzone = wz;
 302                 WarpZone_trace_lastzone = wz;
 303                 if(zone && wz != zone)
 304                         break;
 305                 WarpZone_Trace_AddTransform(wz);
 306                 // we hit a warpzone... so, let's perform the trace after the warp again
 307                 org = WarpZone_TransformOrigin(wz, trace_endpos);
 308                 end = WarpZone_TransformOrigin(wz, end);
 309
 310                 // we got warped, so let's step back a bit
 311                 tracebox(org, mi, ma, org + normalize(org - end) * 32, nomonsters_adjusted, WarpZone_trace_forent);
 312                 org = trace_endpos;
 313         }
 314         WarpZone_MakeAllOther();
 315 :fail
 316         if(contentshack)
 317                 BITCLR_ASSIGN(WarpZone_trace_forent.dphitcontentsmask, DPCONTENTS_SOLID);
 318         trace_startsolid = sol;
 319         v_forward = vf;
 320         v_right = vr;
 321         v_up = vu;
 322 }
 323
 324 void WarpZone_TraceBox(vector org, vector mi, vector ma, vector end, float nomonsters, entity forent)
 325 {
 326         WarpZone_TraceBox_ThroughZone(org, mi, ma, end, nomonsters, forent, world, WarpZone_trace_callback_t_null);
 327 }
 328
 329 void WarpZone_TraceLine(vector org, vector end, float nomonsters, entity forent)
 330 {
 331         WarpZone_TraceBox(org, '0 0 0', '0 0 0', end, nomonsters, forent);
 332 }
 333
 334 void WarpZone_TraceToss_ThroughZone(entity e, entity forent, entity zone, WarpZone_trace_callback_t cb)
 335 {
 336         float g, dt, i;
 337         vector vf, vr, vu, v0, o0;
 338         entity wz;
 339
 340         o0 = e.origin;
 341         v0 = e.velocity;
 342         g = cvar("sv_gravity") * e.gravity;
 343
 344         WarpZone_trace_forent = forent;
 345         WarpZone_trace_firstzone = world;
 346         WarpZone_trace_lastzone = world;
 347         WarpZone_Trace_InitTransform();
 348         WarpZone_tracetoss_time = 0;
 349         if(!warpzone_warpzones_exist)
 350         {
 351                 tracetoss(e, WarpZone_trace_forent);
 352                 if(cb)
 353                         cb(e.origin, trace_endpos, trace_endpos);
 354                 dt = vlen(e.origin - o0) / vlen(e.velocity);
 355                 WarpZone_tracetoss_time += dt;
 356                 e.velocity_z -= dt * g;
 357                 WarpZone_tracetoss_velocity = e.velocity;
 358                 e.velocity = v0;
 359                 return;
 360         }
 361
 362         vf = v_forward;
 363         vr = v_right;
 364         vu = v_up;
 365
 366         // if starting in warpzone, first transform
 367         wz = WarpZone_Find(e.origin + e.mins, e.origin + e.maxs);
 368         if(wz)
 369         {
 370                 WarpZone_trace_firstzone = wz;
 371                 WarpZone_trace_lastzone = wz;
 372                 if(zone && wz != zone)
 373                 {
 374                         // we are in ANOTHER warpzone. This is bad. Make a zero length trace and return.
 375
 376                         WarpZone_tracetoss_time = 0;
 377                         trace_endpos = o0;
 378                         goto fail;
 379                 }
 380                 WarpZone_Trace_AddTransform(wz);
 381                 setorigin(e, WarpZone_TransformOrigin(wz, e.origin));
 382                 e.velocity = WarpZone_TransformVelocity(wz, e.velocity);
 383         }
 384         WarpZone_MakeAllSolid();
 385         i = 16;
 386         for(0;;)
 387         {
 388                 if(--i < 1)
 389                 {
 390                         dprint("Too many warpzones in sequence, aborting trace.\n");
 391                         trace_ent = world;
 392                         break;
 393                 }
 394                 tracetoss(e, WarpZone_trace_forent);
 395                 if(cb)
 396                         cb(e.origin, trace_endpos, trace_endpos);
 397                 dt = vlen(trace_endpos - e.origin) / vlen(e.velocity);
 398                 WarpZone_tracetoss_time += dt;
 399                 e.origin = trace_endpos;
 400                 e.velocity_z -= dt * g;
 401                 if(trace_fraction >= 1)
 402                         break;
 403                 if(trace_ent.classname != "trigger_warpzone")
 404                         break;
 405                 if(trace_ent == wz)
 406                 {
 407                         // FIXME can this check be removed? Do we really need it?
 408                         dprint("I transformed into the same zone again, wtf, aborting the trace\n");
 409                         trace_ent = world;
 410                         break;
 411                 }
 412                 wz = trace_ent;
 413                 if(!WarpZone_trace_firstzone)
 414                         WarpZone_trace_firstzone = wz;
 415                 WarpZone_trace_lastzone = wz;
 416                 if(zone && wz != zone)
 417                         break;
 418                 WarpZone_Trace_AddTransform(wz);
 419                 // we hit a warpzone... so, let's perform the trace after the warp again
 420                 e.origin = WarpZone_TransformOrigin(wz, e.origin);
 421                 e.velocity = WarpZone_TransformVelocity(wz, e.velocity);
 422
 423                 // we got warped, so let's step back a bit
 424                 e.velocity = -e.velocity;
 425                 tracetoss(e, WarpZone_trace_forent);
 426                 dt = vlen(trace_endpos - e.origin) / vlen(e.velocity);
 427                 WarpZone_tracetoss_time -= dt;
 428                 e.origin = trace_endpos;
 429                 e.velocity = -e.velocity;
 430         }
 431         WarpZone_MakeAllOther();
 432 :fail
 433         WarpZone_tracetoss_velocity = e.velocity;
 434         v_forward = vf;
 435         v_right = vr;
 436         v_up = vu;
 437         // restore old entity data (caller just uses trace_endpos, WarpZone_tracetoss_velocity and the transform)
 438         e.velocity = v0;
 439         e.origin = o0;
 440 }
 441
 442 void WarpZone_TraceToss(entity e, entity forent)
 443 {
 444         WarpZone_TraceToss_ThroughZone(e, forent, world, WarpZone_trace_callback_t_null);
 445 }
 446
 447 entity WarpZone_TrailParticles_trace_callback_own;
 448 float WarpZone_TrailParticles_trace_callback_eff;
 449 void WarpZone_TrailParticles_trace_callback(vector from, vector endpos, vector to)
 450 {
 451         trailparticles(WarpZone_TrailParticles_trace_callback_own, WarpZone_TrailParticles_trace_callback_eff, from, endpos);
 452 }
 453
 454 void WarpZone_TrailParticles(entity own, float eff, vector org, vector end)
 455 {
 456         WarpZone_TrailParticles_trace_callback_own = own;
 457         WarpZone_TrailParticles_trace_callback_eff = eff;
 458         WarpZone_TraceBox_ThroughZone(org, '0 0 0', '0 0 0', end, MOVE_NOMONSTERS, world, world, WarpZone_TrailParticles_trace_callback);
 459 }
 460
 461 #ifdef CSQC
 462 float WarpZone_TrailParticles_trace_callback_f;
 463 float WarpZone_TrailParticles_trace_callback_flags;
 464 void WarpZone_TrailParticles_WithMultiplier_trace_callback(vector from, vector endpos, vector to)
 465 {
 466         boxparticles(WarpZone_TrailParticles_trace_callback_eff, WarpZone_TrailParticles_trace_callback_own, from, endpos, WarpZone_TrailParticles_trace_callback_own.velocity, WarpZone_TrailParticles_trace_callback_own.velocity, WarpZone_TrailParticles_trace_callback_f, WarpZone_TrailParticles_trace_callback_flags);
 467 }
 468
 469 void WarpZone_TrailParticles_WithMultiplier(entity own, float eff, vector org, vector end, float f, int boxflags)
 470 {
 471         WarpZone_TrailParticles_trace_callback_own = own;
 472         WarpZone_TrailParticles_trace_callback_eff = eff;
 473         WarpZone_TrailParticles_trace_callback_f = f;
 474         WarpZone_TrailParticles_trace_callback_flags = boxflags | PARTICLES_DRAWASTRAIL;
 475         WarpZone_TraceBox_ThroughZone(org, '0 0 0', '0 0 0', end, MOVE_NOMONSTERS, world, world, WarpZone_TrailParticles_WithMultiplier_trace_callback);
 476 }
 477 #endif
 478
 479 float WarpZone_PlaneDist(entity wz, vector v)
 480 {
 481         return (v - wz.warpzone_origin) * wz.warpzone_forward;
 482 }
 483
 484 float WarpZone_TargetPlaneDist(entity wz, vector v)
 485 {
 486         return (v - wz.warpzone_targetorigin) * wz.warpzone_targetforward;
 487 }
 488
 489 vector WarpZone_TransformOrigin(entity wz, vector v)
 490 {
 491         return wz.warpzone_shift + AnglesTransform_Apply(wz.warpzone_transform, v);
 492 }
 493
 494 vector WarpZone_TransformVelocity(entity wz, vector v)
 495 {
 496         return AnglesTransform_Apply(wz.warpzone_transform, v);
 497 }
 498
 499 vector WarpZone_TransformAngles(entity wz, vector v)
 500 {
 501         return AnglesTransform_ApplyToAngles(wz.warpzone_transform, v);
 502 }
 503
 504 vector WarpZone_TransformVAngles(entity wz, vector ang)
 505 {
 506 #ifdef KEEP_ROLL
 507         float roll;
 508         roll = ang.z;
 509         ang_z = 0;
 510 #endif
 511
 512         ang = AnglesTransform_ApplyToVAngles(wz.warpzone_transform, ang);
 513
 514 #ifdef KEEP_ROLL
 515         ang = AnglesTransform_Normalize(ang, true);
 516         ang = AnglesTransform_CancelRoll(ang);
 517         ang_z = roll;
 518 #else
 519         ang = AnglesTransform_Normalize(ang, false);
 520 #endif
 521
 522         return ang;
 523 }
 524
 525 vector WarpZone_UnTransformOrigin(entity wz, vector v)
 526 {
 527         return AnglesTransform_Apply(AnglesTransform_Invert(wz.warpzone_transform), v - wz.warpzone_shift);
 528 }
 529
 530 vector WarpZone_UnTransformVelocity(entity wz, vector v)
 531 {
 532         return AnglesTransform_Apply(AnglesTransform_Invert(wz.warpzone_transform), v);
 533 }
 534
 535 vector WarpZone_UnTransformAngles(entity wz, vector v)
 536 {
 537         return AnglesTransform_ApplyToAngles(AnglesTransform_Invert(wz.warpzone_transform), v);
 538 }
 539
 540 vector WarpZone_UnTransformVAngles(entity wz, vector ang)
 541 {
 542         float roll;
 543
 544         roll = ang.z;
 545         ang_z = 0;
 546
 547         ang = AnglesTransform_ApplyToVAngles(AnglesTransform_Invert(wz.warpzone_transform), ang);
 548         ang = AnglesTransform_Normalize(ang, true);
 549         ang = AnglesTransform_CancelRoll(ang);
 550
 551         ang_z = roll;
 552         return ang;
 553 }
 554
 555 vector WarpZoneLib_NearestPointOnBox(vector mi, vector ma, vector org)
 556 {
 557         vector nearest;
 558         nearest_x = bound(mi.x, org.x, ma.x);
 559         nearest_y = bound(mi.y, org.y, ma.y);
 560         nearest_z = bound(mi.z, org.z, ma.z);
 561         return nearest;
 562 }
 563
 564 .float WarpZone_findradius_hit;
 565 .entity WarpZone_findradius_next;
 566 void WarpZone_FindRadius_Recurse(vector org, float rad,        vector org0,               vector transform, vector shift, float needlineofsight)
 567 //                               blast origin of current search   original blast origin   how to untransform (victim to blast system)
 568 {
 569         vector org_new;
 570         vector org0_new;
 571         vector shift_new, transform_new;
 572         vector p;
 573         entity e, e0;
 574         entity wz;
 575         if(rad <= 0)
 576                 return;
 577         e0 = findradius(org, rad);
 578         wz = world;
 579
 580         for(e = e0; e; e = e.chain)
 581         {
 582                 p = WarpZoneLib_NearestPointOnBox(e.origin + e.mins, e.origin + e.maxs, org0);
 583                 if(needlineofsight)
 584                 {
 585                         traceline(org, p, MOVE_NOMONSTERS, e);
 586                         if(trace_fraction < 1)
 587                                 continue;
 588                 }
 589                 if(!e.WarpZone_findradius_hit || vlen(e.WarpZone_findradius_dist) > vlen(org0 - p))
 590                 {
 591                         e.WarpZone_findradius_nearest = p;
 592                         e.WarpZone_findradius_dist = org0 - p;
 593                         e.WarpZone_findradius_findorigin = org;
 594                         e.WarpZone_findradius_findradius = rad;
 595                         if(e.classname == "warpzone_refsys")
 596                         {
 597                                 // ignore, especially: do not overwrite the refsys parameters
 598                         }
 599                         else if(e.classname == "trigger_warpzone")
 600                         {
 601                                 e.WarpZone_findradius_next = wz;
 602                                 wz = e;
 603                                 e.WarpZone_findradius_hit = 1;
 604                                 e.enemy.WarpZone_findradius_dist = '0 0 0'; // we don't want to go through this zone ever again
 605                                 e.enemy.WarpZone_findradius_hit = 1;
 606                         }
 607                         else
 608                         {
 609                                 e.warpzone_transform = transform;
 610                                 e.warpzone_shift = shift;
 611                                 e.WarpZone_findradius_hit = 1;
 612                         }
 613                 }
 614         }
 615         for(e = wz; e; e = e.WarpZone_findradius_next)
 616         {
 617                 org0_new = WarpZone_TransformOrigin(e, org);
 618                 traceline(e.warpzone_targetorigin, org0_new, MOVE_NOMONSTERS, e);
 619                 org_new = trace_endpos;
 620
 621                 transform_new = AnglesTransform_Multiply(e.warpzone_transform, transform);
 622                 shift_new = AnglesTransform_Multiply_GetPostShift(e.warpzone_transform, e.warpzone_shift, transform, shift);
 623                 WarpZone_FindRadius_Recurse(
 624                         org_new,
 625                         bound(0, rad - vlen(org_new - org0_new), rad - 8),
 626                         org0_new,
 627                         transform_new, shift_new,
 628                         needlineofsight);
 629                 e.WarpZone_findradius_hit = 0;
 630                 e.enemy.WarpZone_findradius_hit = 0;
 631         }
 632 }
 633 entity WarpZone_FindRadius(vector org, float rad, float needlineofsight)
 634 {
 635         entity e0, e;
 636         WarpZone_FindRadius_Recurse(org, rad, org, '0 0 0', '0 0 0', needlineofsight);
 637         e0 = findchainfloat(WarpZone_findradius_hit, 1);
 638         for(e = e0; e; e = e.chain)
 639                 e.WarpZone_findradius_hit = 0;
 640         return e0;
 641 }
 642
 643 .entity WarpZone_refsys;
 644 void WarpZone_RefSys_GC()
 645 {
 646         // garbage collect unused reference systems
 647         self.nextthink = time + 1;
 648         if(self.owner.WarpZone_refsys != self)
 649                 remove(self);
 650 }
 651 void WarpZone_RefSys_CheckCreate(entity me)
 652 {
 653         if(me.WarpZone_refsys.owner != me)
 654         {
 655                 me.WarpZone_refsys = spawn();
 656                 me.WarpZone_refsys.classname = "warpzone_refsys";
 657                 me.WarpZone_refsys.owner = me;
 658                 me.WarpZone_refsys.think = WarpZone_RefSys_GC;
 659                 me.WarpZone_refsys.nextthink = time + 1;
 660                 WarpZone_Accumulator_Clear(me.WarpZone_refsys);
 661         }
 662 }
 663 void WarpZone_RefSys_Clear(entity me)
 664 {
 665         if(me.WarpZone_refsys)
 666         {
 667                 remove(me.WarpZone_refsys);
 668                 me.WarpZone_refsys = world;
 669         }
 670 }
 671 void WarpZone_RefSys_AddTransform(entity me, vector t, vector s)
 672 {
 673         if(t != '0 0 0' || s != '0 0 0')
 674         {
 675                 WarpZone_RefSys_CheckCreate(me);
 676                 WarpZone_Accumulator_AddTransform(me.WarpZone_refsys, t, s);
 677         }
 678 }
 679 void WarpZone_RefSys_Add(entity me, entity wz)
 680 {
 681         WarpZone_RefSys_AddTransform(me, wz.warpzone_transform, wz.warpzone_shift);
 682 }
 683 void WarpZone_RefSys_AddInverseTransform(entity me, vector t, vector s)
 684 {
 685         if(t != '0 0 0' || s != '0 0 0')
 686         {
 687                 WarpZone_RefSys_CheckCreate(me);
 688                 WarpZone_Accumulator_AddInverseTransform(me.WarpZone_refsys, t, s);
 689         }
 690 }
 691 void WarpZone_RefSys_AddInverse(entity me, entity wz)
 692 {
 693         WarpZone_RefSys_AddInverseTransform(me, wz.warpzone_transform, wz.warpzone_shift);
 694 }
 695 .vector WarpZone_refsys_incremental_shift;
 696 .vector WarpZone_refsys_incremental_transform;
 697 void WarpZone_RefSys_AddIncrementally(entity me, entity ref)
 698 {
 699         //vector t, s;
 700         if(me.WarpZone_refsys_incremental_transform == ref.WarpZone_refsys.warpzone_transform)
 701         if(me.WarpZone_refsys_incremental_shift == ref.WarpZone_refsys.warpzone_shift)
 702                 return;
 703         WarpZone_Accumulator_AddInverseTransform(me.WarpZone_refsys, me.WarpZone_refsys_incremental_transform, me.WarpZone_refsys_incremental_shift);
 704         WarpZone_Accumulator_Add(me.WarpZone_refsys, ref.WarpZone_refsys);
 705         me.WarpZone_refsys_incremental_shift = ref.WarpZone_refsys.warpzone_shift;
 706         me.WarpZone_refsys_incremental_transform = ref.WarpZone_refsys.warpzone_transform;
 707 }
 708 void WarpZone_RefSys_BeginAddingIncrementally(entity me, entity ref)
 709 {
 710         me.WarpZone_refsys_incremental_shift = ref.WarpZone_refsys.warpzone_shift;
 711         me.WarpZone_refsys_incremental_transform = ref.WarpZone_refsys.warpzone_transform;
 712 }
 713 vector WarpZone_RefSys_TransformOrigin(entity from, entity to, vector org)
 714 {
 715         if(from.WarpZone_refsys)
 716                 org = WarpZone_UnTransformOrigin(from.WarpZone_refsys, org);
 717         if(to.WarpZone_refsys)
 718                 org = WarpZone_TransformOrigin(to.WarpZone_refsys, org);
 719         return org;
 720 }
 721 vector WarpZone_RefSys_TransformVelocity(entity from, entity to, vector vel)
 722 {
 723         if(from.WarpZone_refsys)
 724                 vel = WarpZone_UnTransformVelocity(from.WarpZone_refsys, vel);
 725         if(to.WarpZone_refsys)
 726                 vel = WarpZone_TransformVelocity(to.WarpZone_refsys, vel);
 727         return vel;
 728 }
 729 vector WarpZone_RefSys_TransformAngles(entity from, entity to, vector ang)
 730 {
 731         if(from.WarpZone_refsys)
 732                 ang = WarpZone_UnTransformAngles(from.WarpZone_refsys, ang);
 733         if(to.WarpZone_refsys)
 734                 ang = WarpZone_TransformAngles(to.WarpZone_refsys, ang);
 735         return ang;
 736 }
 737 vector WarpZone_RefSys_TransformVAngles(entity from, entity to, vector ang)
 738 {
 739         if(from.WarpZone_refsys)
 740                 ang = WarpZone_UnTransformVAngles(from.WarpZone_refsys, ang);
 741         if(to.WarpZone_refsys)
 742                 ang = WarpZone_TransformVAngles(to.WarpZone_refsys, ang);
 743         return ang;
 744 }
 745 void WarpZone_RefSys_Copy(entity me, entity from)
 746 {
 747         if(from.WarpZone_refsys)
 748         {
 749                 WarpZone_RefSys_CheckCreate(me);
 750                 me.WarpZone_refsys.warpzone_shift = from.WarpZone_refsys.warpzone_shift;
 751                 me.WarpZone_refsys.warpzone_transform = from.WarpZone_refsys.warpzone_transform;
 752         }
 753         else
 754                 WarpZone_RefSys_Clear(me);
 755 }
 756 entity WarpZone_RefSys_SpawnSameRefSys(entity me)
 757 {
 758         entity e;
 759         e = spawn();
 760         WarpZone_RefSys_Copy(e, me);
 761         return e;
 762 }