Include gmqcc binaries for Windows and Linux
[voretournament/voretournament.git] / data / 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_FindTarget()
256 {
257         entity e;
258
259         if(self.killtarget != "")
260         {
261                 self.aiment = find(world, targetname, self.killtarget);
262                 if(self.aiment == world)
263                 {
264                         error("Warp zone with nonexisting killtarget");
265                         return;
266                 }
267         }
268
269         // this way only one of the two ents needs to target
270         if(self.target != "")
271         {
272                 e = find(world, targetname, self.target);
273                 if(e)
274                 {
275                         self.enemy = e;
276                         self.enemy.enemy = self;
277                 }
278         }
279 }
280
281 void WarpZonePosition_InitStep_FindTarget()
282 {
283         if(self.target == "")
284         {
285                 error("Warp zone position with no target");
286                 return;
287         }
288         self.enemy = find(world, targetname, self.target);
289         if(self.enemy == world)
290         {
291                 error("Warp zone position with nonexisting target");
292                 return;
293         }
294         if(self.enemy.aiment)
295         {
296                 // already is positioned
297                 error("Warp zone position targeting already oriented warpzone");
298                 return;
299         }
300         self.enemy.aiment = self;
301 }
302
303 void WarpZoneCamera_InitStep_FindTarget()
304 {
305         if(self.target == "")
306         {
307                 error("Camera with no target");
308                 return;
309         }
310         self.enemy = find(world, targetname, self.target);
311         if(self.enemy == world)
312         {
313                 error("Camera with nonexisting target");
314                 return;
315         }
316 }
317
318 void WarpZone_InitStep_UpdateTransform()
319 {
320         vector org, ang, norm, point;
321         float area;
322         vector tri, a, b, c, p, q, n;
323         float i_s, i_t, n_t;
324         string tex;
325
326         if(!self.enemy || self.enemy.enemy != self)
327         {
328                 error("Invalid warp zone detected. Killed.");
329                 return;
330         }
331
332         org = self.origin;
333         if(org == '0 0 0')
334                 org = 0.5 * (self.mins + self.maxs);
335
336         norm = point = '0 0 0';
337         area = 0;
338         for(i_s = 0; ; ++i_s)
339         {
340                 tex = getsurfacetexture(self, i_s);
341                 if not(tex)
342                         break; // this is beyond the last one
343                 if(tex != "textures/common/warpzone")
344                         continue;
345                 n_t = getsurfacenumtriangles(self, i_s);
346                 for(i_t = 0; i_t < n_t; ++i_t)
347                 {
348                         tri = getsurfacetriangle(self, i_s, i_t);
349                         a = getsurfacepoint(self, i_s, tri_x);
350                         b = getsurfacepoint(self, i_s, tri_y);
351                         c = getsurfacepoint(self, i_s, tri_z);
352                         p = b - a;
353                         q = c - a;
354                         n =     '1 0 0' * (q_y * p_z - q_z * p_y)
355                         +       '0 1 0' * (q_z * p_x - q_x * p_z)
356                         +       '0 0 1' * (q_x * p_y - q_y * p_x);
357                         area = area + vlen(n);
358                         norm = norm + n;
359                         point = point + vlen(n) * (a + b + c);
360                 }
361         }
362         if(area > 0)
363         {
364                 norm = norm * (1 / area);
365                 point = point * (1 / (3 * area));
366                 if(vlen(norm) < 0.99)
367                 {
368                         print("trigger_warpzone near ", vtos(self.aiment.origin), " is nonplanar. BEWARE.\n");
369                         area = 0; // no autofixing in this case
370                 }
371                 norm = normalize(norm);
372         }
373
374         if(self.aiment)
375         {
376                 org = self.aiment.origin;
377                 ang = self.aiment.angles;
378                 if(area > 0)
379                 {
380                         org = org - ((org - point) * norm) * norm; // project to plane
381                         makevectors(ang);
382                         if(norm * v_forward < 0)
383                         {
384                                 print("Position target of trigger_warpzone near ", vtos(self.aiment.origin), " points into trigger_warpzone. BEWARE.\n");
385                                 norm = -1 * norm;
386                         }
387                         ang = vectoangles(norm, v_up); // keep rotation, but turn exactly against plane
388                         ang_x = -ang_x;
389                         if(norm * v_forward < 0.99)
390                                 print("trigger_warpzone near ", vtos(self.aiment.origin), " has been turned to match plane orientation (", vtos(self.aiment.angles), " -> ", vtos(ang), "\n");
391                         if(vlen(org - self.aiment.origin) > 0.5)
392                                 print("trigger_warpzone near ", vtos(self.aiment.origin), " has been moved to match the plane (", vtos(self.aiment.origin), " -> ", vtos(org), ").\n");
393                 }
394         }
395         else if(area > 0)
396         {
397                 org = point;
398                 ang = vectoangles(norm);
399                 ang_x = -ang_x;
400         }
401         else
402                 error("cannot infer origin/angles for this warpzone, please use a killtarget or a trigger_warpzone_position");
403
404         self.warpzone_origin = org;
405         self.warpzone_angles = ang;
406 }
407 void WarpZone_InitStep_FinalizeTransform()
408 {
409         WarpZone_SetUp(self, self.warpzone_origin, self.warpzone_angles, self.enemy.warpzone_origin, self.enemy.warpzone_angles);
410         self.touch = WarpZone_Touch;
411 }
412
413 float warpzone_initialized;
414 entity warpzone_first;
415 entity warpzone_position_first;
416 entity warpzone_camera_first;
417 .entity warpzone_next;
418 void spawnfunc_misc_warpzone_position(void)
419 {
420         // "target", "angles", "origin"
421         self.warpzone_next = warpzone_position_first;
422         warpzone_position_first = self;
423 }
424 void spawnfunc_trigger_warpzone_position(void)
425 {
426         spawnfunc_misc_warpzone_position();
427 }
428 void spawnfunc_trigger_warpzone(void)
429 {
430         // warp zone entities must have:
431         // "killtarget" pointing to a target_position with a direction arrow
432         //              that points AWAY from the warp zone, and that is inside
433         //              the warp zone trigger
434         // "target"     pointing to an identical warp zone at another place in
435         //              the map, with another killtarget to designate its
436         //              orientation
437
438         if(!self.scale)
439                 self.scale = self.modelscale;
440         if(!self.scale)
441                 self.scale = 1;
442         string m;
443         m = self.model;
444         WarpZoneLib_ExactTrigger_Init();
445         if(m != "")
446         {
447                 precache_model(m);
448                 setmodel(self, m); // no precision needed
449         }
450         setorigin(self, self.origin);
451         if(self.scale)
452                 setsize(self, self.mins * self.scale, self.maxs * self.scale);
453         else
454                 setsize(self, self.mins, self.maxs);
455         self.SendEntity = WarpZone_Send;
456         self.SendFlags = 0xFFFFFF;
457         self.effects |= EF_NODEPTHTEST;
458         self.warpzone_next = warpzone_first;
459         warpzone_first = self;
460 }
461 void spawnfunc_func_camera(void)
462 {
463         if(!self.scale)
464                 self.scale = self.modelscale;
465         if(!self.scale)
466                 self.scale = 1;
467         if(self.model != "")
468         {
469                 precache_model(self.model);
470                 setmodel(self, self.model); // no precision needed
471         }
472         setorigin(self, self.origin);
473         if(self.scale)
474                 setsize(self, self.mins * self.scale, self.maxs * self.scale);
475         else
476                 setsize(self, self.mins, self.maxs);
477         if(!self.solid)
478                 self.solid = SOLID_BSP;
479         else if(self.solid < 0)
480                 self.solid = SOLID_NOT;
481         self.SendEntity = WarpZone_Camera_Send;
482         self.SendFlags = 0xFFFFFF;
483         self.warpzone_next = warpzone_camera_first;
484         warpzone_camera_first = self;
485 }
486 void WarpZone_StartFrame()
487 {
488         entity e;
489         if(warpzone_initialized == 0)
490         {
491                 warpzone_initialized = 1;
492                 e = self;
493                 for(self = warpzone_first; self; self = self.warpzone_next)
494                         WarpZone_InitStep_FindTarget();
495                 for(self = warpzone_position_first; self; self = self.warpzone_next)
496                         WarpZonePosition_InitStep_FindTarget();
497                 for(self = warpzone_camera_first; self; self = self.warpzone_next)
498                         WarpZoneCamera_InitStep_FindTarget();
499                 for(self = warpzone_first; self; self = self.warpzone_next)
500                         WarpZone_InitStep_UpdateTransform();
501                 for(self = warpzone_first; self; self = self.warpzone_next)
502                         WarpZone_InitStep_FinalizeTransform();
503                 self = e;
504         }
505         for(e = world; (e = nextent(e)); )
506                 WarpZone_StoreProjectileData(e);
507 }