Remove `-Wno-double-declaration`
[xonotic/xonotic-data.pk3dir.git] / 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 }