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