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