I don't need to test my programs. I have an error-correcting modem.

Legacy:DelayedTeleporter/UT Code

From Unreal Wiki, The Unreal Engine Documentation Site
Jump to: navigation, search
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;
}