Engine.Trigger

//=============================================================================
// Trigger: senses things happening in its proximity and generates 
// sends Trigger/UnTrigger to actors whose names match 'EventName'.
//=============================================================================
class Trigger extends Triggers
	native;

#exec Texture Import File=Textures\Trigger.pcx Name=S_Trigger Mips=Off MASKED=1

//-----------------------------------------------------------------------------
// Trigger variables.

// Trigger type.
var() enum ETriggerType
{
	TT_PlayerProximity,	// Trigger is activated by player proximity.
	TT_PawnProximity,	// Trigger is activated by any pawn's proximity
	TT_ClassProximity,	// Trigger is activated by actor of ClassProximityType only
	TT_AnyProximity,    // Trigger is activated by any actor in proximity.
	TT_Shoot,		    // Trigger is activated by player shooting it.
//NEW
	TT_Use,				// Trigger is activated by player using it.
//OLD
} TriggerType;

//NEW
// Text displayed with use reticle (when using TT_Use).
var() localized string Description;
//OLD

//NEW PWC 8/8/2002
// adding in damage type so that triggers can be set off by specific damage types only

var() class<DamageType> TriggerDamageType;

//NEW
var() name InstigatorTag;
//OLD

// Human readable triggering message.
var() localized string Message;

// Only trigger once and then go dormant.
var() bool bTriggerOnceOnly;

// For triggers that are activated/deactivated by other triggers.
var() bool bInitiallyActive;

var() class<actor> ClassProximityType;
var() array< class<actor> > ClassProximityTypes;	//NEW (mdf) use if more than 1

var() float	RepeatTriggerTime; //if > 0, repeat trigger message at this interval is still touching other
var() float ReTriggerDelay; //minimum time before trigger can be triggered again
var	  float TriggerTime;
var() float DamageThreshold; //minimum damage to trigger if TT_Shoot

var() float UseDistance; // max distance at which TT_Use triggers can be used
var() bool	bNoProximityReticle; // not hightlight secrets / easter eggs

// AI vars
var	actor TriggerActor;	// actor that triggers this trigger
var actor TriggerActor2;

// store for reset

var bool bSavedInitialCollision;
var bool bSavedInitialActive;

//=============================================================================
// AI related functions

event PostBeginPlay()
{
	//NEW
	if ( !GetInitiallyActive() )
	/*OLD
	if ( !bInitiallyActive )
	*/
		FindTriggerActor();
	if ( TriggerType == TT_Shoot )
	{
//		bHidden = false; 	//NEW (mw) -- commented these two out. No idea why this was being done, it doesn't seem to make much sense :)
		bProjTarget = true;
//		SetDrawType(DT_None);
	}
	else if( TriggerType == TT_Use )
		bHiddenUsable = bHidden && GetInitiallyActive();

	//NEW
	bSavedInitialActive = GetInitiallyActive();
	/*OLD
	bSavedInitialActive = bInitiallyActive;
	*/
	bSavedInitialCollision = bCollideActors;
	Super.PostBeginPlay();
}

//NEW (mdf)
event Destroyed()
{
	RemoveAllTimers();
	Super.Destroyed();
}
//OLD

/* Reset() 
reset actor to initial state - used when restarting level without reloading.
*/
function Reset()
{
	Super.Reset();

	// collision, bInitiallyactive
	//NEW
	SetInitiallyActive( bSavedInitialActive );
	/*OLD
	bInitiallyActive = bSavedInitialActive;
	*/
	SetCollision(bSavedInitialCollision, bBlockActors, bBlockPlayers );
}	

//NEW
function bool GetInitiallyActive()
{
	return bInitiallyActive;
}


function SetInitiallyActive( bool bActive )
{
	bInitiallyActive = bActive;

	if( bActive ) //NEW (mw)
		SetCollision( true, false, false );
	else
		SetCollision( false, false, false );

	if( TriggerType == TT_Use )
		bHiddenUsable = bHidden && GetInitiallyActive();
}
//OLD

function FindTriggerActor()
{
	local Actor A;

	TriggerActor = None;
	TriggerActor2 = None;
	ForEach AllActors(class 'Actor', A)
		if ( A.Event == Tag)
		{
//NEW (mdf)
			if ( Counter(A) != None )
/*OLD
			if ( A.IsA('Counter') )
*/
				return; //FIXME - handle counters
			if (TriggerActor == None)
				TriggerActor = A;
			else
			{
				TriggerActor2 = A;
				return;
			}
		}
}

event Actor SpecialHandling(Pawn Other)
{
//NEW
//	local int i;
//OLD
	local Actor A;

	if ( bTriggerOnceOnly && !bCollideActors )
		return None;

	if ( (TriggerType == TT_PlayerProximity) && !Other.IsPlayerPawn() )
		return None;

	//NEW
	if ( !GetInitiallyActive() )
	/*OLD
	if ( !bInitiallyActive )
	*/
	{
		if ( TriggerActor == None )
			FindTriggerActor();
		if ( TriggerActor == None )
			return None;
		if ( (TriggerActor2 != None) 
			&& (VSize(TriggerActor2.Location - Other.Location) < VSize(TriggerActor.Location - Other.Location)) )
			return TriggerActor2;
		else
			return TriggerActor;
	}

	// is this a shootable trigger?
	if ( TriggerType == TT_Shoot )
		return Other.ShootSpecial(self);

	// can other trigger it right away?
	if ( IsRelevant(Other) )
	{
		ForEach TouchingActors(class'Actor', A)
			if ( A == Other )
				Touch(Other);
		return self;
	}

	return self;
}

// when trigger gets turned on, check its touch list

function CheckTouchList()
{
//NEW
//	local int i;
//OLD
	local Actor A;

	ForEach TouchingActors(class'Actor', A)
		Touch(A);
}

//=============================================================================
// Trigger states.

// Trigger is always active.
state() NormalTrigger
{
}

// Other trigger toggles this trigger's activity.
state() OtherTriggerToggles
{
	//NEW (mdf)
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function Trigger( actor Other, pawn EventInstigator )
	*/
	{
		//NEW
		SetInitiallyActive( !GetInitiallyActive() );
		if ( GetInitiallyActive() )
		/*OLD
		bInitiallyActive = !bInitiallyActive;
		if ( bInitiallyActive )
		*/
			CheckTouchList();
	}
}

// Other trigger turns this on.
state() OtherTriggerTurnsOn
{
	//NEW (mdf)
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function Trigger( actor Other, pawn EventInstigator )
	*/
	{
		local bool bWasActive;

		//NEW
		bWasActive = GetInitiallyActive();
		SetInitiallyActive( true );
		/*OLD
		bWasActive = bInitiallyActive;
		bInitiallyActive = true;
		*/

		if ( !bWasActive )
			CheckTouchList();
	}
}

// Other trigger turns this off.
state() OtherTriggerTurnsOff
{
	//NEW (mdf)
	function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	function Trigger( actor Other, pawn EventInstigator )
	*/
	{
		//NEW
		SetInitiallyActive( false );
		/*OLD
		bInitiallyActive = false;
		*/
	}
}

//=============================================================================
// Trigger logic.

//
// See whether the other actor is relevant to this trigger.
//
function bool IsRelevant( actor Other )
{
	local int ii; //NEW (mdf)
	//NEW
	if( !GetInitiallyActive() )
	/*OLD
	if( !bInitiallyActive )
	*/ 
		return false;
	switch( TriggerType )
	{
		case TT_PlayerProximity:
			return (Pawn(Other) != None) && Pawn(Other).IsPlayerPawn();
		case TT_PawnProximity:
			return (Pawn(Other) != None) && Pawn(Other).CanTrigger(self);
		case TT_ClassProximity:
//NEW (mdf)	
			// mainly for backwards compatibility
			if( ClassIsChildOf( Other.Class, ClassProximityType ) )
				return true;
				
			for( ii=0; ii<ClassProximityTypes.Length; ii++ )
				if( ClassIsChildOf( Other.Class, ClassProximityTypes[ ii ] ) )
					return true;
					
			return false;
/*OLD			
			return ClassIsChildOf(Other.Class, ClassProximityType);
*/			
		case TT_AnyProximity:
			return true;
//NEW PWC 8/7/2002
		case TT_Shoot:
			return ( (Projectile(Other) != None) && (Projectile(Other).Damage >= DamageThreshold) && (Projectile(Other).MyDamageType==TriggerDamageType));
//OLD
			/*
		case TT_Shoot:
			return ( (Projectile(Other) != None) && (Projectile(Other).Damage >= DamageThreshold));
			*/
//NEW
		case TT_Use:
			return false;
//OLD
	}
}

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

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

  	TriggerActors( Self, TriggerClass, Other, OtherInstigator, Event, bTriggerNPCs );

	TriggerTime = Level.TimeSeconds;

//NEW
	// disable once-only triggers from future uses
	if( bTriggerOnceOnly )
	{
		//NEW
		SetInitiallyActive( false );
		/*OLD
		bInitiallyActive = false;
		*/
	}
//OLD

	// Send a string message to the screen for debugging purposes
	if( Message != "" )
		DM( Message );
}

function OnUnuse( Actor Other )
{
	local Pawn OtherInstigator;

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

  	UnTriggerActors( Self, TriggerClass, Other, OtherInstigator, Event, bTriggerNPCs );
}

//NEW
function bool IsUsable( optional Actor Other )
{
	// 2003.01.29 (mdf) fix for adding timers (etc.) to invalid (e.g. deleted) actors
	if( bDeleteMe )
		return false;
		
	if( Controller(Other) != None )
		Other = Controller(Other).Pawn;

	return( GetInitiallyActive() &&
			TriggerType==TT_Use &&
			( Other == None || UseDistance ~= 0.0 || VSize( Other.Location - Location ) < UseDistance ) &&  // check custom use distance
			( !bTriggerOnceOnly || TriggerTime ~= 0.0 ) &&  // constrained by number of times triggered
			( ReTriggerDelay ~= 0.0 || TriggerTime ~= 0.0 || Level.TimeSeconds - TriggerTime > ReTriggerDelay ) ); // respect RetriggerDelay
}
/*OLD
function bool IsUsable( optional Actor Other ){ return bInitiallyActive && TriggerType==TT_Use; }
*/
function string GetDescription(){ return Description; }
//OLD

//
// Called when something touches the trigger.
//
event Touch( actor Other )
{
	local int i;
	if (TriggerType == TT_Shoot) return;
	if( IsRelevant( Other ) )
	{
//NEW
// FIX MW: This check should probably go into IsRelevant? 
		if( InstigatorTag == '' || InstigatorTag == 'None' || Other.Tag == InstigatorTag )
		{
			if ( ReTriggerDelay > 0 )
			{
				if ( Level.TimeSeconds - TriggerTime < ReTriggerDelay )
					return;
				TriggerTime = Level.TimeSeconds;
			}
			// Broadcast the Trigger message to all matching actors.
	//NEW
  			TriggerActors( Self, TriggerClass, Other, Other.Instigator, Event, bTriggerNPCs );
	/*OLD
			TriggerEvent(Event, Other, Other.Instigator);
	*/
			if ( (Pawn(Other) != None) && (Pawn(Other).Controller != None) )
			{
				for ( i=0;i<4;i++ )
					if ( Pawn(Other).Controller.GoalList[i] == self )
					{
						Pawn(Other).Controller.GoalList[i] = None;
						break;
					}
			}	

		if( (Message != "") && (Other.Instigator != None) )
			// Send a string message to the toucher.
			Other.Instigator.ClientMessage( Message );

		if( bTriggerOnceOnly )
			// Ignore future touches.
			SetCollision(False);
		else if ( RepeatTriggerTime > 0 )
			SetTimer(RepeatTriggerTime, false);
		}//NEW FIX MW
	}
}

event Timer()
{
	local bool bKeepTiming;
//NEW
//	local int i;
//OLD
	local Actor A;

	bKeepTiming = false;

	ForEach TouchingActors(class'Actor', A)
		if ( IsRelevant(A) )
		{
			bKeepTiming = true;
			Touch(A);
		}

	if ( bKeepTiming )
		SetTimer(RepeatTriggerTime, false);
}

//NEW (mw)
function ReTriggerDelayTimer()
{
	SetCollision( true, false, false );
}
//OLD

function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation, 
						Vector momentum, class<DamageType> damageType)
{
	//NEW PWC 8/7/2002 Adding in damage type activation
//	DM( "DamageType Received " $ damageType $ " I am affected by " $ TriggerDamageType );
	if (TriggerDamageType==damageType||TriggerDamageType==class'DamageType')
	{
		//NEW
		if ( GetInitiallyActive() && (TriggerType == TT_Shoot) && (Damage >= DamageThreshold) && (instigatedBy != None) )
	
		/*OLD
		if ( bInitiallyActive && (TriggerType == TT_Shoot) && (Damage >= DamageThreshold) && (instigatedBy != None) )
		*/
		{
			//NEW (mw) - disable collision while trigger is waiting for ReTriggerDelay to run out 
			//			 (so that TT_Shoot triggers don't collide with projectiles during this time)
			if ( ReTriggerDelay > 0 )
			{
				if ( Level.TimeSeconds - TriggerTime < ReTriggerDelay )
					return; 
				else
				{
					TriggerTime = Level.TimeSeconds;
					SetCollision( false, false, false );
					AddTimer( 'ReTriggerDelayTimer', ReTriggerDelay, false );
				}
			}
			/* OLD
			if ( ReTriggerDelay > 0 )
			{
				if ( Level.TimeSeconds - TriggerTime < ReTriggerDelay )
					return; 
				TriggerTime = Level.TimeSeconds;
			}
			OLD */
					// Broadcast the Trigger message to all matching actors.
	//NEW
		  	TriggerActors( Self, TriggerClass, instigatedBy, instigatedBy, Event, bTriggerNPCs );
	/*OLD
			TriggerEvent(Event, instigatedBy, instigatedBy);
	*/

			if( Message != "" )
				// Send a string message to the toucher.
				instigatedBy.Instigator.ClientMessage( Message );

			if( bTriggerOnceOnly )
				// Ignore future touches.
				SetCollision(False);
		}
	}
}

//
// When something untouches the trigger.
//
event UnTouch( actor Other )
{
	if( IsRelevant( Other ) )
		UntriggerEvent(event, Other, Other.Instigator);
}

defaultproperties
{
	TriggerDamageType=Class'Engine.DamageType'
	bInitiallyActive=true
	InitialState='NormalTrigger'
	Texture=Texture'Engine.S_Trigger'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}