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