teamradar: fix clip fail
[xonotic/xonotic-data.pk3dir.git] / qcsrc / warpzonelib / server.qc
1 .vector warpzone_oldorigin, warpzone_oldvelocity, warpzone_oldangles;
2 .float warpzone_teleport_time;
3
4 void WarpZone_StoreProjectileData(entity e)
5 {
6         e.warpzone_oldorigin = e.origin;
7         e.warpzone_oldvelocity = e.velocity;
8         e.warpzone_oldangles = e.angles;
9 }
10
11 void WarpZone_TeleportPlayer(entity teleporter, entity player, vector to, vector to_angles, vector to_velocity)
12 {
13         vector from;
14
15         makevectors (to_angles);
16
17         from = player.origin;
18         setorigin (player, to);
19         player.oldorigin = to; // for DP's unsticking
20         player.angles = to_angles;
21         player.fixangle = TRUE;
22         player.velocity = to_velocity;
23
24         if(player.effects & EF_TELEPORT_BIT)
25                 player.effects &~= EF_TELEPORT_BIT;
26         else
27                 player.effects |= EF_TELEPORT_BIT;
28
29         if(player.classname == "player")
30                 player.flags &~= FL_ONGROUND;
31
32         WarpZone_PostTeleportPlayer_Callback(player);
33 }
34
35 float WarpZone_Teleport(entity player)
36 {
37         vector o0, a0, v0, o1, a1, v1;
38
39         o0 = player.origin + player.view_ofs;
40         v0 = player.velocity;
41         a0 = player.angles;
42
43         if(WarpZone_PlaneDist(self, o0) >= 0) // wrong side of the trigger_warpzone
44                 return 2;
45         // no failure, we simply don't want to teleport yet; TODO in
46         // this situation we may want to create a temporary clone
47         // entity of the player to fix graphics glitch
48
49         o1 = WarpZone_TransformOrigin(self, o0);
50         v1 = WarpZone_TransformVelocity(self, v0);
51         if(player.classname == "player")
52                 a1 = WarpZone_TransformVAngles(self, player.v_angle);
53         else
54                 a1 = WarpZone_TransformAngles(self, a0);
55
56         // put him inside solid
57         tracebox(o1 - player.view_ofs, player.mins, player.maxs, o1 - player.view_ofs, MOVE_NOMONSTERS, player);
58         if(trace_startsolid)
59         {
60                 vector mi, ma;
61                 mi = player.mins;
62                 ma = player.maxs;
63                 setsize(player, mi - player.view_ofs, ma - player.view_ofs);
64                 setorigin(player, o1);
65                 if(WarpZoneLib_MoveOutOfSolid(player))
66                 {
67                         o1 = player.origin;
68                         setsize(player, mi, ma);
69                         setorigin(player, o0);
70                 }
71                 else
72                 {
73                         print("would have to put player in solid, won't do that\n");
74                         setsize(player, mi, ma);
75                         setorigin(player, o0 - player.view_ofs);
76                         return 0; // cannot fix
77                 }
78         }
79
80         if(WarpZone_TargetPlaneDist(self, o1) <= 0)
81         {
82                 print("inconsistent warp zones or evil roundoff error\n");
83                 return 0;
84         }
85
86         //print(sprintf("warpzone: %f %f %f -> %f %f %f\n", o0_x, o0_y, o0_z, o1_x, o1_y, o1_z));
87
88         //o1 = trace_endpos;
89         WarpZone_RefSys_Add(player, self);
90         WarpZone_TeleportPlayer(self, player, o1 - player.view_ofs, a1, v1);
91         WarpZone_StoreProjectileData(player);
92         player.warpzone_teleport_time = time;
93
94         return 1;
95 }
96
97 void WarpZone_Touch (void)
98 {
99         entity oldself, e;
100
101         if(other.classname == "trigger_warpzone")
102                 return;
103
104         // FIXME needs a better check to know what is safe to teleport and what not
105         if(other.movetype == MOVETYPE_NONE)
106                 return;
107
108         if(WarpZoneLib_ExactTrigger_Touch())
109                 return;
110
111         e = self.enemy;
112         if(WarpZone_Teleport(other))
113         {
114                 if(self.aiment.target)
115                 {
116                         oldself = self;
117                         activator = other;
118                         self = self.aiment;
119                         SUB_UseTargets();
120                         self = oldself;
121                 }
122         }
123         else
124         {
125                 dprint("WARPZONE FAIL AHAHAHAHAH))\n");
126         }
127 }
128
129 float WarpZone_Send(entity to, float sendflags)
130 {
131         WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE);
132
133         // we need THESE to render the warpzone (and cull properly)...
134         WriteCoord(MSG_ENTITY, self.origin_x);
135         WriteCoord(MSG_ENTITY, self.origin_y);
136         WriteCoord(MSG_ENTITY, self.origin_z);
137
138         WriteShort(MSG_ENTITY, self.modelindex);
139         WriteCoord(MSG_ENTITY, self.mins_x);
140         WriteCoord(MSG_ENTITY, self.mins_y);
141         WriteCoord(MSG_ENTITY, self.mins_z);
142         WriteCoord(MSG_ENTITY, self.maxs_x);
143         WriteCoord(MSG_ENTITY, self.maxs_y);
144         WriteCoord(MSG_ENTITY, self.maxs_z);
145         WriteByte(MSG_ENTITY, bound(1, self.scale * 16, 255));
146
147         // we need THESE to calculate the proper transform
148         WriteCoord(MSG_ENTITY, self.warpzone_origin_x);
149         WriteCoord(MSG_ENTITY, self.warpzone_origin_y);
150         WriteCoord(MSG_ENTITY, self.warpzone_origin_z);
151         WriteCoord(MSG_ENTITY, self.warpzone_angles_x);
152         WriteCoord(MSG_ENTITY, self.warpzone_angles_y);
153         WriteCoord(MSG_ENTITY, self.warpzone_angles_z);
154         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_x);
155         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_y);
156         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_z);
157         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_x);
158         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_y);
159         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_z);
160
161         return TRUE;
162 }
163
164 float WarpZone_Camera_Send(entity to, float sendflags)
165 {
166         WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE_CAMERA);
167
168         // we need THESE to render the warpzone (and cull properly)...
169         WriteCoord(MSG_ENTITY, self.origin_x);
170         WriteCoord(MSG_ENTITY, self.origin_y);
171         WriteCoord(MSG_ENTITY, self.origin_z);
172
173         WriteShort(MSG_ENTITY, self.modelindex);
174         WriteCoord(MSG_ENTITY, self.mins_x);
175         WriteCoord(MSG_ENTITY, self.mins_y);
176         WriteCoord(MSG_ENTITY, self.mins_z);
177         WriteCoord(MSG_ENTITY, self.maxs_x);
178         WriteCoord(MSG_ENTITY, self.maxs_y);
179         WriteCoord(MSG_ENTITY, self.maxs_z);
180         WriteByte(MSG_ENTITY, bound(1, self.scale * 16, 255));
181
182         // we need THESE to calculate the proper transform
183         WriteCoord(MSG_ENTITY, self.enemy.origin_x);
184         WriteCoord(MSG_ENTITY, self.enemy.origin_y);
185         WriteCoord(MSG_ENTITY, self.enemy.origin_z);
186         WriteCoord(MSG_ENTITY, self.enemy.angles_x);
187         WriteCoord(MSG_ENTITY, self.enemy.angles_y);
188         WriteCoord(MSG_ENTITY, self.enemy.angles_z);
189
190         return TRUE;
191 }
192
193 float WarpZone_CheckProjectileImpact()
194 {
195         // if self hit a warpzone, abort
196         vector o0, v0, a0;
197         float mpd, pd, dpd;
198         entity wz;
199         wz = WarpZone_Find(self.origin + self.mins, self.origin + self.maxs);
200         if(!wz)
201                 return FALSE;
202         o0 = self.origin;
203         v0 = self.velocity;
204         a0 = self.angles;
205
206         // this approach transports the projectile at its full speed, but does
207         // not properly retain the projectile trail (but we can't retain it
208         // easily anyway without delaying the projectile by two frames, so who
209         // cares)
210         WarpZone_TraceBox_ThroughZone(self.warpzone_oldorigin, self.mins, self.maxs, self.warpzone_oldorigin + self.warpzone_oldvelocity * frametime, MOVE_NORMAL, self, wz, WarpZone_trace_callback_t_null); // this will get us through the warpzone
211         setorigin(self, trace_endpos);
212         self.angles = WarpZone_TransformAngles(WarpZone_trace_transform, self.angles);
213         self.velocity = WarpZone_TransformVelocity(WarpZone_trace_transform, self.velocity);
214         
215         // in case we are in our warp zone post-teleport, shift the projectile forward a bit
216         mpd = max(vlen(self.mins), vlen(self.maxs));
217         pd = WarpZone_TargetPlaneDist(wz, self.origin);
218         if(pd < mpd)
219         {
220                 dpd = normalize(self.velocity) * self.warpzone_targetforward;
221                 setorigin(self, self.origin + normalize(self.velocity) * ((mpd - pd) / dpd));
222                 if(!WarpZoneLib_MoveOutOfSolid(self))
223                 {
224                         setorigin(self, o0);
225                         self.angles = a0;
226                         self.velocity = v0;
227                         return FALSE;
228                 }
229         }
230         WarpZone_RefSys_Add(self, wz);
231         WarpZone_StoreProjectileData(self);
232         self.warpzone_teleport_time = time;
233
234         return TRUE;
235 }
236 float WarpZone_Projectile_Touch()
237 {
238         if(other.classname == "trigger_warpzone")
239                 return TRUE;
240         if(WarpZone_Projectile_Touch_ImpactFilter_Callback())
241                 return TRUE;
242         if(WarpZone_CheckProjectileImpact())
243                 return TRUE;
244         if(self.warpzone_teleport_time == time) // already got teleported this frame? no collision then please
245         {
246                 setorigin(self, self.warpzone_oldorigin);
247                 self.velocity = self.warpzone_oldvelocity;
248                 self.angles = self.warpzone_oldangles;
249                 return TRUE;
250         }
251
252         return FALSE;
253 }
254
255 void WarpZone_InitStep_FindOriginTarget()
256 {
257         if(self.killtarget != "")
258         {
259                 self.aiment = find(world, targetname, self.killtarget);
260                 if(self.aiment == world)
261                 {
262                         error("Warp zone with nonexisting killtarget");
263                         return;
264                 }
265         }
266 }
267
268 void WarpZonePosition_InitStep_FindTarget()
269 {
270         if(self.target == "")
271         {
272                 error("Warp zone position with no target");
273                 return;
274         }
275         self.enemy = find(world, targetname, self.target);
276         if(self.enemy == world)
277         {
278                 error("Warp zone position with nonexisting target");
279                 return;
280         }
281         if(self.enemy.aiment)
282         {
283                 // already is positioned
284                 error("Warp zone position targeting already oriented warpzone");
285                 return;
286         }
287         self.enemy.aiment = self;
288 }
289
290 void WarpZoneCamera_InitStep_FindTarget()
291 {
292         if(self.target == "")
293         {
294                 error("Camera with no target");
295                 return;
296         }
297         self.enemy = find(world, targetname, self.target);
298         if(self.enemy == world)
299         {
300                 error("Camera with nonexisting target");
301                 return;
302         }
303 }
304
305 void WarpZone_InitStep_UpdateTransform()
306 {
307         vector org, ang, norm, point;
308         float area;
309         vector tri, a, b, c, p, q, n;
310         float i_s, i_t, n_t;
311         string tex;
312
313         org = self.origin;
314         if(org == '0 0 0')
315                 org = 0.5 * (self.mins + self.maxs);
316
317         norm = point = '0 0 0';
318         area = 0;
319         for(i_s = 0; ; ++i_s)
320         {
321                 tex = getsurfacetexture(self, i_s);
322                 if not(tex)
323                         break; // this is beyond the last one
324                 if(tex != "textures/common/warpzone")
325                         continue;
326                 n_t = getsurfacenumtriangles(self, i_s);
327                 for(i_t = 0; i_t < n_t; ++i_t)
328                 {
329                         tri = getsurfacetriangle(self, i_s, i_t);
330                         a = getsurfacepoint(self, i_s, tri_x);
331                         b = getsurfacepoint(self, i_s, tri_y);
332                         c = getsurfacepoint(self, i_s, tri_z);
333                         p = b - a;
334                         q = c - a;
335                         n =     '1 0 0' * (q_y * p_z - q_z * p_y)
336                         +       '0 1 0' * (q_z * p_x - q_x * p_z)
337                         +       '0 0 1' * (q_x * p_y - q_y * p_x);
338                         area = area + vlen(n);
339                         norm = norm + n;
340                         point = point + vlen(n) * (a + b + c);
341                 }
342         }
343         if(area > 0)
344         {
345                 norm = norm * (1 / area);
346                 point = point * (1 / (3 * area));
347                 if(vlen(norm) < 0.99)
348                 {
349                         print("trigger_warpzone near ", vtos(self.aiment.origin), " is nonplanar. BEWARE.\n");
350                         area = 0; // no autofixing in this case
351                 }
352                 norm = normalize(norm);
353         }
354
355         if(self.aiment)
356         {
357                 org = self.aiment.origin;
358                 ang = self.aiment.angles;
359                 if(area > 0)
360                 {
361                         org = org - ((org - point) * norm) * norm; // project to plane
362                         makevectors(ang);
363                         if(norm * v_forward < 0)
364                         {
365                                 print("Position target of trigger_warpzone near ", vtos(self.aiment.origin), " points into trigger_warpzone. BEWARE.\n");
366                                 norm = -1 * norm;
367                         }
368                         ang = vectoangles(norm, v_up); // keep rotation, but turn exactly against plane
369                         ang_x = -ang_x;
370                         if(norm * v_forward < 0.99)
371                                 print("trigger_warpzone near ", vtos(self.aiment.origin), " has been turned to match plane orientation (", vtos(self.aiment.angles), " -> ", vtos(ang), "\n");
372                         if(vlen(org - self.aiment.origin) > 0.5)
373                                 print("trigger_warpzone near ", vtos(self.aiment.origin), " has been moved to match the plane (", vtos(self.aiment.origin), " -> ", vtos(org), ").\n");
374                 }
375         }
376         else if(area > 0)
377         {
378                 org = point;
379                 ang = vectoangles(norm);
380                 ang_x = -ang_x;
381         }
382         else
383                 error("cannot infer origin/angles for this warpzone, please use a killtarget or a trigger_warpzone_position");
384
385         self.warpzone_origin = org;
386         self.warpzone_angles = ang;
387 }
388
389 void WarpZone_InitStep_ClearTarget()
390 {
391         if(self.enemy)
392                 self.enemy.enemy = world;
393         self.enemy = world;
394 }
395
396 void WarpZone_InitStep_FindTarget()
397 {
398         float i;
399         entity e, e2;
400
401         // this way only one of the two ents needs to target
402         if(self.target != "")
403         {
404                 e2 = world;
405                 for(e = world; (e = find(e, targetname, self.target)); )
406                         if(!e.enemy)
407                                 if(random() * ++i < 1)
408                                         e2 = e;
409                 if(!e2)
410                 {
411                         error("Warpzone with non-existing target");
412                         return;
413                 }
414                 self.enemy = e2;
415                 e2.enemy = self;
416         }
417 }
418
419 void WarpZone_InitStep_FinalizeTransform()
420 {
421         if(!self.enemy || self.enemy.enemy != self)
422         {
423                 error("Invalid warp zone detected. Killed.");
424                 return;
425         }
426
427         WarpZone_SetUp(self, self.warpzone_origin, self.warpzone_angles, self.enemy.warpzone_origin, self.enemy.warpzone_angles);
428         self.touch = WarpZone_Touch;
429         self.SendFlags = 0xFFFFFF;
430 }
431
432 float warpzone_initialized;
433 entity warpzone_first;
434 entity warpzone_position_first;
435 entity warpzone_camera_first;
436 .entity warpzone_next;
437 void spawnfunc_misc_warpzone_position(void)
438 {
439         // "target", "angles", "origin"
440         self.warpzone_next = warpzone_position_first;
441         warpzone_position_first = self;
442 }
443 void spawnfunc_trigger_warpzone_position(void)
444 {
445         spawnfunc_misc_warpzone_position();
446 }
447 void spawnfunc_trigger_warpzone(void)
448 {
449         // warp zone entities must have:
450         // "killtarget" pointing to a target_position with a direction arrow
451         //              that points AWAY from the warp zone, and that is inside
452         //              the warp zone trigger
453         // "target"     pointing to an identical warp zone at another place in
454         //              the map, with another killtarget to designate its
455         //              orientation
456
457         if(!self.scale)
458                 self.scale = self.modelscale;
459         if(!self.scale)
460                 self.scale = 1;
461         string m;
462         m = self.model;
463         WarpZoneLib_ExactTrigger_Init();
464         if(m != "")
465         {
466                 precache_model(m);
467                 setmodel(self, m); // no precision needed
468         }
469         setorigin(self, self.origin);
470         if(self.scale)
471                 setsize(self, self.mins * self.scale, self.maxs * self.scale);
472         else
473                 setsize(self, self.mins, self.maxs);
474         self.SendEntity = WarpZone_Send;
475         self.SendFlags = 0xFFFFFF;
476         self.effects |= EF_NODEPTHTEST;
477         self.warpzone_next = warpzone_first;
478         warpzone_first = self;
479 }
480 void spawnfunc_func_camera(void)
481 {
482         if(!self.scale)
483                 self.scale = self.modelscale;
484         if(!self.scale)
485                 self.scale = 1;
486         if(self.model != "")
487         {
488                 precache_model(self.model);
489                 setmodel(self, self.model); // no precision needed
490         }
491         setorigin(self, self.origin);
492         if(self.scale)
493                 setsize(self, self.mins * self.scale, self.maxs * self.scale);
494         else
495                 setsize(self, self.mins, self.maxs);
496         if(!self.solid)
497                 self.solid = SOLID_BSP;
498         else if(self.solid < 0)
499                 self.solid = SOLID_NOT;
500         self.SendEntity = WarpZone_Camera_Send;
501         self.SendFlags = 0xFFFFFF;
502         self.warpzone_next = warpzone_camera_first;
503         warpzone_camera_first = self;
504 }
505 void WarpZones_Reconnect()
506 {
507         entity e;
508         e = self;
509         for(self = warpzone_first; self; self = self.warpzone_next)
510                 WarpZone_InitStep_ClearTarget();
511         for(self = warpzone_first; self; self = self.warpzone_next)
512                 WarpZone_InitStep_FindTarget();
513         for(self = warpzone_first; self; self = self.warpzone_next)
514                 WarpZone_InitStep_FinalizeTransform();
515         self = e;
516 }
517
518 void WarpZone_StartFrame()
519 {
520         entity e;
521         if(warpzone_initialized == 0)
522         {
523                 warpzone_initialized = 1;
524                 e = self;
525                 for(self = warpzone_first; self; self = self.warpzone_next)
526                         WarpZone_InitStep_FindOriginTarget();
527                 for(self = warpzone_position_first; self; self = self.warpzone_next)
528                         WarpZonePosition_InitStep_FindTarget();
529                 for(self = warpzone_camera_first; self; self = self.warpzone_next)
530                         WarpZoneCamera_InitStep_FindTarget();
531                 for(self = warpzone_first; self; self = self.warpzone_next)
532                         WarpZone_InitStep_UpdateTransform();
533                 self = e;
534                 WarpZones_Reconnect();
535         }
536         for(e = world; (e = nextent(e)); )
537                 WarpZone_StoreProjectileData(e);
538 }
539
540 void target_warpzone_reconnect_use()
541 {
542         entity e;
543         e = self;
544         // NOTE: this matches for target, not targetname, but of course
545         // targetname must be set too on the other entities
546         for(self = warpzone_first; self; self = self.warpzone_next)
547                 if(e.target == "" || self.target == e.target)
548                         WarpZone_InitStep_ClearTarget();
549         for(self = warpzone_first; self; self = self.warpzone_next)
550                 if(e.target == "" || self.target == e.target)
551                         WarpZone_InitStep_FindTarget();
552         for(self = warpzone_first; self; self = self.warpzone_next)
553                 if(e.target == "" || self.target == e.target || self.enemy.target == e.target)
554                         WarpZone_InitStep_FinalizeTransform();
555         self = e;
556 }
557
558 void trigger_warpzone_reconnect()
559 {
560         self.use = target_warpzone_reconnect_use;
561 }