data/qcsrc/server/portals.qc

   1 .vector portal_transform;
   2 .vector portal_safe_origin;
   3 .float portal_wants_to_vanish;
   4 .float portal_activatetime;
   5 .float portal_id;
   6
   7 .entity portal_in, portal_out;
   8
   9 vector Portal_Transform_Apply(vector transform, vector v)
  10 {
  11         fixedmakevectors(transform);
  12         return v_forward * v_x
  13              + v_right   * (-v_y)
  14                  + v_up      * v_z;
  15 }
  16
  17 vector Portal_Transform_Multiply(vector t1, vector t2)
  18 {
  19         vector m_forward, m_up;
  20         fixedmakevectors(t2); m_forward = v_forward; m_up = v_up;
  21         m_forward = Portal_Transform_Apply(t1, m_forward);
  22         m_up = Portal_Transform_Apply(t1, m_up);
  23         return vectoangles2(m_forward, m_up);
  24 }
  25
  26 vector Portal_Transform_Invert(vector transform)
  27 {
  28         vector i_forward, i_up;
  29         fixedmakevectors(transform);
  30         // we want angles that turn v_forward into '1 0 0', v_right into '0 1 0' and v_up into '0 0 1'
  31         // but these are orthogonal unit vectors!
  32         // so to invert, we can simply vectoangles the TRANSPOSED matrix
  33         // TODO is this always -transform?
  34         i_forward_x = v_forward_x;
  35         i_forward_y = -v_right_x;
  36         i_forward_z = v_up_x;
  37         i_up_x = v_forward_z;
  38         i_up_y = -v_right_z;
  39         i_up_z = v_up_z;
  40 #ifdef DEBUG
  41         vector v;
  42         v = vectoangles2(i_forward, i_up);
  43         print("Transform: ", vtos(transform), "\n");
  44         print("Inverted: ", vtos(v), "\n");
  45         print("Verify: ", vtos(Portal_Transform_Multiply(v, transform)), "\n");
  46         fixedmakevectors(Portal_Transform_Multiply(v, transform));
  47         print("Verify: ", vtos(v_forward), "\n");
  48         print("Verify: ", vtos(v_right), "\n");
  49         print("Verify: ", vtos(v_up), "\n");
  50 #endif
  51         return vectoangles2(i_forward, i_up);
  52 }
  53
  54 vector Portal_Transform_TurnDirection(vector transform)
  55 {
  56         // turn 180 degrees around v_up
  57         // changes in-direction to out-direction
  58         fixedmakevectors(transform);
  59         return vectoangles2(-1 * v_forward, 1 * v_up);
  60 }
  61
  62 vector Portal_Transform_Divide(vector to_transform, vector from_transform)
  63 {
  64         return Portal_Transform_Multiply(to_transform, Portal_Transform_Invert(from_transform));
  65 }
  66
  67 float PlayerEdgeDistance(entity p, vector v)
  68 {
  69         vector vbest;
  70
  71         if(v_x < 0) vbest_x = p.mins_x; else vbest_x = p.maxs_x;
  72         if(v_y < 0) vbest_y = p.mins_y; else vbest_y = p.maxs_y;
  73         if(v_z < 0) vbest_z = p.mins_z; else vbest_z = p.maxs_z;
  74
  75         return vbest * v;
  76 }
  77
  78 .vector right_vector;
  79 float Portal_TeleportPlayer(entity teleporter, entity player)
  80 {
  81         vector from, to, safe, step, transform, ang, newvel;
  82         float planeshift, s, t;
  83         from = teleporter.origin;
  84         transform = teleporter.portal_transform;
  85
  86         to = teleporter.enemy.origin;
  87         to = to + Portal_Transform_Apply(teleporter.portal_transform, player.origin - from);
  88         newvel = Portal_Transform_Apply(transform, player.velocity);
  89         // this now is INSIDE the plane... can't use that
  90
  91         // shift it out
  92         fixedmakevectors(teleporter.enemy.angles);
  93
  94         // first shift it ON the plane if needed
  95         planeshift = ((teleporter.enemy.origin - to) * v_forward) + PlayerEdgeDistance(player, v_forward);
  96         if(planeshift > 0)
  97                 to += newvel * (planeshift / (newvel * v_forward));
  98
  99         s = bound(-48, (to - teleporter.enemy.origin) * v_right, 48);
 100         t = bound(-48, (to - teleporter.enemy.origin) * v_up, 48);
 101         to = teleporter.enemy.origin
 102            + (to * v_forward) * v_forward
 103            +     s            * v_right
 104            +     t            * v_up;
 105
 106         safe = teleporter.enemy.portal_safe_origin; // a valid player origin
 107         step = to + ((safe - to) * v_forward) * v_forward;
 108         tracebox(safe, PL_MIN, PL_MAX, step, MOVE_NOMONSTERS, player);
 109         if(trace_startsolid)
 110         {
 111                 bprint("'safe' teleport location is not safe!\n");
 112                 // FAIL TODO why does this happen?
 113                 return 0;
 114         }
 115         safe = trace_endpos;
 116         tracebox(safe, PL_MIN, PL_MAX, to, MOVE_NOMONSTERS, player);
 117         if(trace_startsolid)
 118                 error("trace_endpos in solid!");
 119         to = trace_endpos;
 120
 121         // ang_x stuff works around weird quake angles
 122         if(player.classname == "player")
 123         {
 124                 ang = player.v_angle;
 125                 ang_x = -ang_x;
 126                 ang = Portal_Transform_Multiply(transform, ang);
 127                 ang_z = player.angles_z;
 128         }
 129         else
 130         {
 131                 ang = player.angles;
 132                 ang_x = -ang_x;
 133                 ang = Portal_Transform_Multiply(transform, player.angles);
 134         }
 135         ang_x = -ang_x;
 136
 137         // factor -1 allows chaining portals, but may be weird
 138         player.right_vector = -1 * Portal_Transform_Apply(transform, player.right_vector);
 139
 140         if(player.flagcarried)
 141                 DropFlag(player.flagcarried);
 142         TeleportPlayer(teleporter, player, to, ang, newvel, teleporter.enemy.absmin, teleporter.enemy.absmax);
 143
 144         // reset fade counter
 145         teleporter.portal_wants_to_vanish = 0;
 146         teleporter.fade_time = time + 15;
 147         teleporter.enemy.health = 300;
 148
 149         return 1;
 150 }
 151
 152 float Portal_FindSafeOrigin(entity portal)
 153 {
 154         vector o;
 155         o = portal.origin;
 156         portal.mins = PL_MIN - '8 8 8';
 157         portal.maxs = PL_MAX + '8 8 8';
 158         fixedmakevectors(portal.angles);
 159         portal.origin += 16 * v_forward;
 160         if(!move_out_of_solid(portal))
 161         {
 162 #ifdef DEBUG
 163                 print("NO SAFE ORIGIN\n");
 164 #endif
 165                 return 0;
 166         }
 167         portal.portal_safe_origin = portal.origin;
 168         setorigin(portal, o);
 169         return 1;
 170 }
 171
 172 void Portal_Touch()
 173 {
 174         if(other.classname == "porto")
 175         {
 176                 if(other.portal_id == self.portal_id)
 177                         return;
 178         }
 179         if(time < self.portal_activatetime)
 180                 if(other == self.owner)
 181                 {
 182                         self.portal_activatetime = time + 0.1;
 183                         return;
 184                 }
 185         fixedmakevectors(self.angles);
 186         if((other.origin - self.origin) * v_forward < 0)
 187                 return;
 188         if(other.mins_x < PL_MIN_x || other.mins_y < PL_MIN_y || other.mins_z < PL_MIN_z
 189         || other.maxs_x > PL_MAX_x || other.maxs_y > PL_MAX_y || other.maxs_z > PL_MAX_z)
 190         {
 191                 // can't teleport this
 192                 return;
 193         }
 194         if(Portal_TeleportPlayer(self, other))
 195                 if(other.classname == "porto")
 196                         if(other.cnt == 0)
 197                                 other.cnt = 1;
 198 }
 199
 200 void Portal_MakeBrokenPortal(entity portal)
 201 {
 202         portal.solid = SOLID_NOT;
 203         portal.touch = SUB_Null;
 204         portal.effects = 0;
 205         //portal.colormod = '1 1 1';
 206         portal.nextthink = 0;
 207         portal.takedamage = DAMAGE_NO;
 208 }
 209
 210 void Portal_MakeWaitingPortal(entity portal)
 211 {
 212         portal.solid = SOLID_NOT;
 213         portal.touch = SUB_Null;
 214         portal.effects = EF_ADDITIVE;
 215         portal.colormod = '1 1 1';
 216         portal.nextthink = 0;
 217         portal.takedamage = DAMAGE_YES;
 218 }
 219
 220 void Portal_MakeInPortal(entity portal)
 221 {
 222         portal.solid = SOLID_TRIGGER;
 223         portal.touch = Portal_Touch;
 224         portal.effects = EF_RED;
 225         portal.colormod = '1 0 0';
 226         portal.nextthink = time;
 227         portal.takedamage = DAMAGE_NO;
 228 }
 229
 230 void Portal_MakeOutPortal(entity portal)
 231 {
 232         portal.solid = SOLID_NOT;
 233         portal.touch = SUB_Null;
 234         portal.effects = EF_STARDUST | EF_BLUE;
 235         portal.colormod = '0 0 1';
 236         portal.nextthink = 0;
 237         portal.takedamage = DAMAGE_YES;
 238 }
 239
 240 void Portal_Disconnect(entity teleporter, entity destination)
 241 {
 242         teleporter.enemy = world;
 243         destination.enemy = world;
 244         Portal_MakeBrokenPortal(teleporter);
 245         Portal_MakeBrokenPortal(destination);
 246 }
 247
 248 void Portal_Connect(entity teleporter, entity destination)
 249 {
 250         teleporter.portal_transform = Portal_Transform_Divide(Portal_Transform_TurnDirection(destination.angles), teleporter.angles);
 251
 252 #ifdef DEBUG
 253         {
 254                 // let's verify the transform
 255                 vector in_f, in_r, in_u;
 256                 vector out_f, out_r, out_u;
 257                 fixedmakevectors(teleporter.angles);
 258                 in_f = v_forward;
 259                 in_r = v_right;
 260                 in_u = v_up;
 261                 print("teleporter: ", vtos(in_f), " ", vtos(in_r), " ", vtos(in_u), "\n");
 262                 fixedmakevectors(destination.angles);
 263                 out_f = v_forward;
 264                 out_r = v_right;
 265                 out_u = v_up;
 266                 print("dest: ", vtos(out_f), " ", vtos(out_r), " ", vtos(out_u), "\n");
 267                 // INTENDED TRANSFORM:
 268                 //   in_f -> -out_f
 269                 //   in_r -> -out_r
 270                 //   in_u -> +out_u
 271                 print("FORWARD: ", vtos(in_f), " -> ", vtos(Portal_Transform_Apply(teleporter.portal_transform, in_f)), ", should be", vtos(-1 * out_f), "\n");
 272                 print("RIGHT: ", vtos(in_r), " -> ", vtos(Portal_Transform_Apply(teleporter.portal_transform, in_r)), ", should be", vtos(-1 * out_r), "\n");
 273                 print("UP: ", vtos(in_u), " -> ", vtos(Portal_Transform_Apply(teleporter.portal_transform, in_u)), ", should be", vtos(out_u), "\n");
 274
 275                 te_lightning3(world, teleporter.origin, teleporter.origin + in_r * 1000);
 276                 te_lightning3(world, destination.origin, destination.origin + out_r * 1000);
 277         }
 278 #endif
 279
 280         teleporter.enemy = destination;
 281         destination.enemy = teleporter;
 282         Portal_MakeInPortal(teleporter);
 283         Portal_MakeOutPortal(destination);
 284         teleporter.fade_time = time + 15;
 285         destination.fade_time = time + 15;
 286         teleporter.portal_wants_to_vanish = 0;
 287         destination.portal_wants_to_vanish = 0;
 288 }
 289
 290 void Portal_Remove(entity portal, float killed)
 291 {
 292         entity e;
 293         e = portal.enemy;
 294
 295         if(e)
 296         {
 297                 Portal_Disconnect(portal, e);
 298                 Portal_Remove(e, killed);
 299         }
 300
 301         if(portal == portal.owner.portal_in)
 302                 portal.owner.portal_in = world;
 303         if(portal == portal.owner.portal_out)
 304                 portal.owner.portal_out = world;
 305         portal.owner = world;
 306
 307         // makes the portal vanish
 308         if(killed)
 309         {
 310                 fixedmakevectors(portal.angles);
 311                 pointparticles(particleeffectnum("rocket_explode"), portal.origin + v_forward * 16, v_forward * 1024, 4);
 312                 remove(portal);
 313         }
 314         else
 315         {
 316                 Portal_MakeBrokenPortal(portal);
 317                 SUB_SetFade(portal, time, 0.5);
 318         }
 319 }
 320
 321 void Portal_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 322 {
 323         if(deathtype == DEATH_TELEFRAG)
 324                 return;
 325         self.health -= damage;
 326         if(self.health < 0)
 327         {
 328                 Portal_Remove(self, 1);
 329         }
 330 }
 331
 332 void Portal_Think()
 333 {
 334         entity e, o;
 335
 336         if(self.solid != SOLID_TRIGGER)
 337                 error("Portal_Think called for a portal that should not be thinking");
 338
 339         o = self.owner;
 340         self.solid = SOLID_BBOX;
 341         self.owner = world;
 342         FOR_EACH_PLAYER(e)
 343         {
 344                 if(time < self.portal_activatetime)
 345                         if(e == o)
 346                                 continue;
 347                 // if e would hit the portal in a frame...
 348                 // already teleport him
 349                 tracebox(e.origin, e.mins, e.maxs, e.origin + e.velocity * 2 * frametime, MOVE_NORMAL, e);
 350                 if(trace_ent == self)
 351                         Portal_TeleportPlayer(self, e);
 352         }
 353         self.solid = SOLID_TRIGGER;
 354         self.owner = o;
 355
 356         self.nextthink = time;
 357
 358         if(time > self.fade_time)
 359                 Portal_Remove(self, 0);
 360 }
 361
 362
 363 // cleanup:
 364 //   when creating in-portal:
 365 //     disconnect
 366 //     clear existing in-portal
 367 //     set as in-portal
 368 //     connect
 369 //   when creating out-portal:
 370 //     disconnect
 371 //     clear existing out-portal
 372 //     set as out-portal
 373 //   when player dies:
 374 //     disconnect portals
 375 //     clear both portals
 376 //   after timeout of in-portal:
 377 //     disconnect portals
 378 //     clear both portals
 379 //   TODO: ensure only one portal shot at once
 380 float Portal_SetInPortal(entity own, entity portal)
 381 {
 382         if(own.portal_in)
 383         {
 384                 if(own.portal_out)
 385                         Portal_Disconnect(own.portal_in, own.portal_out);
 386                 Portal_Remove(own.portal_in, 0);
 387         }
 388         own.portal_in = portal;
 389         if(own.portal_out)
 390                 Portal_Connect(own.portal_in, own.portal_out);
 391         return 2;
 392 }
 393 float Portal_SetOutPortal(entity own, entity portal)
 394 {
 395         if(own.portal_out)
 396         {
 397                 if(own.portal_in)
 398                         Portal_Disconnect(own.portal_in, own.portal_out);
 399                 Portal_Remove(own.portal_out, 0);
 400         }
 401         own.portal_out = portal;
 402         if(own.portal_in)
 403                 Portal_Connect(own.portal_in, own.portal_out);
 404         return 1;
 405 }
 406 void Portal_ClearAll(entity own)
 407 {
 408         if(own.portal_in)
 409                 Portal_Remove(own.portal_in, 0);
 410         if(own.portal_out)
 411                 Portal_Remove(own.portal_out, 0);
 412 }
 413 void Portal_ClearWithID(entity own, float id)
 414 {
 415         if(own.portal_in)
 416                 if(own.portal_in.portal_id == id)
 417                 {
 418                         if(own.portal_out)
 419                                 Portal_Disconnect(own.portal_in, own.portal_out);
 420                         Portal_Remove(own.portal_in, 0);
 421                 }
 422         if(own.portal_out)
 423                 if(own.portal_out.portal_id == id)
 424                 {
 425                         if(own.portal_in)
 426                                 Portal_Disconnect(own.portal_in, own.portal_out);
 427                         Portal_Remove(own.portal_out, 0);
 428                 }
 429 }
 430
 431 entity Portal_Spawn(entity own, vector org, vector ang)
 432 {
 433         entity portal;
 434
 435         fixedmakevectors(ang);
 436         if(!CheckWireframeBox(own, org - 48 * v_right - 48 * v_up + 16 * v_forward, 96 * v_right, 96 * v_up, 96 * v_forward))
 437                 return world;
 438
 439         portal = spawn();
 440         portal.classname = "portal";
 441         portal.owner = own;
 442         portal.origin = org;
 443         portal.angles = ang;
 444         portal.think = Portal_Think;
 445         portal.nextthink = 0;
 446         portal.fade_time = time + 15;
 447         portal.portal_activatetime = time + 0.1;
 448         portal.event_damage = Portal_Damage;
 449         portal.health = 300;
 450         setmodel(portal, "models/portal.md3");
 451
 452         if(!Portal_FindSafeOrigin(portal))
 453         {
 454                 remove(portal);
 455                 return world;
 456         }
 457
 458         setsize(portal, '-48 -48 -48', '48 48 48');
 459         Portal_MakeWaitingPortal(portal);
 460
 461         return portal;
 462 }
 463
 464 float Portal_SpawnInPortalAtTrace(entity own, vector dir, float portal_id_val)
 465 {
 466         entity portal;
 467         vector ang;
 468         vector org;
 469
 470         if(trace_ent.movetype == MOVETYPE_WALK)
 471         {
 472                 trace_endpos = trace_ent.origin + '0 0 1' * PL_MIN_z;
 473                 trace_plane_normal = '0 0 1';
 474                 dir = -1 * dir; // create telefrag portals the other way round
 475         }
 476
 477         org = trace_endpos;
 478         ang = vectoangles2(trace_plane_normal, dir);
 479         fixedmakevectors(ang);
 480
 481         portal = Portal_Spawn(own, org, ang);
 482         if(!portal)
 483         {
 484                 if(!self.portal_out || self.portal_out.portal_id == portal_id_val)
 485                         Portal_ClearAll(own);
 486                 return 0;
 487         }
 488
 489         portal.portal_id = portal_id_val;
 490         Portal_SetInPortal(own, portal);
 491
 492         return 1;
 493 }
 494
 495 float Portal_SpawnOutPortalAtTrace(entity own, vector dir, float portal_id_val)
 496 {
 497         entity portal;
 498         vector ang;
 499         vector org;
 500
 501         if(trace_ent.movetype == MOVETYPE_WALK)
 502         {
 503                 trace_endpos = trace_ent.origin + '0 0 1' * PL_MIN_z;
 504                 trace_plane_normal = '0 0 1';
 505                 dir = -1 * dir; // create telefrag portals the other way round
 506         }
 507
 508         org = trace_endpos;
 509         ang = vectoangles2(trace_plane_normal, dir);
 510         fixedmakevectors(ang);
 511
 512         portal = Portal_Spawn(own, org, ang);
 513         if(!portal)
 514         {
 515                 if(!self.portal_in || self.portal_in.portal_id == portal_id_val)
 516                         Portal_ClearAll(own);
 517                 return 0;
 518         }
 519
 520         portal.portal_id = portal_id_val;
 521         Portal_SetOutPortal(own, portal);
 522
 523         return 1;
 524 }