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