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(clienttype(player) != CLIENTTYPE_NOTACLIENT)
  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 = servertime;
  93         player.warpzone_teleport_zone = self;
  94
  95         return 1;
  96 }
  97
  98 void WarpZone_Touch (void)
  99 {
 100         entity oldself, e;
 101
 102         if(other.classname == "trigger_warpzone")
 103                 return;
 104
 105         // FIXME needs a better check to know what is safe to teleport and what not
 106         if(other.movetype == MOVETYPE_NONE)
 107                 return;
 108
 109         if(WarpZoneLib_ExactTrigger_Touch())
 110                 return;
 111
 112         e = self.enemy;
 113         if(WarpZone_Teleport(other))
 114         {
 115                 string save1, save2;
 116                 activator = other;
 117
 118                 save1 = self.target; self.target = string_null;
 119                 save2 = self.target3; self.target3 = string_null;
 120                 SUB_UseTargets();
 121                 if not(self.target) self.target = save1;
 122                 if not(self.target3) self.target3 = save2;
 123
 124                 oldself = self;
 125                 self = self.enemy;
 126                 save1 = self.target; self.target = string_null;
 127                 save2 = self.target2; self.target2 = string_null;
 128                 SUB_UseTargets();
 129                 if not(self.target) self.target = save1;
 130                 if not(self.target2) self.target2 = save2;
 131                 self = oldself;
 132         }
 133         else
 134         {
 135                 dprint("WARPZONE FAIL AHAHAHAHAH))\n");
 136         }
 137 }
 138
 139 float WarpZone_Send(entity to, float sendflags)
 140 {
 141         float f;
 142         WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE);
 143
 144         // we must send this flag for clientside to match properly too
 145         f = 0;
 146         if(self.warpzone_isboxy)
 147                 f |= 1;
 148         if(self.warpzone_fadestart)
 149                 f |= 2;
 150         if(self.origin != '0 0 0')
 151                 f |= 4;
 152         WriteByte(MSG_ENTITY, f);
 153
 154         // we need THESE to render the warpzone (and cull properly)...
 155         if(f & 4)
 156         {
 157                 WriteCoord(MSG_ENTITY, self.origin_x);
 158                 WriteCoord(MSG_ENTITY, self.origin_y);
 159                 WriteCoord(MSG_ENTITY, self.origin_z);
 160         }
 161
 162         WriteShort(MSG_ENTITY, self.modelindex);
 163         WriteCoord(MSG_ENTITY, self.mins_x);
 164         WriteCoord(MSG_ENTITY, self.mins_y);
 165         WriteCoord(MSG_ENTITY, self.mins_z);
 166         WriteCoord(MSG_ENTITY, self.maxs_x);
 167         WriteCoord(MSG_ENTITY, self.maxs_y);
 168         WriteCoord(MSG_ENTITY, self.maxs_z);
 169         WriteByte(MSG_ENTITY, bound(1, self.scale * 16, 255));
 170
 171         // we need THESE to calculate the proper transform
 172         WriteCoord(MSG_ENTITY, self.warpzone_origin_x);
 173         WriteCoord(MSG_ENTITY, self.warpzone_origin_y);
 174         WriteCoord(MSG_ENTITY, self.warpzone_origin_z);
 175         WriteCoord(MSG_ENTITY, self.warpzone_angles_x);
 176         WriteCoord(MSG_ENTITY, self.warpzone_angles_y);
 177         WriteCoord(MSG_ENTITY, self.warpzone_angles_z);
 178         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_x);
 179         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_y);
 180         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_z);
 181         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_x);
 182         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_y);
 183         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_z);
 184
 185         if(f & 2)
 186         {
 187                 WriteShort(MSG_ENTITY, self.warpzone_fadestart);
 188                 WriteShort(MSG_ENTITY, self.warpzone_fadeend);
 189         }
 190
 191         return TRUE;
 192 }
 193
 194 float WarpZone_Camera_Send(entity to, float sendflags)
 195 {
 196         float f;
 197         WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE_CAMERA);
 198
 199         if(self.warpzone_fadestart)
 200                 f |= 2;
 201         if(self.origin != '0 0 0')
 202                 f |= 4;
 203         WriteByte(MSG_ENTITY, f);
 204
 205         // we need THESE to render the warpzone (and cull properly)...
 206         if(f & 4)
 207         {
 208                 WriteCoord(MSG_ENTITY, self.origin_x);
 209                 WriteCoord(MSG_ENTITY, self.origin_y);
 210                 WriteCoord(MSG_ENTITY, self.origin_z);
 211         }
 212
 213         WriteShort(MSG_ENTITY, self.modelindex);
 214         WriteCoord(MSG_ENTITY, self.mins_x);
 215         WriteCoord(MSG_ENTITY, self.mins_y);
 216         WriteCoord(MSG_ENTITY, self.mins_z);
 217         WriteCoord(MSG_ENTITY, self.maxs_x);
 218         WriteCoord(MSG_ENTITY, self.maxs_y);
 219         WriteCoord(MSG_ENTITY, self.maxs_z);
 220         WriteByte(MSG_ENTITY, bound(1, self.scale * 16, 255));
 221
 222         // we need THESE to calculate the proper transform
 223         WriteCoord(MSG_ENTITY, self.enemy.origin_x);
 224         WriteCoord(MSG_ENTITY, self.enemy.origin_y);
 225         WriteCoord(MSG_ENTITY, self.enemy.origin_z);
 226         WriteCoord(MSG_ENTITY, self.enemy.angles_x);
 227         WriteCoord(MSG_ENTITY, self.enemy.angles_y);
 228         WriteCoord(MSG_ENTITY, self.enemy.angles_z);
 229
 230         if(f & 2)
 231         {
 232                 WriteShort(MSG_ENTITY, self.warpzone_fadestart);
 233                 WriteShort(MSG_ENTITY, self.warpzone_fadeend);
 234         }
 235
 236         return TRUE;
 237 }
 238
 239 float WarpZone_CheckProjectileImpact()
 240 {
 241         // if self hit a warpzone, abort
 242         vector o0, v0, a0;
 243         float mpd, pd, dpd;
 244         entity wz;
 245         wz = WarpZone_Find(self.origin + self.mins, self.origin + self.maxs);
 246         if(!wz)
 247                 return 0;
 248         if(self.warpzone_teleport_time == time)
 249         {
 250                 // just ignore if we got teleported this frame already and now hit a wall and are in a warpzone again (this will cause a detonation)
 251                 // print("2 warps 1 frame\n");
 252                 return -1;
 253         }
 254         o0 = self.origin;
 255         v0 = self.velocity;
 256         a0 = self.angles;
 257
 258         // this approach transports the projectile at its full speed, but does
 259         // not properly retain the projectile trail (but we can't retain it
 260         // easily anyway without delaying the projectile by two frames, so who
 261         // cares)
 262         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
 263         setorigin(self, trace_endpos);
 264         self.angles = WarpZone_TransformAngles(WarpZone_trace_transform, self.angles);
 265         self.velocity = WarpZone_TransformVelocity(WarpZone_trace_transform, self.warpzone_oldvelocity);
 266
 267         // in case we are in our warp zone post-teleport, shift the projectile forward a bit
 268         mpd = max(vlen(self.mins), vlen(self.maxs));
 269         pd = WarpZone_TargetPlaneDist(wz, self.origin);
 270         if(pd < mpd)
 271         {
 272                 dpd = normalize(self.velocity) * wz.warpzone_targetforward;
 273                 setorigin(self, self.origin + normalize(self.velocity) * ((mpd - pd) / dpd));
 274                 if(!WarpZoneLib_MoveOutOfSolid(self))
 275                 {
 276                         setorigin(self, o0);
 277                         self.angles = a0;
 278                         self.velocity = v0;
 279                         return 0;
 280                 }
 281         }
 282         WarpZone_RefSys_Add(self, wz);
 283         WarpZone_StoreProjectileData(self);
 284         self.warpzone_teleport_time = time;
 285
 286         return +1;
 287 }
 288 float WarpZone_Projectile_Touch()
 289 {
 290         float f;
 291         if(other.classname == "trigger_warpzone")
 292                 return TRUE;
 293         if(WarpZone_Projectile_Touch_ImpactFilter_Callback())
 294                 return TRUE;
 295         if((f = WarpZone_CheckProjectileImpact()) != 0)
 296                 return (f > 0);
 297         if(self.warpzone_teleport_time == time)
 298         {
 299                 // sequence: hit warpzone, get teleported, hit wall
 300                 // print("2 hits 1 frame\n");
 301                 setorigin(self, self.warpzone_oldorigin);
 302                 self.velocity = self.warpzone_oldvelocity;
 303                 self.angles = self.warpzone_oldangles;
 304                 return TRUE;
 305         }
 306         return FALSE;
 307 }
 308
 309 void WarpZone_InitStep_FindOriginTarget()
 310 {
 311         if(self.killtarget != "")
 312         {
 313                 self.aiment = find(world, targetname, self.killtarget);
 314                 if(self.aiment == world)
 315                 {
 316                         error("Warp zone with nonexisting killtarget");
 317                         return;
 318                 }
 319                 self.killtarget = string_null;
 320         }
 321 }
 322
 323 void WarpZonePosition_InitStep_FindTarget()
 324 {
 325         if(self.target == "")
 326         {
 327                 error("Warp zone position with no target");
 328                 return;
 329         }
 330         self.enemy = find(world, targetname, self.target);
 331         if(self.enemy == world)
 332         {
 333                 error("Warp zone position with nonexisting target");
 334                 return;
 335         }
 336         if(self.enemy.aiment)
 337         {
 338                 // already is positioned
 339                 error("Warp zone position targeting already oriented warpzone");
 340                 return;
 341         }
 342         self.enemy.aiment = self;
 343 }
 344
 345 void WarpZoneCamera_InitStep_FindTarget()
 346 {
 347         entity e;
 348         float i;
 349         if(self.target == "")
 350         {
 351                 error("Camera with no target");
 352                 return;
 353         }
 354         self.enemy = world;
 355         for(e = world, i = 0; (e = find(e, targetname, self.target)); )
 356                 if(random() * ++i < 1)
 357                         self.enemy = e;
 358         if(self.enemy == world)
 359         {
 360                 error("Camera with nonexisting target");
 361                 return;
 362         }
 363         warpzone_cameras_exist = 1;
 364         WarpZone_Camera_SetUp(self, self.enemy.origin, self.enemy.angles);
 365         self.SendFlags = 0xFFFFFF;
 366 }
 367
 368 void WarpZone_InitStep_UpdateTransform()
 369 {
 370         vector org, ang, norm, point;
 371         float area;
 372         vector tri, a, b, c, p, q, n;
 373         float i_s, i_t, n_t;
 374         string tex;
 375
 376         org = self.origin;
 377         if(org == '0 0 0')
 378                 org = 0.5 * (self.mins + self.maxs);
 379
 380         norm = point = '0 0 0';
 381         area = 0;
 382         for(i_s = 0; ; ++i_s)
 383         {
 384                 tex = getsurfacetexture(self, i_s);
 385                 if not(tex)
 386                         break; // this is beyond the last one
 387                 if(tex == "textures/common/trigger")
 388                         continue;
 389                 n_t = getsurfacenumtriangles(self, i_s);
 390                 for(i_t = 0; i_t < n_t; ++i_t)
 391                 {
 392                         tri = getsurfacetriangle(self, i_s, i_t);
 393                         a = getsurfacepoint(self, i_s, tri_x);
 394                         b = getsurfacepoint(self, i_s, tri_y);
 395                         c = getsurfacepoint(self, i_s, tri_z);
 396                         p = b - a;
 397                         q = c - a;
 398                         n =     '1 0 0' * (q_y * p_z - q_z * p_y)
 399                         +       '0 1 0' * (q_z * p_x - q_x * p_z)
 400                         +       '0 0 1' * (q_x * p_y - q_y * p_x);
 401                         area = area + vlen(n);
 402                         norm = norm + n;
 403                         point = point + vlen(n) * (a + b + c);
 404                 }
 405         }
 406         if(area > 0)
 407         {
 408                 norm = norm * (1 / area);
 409                 point = point * (1 / (3 * area));
 410                 if(vlen(norm) < 0.99)
 411                 {
 412                         print("trigger_warpzone near ", vtos(self.aiment.origin), " is nonplanar. BEWARE.\n");
 413                         area = 0; // no autofixing in this case
 414                 }
 415                 norm = normalize(norm);
 416         }
 417
 418         if(self.aiment)
 419         {
 420                 org = self.aiment.origin;
 421                 ang = self.aiment.angles;
 422                 if(area > 0)
 423                 {
 424                         org = org - ((org - point) * norm) * norm; // project to plane
 425                         makevectors(ang);
 426                         if(norm * v_forward < 0)
 427                         {
 428                                 print("Position target of trigger_warpzone near ", vtos(self.aiment.origin), " points into trigger_warpzone. BEWARE.\n");
 429                                 norm = -1 * norm;
 430                         }
 431                         ang = vectoangles(norm, v_up); // keep rotation, but turn exactly against plane
 432                         ang_x = -ang_x;
 433                         if(norm * v_forward < 0.99)
 434                                 print("trigger_warpzone near ", vtos(self.aiment.origin), " has been turned to match plane orientation (", vtos(self.aiment.angles), " -> ", vtos(ang), "\n");
 435                         if(vlen(org - self.aiment.origin) > 0.5)
 436                                 print("trigger_warpzone near ", vtos(self.aiment.origin), " has been moved to match the plane (", vtos(self.aiment.origin), " -> ", vtos(org), ").\n");
 437                 }
 438         }
 439         else if(area > 0)
 440         {
 441                 org = point;
 442                 ang = vectoangles(norm);
 443                 ang_x = -ang_x;
 444         }
 445         else
 446                 error("cannot infer origin/angles for this warpzone, please use a killtarget or a trigger_warpzone_position");
 447
 448         self.warpzone_origin = org;
 449         self.warpzone_angles = ang;
 450 }
 451
 452 void WarpZone_InitStep_ClearTarget()
 453 {
 454         if(self.enemy)
 455                 self.enemy.enemy = world;
 456         self.enemy = world;
 457 }
 458
 459 entity warpzone_first; .entity warpzone_next;
 460 void WarpZone_InitStep_FindTarget()
 461 {
 462         float i;
 463         entity e, e2;
 464
 465         if(self.enemy)
 466                 return;
 467
 468         // this way only one of the two ents needs to target
 469         if(self.target != "")
 470         {
 471                 self.enemy = self; // so the if(!e.enemy) check also skips self, saves one IF
 472
 473                 e2 = world;
 474                 for(e = world, i = 0; (e = find(e, targetname, self.target)); )
 475                         if(!e.enemy)
 476                                 if(e.classname == self.classname) // possibly non-warpzones may use the same targetname!
 477                                         if(random() * ++i < 1)
 478                                                 e2 = e;
 479                 if(!e2)
 480                 {
 481                         self.enemy = world;
 482                         error("Warpzone with non-existing target");
 483                         return;
 484                 }
 485                 self.enemy = e2;
 486                 e2.enemy = self;
 487         }
 488 }
 489
 490 void WarpZone_InitStep_FinalizeTransform()
 491 {
 492         if(!self.enemy || self.enemy.enemy != self)
 493         {
 494                 error("Invalid warp zone detected. Killed.");
 495                 return;
 496         }
 497
 498         warpzone_warpzones_exist = 1;
 499         WarpZone_SetUp(self, self.warpzone_origin, self.warpzone_angles, self.enemy.warpzone_origin, self.enemy.warpzone_angles);
 500         self.touch = WarpZone_Touch;
 501         self.SendFlags = 0xFFFFFF;
 502 }
 503
 504 float warpzone_initialized;
 505 entity warpzone_first;
 506 entity warpzone_position_first;
 507 entity warpzone_camera_first;
 508 .entity warpzone_next;
 509 void spawnfunc_misc_warpzone_position(void)
 510 {
 511         // "target", "angles", "origin"
 512         self.warpzone_next = warpzone_position_first;
 513         warpzone_position_first = self;
 514 }
 515 void spawnfunc_trigger_warpzone_position(void)
 516 {
 517         spawnfunc_misc_warpzone_position();
 518 }
 519 void spawnfunc_trigger_warpzone(void)
 520 {
 521         // warp zone entities must have:
 522         // "killtarget" pointing to a target_position with a direction arrow
 523         //              that points AWAY from the warp zone, and that is inside
 524         //              the warp zone trigger
 525         // "target"     pointing to an identical warp zone at another place in
 526         //              the map, with another killtarget to designate its
 527         //              orientation
 528
 529         if(!self.scale)
 530                 self.scale = self.modelscale;
 531         if(!self.scale)
 532                 self.scale = 1;
 533         string m;
 534         m = self.model;
 535         WarpZoneLib_ExactTrigger_Init();
 536         if(m != "")
 537         {
 538                 precache_model(m);
 539                 setmodel(self, m); // no precision needed
 540         }
 541         setorigin(self, self.origin);
 542         if(self.scale)
 543                 setsize(self, self.mins * self.scale, self.maxs * self.scale);
 544         else
 545                 setsize(self, self.mins, self.maxs);
 546         self.SendEntity = WarpZone_Send;
 547         self.SendFlags = 0xFFFFFF;
 548         self.effects |= EF_NODEPTHTEST;
 549         self.warpzone_next = warpzone_first;
 550         warpzone_first = self;
 551 }
 552 void spawnfunc_func_camera(void)
 553 {
 554         if(!self.scale)
 555                 self.scale = self.modelscale;
 556         if(!self.scale)
 557                 self.scale = 1;
 558         if(self.model != "")
 559         {
 560                 precache_model(self.model);
 561                 setmodel(self, self.model); // no precision needed
 562         }
 563         setorigin(self, self.origin);
 564         if(self.scale)
 565                 setsize(self, self.mins * self.scale, self.maxs * self.scale);
 566         else
 567                 setsize(self, self.mins, self.maxs);
 568         if(!self.solid)
 569                 self.solid = SOLID_BSP;
 570         else if(self.solid < 0)
 571                 self.solid = SOLID_NOT;
 572         self.SendEntity = WarpZone_Camera_Send;
 573         self.SendFlags = 0xFFFFFF;
 574         self.warpzone_next = warpzone_camera_first;
 575         warpzone_camera_first = self;
 576 }
 577 void WarpZones_Reconnect()
 578 {
 579         entity e;
 580         e = self;
 581         for(self = warpzone_first; self; self = self.warpzone_next)
 582                 WarpZone_InitStep_ClearTarget();
 583         for(self = warpzone_first; self; self = self.warpzone_next)
 584                 WarpZone_InitStep_FindTarget();
 585         for(self = warpzone_camera_first; self; self = self.warpzone_next)
 586                 WarpZoneCamera_InitStep_FindTarget();
 587         for(self = warpzone_first; self; self = self.warpzone_next)
 588                 WarpZone_InitStep_FinalizeTransform();
 589         self = e;
 590 }
 591
 592 void WarpZone_StartFrame()
 593 {
 594         entity e;
 595         if(warpzone_initialized == 0)
 596         {
 597                 warpzone_initialized = 1;
 598                 e = self;
 599                 for(self = warpzone_first; self; self = self.warpzone_next)
 600                         WarpZone_InitStep_FindOriginTarget();
 601                 for(self = warpzone_position_first; self; self = self.warpzone_next)
 602                         WarpZonePosition_InitStep_FindTarget();
 603                 for(self = warpzone_first; self; self = self.warpzone_next)
 604                         WarpZone_InitStep_UpdateTransform();
 605                 self = e;
 606                 WarpZones_Reconnect();
 607         }
 608
 609         if(warpzone_warpzones_exist)
 610         {
 611                 entity oldself, oldother;
 612                 oldself = self;
 613                 oldother = other;
 614                 for(e = world; (e = nextent(e)); )
 615                 {
 616                         WarpZone_StoreProjectileData(e);
 617                         float f;
 618                         f = clienttype(e);
 619                         if(f == CLIENTTYPE_REAL)
 620                         {
 621                                 if(e.solid != SOLID_NOT) // not spectating?
 622                                         continue;
 623                                 if(e.movetype != MOVETYPE_NOCLIP && e.movetype != MOVETYPE_FLY) // not spectating? (this is to catch observers)
 624                                         continue;
 625                                 self = WarpZone_Find(e.origin + e.mins, e.origin + e.maxs);
 626                                 if(!self)
 627                                         continue;
 628                                 other = e;
 629                                 if(WarpZoneLib_ExactTrigger_Touch())
 630                                         continue;
 631                                 WarpZone_Teleport(e); // NOT triggering targets by this!
 632                         }
 633                         if(f == CLIENTTYPE_NOTACLIENT)
 634                         {
 635                                 for(; (e = nextent(e)); )
 636                                         WarpZone_StoreProjectileData(e);
 637                                 break;
 638                         }
 639                 }
 640                 self = oldself;
 641                 other = oldother;
 642         }
 643 }
 644
 645 .float warpzone_reconnecting;
 646 float visible_to_some_client(entity ent)
 647 {
 648         entity e;
 649         for(e = nextent(world); clienttype(e) != CLIENTTYPE_NOTACLIENT; e = nextent(e))
 650                 if(e.classname == "player" && clienttype(e) == CLIENTTYPE_REAL)
 651                         if(checkpvs(e.origin + e.view_ofs, ent))
 652                                 return 1;
 653         return 0;
 654 }
 655 void trigger_warpzone_reconnect_use()
 656 {
 657         entity e;
 658         e = self;
 659         // NOTE: this matches for target, not targetname, but of course
 660         // targetname must be set too on the other entities
 661         for(self = warpzone_first; self; self = self.warpzone_next)
 662                 self.warpzone_reconnecting = ((e.target == "" || self.target == e.target) && !((e.spawnflags & 1) && (visible_to_some_client(self) || visible_to_some_client(self.enemy))));
 663         for(self = warpzone_camera_first; self; self = self.warpzone_next)
 664                 self.warpzone_reconnecting = ((e.target == "" || self.target == e.target) && !((e.spawnflags & 1) && visible_to_some_client(self)));
 665         for(self = warpzone_first; self; self = self.warpzone_next)
 666                 if(self.warpzone_reconnecting)
 667                         WarpZone_InitStep_ClearTarget();
 668         for(self = warpzone_first; self; self = self.warpzone_next)
 669                 if(self.warpzone_reconnecting)
 670                         WarpZone_InitStep_FindTarget();
 671         for(self = warpzone_camera_first; self; self = self.warpzone_next)
 672                 if(self.warpzone_reconnecting)
 673                         WarpZoneCamera_InitStep_FindTarget();
 674         for(self = warpzone_first; self; self = self.warpzone_next)
 675                 if(self.warpzone_reconnecting || self.enemy.warpzone_reconnecting)
 676                         WarpZone_InitStep_FinalizeTransform();
 677         self = e;
 678 }
 679
 680 void spawnfunc_trigger_warpzone_reconnect()
 681 {
 682         self.use = trigger_warpzone_reconnect_use;
 683 }
 684
 685 void spawnfunc_target_warpzone_reconnect()
 686 {
 687         spawnfunc_trigger_warpzone_reconnect(); // both names make sense here :(
 688 }
 689
 690 void WarpZone_PlayerPhysics_FixVAngle(void)
 691 {
 692         if(time < self.warpzone_teleport_time)
 693                 self.v_angle = WarpZone_TransformVAngles(self.warpzone_teleport_zone, self.v_angle);
 694 }