data/qcsrc/server/portals.qc

   1 #define SAFENUDGE '1 1 1'
   2 #define SAFERNUDGE '8 8 8'
   3
   4 .vector portal_transform;
   5 .vector portal_safe_origin;
   6 .float portal_wants_to_vanish;
   7 .float portal_activatetime;
   8
   9 float PlayerEdgeDistance(entity p, vector v)
  10 {
  11         vector vbest;
  12
  13         if(v_x < 0) vbest_x = p.mins_x; else vbest_x = p.maxs_x;
  14         if(v_y < 0) vbest_y = p.mins_y; else vbest_y = p.maxs_y;
  15         if(v_z < 0) vbest_z = p.mins_z; else vbest_z = p.maxs_z;
  16
  17         return vbest * v;
  18 }
  19
  20 .vector right_vector;
  21 float Portal_TeleportPlayer(entity teleporter, entity player)
  22 {
  23         vector from, to, safe, step, transform, ang, newvel;
  24         vector new_forward, new_up;
  25         vector old_forward, old_up;
  26         vector new_yawforward;
  27         vector old_yawforward;
  28         float planeshift, s, t;
  29
  30         if not(teleporter.enemy)
  31         {
  32                 backtrace("Portal_TeleportPlayer called without other portal being set. Stop.");
  33                 return 0;
  34         }
  35
  36         from = teleporter.origin;
  37         transform = teleporter.portal_transform;
  38
  39         to = teleporter.enemy.origin;
  40         to = to + AnglesTransform_Apply(teleporter.portal_transform, player.origin - from);
  41         newvel = AnglesTransform_Apply(transform, player.velocity);
  42         // this now is INSIDE the plane... can't use that
  43
  44         // shift it out
  45         fixedmakevectors(teleporter.enemy.angles);
  46
  47         // first shift it ON the plane if needed
  48         planeshift = ((teleporter.enemy.origin - to) * v_forward) + PlayerEdgeDistance(player, v_forward) + 1;
  49         if(planeshift > 0 && (newvel * v_forward) > vlen(newvel) * 0.01)
  50                 // if we can't, let us not do the planeshift and do somewhat incorrect transformation in the end
  51                 to += newvel * (planeshift / (newvel * v_forward));
  52         else
  53                 to += trace_plane_normal * planeshift;
  54
  55         s = (to - teleporter.enemy.origin) * v_right;
  56         t = (to - teleporter.enemy.origin) * v_up;
  57         s = bound(-48, s, 48);
  58         t = bound(-48, t, 48);
  59         to = teleporter.enemy.origin
  60            + ((to - teleporter.enemy.origin) * v_forward) * v_forward
  61            +     s                                        * v_right
  62            +     t                                        * v_up;
  63
  64         safe = teleporter.enemy.portal_safe_origin; // a valid player origin
  65         step = to + ((safe - to) * v_forward) * v_forward;
  66         tracebox(safe, player.mins - SAFENUDGE, player.maxs + SAFENUDGE, step, MOVE_NOMONSTERS, player);
  67         if(trace_startsolid)
  68         {
  69                 print("'safe' teleport location is not safe!\n");
  70                 // FAIL TODO why does this happen?
  71                 return 0;
  72         }
  73         safe = trace_endpos + normalize(safe - trace_endpos) * 0;
  74         tracebox(safe, player.mins - SAFENUDGE, player.maxs + SAFENUDGE, to, MOVE_NOMONSTERS, player);
  75         if(trace_startsolid)
  76         {
  77                 print("trace_endpos in solid, this can't be!\n");
  78                 // FAIL TODO why does this happen? (reported by MrBougo)
  79                 return 0;
  80         }
  81         to = trace_endpos + normalize(safe - trace_endpos) * 0;
  82         //print(vtos(to), "\n");
  83
  84         // ang_x stuff works around weird quake angles
  85         if(player.classname == "player")
  86         {
  87                 ang = player.v_angle;
  88                 /*
  89                 ang_x = bound(-89, mod(-ang_x + 180, 360) - 180, 89);
  90                 ang = AnglesTransform_Multiply(transform, ang);
  91                 */
  92
  93                 // PLAYERS use different math
  94                 ang_x = -ang_x;
  95
  96                 //print("reference: ", vtos(AnglesTransform_Multiply(transform, ang)), "\n");
  97
  98                 fixedmakevectors(ang);
  99                 old_forward = v_forward;
 100                 old_up = v_up;
 101                 fixedmakevectors(ang_y * '0 1 0');
 102                 old_yawforward = v_forward;
 103
 104                 // their aiming directions are portalled...
 105                 new_forward = AnglesTransform_Apply(transform, old_forward);
 106                 new_up = AnglesTransform_Apply(transform, old_up);
 107                 new_yawforward = AnglesTransform_Apply(transform, old_yawforward);
 108
 109                 // but now find a new sense of direction
 110                 // this is NOT easy!
 111                 // assume new_forward points straight up.
 112                 // What is our yaw?
 113                 //
 114                 // new_up could now point forward OR backward... which direction to choose?
 115
 116                 if(new_forward_z > 0.7 || new_forward_z < -0.7) // far up; in this case, the "up" vector points backwards
 117                 {
 118                         // new_yawforward and new_yawup define the new aiming half-circle
 119                         // we "just" need to find out whether new_up or -new_up is in that half circle
 120                         ang = fixedvectoangles(new_forward); // this still gets us a nice pitch value...
 121                         if(new_up * new_yawforward < 0)
 122                                 new_up = -1 * new_up;
 123                         ang_y = vectoyaw(new_up); // this vector is the yaw we want
 124                         //print("UP/DOWN path: ", vtos(ang), "\n");
 125                 }
 126                 else
 127                 {
 128                         // good angles; here, "forward" suffices
 129                         ang = fixedvectoangles(new_forward);
 130                         //print("GOOD path: ", vtos(ang), "\n");
 131                 }
 132
 133                 ang_x = -ang_x;
 134                 ang_z = player.angles_z;
 135         }
 136         else
 137         {
 138                 ang = player.angles;
 139                 ang = AnglesTransform_Multiply(transform, player.angles);
 140         }
 141
 142         // factor -1 allows chaining portals, but may be weird
 143         player.right_vector = -1 * AnglesTransform_Apply(transform, player.right_vector);
 144
 145         if(player.flagcarried)
 146                 DropFlag(player.flagcarried, player, world);
 147
 148         if not(teleporter.enemy)
 149         {
 150                 backtrace("Portal_TeleportPlayer ended up without other portal being set BEFORE TeleportPlayer. Stop.");
 151                 return 0;
 152         }
 153
 154         TeleportPlayer(teleporter, player, to, ang, newvel, teleporter.enemy.absmin, teleporter.enemy.absmax);
 155
 156         if not(teleporter.enemy)
 157         {
 158                 backtrace("Portal_TeleportPlayer ended up without other portal being set AFTER TeleportPlayer. Stop.");
 159                 return 0;
 160         }
 161
 162         // reset fade counter
 163         teleporter.portal_wants_to_vanish = 0;
 164         teleporter.fade_time = time + cvar("g_balance_portal_lifetime");
 165         teleporter.health = cvar("g_balance_portal_health");
 166         teleporter.enemy.health = cvar("g_balance_portal_health");
 167
 168         return 1;
 169 }
 170
 171 float Portal_FindSafeOrigin(entity portal)
 172 {
 173         vector o;
 174         o = portal.origin;
 175         portal.mins = PL_MIN - SAFERNUDGE;
 176         portal.maxs = PL_MAX + SAFERNUDGE;
 177         fixedmakevectors(portal.angles);
 178         portal.origin += 16 * v_forward;
 179         if(!move_out_of_solid(portal))
 180         {
 181 #ifdef DEBUG
 182                 print("NO SAFE ORIGIN\n");
 183 #endif
 184                 return 0;
 185         }
 186         portal.portal_safe_origin = portal.origin;
 187         setorigin(portal, o);
 188         return 1;
 189 }
 190
 191 float Portal_WillHitPlane(vector eorg, vector emins, vector emaxs, vector evel, vector porg, vector pnorm, float psize)
 192 {
 193         float dist, distpersec, delta;
 194         vector v;
 195
 196         dist = (eorg - porg) * pnorm;
 197         dist += min(emins_x * pnorm_x, emaxs_x * pnorm_x);
 198         dist += min(emins_y * pnorm_y, emaxs_y * pnorm_y);
 199         dist += min(emins_z * pnorm_z, emaxs_z * pnorm_z);
 200         if(dist < -1) // other side?
 201                 return 0;
 202         distpersec = evel * pnorm;
 203         if(distpersec >= 0) // going away from the portal?
 204                 return 0;
 205         delta = dist / distpersec;
 206         v = eorg - evel * delta - porg;
 207         v = v - pnorm * (pnorm * v);
 208         return vlen(v) < psize;
 209 }
 210
 211 void Portal_Touch()
 212 {
 213         vector g;
 214
 215         // portal is being removed?
 216         if(self.solid != SOLID_TRIGGER)
 217                 return; // possibly engine bug
 218
 219         if(other.classname == "player")
 220                 return; // handled by think
 221
 222         if(other.classname == "item_flag_team")
 223                 return; // never portal these
 224
 225         if(other.classname == "grapplinghook")
 226                 return; // handled by think
 227
 228         if(!self.enemy)
 229                 error("Portal_Touch called for a broken portal\n");
 230
 231         if(trace_fraction < 1)
 232                 return; // only handle TouchAreaGrid ones (only these can teleport)
 233                 // for some unknown reason, this also gets collisions from SV_Impact sometimes
 234
 235         if(other.classname == "porto")
 236         {
 237                 if(other.portal_id == self.portal_id)
 238                         return;
 239         }
 240         if(time < self.portal_activatetime)
 241                 if(other == self.owner)
 242                 {
 243                         self.portal_activatetime = time + 0.1;
 244                         return;
 245                 }
 246         if(other != self.owner)
 247                 if(other.classname == "player")
 248                         if(IS_INDEPENDENT_PLAYER(other) || IS_INDEPENDENT_PLAYER(self.owner))
 249                                 return; // cannot go through someone else's portal
 250         if(other.owner != self.owner)
 251                 if(other.owner.classname == "player")
 252                         if(IS_INDEPENDENT_PLAYER(other.owner) || IS_INDEPENDENT_PLAYER(self.owner))
 253                                 return; // cannot go through someone else's portal
 254         fixedmakevectors(self.angles);
 255         g = frametime * '0 0 -1' * cvar("sv_gravity");
 256         if(!Portal_WillHitPlane(other.origin, other.mins, other.maxs, other.velocity + g, self.origin, v_forward, self.maxs_x))
 257                 return;
 258
 259         /*
 260         if(other.mins_x < PL_MIN_x || other.mins_y < PL_MIN_y || other.mins_z < PL_MIN_z
 261         || other.maxs_x > PL_MAX_x || other.maxs_y > PL_MAX_y || other.maxs_z > PL_MAX_z)
 262         {
 263                 // can't teleport this
 264                 return;
 265         }
 266         */
 267
 268         if(Portal_TeleportPlayer(self, other))
 269                 if(other.classname == "porto")
 270                         if(other.effects & EF_RED)
 271                                 other.effects += EF_BLUE - EF_RED;
 272 }
 273
 274 void Portal_Think();
 275 void Portal_MakeBrokenPortal(entity portal)
 276 {
 277         portal.skin = 2;
 278         portal.solid = SOLID_NOT;
 279         portal.touch = SUB_Null;
 280         portal.think = SUB_Null;
 281         portal.effects = 0;
 282         portal.nextthink = 0;
 283         portal.takedamage = DAMAGE_NO;
 284 }
 285
 286 void Portal_MakeWaitingPortal(entity portal)
 287 {
 288         portal.skin = 2;
 289         portal.solid = SOLID_NOT;
 290         portal.touch = SUB_Null;
 291         portal.think = SUB_Null;
 292         portal.effects = EF_ADDITIVE;
 293         portal.nextthink = 0;
 294         portal.takedamage = DAMAGE_YES;
 295 }
 296
 297 void Portal_MakeInPortal(entity portal)
 298 {
 299         portal.skin = 0;
 300         portal.solid = SOLID_TRIGGER;
 301         portal.touch = Portal_Touch;
 302         portal.think = Portal_Think;
 303         portal.effects = EF_RED;
 304         portal.nextthink = time;
 305         portal.takedamage = DAMAGE_NO;
 306 }
 307
 308 void Portal_MakeOutPortal(entity portal)
 309 {
 310         portal.skin = 1;
 311         portal.solid = SOLID_NOT;
 312         portal.touch = SUB_Null;
 313         portal.think = SUB_Null;
 314         portal.effects = EF_STARDUST | EF_BLUE;
 315         portal.nextthink = 0;
 316         portal.takedamage = DAMAGE_YES;
 317 }
 318
 319 void Portal_Disconnect(entity teleporter, entity destination)
 320 {
 321         teleporter.enemy = world;
 322         destination.enemy = world;
 323         Portal_MakeBrokenPortal(teleporter);
 324         Portal_MakeBrokenPortal(destination);
 325 }
 326
 327 void Portal_Connect(entity teleporter, entity destination)
 328 {
 329         teleporter.portal_transform = AnglesTransform_Divide(AnglesTransform_TurnDirection(destination.angles), teleporter.angles);
 330
 331         teleporter.enemy = destination;
 332         destination.enemy = teleporter;
 333         Portal_MakeInPortal(teleporter);
 334         Portal_MakeOutPortal(destination);
 335         teleporter.fade_time = time + 15;
 336         destination.fade_time = time + 15;
 337         teleporter.portal_wants_to_vanish = 0;
 338         destination.portal_wants_to_vanish = 0;
 339 }
 340
 341 void Portal_Remove(entity portal, float killed)
 342 {
 343         entity e;
 344         e = portal.enemy;
 345
 346         if(e)
 347         {
 348                 Portal_Disconnect(portal, e);
 349                 Portal_Remove(e, killed);
 350         }
 351
 352         if(portal == portal.owner.portal_in)
 353                 portal.owner.portal_in = world;
 354         if(portal == portal.owner.portal_out)
 355                 portal.owner.portal_out = world;
 356         //portal.owner = world;
 357
 358         // makes the portal vanish
 359         if(killed)
 360         {
 361                 fixedmakevectors(portal.angles);
 362                 sound(portal, CHAN_PROJECTILE, "porto/explode.wav", VOL_BASE, ATTN_NORM);
 363                 pointparticles(particleeffectnum("rocket_explode"), portal.origin + v_forward * 16, v_forward * 1024, 4);
 364                 remove(portal);
 365         }
 366         else
 367         {
 368                 Portal_MakeBrokenPortal(portal);
 369                 sound(portal, CHAN_PROJECTILE, "porto/expire.wav", VOL_BASE, ATTN_NORM);
 370                 SUB_SetFade(portal, time, 0.5);
 371         }
 372 }
 373
 374 void Portal_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 375 {
 376         if(deathtype == DEATH_TELEFRAG)
 377                 return;
 378         if(attacker != self.owner)
 379                 if(IS_INDEPENDENT_PLAYER(attacker) || IS_INDEPENDENT_PLAYER(self.owner))
 380                         return;
 381         self.health -= damage;
 382         if(self.health < 0)
 383                 Portal_Remove(self, 1);
 384 }
 385
 386 void Portal_Think_TryTeleportPlayer(entity e, vector g)
 387 {
 388         if(!Portal_WillHitPlane(e.origin, e.mins, e.maxs, e.velocity + g, self.origin, v_forward, self.maxs_x))
 389                 return;
 390
 391         // if e would hit the portal in a frame...
 392         // already teleport him
 393         tracebox(e.origin, e.mins, e.maxs, e.origin + e.velocity * 2 * frametime, MOVE_NORMAL, e);
 394         if(trace_ent == self)
 395                 Portal_TeleportPlayer(self, e);
 396 }
 397
 398 void Portal_Think()
 399 {
 400         entity e, o;
 401         vector g;
 402
 403         // portal is being removed?
 404         if(self.solid != SOLID_TRIGGER)
 405                 return; // possibly engine bug
 406
 407         if(!self.enemy)
 408                 error("Portal_Think called for a broken portal\n");
 409
 410         o = self.owner;
 411         self.solid = SOLID_BBOX;
 412         self.owner = world;
 413
 414         g = frametime * '0 0 -1' * cvar("sv_gravity");
 415
 416         fixedmakevectors(self.angles);
 417
 418         FOR_EACH_PLAYER(e)
 419         {
 420                 if(e != o)
 421                         if(IS_INDEPENDENT_PLAYER(e) || IS_INDEPENDENT_PLAYER(o))
 422                                 continue; // cannot go through someone else's portal
 423
 424                 if(e != o || time >= self.portal_activatetime)
 425                         Portal_Think_TryTeleportPlayer(e, g);
 426
 427                 if(e.hook)
 428                         Portal_Think_TryTeleportPlayer(e.hook, g);
 429         }
 430         self.solid = SOLID_TRIGGER;
 431         self.owner = o;
 432
 433         self.nextthink = time;
 434
 435         if(time > self.fade_time)
 436                 Portal_Remove(self, 0);
 437 }
 438
 439 float Portal_Customize()
 440 {
 441         if(other.classname == "spectator")
 442                 other = other.enemy;
 443         if(other == self.owner)
 444         {
 445                 self.modelindex = self.modelindex_lod0;
 446         }
 447         else if(IS_INDEPENDENT_PLAYER(other) || IS_INDEPENDENT_PLAYER(self.owner))
 448         {
 449                 self.modelindex = 0;
 450         }
 451         else
 452         {
 453                 self.modelindex = self.modelindex_lod0;
 454         }
 455         return TRUE;
 456 }
 457
 458 // cleanup:
 459 //   when creating in-portal:
 460 //     disconnect
 461 //     clear existing in-portal
 462 //     set as in-portal
 463 //     connect
 464 //   when creating out-portal:
 465 //     disconnect
 466 //     clear existing out-portal
 467 //     set as out-portal
 468 //   when player dies:
 469 //     disconnect portals
 470 //     clear both portals
 471 //   after timeout of in-portal:
 472 //     disconnect portals
 473 //     clear both portals
 474 //   TODO: ensure only one portal shot at once
 475 float Portal_SetInPortal(entity own, entity portal)
 476 {
 477         if(own.portal_in)
 478         {
 479                 if(own.portal_out)
 480                         Portal_Disconnect(own.portal_in, own.portal_out);
 481                 Portal_Remove(own.portal_in, 0);
 482         }
 483         own.portal_in = portal;
 484         if(own.portal_out)
 485         {
 486                 own.portal_out.portal_id = portal.portal_id;
 487                 Portal_Connect(own.portal_in, own.portal_out);
 488         }
 489         return 2;
 490 }
 491 float Portal_SetOutPortal(entity own, entity portal)
 492 {
 493         if(own.portal_out)
 494         {
 495                 if(own.portal_in)
 496                         Portal_Disconnect(own.portal_in, own.portal_out);
 497                 Portal_Remove(own.portal_out, 0);
 498         }
 499         own.portal_out = portal;
 500         if(own.portal_in)
 501         {
 502                 own.portal_in.portal_id = portal.portal_id;
 503                 Portal_Connect(own.portal_in, own.portal_out);
 504         }
 505         return 1;
 506 }
 507 void Portal_ClearAll_PortalsOnly(entity own)
 508 {
 509         if(own.portal_in)
 510                 Portal_Remove(own.portal_in, 0);
 511         if(own.portal_out)
 512                 Portal_Remove(own.portal_out, 0);
 513 }
 514 void Portal_ClearAll(entity own)
 515 {
 516         Portal_ClearAll_PortalsOnly(own);
 517         W_Porto_Remove(own);
 518 }
 519 void Portal_RemoveLater_Think()
 520 {
 521         Portal_Remove(self, self.cnt);
 522 }
 523 void Portal_RemoveLater(entity portal, float kill)
 524 {
 525         Portal_MakeBrokenPortal(portal);
 526         portal.cnt = kill;
 527         portal.think = Portal_RemoveLater_Think;
 528         portal.nextthink = time;
 529 }
 530 void Portal_ClearAllLater_PortalsOnly(entity own)
 531 {
 532         if(own.portal_in)
 533                 Portal_RemoveLater(own.portal_in, 0);
 534         if(own.portal_out)
 535                 Portal_RemoveLater(own.portal_out, 0);
 536 }
 537 void Portal_ClearAllLater(entity own)
 538 {
 539         Portal_ClearAllLater_PortalsOnly(own);
 540         W_Porto_Remove(own);
 541 }
 542 void Portal_ClearWithID(entity own, float id)
 543 {
 544         if(own.portal_in)
 545                 if(own.portal_in.portal_id == id)
 546                 {
 547                         if(own.portal_out)
 548                                 Portal_Disconnect(own.portal_in, own.portal_out);
 549                         Portal_Remove(own.portal_in, 0);
 550                 }
 551         if(own.portal_out)
 552                 if(own.portal_out.portal_id == id)
 553                 {
 554                         if(own.portal_in)
 555                                 Portal_Disconnect(own.portal_in, own.portal_out);
 556                         Portal_Remove(own.portal_out, 0);
 557                 }
 558 }
 559
 560 entity Portal_Spawn(entity own, vector org, vector ang)
 561 {
 562         entity portal;
 563
 564         fixedmakevectors(ang);
 565         if(!CheckWireframeBox(own, org - 48 * v_right - 48 * v_up + 16 * v_forward, 96 * v_right, 96 * v_up, 96 * v_forward))
 566                 return world;
 567
 568         portal = spawn();
 569         portal.classname = "portal";
 570         portal.owner = own;
 571         portal.origin = org;
 572         portal.angles = ang;
 573         portal.think = Portal_Think;
 574         portal.nextthink = 0;
 575         portal.portal_activatetime = time + 0.1;
 576         portal.event_damage = Portal_Damage;
 577         portal.health = 200;
 578         portal.fade_time = time + cvar("g_balance_portal_lifetime");
 579         portal.health = cvar("g_balance_portal_health");
 580         setmodel(portal, "models/portal.md3");
 581         portal.modelindex_lod0 = portal.modelindex;
 582         portal.customizeentityforclient = Portal_Customize;
 583
 584         if(!Portal_FindSafeOrigin(portal))
 585         {
 586                 remove(portal);
 587                 return world;
 588         }
 589
 590         setsize(portal, '-48 -48 -48', '48 48 48');
 591         Portal_MakeWaitingPortal(portal);
 592
 593         return portal;
 594 }
 595
 596 float Portal_SpawnInPortalAtTrace(entity own, vector dir, float portal_id_val)
 597 {
 598         entity portal;
 599         vector ang;
 600         vector org;
 601
 602         org = trace_endpos;
 603         ang = fixedvectoangles2(trace_plane_normal, dir);
 604         fixedmakevectors(ang);
 605
 606         portal = Portal_Spawn(own, org, ang);
 607         if(!portal)
 608         {
 609                 // if(!own.portal_out || own.portal_out.portal_id == portal_id_val)
 610                         Portal_ClearAll_PortalsOnly(own);
 611                 return 0;
 612         }
 613
 614         portal.portal_id = portal_id_val;
 615         Portal_SetInPortal(own, portal);
 616
 617         return 1;
 618 }
 619
 620 float Portal_SpawnOutPortalAtTrace(entity own, vector dir, float portal_id_val)
 621 {
 622         entity portal;
 623         vector ang;
 624         vector org;
 625
 626         org = trace_endpos;
 627         ang = fixedvectoangles2(trace_plane_normal, dir);
 628         fixedmakevectors(ang);
 629
 630         portal = Portal_Spawn(own, org, ang);
 631         if(!portal)
 632         {
 633                 // if(!own.portal_in || own.portal_in.portal_id == portal_id_val)
 634                         Portal_ClearAll_PortalsOnly(own);
 635                 return 0;
 636         }
 637
 638         portal.portal_id = portal_id_val;
 639         Portal_SetOutPortal(own, portal);
 640
 641         return 1;
 642 }