Legend.AttachTrigger

//=============================================================================
// $Author: Mfox $
// $Date: 8/20/02 3:42p $
// $Revision: 10 $
//=============================================================================

//------------------------------------------------------------------------------
// Name:	AttachTrigger.uc
// Author:	Aaron R Leiby
// Date:	17 Feb 2002
//------------------------------------------------------------------------------
// Description:	Used to attach actors to actors (like attaching a particle
// system to a player when he enters/leaves a zone.
//------------------------------------------------------------------------------
// How to use this class:
//------------------------------------------------------------------------------

class AttachTrigger extends Triggers;

var() float TimerDuration;

enum EAttachMode
{
	AM_Player,		// the player character.
	AM_Other,		// the trigger other.
	AM_Instigator,	// the trigger instigator.
	AM_Tag,			// tag of any actor.
};

/* -- how would you know which actor to destroy on detach?
var() class<Actor>	Attach_Instance;	// type of actor to create and attach.
*/

var() Actor			Attach_Actor;		// actor to attach.
var() vector		Attach_Offset;		// attachment offset relative to player.
var() vector		Attach_PostOffset;	// offset from Attach_Offset.
var() EAttachMode	Attach_Mode;		// mode for choosing what to attach to.
var() name			Attach_Class;		// filter class for source/dest/other/instigator attachment.
var() name			Attach_Tag;			// tag of actor to attach to.

var   Actor			Attach_Target;		// actor we are currently attached to.

var() bool bRelativeRotation;
var() bool bRelativeViewRotation;
var() bool bPostRelativeRotation;
var() bool bPostRelativeViewRotation;


//------------------------------------------------------------------------------
function AttachActor( optional Actor Other, optional Pawn Instigator )
{
	local Controller C;
	local Actor A;

	//DMN("AttachActor: Attach_Mode="$Attach_Mode$" Other="$Other$" Instigator="$Instigator);

	switch(Attach_Mode)
	{
	case AM_Player:
		for(C=Level.ControllerList;C!=None;C=C.nextController)
			if(PlayerController(C)!=None && PlayerController(C).Player!=None)
				DoAttachActor(C);
		break;

	case AM_Other:
		if(Other.IsA(Attach_Class))
			DoAttachActor(Other);
		break;

	case AM_Instigator:
		if(Instigator.IsA(Attach_Class))
			DoAttachActor(Instigator);
		break;

	case AM_Tag:
		foreach AllActors(class'Actor',A,Attach_Tag)
			DoAttachActor(A);
		break;
	}
}

//------------------------------------------------------------------------------
function DetachActor( optional Actor Other, optional Pawn Instigator )
{
	local Controller C;
	local Actor A;

	//DMN("DetachActor: Attach_Mode="$Attach_Mode$" Other="$Other$" Instigator="$Instigator);

	switch(Attach_Mode)
	{
	case AM_Player:
		for(C=Level.ControllerList;C!=None;C=C.nextController)
			if(PlayerController(C)!=None && PlayerController(C).Player!=None)
				DoDetachActor(C.Pawn);
		break;

	case AM_Other:
		if(Other.IsA(Attach_Class))
			DoDetachActor(Other);
		break;

	case AM_Instigator:
		if(Instigator.IsA(Attach_Class))
			DoDetachActor(Instigator);
		break;

	case AM_Tag:
		foreach AllActors(class'Actor',A,Attach_Tag)
			DoDetachActor(A);
		break;
	}
}

//------------------------------------------------------------------------------
function DoAttachActor( Actor A )
{
	//DMN("DoAttachActor: "$A);

	if(Attach_Target!=None)
		DoDetachActor(Attach_Target);

	if(A==None)
		return;

	Enable('Tick');
	Attach_Target = A;

	UpdateActorLocation();
//	Attach_Actor.SetBase(A);
}

//------------------------------------------------------------------------------
function DoDetachActor( Actor A )
{
	//DMN("DoDetachActor: "$A);

//	Attach_Actor.SetBase(None);

	Disable('Tick');
	Attach_Target = None;
}

event PreBeginPlay()
{
	//DMN("PreBeginPlay");
	Super.PreBeginPlay();
	Disable('Tick');
}

event Destroyed()
{
	RemoveAllTimers();
	Super.Destroyed();
}

event Tick( float DeltaTime )
{
	//DMN("Tick");
	Super.Tick( DeltaTime );
	if( Attach_Target!=None && Attach_Actor!=None )
	{
		UpdateActorLocation();
	}
	else
	{
		Disable('Tick');
	}
}

function UpdateActorLocation()
{
	local vector Loc;
	local pawn Pawn;

	Pawn = pawn(Attach_Target);

	Loc = Attach_Target.Location;

	if( bRelativeViewRotation && Pawn!=None )
	{
		Loc += Attach_Offset >> Pawn.GetViewRotation();
	}
	else if( bRelativeRotation )
	{
		Loc += Attach_Offset >> Attach_Target.Rotation;
	}

	if( bPostRelativeViewRotation && Pawn!=None )
	{
		Loc += Attach_PostOffset >> Pawn.GetViewRotation();
	}
	else if( bPostRelativeRotation )
	{
		Loc += Attach_PostOffset >> Attach_Target.Rotation;
	}

	Attach_Actor.SetLocation( Loc );
}

/* -- how do you remember if you need to attach or detach on a per-actor basis?
//------------------------------------------------------------------------------
simulated state() TriggerToggle
{
	simulated function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		AttachActor( Other, EventInstigator );
	}
}
*/

//------------------------------------------------------------------------------
simulated state() TriggerControl
{
	simulated function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		AttachActor( Other, EventInstigator );
	}

	simulated function UnTrigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		DetachActor( Other, EventInstigator );
	}
}

simulated state() InitiallyOn
{
	simulated event BeginState()
	{
		AddTimer( 'DelayedAttach', 0.0 );	// delay until after player has been spawned.
	}

	simulated function DelayedAttach()
	{
		//DMN("DelayedAttach");
		AttachActor();
	}
}

/* -- needs to remember which actors we attached to so it can unattach appropriately in the timer.
//------------------------------------------------------------------------------
simulated state() TriggerTimed
{
	simulated function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	{
		AttachActor( Other, EventInstigator );
		SetTimer( TimerDuration, false );
	}

	simulated event Timer()
	{
		DetachActor( Other, EventInstigator );
	}
}
*/

defaultproperties
{
	InitialState='TriggerControl'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}