qcsrc/warpzonelib/server.qc

   1 // for think function
   2 .vector warpzone_save_origin;
   3 .vector warpzone_save_angles;
   4 .vector warpzone_save_eorigin;
   5 .vector warpzone_save_eangles;
   6
   7 // for all entities
   8 .vector warpzone_oldorigin, warpzone_oldvelocity, warpzone_oldangles;
   9 .float warpzone_teleport_time;
  10 .float warpzone_teleport_finishtime;
  11 .entity warpzone_teleport_zone;
  12
  13 void WarpZone_StoreProjectileData(entity e)
  14 {
  15         e.warpzone_oldorigin = e.origin;
  16         e.warpzone_oldvelocity = e.velocity;
  17         e.warpzone_oldangles = e.angles;
  18 }
  19
  20 void WarpZone_TeleportPlayer(entity teleporter, entity player, vector to, vector to_angles, vector to_velocity)
  21 {
  22         setorigin (player, to);
  23         player.oldorigin = to; // for DP's unsticking
  24         player.angles = to_angles;
  25         player.fixangle = TRUE;
  26         player.velocity = to_velocity;
  27
  28         BITXOR_ASSIGN(player.effects, EF_TELEPORT_BIT);
  29
  30         if(player.classname == "player")
  31                 BITCLR_ASSIGN(player.flags, FL_ONGROUND);
  32
  33         WarpZone_PostTeleportPlayer_Callback(player);
  34 }
  35
  36 float WarpZone_Teleported_Send(entity to, float sf)
  37 {
  38         WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE_TELEPORTED);
  39         WriteCoord(MSG_ENTITY, self.angles_x);
  40         WriteCoord(MSG_ENTITY, self.angles_y);
  41         WriteCoord(MSG_ENTITY, self.angles_z);
  42         return TRUE;
  43 }
  44
  45 #define WARPZONE_TELEPORT_FIXSOLID(ret) \
  46         do \
  47         { \
  48                 setorigin(player, o1 - player.view_ofs); \
  49                 if(WarpZoneLib_MoveOutOfSolid(player)) \
  50                 { \
  51                         o1 = player.origin + player.view_ofs; \
  52                         setorigin(player, o0 - player.view_ofs); \
  53                 } \
  54                 else \
  55                 { \
  56                         print("would have to put player in solid, won't do that\n"); \
  57                         setorigin(player, o0 - player.view_ofs); \
  58                         return (ret); \
  59                 } \
  60         } \
  61         while(0)
  62 #define WARPZONE_TELEPORT_DOTELEPORT() \
  63         do \
  64         { \
  65                 WarpZone_RefSys_Add(player, wz); \
  66                 WarpZone_TeleportPlayer(wz, player, o1 - player.view_ofs, a1, v1); \
  67                 WarpZone_StoreProjectileData(player); \
  68                 player.warpzone_teleport_time = time; \
  69                 player.warpzone_teleport_finishtime = time; \
  70                 player.warpzone_teleport_zone = wz; \
  71         } \
  72         while(0)
  73
  74 float WarpZone_Teleport(entity wz, entity player, float f0, float f1)
  75 {
  76         vector o0, a0, v0, o1, a1, v1, o10;
  77
  78         o0 = player.origin + player.view_ofs;
  79         v0 = player.velocity;
  80         a0 = player.angles;
  81
  82         o10 = o1 = WarpZone_TransformOrigin(wz, o0);
  83         v1 = WarpZone_TransformVelocity(wz, v0);
  84         if(clienttype(player) != CLIENTTYPE_NOTACLIENT)
  85                 a1 = WarpZone_TransformVAngles(wz, player.v_angle);
  86         else
  87                 a1 = WarpZone_TransformAngles(wz, a0);
  88
  89         if(f0 != 0 || f1 != 0)
  90         {
  91                 // retry last move but behind the warpzone!
  92                 // we must first go back as far as we can, then forward again, to not cause double touch events!
  93
  94                 tracebox(o1 - player.view_ofs + v1 * frametime * f1, player.mins, player.maxs, o1 - player.view_ofs + v1 * frametime * f0, MOVE_WORLDONLY, player);
  95                 {
  96                         entity own;
  97                         own = player.owner;
  98                         player.owner = world;
  99                         tracebox(trace_endpos, player.mins, player.maxs, o1 - player.view_ofs + v1 * frametime * f1, MOVE_NORMAL, player); // this should get us through the warpzone
 100                         player.owner = own;
 101                 }
 102                 o1 = trace_endpos + player.view_ofs;
 103
 104                 float d, dv, md;
 105                 md = max(vlen(player.mins), vlen(player.maxs));
 106                 d = WarpZone_TargetPlaneDist(wz, o1);
 107                 dv = WarpZone_TargetPlaneDist(wz, v1);
 108                 if(d < 0)
 109                         o1 = o1 - v1 * (d / dv);
 110         }
 111
 112         // put him inside solid
 113         tracebox(o1 - player.view_ofs, player.mins, player.maxs, o1 - player.view_ofs, MOVE_NOMONSTERS, player);
 114         if(trace_startsolid)
 115                 WARPZONE_TELEPORT_FIXSOLID(0);
 116
 117         WARPZONE_TELEPORT_DOTELEPORT();
 118
 119         // prevent further teleports back
 120         float dt = (o1 - o10) * v1 * (1 / (v1 * v1));
 121         if(dt < sys_frametime)
 122                 player.warpzone_teleport_finishtime += sys_frametime - dt;
 123
 124 #ifndef WARPZONE_USE_FIXANGLE
 125         if(player.classname == "player")
 126         {
 127                 // instead of fixangle, send the transform to the client for smoother operation
 128                 player.fixangle = FALSE;
 129
 130                 entity ts = spawn();
 131                 setmodel(ts, "null");
 132                 ts.SendEntity = WarpZone_Teleported_Send;
 133                 ts.SendFlags = 0xFFFFFF;
 134                 ts.drawonlytoclient = player;
 135                 ts.think = SUB_Remove;
 136                 ts.nextthink = time + 1;
 137                 ts.owner = player;
 138                 ts.enemy = wz;
 139                 ts.effects = EF_NODEPTHTEST;
 140                 ts.classname = "warpzone_teleported";
 141                 ts.angles = wz.warpzone_transform;
 142         }
 143 #endif
 144
 145         return 1;
 146 }
 147
 148 void WarpZone_Touch (void)
 149 {
 150         entity oldself;
 151
 152         if(other.classname == "trigger_warpzone")
 153                 return;
 154
 155         if(time <= other.warpzone_teleport_finishtime) // already teleported this frame
 156                 return;
 157
 158         // FIXME needs a better check to know what is safe to teleport and what not
 159         if(other.movetype == MOVETYPE_NONE || other.movetype == MOVETYPE_FOLLOW || other.tag_entity)
 160                 return;
 161
 162         if(WarpZoneLib_ExactTrigger_Touch())
 163                 return;
 164
 165         if(WarpZone_PlaneDist(self, other.origin + other.view_ofs) >= 0) // wrong side of the trigger_warpzone (don't teleport yet)
 166                 return;
 167
 168         float f;
 169         if(clienttype(self) == CLIENTTYPE_NOTACLIENT)
 170                 f = min(-1, -64 / vlen(self.velocity));
 171         else
 172                 f = -1;
 173         if(WarpZone_Teleport(self, other, f, 0))
 174         {
 175                 string save1, save2;
 176                 activator = other;
 177
 178                 save1 = self.target; self.target = string_null;
 179                 save2 = self.target3; self.target3 = string_null;
 180                 SUB_UseTargets();
 181                 if not(self.target) self.target = save1;
 182                 if not(self.target3) self.target3 = save2;
 183
 184                 oldself = self;
 185                 self = self.enemy;
 186                 save1 = self.target; self.target = string_null;
 187                 save2 = self.target2; self.target2 = string_null;
 188                 SUB_UseTargets();
 189                 if not(self.target) self.target = save1;
 190                 if not(self.target2) self.target2 = save2;
 191                 self = oldself;
 192         }
 193         else
 194         {
 195                 dprint("WARPZONE FAIL AHAHAHAHAH))\n");
 196         }
 197 }
 198
 199 float WarpZone_Send(entity to, float sendflags)
 200 {
 201         float f;
 202         WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE);
 203
 204         // we must send this flag for clientside to match properly too
 205         f = 0;
 206         if(self.warpzone_isboxy)
 207                 BITSET_ASSIGN(f, 1);
 208         if(self.warpzone_fadestart)
 209                 BITSET_ASSIGN(f, 2);
 210         if(self.origin != '0 0 0')
 211                 BITSET_ASSIGN(f, 4);
 212         WriteByte(MSG_ENTITY, f);
 213
 214         // we need THESE to render the warpzone (and cull properly)...
 215         if(f & 4)
 216         {
 217                 WriteCoord(MSG_ENTITY, self.origin_x);
 218                 WriteCoord(MSG_ENTITY, self.origin_y);
 219                 WriteCoord(MSG_ENTITY, self.origin_z);
 220         }
 221
 222         WriteShort(MSG_ENTITY, self.modelindex);
 223         WriteCoord(MSG_ENTITY, self.mins_x);
 224         WriteCoord(MSG_ENTITY, self.mins_y);
 225         WriteCoord(MSG_ENTITY, self.mins_z);
 226         WriteCoord(MSG_ENTITY, self.maxs_x);
 227         WriteCoord(MSG_ENTITY, self.maxs_y);
 228         WriteCoord(MSG_ENTITY, self.maxs_z);
 229         WriteByte(MSG_ENTITY, bound(1, self.scale * 16, 255));
 230
 231         // we need THESE to calculate the proper transform
 232         WriteCoord(MSG_ENTITY, self.warpzone_origin_x);
 233         WriteCoord(MSG_ENTITY, self.warpzone_origin_y);
 234         WriteCoord(MSG_ENTITY, self.warpzone_origin_z);
 235         WriteCoord(MSG_ENTITY, self.warpzone_angles_x);
 236         WriteCoord(MSG_ENTITY, self.warpzone_angles_y);
 237         WriteCoord(MSG_ENTITY, self.warpzone_angles_z);
 238         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_x);
 239         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_y);
 240         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_z);
 241         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_x);
 242         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_y);
 243         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_z);
 244
 245         if(f & 2)
 246         {
 247                 WriteShort(MSG_ENTITY, self.warpzone_fadestart);
 248                 WriteShort(MSG_ENTITY, self.warpzone_fadeend);
 249         }
 250
 251         return TRUE;
 252 }
 253
 254 float WarpZone_Camera_Send(entity to, float sendflags)
 255 {
 256         float f;
 257         WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE_CAMERA);
 258
 259         if(self.warpzone_fadestart)
 260                 BITSET_ASSIGN(f, 2);
 261         if(self.origin != '0 0 0')
 262                 BITSET_ASSIGN(f, 4);
 263         WriteByte(MSG_ENTITY, f);
 264
 265         // we need THESE to render the warpzone (and cull properly)...
 266         if(f & 4)
 267         {
 268                 WriteCoord(MSG_ENTITY, self.origin_x);
 269                 WriteCoord(MSG_ENTITY, self.origin_y);
 270                 WriteCoord(MSG_ENTITY, self.origin_z);
 271         }
 272
 273         WriteShort(MSG_ENTITY, self.modelindex);
 274         WriteCoord(MSG_ENTITY, self.mins_x);
 275         WriteCoord(MSG_ENTITY, self.mins_y);
 276         WriteCoord(MSG_ENTITY, self.mins_z);
 277         WriteCoord(MSG_ENTITY, self.maxs_x);
 278         WriteCoord(MSG_ENTITY, self.maxs_y);
 279         WriteCoord(MSG_ENTITY, self.maxs_z);
 280         WriteByte(MSG_ENTITY, bound(1, self.scale * 16, 255));
 281
 282         // we need THESE to calculate the proper transform
 283         WriteCoord(MSG_ENTITY, self.enemy.origin_x);
 284         WriteCoord(MSG_ENTITY, self.enemy.origin_y);
 285         WriteCoord(MSG_ENTITY, self.enemy.origin_z);
 286         WriteCoord(MSG_ENTITY, self.enemy.angles_x);
 287         WriteCoord(MSG_ENTITY, self.enemy.angles_y);
 288         WriteCoord(MSG_ENTITY, self.enemy.angles_z);
 289
 290         if(f & 2)
 291         {
 292                 WriteShort(MSG_ENTITY, self.warpzone_fadestart);
 293                 WriteShort(MSG_ENTITY, self.warpzone_fadeend);
 294         }
 295
 296         return TRUE;
 297 }
 298
 299 float WarpZone_CheckProjectileImpact(entity player)
 300 {
 301         vector o0, v0;
 302
 303         o0 = player.origin + player.view_ofs;
 304         v0 = player.velocity;
 305
 306         // if we teleported shortly before, abort
 307         if(time <= player.warpzone_teleport_finishtime + 0.1)
 308                 return 0;
 309
 310         // if player hit a warpzone, abort
 311         entity wz;
 312         wz = WarpZone_Find(o0 + player.mins, o0 + player.maxs);
 313         if(!wz)
 314                 return 0;
 315
 316         print("impactfilter found something - and it even gets handled correctly - please tell divVerent that this code apparently gets triggered again\n");
 317
 318         // retry previous move
 319         setorigin(player, player.warpzone_oldorigin);
 320         player.velocity = player.warpzone_oldvelocity;
 321         if(WarpZone_Teleport(wz, player, 0, 1))
 322         {
 323                 entity oldself;
 324                 string save1, save2;
 325
 326                 oldself = self;
 327                 self = wz;
 328                 other = player;
 329                 activator = player;
 330
 331                 save1 = self.target; self.target = string_null;
 332                 save2 = self.target3; self.target3 = string_null;
 333                 SUB_UseTargets();
 334                 if not(self.target) self.target = save1;
 335                 if not(self.target3) self.target3 = save2;
 336
 337                 self = self.enemy;
 338                 save1 = self.target; self.target = string_null;
 339                 save2 = self.target2; self.target2 = string_null;
 340                 SUB_UseTargets();
 341                 if not(self.target) self.target = save1;
 342                 if not(self.target2) self.target2 = save2;
 343                 self = oldself;
 344         }
 345         else
 346         {
 347                 setorigin(player, o0 - player.view_ofs);
 348                 player.velocity = v0;
 349         }
 350
 351         return +1;
 352 }
 353 float WarpZone_Projectile_Touch()
 354 {
 355         float f;
 356         if(other.classname == "trigger_warpzone")
 357                 return TRUE;
 358
 359         // no further impacts if we teleported this frame!
 360         if(time == self.warpzone_teleport_time)
 361                 return TRUE;
 362
 363         // this SEEMS to not happen at the moment, but if it did, it would be more reliable
 364         {
 365                 float save_dpstartcontents;
 366                 float save_dphitcontents;
 367                 float save_dphitq3surfaceflags;
 368                 string save_dphittexturename;
 369                 float save_allsolid;
 370                 float save_startsolid;
 371                 float save_fraction;
 372                 vector save_endpos;
 373                 vector save_plane_normal;
 374                 float save_plane_dist;
 375                 entity save_ent;
 376                 float save_inopen;
 377                 float save_inwater;
 378                 save_dpstartcontents = trace_dpstartcontents;
 379                 save_dphitcontents = trace_dphitcontents;
 380                 save_dphitq3surfaceflags = trace_dphitq3surfaceflags;
 381                 save_dphittexturename = trace_dphittexturename;
 382                 save_allsolid = trace_allsolid;
 383                 save_startsolid = trace_startsolid;
 384                 save_fraction = trace_fraction;
 385                 save_endpos = trace_endpos;
 386                 save_plane_normal = trace_plane_normal;
 387                 save_plane_dist = trace_plane_dist;
 388                 save_ent = trace_ent;
 389                 save_inopen = trace_inopen;
 390                 save_inwater = trace_inwater;
 391                 if((f = WarpZone_CheckProjectileImpact(self)) != 0)
 392                         return (f > 0);
 393                 trace_dpstartcontents = save_dpstartcontents;
 394                 trace_dphitcontents = save_dphitcontents;
 395                 trace_dphitq3surfaceflags = save_dphitq3surfaceflags;
 396                 trace_dphittexturename = save_dphittexturename;
 397                 trace_allsolid = save_allsolid;
 398                 trace_startsolid = save_startsolid;
 399                 trace_fraction = save_fraction;
 400                 trace_endpos = save_endpos;
 401                 trace_plane_normal = save_plane_normal;
 402                 trace_plane_dist = save_plane_dist;
 403                 trace_ent = save_ent;
 404                 trace_inopen = save_inopen;
 405                 trace_inwater = save_inwater;
 406         }
 407
 408         if(WarpZone_Projectile_Touch_ImpactFilter_Callback())
 409                 return TRUE;
 410
 411         return FALSE;
 412 }
 413
 414 void WarpZone_InitStep_FindOriginTarget()
 415 {
 416         if(self.killtarget != "")
 417         {
 418                 self.aiment = find(world, targetname, self.killtarget);
 419                 if(self.aiment == world)
 420                 {
 421                         error("Warp zone with nonexisting killtarget");
 422                         return;
 423                 }
 424                 self.killtarget = string_null;
 425         }
 426 }
 427
 428 void WarpZonePosition_InitStep_FindTarget()
 429 {
 430         if(self.target == "")
 431         {
 432                 error("Warp zone position with no target");
 433                 return;
 434         }
 435         self.enemy = find(world, targetname, self.target);
 436         if(self.enemy == world)
 437         {
 438                 error("Warp zone position with nonexisting target");
 439                 return;
 440         }
 441         if(self.enemy.aiment)
 442         {
 443                 // already is positioned
 444                 error("Warp zone position targeting already oriented warpzone");
 445                 return;
 446         }
 447         self.enemy.aiment = self;
 448 }
 449
 450 void WarpZoneCamera_Think(void)
 451 {
 452         if(self.warpzone_save_origin != self.origin
 453         || self.warpzone_save_angles != self.angles
 454         || self.warpzone_save_eorigin != self.enemy.origin
 455         || self.warpzone_save_eangles != self.enemy.angles)
 456         {
 457                 WarpZone_Camera_SetUp(self, self.enemy.origin, self.enemy.angles);
 458                 self.warpzone_save_origin = self.origin;
 459                 self.warpzone_save_angles = self.angles;
 460                 self.warpzone_save_eorigin = self.enemy.origin;
 461                 self.warpzone_save_eangles = self.enemy.angles;
 462         }
 463         self.nextthink = time;
 464 }
 465
 466 void WarpZoneCamera_InitStep_FindTarget()
 467 {
 468         entity e;
 469         float i;
 470         if(self.target == "")
 471         {
 472                 error("Camera with no target");
 473                 return;
 474         }
 475         self.enemy = world;
 476         for(e = world, i = 0; (e = find(e, targetname, self.target)); )
 477                 if(random() * ++i < 1)
 478                         self.enemy = e;
 479         if(self.enemy == world)
 480         {
 481                 error("Camera with nonexisting target");
 482                 return;
 483         }
 484         warpzone_cameras_exist = 1;
 485         WarpZone_Camera_SetUp(self, self.enemy.origin, self.enemy.angles);
 486         self.SendFlags = 0xFFFFFF;
 487         if(self.spawnflags & 1)
 488         {
 489                 self.think = WarpZoneCamera_Think;
 490                 self.nextthink = time;
 491         }
 492         else
 493                 self.nextthink = 0;
 494 }
 495
 496 void WarpZone_InitStep_UpdateTransform()
 497 {
 498         vector org, ang, norm, point;
 499         float area;
 500         vector tri, a, b, c, p, q, n;
 501         float i_s, i_t, n_t;
 502         string tex;
 503
 504         org = self.origin;
 505         if(org == '0 0 0')
 506                 org = 0.5 * (self.mins + self.maxs);
 507
 508         norm = point = '0 0 0';
 509         area = 0;
 510         for(i_s = 0; ; ++i_s)
 511         {
 512                 tex = getsurfacetexture(self, i_s);
 513                 if not(tex)
 514                         break; // this is beyond the last one
 515                 if(tex == "textures/common/trigger" || tex == "trigger")
 516                         continue;
 517                 n_t = getsurfacenumtriangles(self, i_s);
 518                 for(i_t = 0; i_t < n_t; ++i_t)
 519                 {
 520                         tri = getsurfacetriangle(self, i_s, i_t);
 521                         a = getsurfacepoint(self, i_s, tri_x);
 522                         b = getsurfacepoint(self, i_s, tri_y);
 523                         c = getsurfacepoint(self, i_s, tri_z);
 524                         p = b - a;
 525                         q = c - a;
 526                         n =     '1 0 0' * (q_y * p_z - q_z * p_y)
 527                         +       '0 1 0' * (q_z * p_x - q_x * p_z)
 528                         +       '0 0 1' * (q_x * p_y - q_y * p_x);
 529                         area = area + vlen(n);
 530                         norm = norm + n;
 531                         point = point + vlen(n) * (a + b + c);
 532                 }
 533         }
 534         if(area > 0)
 535         {
 536                 norm = norm * (1 / area);
 537                 point = point * (1 / (3 * area));
 538                 if(vlen(norm) < 0.99)
 539                 {
 540                         print("trigger_warpzone near ", vtos(self.aiment.origin), " is nonplanar. BEWARE.\n");
 541                         area = 0; // no autofixing in this case
 542                 }
 543                 norm = normalize(norm);
 544         }
 545
 546         if(self.aiment)
 547         {
 548                 org = self.aiment.origin;
 549                 ang = self.aiment.angles;
 550                 if(area > 0)
 551                 {
 552                         org = org - ((org - point) * norm) * norm; // project to plane
 553                         makevectors(ang);
 554                         if(norm * v_forward < 0)
 555                         {
 556                                 print("Position target of trigger_warpzone near ", vtos(self.aiment.origin), " points into trigger_warpzone. BEWARE.\n");
 557                                 norm = -1 * norm;
 558                         }
 559                         ang = vectoangles(norm, v_up); // keep rotation, but turn exactly against plane
 560                         ang_x = -ang_x;
 561                         if(norm * v_forward < 0.99)
 562                                 print("trigger_warpzone near ", vtos(self.aiment.origin), " has been turned to match plane orientation (", vtos(self.aiment.angles), " -> ", vtos(ang), "\n");
 563                         if(vlen(org - self.aiment.origin) > 0.5)
 564                                 print("trigger_warpzone near ", vtos(self.aiment.origin), " has been moved to match the plane (", vtos(self.aiment.origin), " -> ", vtos(org), ").\n");
 565                 }
 566         }
 567         else if(area > 0)
 568         {
 569                 org = point;
 570                 ang = vectoangles(norm);
 571                 ang_x = -ang_x;
 572         }
 573         else
 574                 error("cannot infer origin/angles for this warpzone, please use a killtarget or a trigger_warpzone_position");
 575
 576         self.warpzone_origin = org;
 577         self.warpzone_angles = ang;
 578 }
 579
 580 void WarpZone_InitStep_ClearTarget()
 581 {
 582         if(self.enemy)
 583                 self.enemy.enemy = world;
 584         self.enemy = world;
 585 }
 586
 587 entity warpzone_first; .entity warpzone_next;
 588 void WarpZone_InitStep_FindTarget()
 589 {
 590         float i;
 591         entity e, e2;
 592
 593         if(self.enemy)
 594                 return;
 595
 596         // this way only one of the two ents needs to target
 597         if(self.target != "")
 598         {
 599                 self.enemy = self; // so the if(!e.enemy) check also skips self, saves one IF
 600
 601                 e2 = world;
 602                 for(e = world, i = 0; (e = find(e, targetname, self.target)); )
 603                         if(!e.enemy)
 604                                 if(e.classname == self.classname) // possibly non-warpzones may use the same targetname!
 605                                         if(random() * ++i < 1)
 606                                                 e2 = e;
 607                 if(!e2)
 608                 {
 609                         self.enemy = world;
 610                         error("Warpzone with non-existing target");
 611                         return;
 612                 }
 613                 self.enemy = e2;
 614                 e2.enemy = self;
 615         }
 616 }
 617
 618 void WarpZone_Think();
 619 void WarpZone_InitStep_FinalizeTransform()
 620 {
 621         if(!self.enemy || self.enemy.enemy != self)
 622         {
 623                 error("Invalid warp zone detected. Killed.");
 624                 return;
 625         }
 626
 627         warpzone_warpzones_exist = 1;
 628         WarpZone_SetUp(self, self.warpzone_origin, self.warpzone_angles, self.enemy.warpzone_origin, self.enemy.warpzone_angles);
 629         self.touch = WarpZone_Touch;
 630         self.SendFlags = 0xFFFFFF;
 631         if(self.spawnflags & 1)
 632         {
 633                 self.think = WarpZone_Think;
 634                 self.nextthink = time;
 635         }
 636         else
 637                 self.nextthink = 0;
 638 }
 639
 640 float warpzone_initialized;
 641 entity warpzone_first;
 642 entity warpzone_position_first;
 643 entity warpzone_camera_first;
 644 .entity warpzone_next;
 645 void spawnfunc_misc_warpzone_position(void)
 646 {
 647         // "target", "angles", "origin"
 648         self.warpzone_next = warpzone_position_first;
 649         warpzone_position_first = self;
 650 }
 651 void spawnfunc_trigger_warpzone_position(void)
 652 {
 653         spawnfunc_misc_warpzone_position();
 654 }
 655 void spawnfunc_trigger_warpzone(void)
 656 {
 657         // warp zone entities must have:
 658         // "killtarget" pointing to a target_position with a direction arrow
 659         //              that points AWAY from the warp zone, and that is inside
 660         //              the warp zone trigger
 661         // "target"     pointing to an identical warp zone at another place in
 662         //              the map, with another killtarget to designate its
 663         //              orientation
 664
 665 #ifndef WARPZONE_USE_FIXANGLE
 666         // used when teleporting
 667         precache_model("null");
 668 #endif
 669
 670         if(!self.scale)
 671                 self.scale = self.modelscale;
 672         if(!self.scale)
 673                 self.scale = 1;
 674         string m;
 675         m = self.model;
 676         WarpZoneLib_ExactTrigger_Init();
 677         if(m != "")
 678         {
 679                 precache_model(m);
 680                 setmodel(self, m); // no precision needed
 681         }
 682         setorigin(self, self.origin);
 683         if(self.scale)
 684                 setsize(self, self.mins * self.scale, self.maxs * self.scale);
 685         else
 686                 setsize(self, self.mins, self.maxs);
 687         self.SendEntity = WarpZone_Send;
 688         self.SendFlags = 0xFFFFFF;
 689         BITSET_ASSIGN(self.effects, EF_NODEPTHTEST);
 690         self.warpzone_next = warpzone_first;
 691         warpzone_first = self;
 692 }
 693 void spawnfunc_func_camera(void)
 694 {
 695         if(!self.scale)
 696                 self.scale = self.modelscale;
 697         if(!self.scale)
 698                 self.scale = 1;
 699         if(self.model != "")
 700         {
 701                 precache_model(self.model);
 702                 setmodel(self, self.model); // no precision needed
 703         }
 704         setorigin(self, self.origin);
 705         if(self.scale)
 706                 setsize(self, self.mins * self.scale, self.maxs * self.scale);
 707         else
 708                 setsize(self, self.mins, self.maxs);
 709         if(!self.solid)
 710                 self.solid = SOLID_BSP;
 711         else if(self.solid < 0)
 712                 self.solid = SOLID_NOT;
 713         self.SendEntity = WarpZone_Camera_Send;
 714         self.SendFlags = 0xFFFFFF;
 715         self.warpzone_next = warpzone_camera_first;
 716         warpzone_camera_first = self;
 717 }
 718 void WarpZones_Reconnect()
 719 {
 720         entity e;
 721         e = self;
 722         for(self = warpzone_first; self; self = self.warpzone_next)
 723                 WarpZone_InitStep_ClearTarget();
 724         for(self = warpzone_first; self; self = self.warpzone_next)
 725                 WarpZone_InitStep_FindTarget();
 726         for(self = warpzone_camera_first; self; self = self.warpzone_next)
 727                 WarpZoneCamera_InitStep_FindTarget();
 728         for(self = warpzone_first; self; self = self.warpzone_next)
 729                 WarpZone_InitStep_FinalizeTransform();
 730         self = e;
 731 }
 732
 733 void WarpZone_Think()
 734 {
 735         if(self.warpzone_save_origin != self.origin
 736         || self.warpzone_save_angles != self.angles
 737         || self.warpzone_save_eorigin != self.enemy.origin
 738         || self.warpzone_save_eangles != self.enemy.angles)
 739         {
 740                 entity oldself;
 741                 oldself = self;
 742                 WarpZone_InitStep_UpdateTransform();
 743                 self = self.enemy;
 744                 WarpZone_InitStep_UpdateTransform();
 745                 self = oldself;
 746                 WarpZone_InitStep_FinalizeTransform();
 747                 self = self.enemy;
 748                 WarpZone_InitStep_FinalizeTransform();
 749                 self = oldself;
 750                 self.warpzone_save_origin = self.origin;
 751                 self.warpzone_save_angles = self.angles;
 752                 self.warpzone_save_eorigin = self.enemy.origin;
 753                 self.warpzone_save_eangles = self.enemy.angles;
 754         }
 755         self.nextthink = time;
 756 }
 757
 758 void WarpZone_StartFrame()
 759 {
 760         entity e;
 761         if(warpzone_initialized == 0)
 762         {
 763                 warpzone_initialized = 1;
 764                 e = self;
 765                 for(self = warpzone_first; self; self = self.warpzone_next)
 766                         WarpZone_InitStep_FindOriginTarget();
 767                 for(self = warpzone_position_first; self; self = self.warpzone_next)
 768                         WarpZonePosition_InitStep_FindTarget();
 769                 for(self = warpzone_first; self; self = self.warpzone_next)
 770                         WarpZone_InitStep_UpdateTransform();
 771                 self = e;
 772                 WarpZones_Reconnect();
 773                 WarpZone_PostInitialize_Callback();
 774         }
 775
 776         if(warpzone_warpzones_exist)
 777         {
 778                 entity oldself, oldother;
 779                 oldself = self;
 780                 oldother = other;
 781                 for(e = world; (e = nextent(e)); )
 782                 {
 783                         WarpZone_StoreProjectileData(e);
 784                         float f;
 785                         f = clienttype(e);
 786                         if(f == CLIENTTYPE_REAL)
 787                         {
 788                                 if(e.solid != SOLID_NOT) // not spectating?
 789                                         continue;
 790                                 if(e.movetype != MOVETYPE_NOCLIP && e.movetype != MOVETYPE_FLY) // not spectating? (this is to catch observers)
 791                                         continue;
 792                                 self = WarpZone_Find(e.origin + e.mins, e.origin + e.maxs);
 793                                 if(!self)
 794                                         continue;
 795                                 other = e;
 796                                 if(WarpZoneLib_ExactTrigger_Touch())
 797                                         continue;
 798                                 if(WarpZone_PlaneDist(self, e.origin + e.view_ofs) <= 0)
 799                                         WarpZone_Teleport(self, e, -1, 0); // NOT triggering targets by this!
 800                         }
 801                         if(f == CLIENTTYPE_NOTACLIENT)
 802                         {
 803                                 for(; (e = nextent(e)); )
 804                                         WarpZone_StoreProjectileData(e);
 805                                 break;
 806                         }
 807                 }
 808                 self = oldself;
 809                 other = oldother;
 810         }
 811 }
 812
 813 .float warpzone_reconnecting;
 814 float visible_to_some_client(entity ent)
 815 {
 816         entity e;
 817         for(e = nextent(world); clienttype(e) != CLIENTTYPE_NOTACLIENT; e = nextent(e))
 818                 if(e.classname == "player" && clienttype(e) == CLIENTTYPE_REAL)
 819                         if(checkpvs(e.origin + e.view_ofs, ent))
 820                                 return 1;
 821         return 0;
 822 }
 823 void trigger_warpzone_reconnect_use()
 824 {
 825         entity e;
 826         e = self;
 827         // NOTE: this matches for target, not targetname, but of course
 828         // targetname must be set too on the other entities
 829         for(self = warpzone_first; self; self = self.warpzone_next)
 830                 self.warpzone_reconnecting = ((e.target == "" || self.target == e.target) && !((e.spawnflags & 1) && (visible_to_some_client(self) || visible_to_some_client(self.enemy))));
 831         for(self = warpzone_camera_first; self; self = self.warpzone_next)
 832                 self.warpzone_reconnecting = ((e.target == "" || self.target == e.target) && !((e.spawnflags & 1) && visible_to_some_client(self)));
 833         for(self = warpzone_first; self; self = self.warpzone_next)
 834                 if(self.warpzone_reconnecting)
 835                         WarpZone_InitStep_ClearTarget();
 836         for(self = warpzone_first; self; self = self.warpzone_next)
 837                 if(self.warpzone_reconnecting)
 838                         WarpZone_InitStep_FindTarget();
 839         for(self = warpzone_camera_first; self; self = self.warpzone_next)
 840                 if(self.warpzone_reconnecting)
 841                         WarpZoneCamera_InitStep_FindTarget();
 842         for(self = warpzone_first; self; self = self.warpzone_next)
 843                 if(self.warpzone_reconnecting || self.enemy.warpzone_reconnecting)
 844                         WarpZone_InitStep_FinalizeTransform();
 845         self = e;
 846 }
 847
 848 void spawnfunc_trigger_warpzone_reconnect()
 849 {
 850         self.use = trigger_warpzone_reconnect_use;
 851 }
 852
 853 void spawnfunc_target_warpzone_reconnect()
 854 {
 855         spawnfunc_trigger_warpzone_reconnect(); // both names make sense here :(
 856 }
 857
 858 void WarpZone_PlayerPhysics_FixVAngle(void)
 859 {
 860 #ifndef WARPZONE_DONT_FIX_VANGLE
 861         if(clienttype(self) == CLIENTTYPE_REAL)
 862         if(self.v_angle_z <= 360) // if not already adjusted
 863         if(time - self.ping * 0.001 < self.warpzone_teleport_time)
 864         {
 865                 self.v_angle = WarpZone_TransformVAngles(self.warpzone_teleport_zone, self.v_angle);
 866                 self.v_angle_z += 720; // mark as adjusted
 867         }
 868 #endif
 869 }