qcsrc/warpzonelib/server.qc

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