Engine.Mover

//=============================================================================
// The moving brush class.
// This is a built-in Unreal class and it shouldn't be modified.
// Note that movers by default have bNoDelete==true.  This makes movers and their default properties
// remain on the client side.  If a mover subclass has bNoDelete=false, then its default properties must
// be replicated
//=============================================================================
class Mover extends Actor
	native
	nativereplication;

// How the mover should react when it encroaches an actor.
var() enum EMoverEncroachType
{
	ME_StopWhenEncroach,	// Stop when we hit an actor.
	ME_ReturnWhenEncroach,	// Return to previous position when we hit an actor.
   	ME_CrushWhenEncroach,   // Crush the poor helpless actor.
   	ME_IgnoreWhenEncroach,  // Ignore encroached actors.
   	ME_LiftWhenEncroach,    //NEW (mwp) Adjust Pawn collision up to avoid encroachment (mover / falling Pawn work-around)
} MoverEncroachType;

// How the mover moves from one position to another.
var() enum EMoverGlideType
{
	MV_MoveByTime,			// Move linearly.
	MV_GlideByTime,			// Move with smooth acceleration.
} MoverGlideType;

// What classes can bump trigger this mover
var() enum EBumpType
{
	BT_PlayerBump,		// Can only be bumped by player.
	BT_PawnBump,		// Can be bumped by any pawn
	BT_AnyBump,			// Can be bumped by any solid actor
} BumpType;

var() name		 DoorEvent; //NEW (mw) - support for triggering AntiPortal when door opens/closes

//-----------------------------------------------------------------------------
// Keyframe numbers.
var() byte       KeyNum;           // Current or destination keyframe.
var byte         PrevKeyNum;       // Previous keyframe.
var() const byte NumKeys;          // Number of keyframes in total (0-3).
var() const byte WorldRaytraceKey; // Raytrace the world with the brush here.
var() const byte BrushRaytraceKey; // Raytrace the brush here.

//-----------------------------------------------------------------------------
// Movement parameters.
var() float      MoveTime;         // Time to spend moving between keyframes.
//NEW (mw) Support for different interpolation times
var() float		 KeyMoveTime[8];
//OLD
var() float      StayOpenTime;     // How long to remain open before closing.
var() float      OtherTime;        // TriggerPound stay-open time.
var() int        EncroachDamage;   // How much to damage encroached actors.

var int NextKeyNum;	//NEW: LoopMovers

//-----------------------------------------------------------------------------
// Mover state.
var() bool       bTriggerOnceOnly; // Go dormant after first trigger.
var() bool       bSlave;           // This brush is a slave.
var() bool		 bUseTriggered;		// Triggered by player grab
var() bool		 bDamageTriggered;	// Triggered by taking damage
var() bool       bDynamicLightMover; // Apply dynamic lighting to mover.
var() name       PlayerBumpEvent;  // Optional event to cause when the player bumps the mover.
var() name       BumpEvent;			// Optional event to cause when any valid bumper bumps the mover.
var   actor      SavedTrigger;      // Who we were triggered by.
var() float		 DamageThreshold;	// minimum damage to trigger
var	  int		 numTriggerEvents;	// number of times triggered ( count down to untrigger )
var	  Mover		 Leader;			// for having multiple movers return together
var	  Mover		 Follower;
var() name		 ReturnGroup;		// if none, same as tag
var() float		 DelayTime;			// delay before starting to open

var() localized string	Description;		//NEW: Set for UseKey description.

//-----------------------------------------------------------------------------
// Audio.
var(MoverSounds) sound      OpeningSound;     // When start opening.
var(MoverSounds) sound      OpenedSound;      // When finished opening.
var(MoverSounds) sound      ClosingSound;     // When start closing.
var(MoverSounds) sound      ClosedSound;      // When finish closing.
var(MoverSounds) sound      MoveAmbientSound; // Optional ambient sound when moving.
var(MoverSounds) vector		SoundLocationOffset;	// Offset for CheckHearSound

//-----------------------------------------------------------------------------
// Internal.
var vector       KeyPos[8];
var rotator      KeyRot[8];
var vector       BasePos, OldPos, OldPrePivot, SavedPos;
var rotator      BaseRot, OldRot, SavedRot;
var           float       PhysAlpha;       // Interpolating position, 0.0-1.0.
var           float       PhysRate;        // Interpolation rate per second.

// AI related
var       NavigationPoint  myMarker;
var		  bool			bOpening, bDelaying, bClientPause;
var		  bool			bClosed;	// mover is in closed position, and no longer moving
var		  bool			bPlayerOnly;

// for client side replication
var		vector			SimOldPos;
var		int				SimOldRotPitch, SimOldRotYaw, SimOldRotRoll;
var		vector			SimInterpolate;
var		vector			RealPosition;
var     rotator			RealRotation;
var		int				ClientUpdate;

/*
replication
{
	// Things the server should send to the client.
	reliable if( Role==ROLE_Authority )
		SimOldPos, SimOldRotPitch, SimOldRotYaw, SimOldRotRoll, SimInterpolate, RealPosition, RealRotation;
}
*/

event  Replication()
{
	Super.Replication();
	DOREP('SimOldPos');
	DOREP('SimOldRotPitch');
	DOREP('SimOldRotYaw');
	DOREP('SimOldRotRoll');
	DOREP('SimInterpolate');
	DOREP('RealPosition');
	DOREP('RealRotation');
	DOREP('Velocity');
}

/* StartInterpolation()
when this function is called, the actor will start moving along an interpolation path
beginning at Dest
*/	
simulated function StartInterpolation()
{
	GotoState('');
	bInterpolating = true;
	SetPhysics(PHYS_None);
}

simulated event Timer()
{
	if ( Velocity != vect(0,0,0) )
	{
		bClientPause = false;
		return;		
	}
	if ( Level.NetMode == NM_Client )
	{
		if ( ClientUpdate == 0 ) // not doing a move
		{
			if ( bClientPause )
			{
				if ( VSize(RealPosition - Location) > 3 )
					SetLocation(RealPosition);
				else
					RealPosition = Location;
				SetRotation(RealRotation);
				bClientPause = false;
			}
			else if ( RealPosition != Location )
				bClientPause = true;
		}
		else
			bClientPause = false;
	}
	else 
	{
		RealPosition = Location;
		RealRotation = Rotation;
	}
}

//-----------------------------------------------------------------------------
// Movement functions.

// Interpolate to keyframe KeyNum in Seconds time.
final function InterpolateTo( byte NewKeyNum, float Seconds )
{
	NewKeyNum = Clamp( NewKeyNum, 0, ArrayCount(KeyPos)-1 );
	if( NewKeyNum==PrevKeyNum && KeyNum!=PrevKeyNum )
	{
		// Reverse the movement smoothly.
		PhysAlpha = 1.0 - PhysAlpha;
		OldPos    = BasePos + KeyPos[KeyNum];
		OldRot    = BaseRot + KeyRot[KeyNum];
	}
	else
	{
		// Start a new movement.
		OldPos    = Location;
		OldRot    = Rotation;
		PhysAlpha = 0.0;
	}

	// Setup physics.
	SetPhysics(PHYS_MovingBrush);
	bInterpolating   = true;
	PrevKeyNum       = KeyNum;
	KeyNum			 = NewKeyNum;
	PhysRate         = 1.0 / FMax(Seconds, 0.005);

	ClientUpdate++;
	SimOldPos = OldPos;
	SimOldRotYaw = OldRot.Yaw;
	SimOldRotPitch = OldRot.Pitch;
	SimOldRotRoll = OldRot.Roll;
	SimInterpolate.X = 100 * PhysAlpha;
	SimInterpolate.Y = 100 * FMax(0.01, PhysRate);
	SimInterpolate.Z = 256 * PrevKeyNum + KeyNum;
}

// Set the specified keyframe.
final function SetKeyframe( byte NewKeyNum, vector NewLocation, rotator NewRotation )
{
	KeyNum         = Clamp( NewKeyNum, 0, ArrayCount(KeyPos)-1 );
	KeyPos[KeyNum] = NewLocation;
	KeyRot[KeyNum] = NewRotation;
}

// Interpolation ended.
event KeyFrameReached()
{
	local byte OldKeyNum;

	OldKeyNum  = PrevKeyNum;
	PrevKeyNum = KeyNum;
	PhysAlpha  = 0;
	ClientUpdate--;

	// If more than two keyframes, chain them.
	if( KeyNum>0 && KeyNum<OldKeyNum )
	{
		// Chain to previous.
		if( KeyMoveTime[KeyNum] != -1 )
			InterpolateTo(KeyNum-1,KeyMoveTime[KeyNum]);
		else
			InterpolateTo(KeyNum-1,MoveTime);
	}
	else if( KeyNum<NumKeys-1 && KeyNum>OldKeyNum )
	{
		// Chain to next.
		if( KeyMoveTime[KeyNum+1] != -1 )
			InterpolateTo(KeyNum+1,KeyMoveTime[KeyNum+1]);
		else
			InterpolateTo(KeyNum+1,MoveTime);
	}
	else
	{
		// Finished interpolating.
		AmbientSound = None;
		if ( (ClientUpdate == 0) && (Level.NetMode != NM_Client) )
		{
			RealPosition = Location;
			RealRotation = Rotation;
		}
	}
}

//-----------------------------------------------------------------------------
// Mover functions.

// Notify AI that mover finished movement
function FinishNotify()
{
	local Controller C;

	for ( C=Level.ControllerList; C!=None; C=C.nextController )
		if ( (C.Pawn != None) && (C.PendingMover == self) )
			C.MoverFinished();
}

// Handle when the mover finishes closing.
function FinishedClosing()
{
	// Update sound effects.
	PlaySound( ClosedSound, SLOT_None, SoundVolume / 255.0, false, SoundRadius, SoundPitch / 64.0); 
		
	// Untrigger our AntiPortal 
	UntriggerEvent( DoorEvent, self, Instigator );  //NEW (mw)
	
	// Notify our triggering actor that we have completed.
	if( SavedTrigger != None )
		SavedTrigger.EndEvent();
	SavedTrigger = None;
	Instigator = None;
	If ( MyMarker != None )
		MyMarker.MoverClosed();
	bClosed = true;
	FinishNotify(); 
}

// Handle when the mover finishes opening.
function FinishedOpening()
{
	// Update sound effects.
	PlaySound( OpenedSound, SLOT_None, SoundVolume / 255.0, false, SoundRadius, SoundPitch / 64.0);
	
	// Trigger any chained movers.
	TriggerEvent(Event, Self, Instigator);

	If ( MyMarker != None )
		MyMarker.MoverOpened();
	FinishNotify();
}

// Open the mover.
function DoOpen()
{
	bOpening = true;
	bDelaying = false;
	if( KeyMoveTime[1] != -1 )
		InterpolateTo( 1, KeyMoveTime[1] );
	else
		InterpolateTo( 1, MoveTime );
	PlaySound( OpeningSound, SLOT_None, SoundVolume / 255.0, false, SoundRadius, SoundPitch / 64.0);
	AmbientSound = MoveAmbientSound;

	// Trigger AntiPortal
	TriggerEvent( DoorEvent, self, Instigator );  //NEW (mw)
}

// Close the mover.
function DoClose()
{
	bOpening = false;
	bDelaying = false;
	if( KeyMoveTime[Max(0,KeyNum)] != -1 )
		InterpolateTo( Max(0,KeyNum-1), KeyMoveTime[Max(0,KeyNum)] );
	else	
		InterpolateTo( Max(0,KeyNum-1), MoveTime );
	PlaySound( ClosingSound, SLOT_None, SoundVolume / 255.0, false, SoundRadius, SoundPitch / 64.0);
	UntriggerEvent(Event, self, Instigator);
	AmbientSound = MoveAmbientSound;
}

// Open the mover.
function DoAdvance()
{
	bOpening = true;
	bDelaying = false;
	if( KeyMoveTime[1] != -1 )
		InterpolateTo( KeyNum+1, KeyMoveTime[1] );
	else
		InterpolateTo( KeyNum+1, MoveTime );
	PlaySound( OpeningSound, SLOT_None, SoundVolume / 255.0, false, SoundRadius, SoundPitch / 64.0);
	AmbientSound = MoveAmbientSound;
}

//-----------------------------------------------------------------------------
// Engine notifications.

// When mover enters gameplay.
simulated event BeginPlay()
{
	local rotator R;

	// timer updates real position every second in network play
	if ( Level.NetMode != NM_Standalone )
	{
		if ( Level.NetMode == NM_Client )
			settimer(4.0, true);
		else
			settimer(1.0, true);
		if ( Role < ROLE_Authority )
			return;
	}

	if ( Level.NetMode != NM_Client )
	{
		RealPosition = Location;
		RealRotation = Rotation;
	}

	// Init key info.
	Super.BeginPlay();
	KeyNum         = Clamp( KeyNum, 0, ArrayCount(KeyPos)-1 );
	PhysAlpha      = 0.0;

	// Set initial location.
	Move( BasePos + KeyPos[KeyNum] - Location );

	// Initial rotation.
	SetRotation( BaseRot + KeyRot[KeyNum] );

	// find movers in same group
	if ( ReturnGroup == '' )
		ReturnGroup = tag;
}

// Immediately after mover enters gameplay.
event PostBeginPlay()
{
	local mover M;

//NEW: CDH... super wasn't being called; may be necessary for mounting
	Super.PostBeginPlay();
//OLD
	// Initialize all slaves.
	if( !bSlave )
	{
		foreach DynamicActors( class 'Mover', M, Tag )
		{
			if( M.bSlave )
			{
				M.GotoState('');
				M.SetBase( Self );
			}
		}
	}
	if ( Leader == None )
	{	
		Leader = self;
		ForEach DynamicActors( class'Mover', M )
			if ( (M != self) && (M.ReturnGroup == ReturnGroup) )
			{
				M.Leader = self;
				M.Follower = Follower;
				Follower = M;
			}
	}
}

function MakeGroupStop()
{
	// Stop moving immediately.
	bInterpolating = false;
	AmbientSound = None;
	//NEW (mdf)
	GotoLabel( '' );
	/*OLD
	GotoState( , '' );
	*/

	if ( Follower != None )
		Follower.MakeGroupStop();
}

function MakeGroupReturn()
{
	// Abort move and reverse course.
	bInterpolating = false;
	AmbientSound = None;

	//NEW (mdf)
	if( KeyNum<PrevKeyNum )
		GotoLabel( 'Open' );
	else
		GotoLabel( 'Close' );
	/* OLD
	if( KeyNum<PrevKeyNum )
		GotoState( , 'Open' );
	else
		GotoState( , 'Close' );
	*/

	if ( Follower != None )
		Follower.MakeGroupReturn();
}
		
// Return true to abort, false to continue.
event bool EncroachingOn( actor Other )
{
	local Pawn P;
//DM( self$"LIFT: EncroachingOn( " $ Other $ " )" ); //!!mwp
	if ( ((Pawn(Other) != None) && (Pawn(Other).Controller == None)) || Other.IsA('Decoration') )
	{
		Other.TakeDamage(10000, None, Other.Location, vect(0,0,0), class'Crushed');
		return false;
	}
	if ( Other.IsA('Pickup') )
	{
		if ( !Other.bAlwaysRelevant && (Other.Owner == None) )
			Other.Destroy();
		return false;
	}
	if ( Other.IsA('Fragment') )
	{
		Other.Destroy();
		return false;
	}

	// Damage the encroached actor.
	if( EncroachDamage != 0 )
		Other.TakeDamage( EncroachDamage, Instigator, Other.Location, vect(0,0,0), class'Crushed' );

	// If we have a bump-player event, and Other is a pawn, do the bump thing.
	P = Pawn(Other);
	if( P!=None && (P.Controller != None) && P.IsPlayerPawn() )
	{
		if ( PlayerBumpEvent!='' )
			Bump( Other );
		if ( (P.Base != self) && (P.Controller.PendingMover == self) )
			P.Controller.UnderLift(self);	// pawn is under lift - tell him to move
	}

	// Stop, return, or whatever.
	if( MoverEncroachType == ME_StopWhenEncroach )
	{
		Leader.MakeGroupStop();
		return true;
	}
	else if( MoverEncroachType == ME_ReturnWhenEncroach )
	{
		Leader.MakeGroupReturn();
		if ( Other.IsA('Pawn') )
		{
/*OLD (mdf) sounds should already be handled if Pawn takes damage above?
			if ( Pawn(Other).IsPlayerPawn() )
				Pawn(Other).PlaySound(Pawn(Other).Land, SLOT_Talk);
			else
				Pawn(Other).PlaySound(Pawn(Other).HitSound[0], SLOT_Talk);
*/
		}	
		return true;
	}
	else if( MoverEncroachType == ME_CrushWhenEncroach )
	{
		// Kill it.
//NEW (mdf)	go through TakeDamage
		Other.TakeDamage( 10000, None, Other.Location, vect(0,0,0), class'Crushed' );
/*OLD		
		Other.KilledBy( Instigator );
*/		
		return false;
	}
	else if( MoverEncroachType == ME_IgnoreWhenEncroach )
	{
		// Ignore it.
		return false;
	}
//NEW (mwp)
	else if( MoverEncroachType == ME_LiftWhenEncroach )
	{
//DM( "LIFT: MoverEncroachType == ME_LiftWhenEncroach" @ self @ Other ); //!!mwp
		// lift Pawns
		if( Pawn(Other) != None )
			return LiftWhenEncroach( Pawn(Other) );
		// Ignore all others
		return false;
	}
//OLD
}

function bool LiftWhenEncroach( Pawn Other )
{
	local bool bResult;
	local CheckResult Hit;
	local vector Start, End, Extent, TraceLength;
	local float AdjustLength;

	// set the Pawn Location to recompute encroachment with the mover
//	DM( Level.TimeSeconds );
//	DM( "Other Location = "$ Other.Location );
//	DM( "Mover Location = "$ Location );
//	Other.SetLocation( Other.Location );

	// put the pawn back on the mover
	Start = Other.Location + vect(0,0,1)*Other.CollisionHeight;
	End = Other.Location - vect(0,0,1)*Other.CollisionHeight;
	Extent.X = Other.CollisionRadius;
	Extent.Y = Other.CollisionRadius;
	Extent.Z = Other.CollisionHeight;
	bResult = SingleLineCheck( Hit, Other, End, Start, TRACE_Movers, Extent );
//	DM( "Other Location = "$ Other.Location );
//	DM( "Mover Location = "$ Location );
//	DM( "Hit.Location = "$ Hit.Location @ bResult @ Hit.Actor );
	TraceLength = Start - Hit.Location;
	AdjustLength = TraceLength.Z - Other.CollisionHeight;
//	DM( "AdjustLength = "$ AdjustLength @ Other.CollisionHeight*2 );
	if( AdjustLength > 0 && AdjustLength < Other.CollisionHeight )
	{
		Other.SetLocation( Other.Location + AdjustLength*vect(0,0,1) );
		Other.SetPhysics( PHYS_Walking );
		Other.SetBase( self );
		return true;
	}

	return false;
}

// When bumped by player.
event Bump( actor Other )
{
	local pawn  P;

	P = Pawn(Other);
	if ( bUseTriggered && (P != None) && !P.IsHumanControlled() && P.IsPlayerPawn() )
	{
		Trigger(P,P);
		P.Controller.WaitForMover(self);
	}	
	if ( (BumpType != BT_AnyBump) && (P == None) )
		return;
	if ( (BumpType == BT_PlayerBump) && !P.IsPlayerPawn() )
		return;
	if ( (BumpType == BT_PawnBump) && P.bAmbientCreature )
		return;
	TriggerEvent(BumpEvent, self, P);

	if ( (P != None) && P.IsPlayerPawn() )
		TriggerEvent(PlayerBumpEvent, self, P);
}

// When damaged
function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation, 
						Vector momentum, class<DamageType> damageType)
{
	if ( bDamageTriggered && (Damage >= DamageThreshold) )
//NEW (mdf) fix (Self.XXX is redundant)
		Trigger(self, instigatedBy);
/*OLD
		self.Trigger(self, instigatedBy);
*/
}

//========================================================================
// Master State for OpenTimed mover states (for movers that open and close)

state OpenTimedMover
{
	function DisableTrigger();
	function EnableTrigger();

Open:
	bClosed = false;
	DisableTrigger();
	if ( DelayTime > 0 )
	{
		bDelaying = true;
		Sleep(DelayTime);
	}
	DoOpen();
	FinishInterpolation();
	FinishedOpening();
	Sleep( StayOpenTime );
	if( bTriggerOnceOnly )
		GotoState('');
Close:
	DoClose();
	FinishInterpolation();
	FinishedClosing();
	EnableTrigger();
}

// Open when stood on, wait, then close.
state() StandOpenTimed extends OpenTimedMover
{
	event Attach( actor Other )
	{
		local pawn  P;

		P = Pawn(Other);
		if ( (BumpType != BT_AnyBump) && (P == None) )
			return;
		if ( (BumpType == BT_PlayerBump) && !P.IsPlayerPawn() )
			return;
		if ( (BumpType == BT_PawnBump) && (Other.Mass < 10) )
			return;
		SavedTrigger = None;
		GotoState( 'StandOpenTimed', 'Open' );
	}

	function DisableTrigger()
	{
		Disable( 'Attach' );
	}

	function EnableTrigger()
	{
		Enable('Attach');
	}
}

// Open when bumped, wait, then close.
state() BumpOpenTimed extends OpenTimedMover
{
	event Bump( actor Other )
	{
		if ( (BumpType != BT_AnyBump) && (Pawn(Other) == None) )
			return;
		if ( (BumpType == BT_PlayerBump) && !Pawn(Other).IsPlayerPawn() )
			return;
		if ( (BumpType == BT_PawnBump) && (Other.Mass < 10) )
			return;
		Global.Bump( Other );
		SavedTrigger = None;
		Instigator = Pawn(Other);
		Instigator.Controller.WaitForMover(self);
		GotoState( 'BumpOpenTimed', 'Open' );
	}

	function DisableTrigger()
	{
		Disable( 'Bump' );
	}

	function EnableTrigger()
	{
		Enable('Bump');
	}
}

// When triggered, open, wait, then close.
state() TriggerOpenTimed extends OpenTimedMover
{
	//NEW (mdf)
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function Trigger( Actor Other, Pawn EventInstigator )
	*/
	{
		SavedTrigger = Other;
		Instigator = EventInstigator;
		if ( SavedTrigger != None )
			SavedTrigger.BeginEvent();
		GotoState( 'TriggerOpenTimed', 'Open' );
	}

	function DisableTrigger()
	{
		Disable( 'Trigger' );
	}

	function EnableTrigger()
	{
		Enable('Trigger');
	}
}

//=================================================================
// Other Mover States

// Goes to next keyframe when triggered
state() TriggerAdvance
{
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		SavedTrigger = Other;
		Instigator = EventInstigator;
		if ( SavedTrigger != None )
			SavedTrigger.BeginEvent();
		GotoState( 'TriggerAdvance', 'Advance' );
	}

Advance:
	if ( DelayTime > 0 )
	{
		bDelaying = true;
		Sleep(DelayTime);
	}
	DoAdvance();
	FinishInterpolation();
	FinishedOpening();
	if ( SavedTrigger != None )
		SavedTrigger.EndEvent();
	Stop;
}

// Toggle when triggered.
state() TriggerToggle
{
	//NEW (mdf)
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function Trigger( Actor Other, Pawn EventInstigator )
	*/
	{
		SavedTrigger = Other;
		Instigator = EventInstigator;
		if ( SavedTrigger != None )
			SavedTrigger.BeginEvent();
		if( KeyNum==0 || KeyNum<PrevKeyNum )
			GotoState( 'TriggerToggle', 'Open' );
		else
			GotoState( 'TriggerToggle', 'Close' );
	}
Open:
	bClosed = false;
	if ( DelayTime > 0 )
	{
		bDelaying = true;
		Sleep(DelayTime);
	}
	DoOpen();
	FinishInterpolation();
	FinishedOpening();
	if ( SavedTrigger != None )
		SavedTrigger.EndEvent();
	Stop;
Close:		
	DoClose();
	FinishInterpolation();
	FinishedClosing();
}

// Open when triggered, close when get untriggered.
state() TriggerControl
{
	//NEW (mdf)
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function Trigger( Actor Other, Pawn EventInstigator )
	*/
	{
		numTriggerEvents++;
		SavedTrigger = Other;
		Instigator = EventInstigator;
		if ( SavedTrigger != None )
			SavedTrigger.BeginEvent();
		if( !bOpening )
			GotoState( 'TriggerControl', 'Open' );
	}
	//NEW (mdf)
	function UnTrigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function UnTrigger( Actor Other, Pawn EventInstigator )
	*/
	{
		numTriggerEvents--;
		if ( numTriggerEvents <=0 )
		{
			numTriggerEvents = 0;
			SavedTrigger = Other;
			Instigator = EventInstigator;
			SavedTrigger.BeginEvent();
			if( !bClosed )
				GotoState( 'TriggerControl', 'Close' );
		}
	}

	event BeginState()
	{
		numTriggerEvents = 0;
	}

Open:
	bClosed = false;
	if ( DelayTime > 0 )
	{
		bDelaying = true;
		Sleep(DelayTime);
	}
	DoOpen();
	FinishInterpolation();
	FinishedOpening();
	SavedTrigger.EndEvent();
	if( bTriggerOnceOnly )
		GotoState('');
	Stop;
Close:		
	DoClose();
	FinishInterpolation();
	FinishedClosing();
}

// Start pounding when triggered.
state() TriggerPound
{
	//NEW (mdf)
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function Trigger( Actor Other, Pawn EventInstigator )
	*/
	{
		numTriggerEvents++;
		SavedTrigger = Other;
		Instigator = EventInstigator;
		GotoState( 'TriggerPound', 'Open' );
	}
	//NEW (mdf)
	function UnTrigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function UnTrigger( Actor Other, Pawn EventInstigator )
	*/
	{
		numTriggerEvents--;
		if ( numTriggerEvents <= 0 )
		{
			numTriggerEvents = 0;
			SavedTrigger = None;
			Instigator = None;
			GotoState( 'TriggerPound', 'Close' );
		}
	}
	event BeginState()
	{
		numTriggerEvents = 0;
	}

Open:
	bClosed = false;
	if ( DelayTime > 0 )
	{
		bDelaying = true;
		Sleep(DelayTime);
	}
	DoOpen();
	FinishInterpolation();
	Sleep(OtherTime);
Close:
	DoClose();
	FinishInterpolation();
	Sleep(StayOpenTime);
	if( bTriggerOnceOnly )
		GotoState('');
	if( SavedTrigger != None )
		goto 'Open';
}

//-----------------------------------------------------------------------------
// Bump states.


// Open when bumped, close when reset.
state() BumpButton
{
	event Bump( actor Other )
	{
		if ( (BumpType != BT_AnyBump) && (Pawn(Other) == None) )
			return;
		if ( (BumpType == BT_PlayerBump) && !Pawn(Other).IsPlayerPawn() )
			return;
		if ( (BumpType == BT_PawnBump) && (Other.Mass < 10) )
			return;
		Global.Bump( Other );
		SavedTrigger = Other;
		Instigator = Pawn( Other );
		Instigator.Controller.WaitForMover(self);
		GotoState( 'BumpButton', 'Open' );
	}
	function BeginEvent()
	{
		bSlave=true;
	}
	function EndEvent()
	{
		bSlave     = false;
		Instigator = None;
		GotoState( 'BumpButton', 'Close' );
	}
Open:
	bClosed = false;
	Disable( 'Bump' );
	if ( DelayTime > 0 )
	{
		bDelaying = true;
		Sleep(DelayTime);
	}
	DoOpen();
	FinishInterpolation();
	FinishedOpening();
	if( bTriggerOnceOnly )
		GotoState('');
	if( bSlave )
		Stop;
Close:
	DoClose();
	FinishInterpolation();
	FinishedClosing();
	Enable( 'Bump' );
}

//NEW: LoopMovers.

// When the last keyframe position is reached, this mover 
// interpolates to the first keyframe (directly, not through
// the intermediate frames), and repeats the movement forever.

state() LoopMove
{
	event BeginState() 
	{
		KeyNum = 0;
	}

	function DoOpen() 
	{
		// Move to the next keyframe.
		//
		if( KeyMoveTime[NextKeyNum] != -1 )
			InterpolateTo( NextKeyNum, KeyMoveTime[NextKeyNum] );
		else
			InterpolateTo( NextKeyNum, MoveTime );
		PlaySound( OpeningSound );
		AmbientSound = MoveAmbientSound;
	}

	//NEW (mdf)
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function Trigger( Actor Other, Pawn EventInstigator )
	*/
	{
		SavedTrigger = Other;
		Instigator = EventInstigator;
		SavedTrigger.BeginEvent();
		GotoState( 'LoopMove', 'Open' );
	}

	//NEW (mdf)
	function UnTrigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function UnTrigger( Actor Other, Pawn EventInstigator )
	*/
	{
		Enable( 'Trigger' );
		SavedTrigger = Other;
		Instigator = EventInstigator;
		GotoState( 'LoopMove', 'InactiveState' );
	}
		
	function InterpolateEnd(actor Other) {	
	}

Open:
	Disable ('Trigger');
	NextKeyNum = KeyNum + 1;
	if( NextKeyNum >= NumKeys ) NextKeyNum = 0;
	DoOpen();
	FinishInterpolation();
	FinishedOpening();

	// Loop forever
	GotoState( 'LoopMove', 'Open' );
InactiveState:
	FinishInterpolation();
	FinishedOpening();
	Stop;
}
//OLD

//NEW
function OnUse( Actor Other )
{
	local Pawn OtherInstigator;

	OtherInstigator = Pawn(Other);
	if( OtherInstigator==None )
		OtherInstigator = Other.Instigator;

	Trigger( Other, OtherInstigator );
}

function OnUnuse( Actor Other )
{
	local Pawn OtherInstigator;

	OtherInstigator = Pawn(Other);
	if( OtherInstigator==None )
		OtherInstigator = Other.Instigator;

	UnTrigger( Other, OtherInstigator );
}

function bool IsUsable( optional Actor Other ){ return !bDeleteMe && bUseTriggered; }
function string GetDescription(){ return Description; }
//OLD

defaultproperties
{
	MoverEncroachType=ME_ReturnWhenEncroach
	MoverGlideType=MV_GlideByTime
	NumKeys=2
	MoveTime=1.000000
	KeyMoveTime(0)=-1.000000
	KeyMoveTime(1)=-1.000000
	KeyMoveTime(2)=-1.000000
	KeyMoveTime(3)=-1.000000
	KeyMoveTime(4)=-1.000000
	KeyMoveTime(5)=-1.000000
	KeyMoveTime(6)=-1.000000
	KeyMoveTime(7)=-1.000000
	StayOpenTime=4.000000
	bClosed=true
	Physics=PHYS_MovingBrush
	bNoDelete=true
	bAcceptsProjectors=true
	bAlwaysRelevant=true
	RemoteRole=ROLE_SimulatedProxy
	InitialState='BumpOpenTimed'
	bMustFace=false
	bShadowCast=true
	SoundVolume=228
	TransientSoundVolume=3.000000
	CollisionRadius=160.000000
	CollisionHeight=160.000000
	bCollideActors=true
	bBlockActors=true
	bBlockPlayers=true
	bPathColliding=true
	NetPriority=2.700000
	bEdShouldSnap=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}