Legacy:DelayedTeleporter/UT Code - Unreal Wiki

# Legacy:DelayedTeleporter/UT Code

### From Unreal Wiki, The Unreal Engine Documentation Site

< Legacy:DelayedTeleporter
UT :: Actor (UT) >> NavigationPoint (UT) >> Teleporter >> DelayedTeleporter (Code)

To use this actor, subclass Teleporter with the following code. This class has been tested offline only. See Create A Subclass and Embedding Code for how to use this script. Set bStatic to False and bNoDelete to True in the DelayedTeleporter's default properties.

    class DelayedTeleporter extends Teleporter;
    /******************************************************************************
    * DelayedTeleporter by Wormbo                                                 *
    *                                                                             *
    * TeleporterEnterDelay specifies, how long the teleporter is disabled after   *
    * someone entered it.                                                         *
    * bFixedExitRotation specifies, that the player's rotation after exiting this *
    * teleporter should be set to the teleporter's rotation.                      *
    *                                                                             *
    * To make the delay work, set bStatic=False and bNoDelete=True in defaults.   *
    ******************************************************************************/

    var(Teleporter) float TeleportEnterDelay;
    var(Teleporter) bool bFixedExitRotation;
    var float Delay;
    var Actor LastIncoming;

    replication
    {
            reliable if ( Role == ROLE_Authority )
                    Delay;
    }

    simulated function Tick(float DeltaTime)
    {
            local int i;

            if ( Delay > 0 ) {
                    Delay -= DeltaTime;
                    if ( Delay <= 0 ) //teleport any pawns already in my radius
                            for (i = 0; i < 4; i++)
                                    if ( Touching[i] != None )
                                            Touch(Touching[i]);
            }
    }

    simulated function bool Accept(actor Incoming, Actor Source)
    {
            local rotator newRot, oldRot;
            local pawn P;

            // Move the actor here.
            Disable('Touch');
            //log("Move Actor here "$tag);
            newRot = Incoming.Rotation;
            if ( bChangesYaw ) {
                    oldRot = Incoming.Rotation;
                    newRot.Yaw = Rotation.Yaw;
                    if ( !bFixedExitRotation && Source != None )
                            newRot.Yaw += (32768 + Incoming.Rotation.Yaw - Source.Rotation.Yaw);
            }

            if ( Pawn(Incoming) != None ) {
                    //tell enemies about teleport
                    if ( Role == ROLE_Authority ) {
                            P = Level.PawnList;
                            While ( P != None ) {
                                    if ( P.Enemy == Incoming )
                                            P.LastSeenPos = Incoming.Location;
                                    P = P.nextPawn;
                            }
                    }
                    Pawn(Incoming).SetLocation(Location);
                    if ( Role == ROLE_Authority || Level.TimeSeconds - LastFired > 0.5 ) {
                            Pawn(Incoming).SetRotation(newRot);
                            Pawn(Incoming).ViewRotation = newRot;
                            LastFired = Level.TimeSeconds;
                    }
                    Pawn(Incoming).MoveTimer = -1.0;
                    Pawn(Incoming).MoveTarget = self;
                    PlayTeleportEffect( Incoming, false);
            }
            else {
                    if ( !Incoming.SetLocation(Location) ) {
                            Enable('Touch');
                            return false;
                    }
                    if ( bChangesYaw )
                            Incoming.SetRotation(newRot);
            }

            Enable('Touch');

            if ( bChangesVelocity )
                    Incoming.Velocity = TargetVelocity;
            else {
                    if ( bChangesYaw ) {
                            if ( Incoming.Physics == PHYS_Walking )
                                    OldRot.Pitch = 0;
                            // adjust the actor's velocity
                            Incoming.Velocity = Incoming.Velocity << OldRot;
                            Incoming.Velocity = Incoming.Velocity >> NewRot;
                            Incoming.Acceleration = Incoming.Acceleration << OldRot;
                            Incoming.Acceleration = Incoming.Acceleration >> NewRot;
                    }
                    if ( bReversesX )
                            Incoming.Velocity.X *= -1.0;
                    if ( bReversesY )
                            Incoming.Velocity.Y *= -1.0;
                    if ( bReversesZ )
                            Incoming.Velocity.Z *= -1.0;
            }

            LastIncoming = Incoming;

            return true;
    }

    // Teleporter was touched by an actor.
    simulated function Touch(actor Other)
    {
            local Teleporter Dest;
            local int i;
            local Actor A;

            if ( !bEnabled || Delay > 0 || Other == LastIncoming )
                    return;

            if ( Other.bCanTeleport && Other.PreTeleport(Self) == false ) {
                    if ( InStr(URL, "/") >= 0 || InStr(URL, "#") >= 0 ) {
                            // Teleport to a level on the net.
                            if ( Role == ROLE_Authority && PlayerPawn(Other) != None )
                                    Level.Game.SendPlayer(PlayerPawn(Other), URL);
                    }
                    else {
                            // Teleport to a random teleporter in this local level, if more than one pick random.
                            foreach AllActors(class 'Teleporter', Dest)
                                    if ( string(Dest.Tag) ~= URL && Dest != Self )
                                            i++;
                            i = rand(i);
                            foreach AllActors(class 'Teleporter', Dest)
                                    if ( string(Dest.Tag) ~= URL && Dest != Self && i-- == 0 )
                                            break;

                            if ( Dest != None ) {
                                    // Teleport the actor into the other teleporter.
                                    if ( Other.IsA('Pawn') )
                                            PlayTeleportEffect(Pawn(Other), false);

                                    if ( Dest.Accept(Other, Self) )
                                            Delay = TeleportEnterDelay;

                                    if ( Event != '' && Other.IsA('Pawn') )
                                            foreach AllActors(class 'Actor', A, Event)
                                                    A.Trigger(Other, Other.Instigator);
                            }
                            else if ( Role == ROLE_Authority )
                                    Pawn(Other).ClientMessage("Teleport destination for "$self$" not found!");
                    }
            }
    }

    simulated function UnTouch(actor Other)
    {
            if ( Other == LastIncoming )
                    LastIncoming = None;

            Super.UnTouch(Other);
    }

Fyfe: `Accept()` can be reduced to:

    simulated function bool Accept( Actor Incoming, Actor Source )
    {
            if ( bFixedExitRotation )
                    Source = None;

            if ( Super.Accept( Incoming, Source ) )
            {
                    LastIncoming = Incoming;
                    return true;
            }
            else
                    return false;
    }

##### Views

- Legacy
- Discussion
- Current revision

##### Search