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