U2Dialog.DialogTrigger

//=============================================================================
// DialogTrigger.uc
// Created By: Mike Baldwin
// Created On: 3/29/2001
// $Author: Mbaldwin $
// $Date: 12/17/02 1:10p $
// $Revision: 12 $
//=============================================================================

class DialogTrigger extends Trigger;

/*
When Actors come into range of the trigger, the Participants list is evaluated
against the current Actors list.  If the list is matched, then the
DialogList[] is processed in order to invoke a dialog session for the specified
participants (involuntary participants are also added by the dialog system due
to "Proximity" -- but they may be dropped if none of the trees contain dialog
for them).

When the trigger is triggered, the "bEnabled" status for each entry in the
DialogList[] is re-evaluated based on LastDialogTime and the Delay. 
(bEnabled=true nodes are automatically skipped).

If one or more trees are found to be "enabled", a dialog session is created, and
the selected tree is added to that session.

When the session is concluded, the LastDialogTime is updated, and the bEnabled
flags are adjusted according corresponding value of the bLeaveEnabled flags.
*/

struct DialogListT
{
	var() name Topic;					// dialog tree topic
	var() float Delay;					// time to wait before "enabling" the next entry in the list
	var() bool bEnabled;				// available for characters to speak
	var() bool bLeaveEnabled;			// after delivery -- normally false
};

var() array<DialogListT> DialogList;	// list of Dialogs Trees to trigger for these participants
var() array<string> Participants;		// speaker strings of characters that must be present
var() bool bEnforceTalkRadius;			// Actors leaving dialog trigger radius will be removed from dialog

var array<Actor> ActorsInRange;			// references to the actors that are within trigger radius
var float LastDialogTime;				// tracks the the time that the previous dialog ended in order to determine when the next "Delay" will allow delivery of successive nodes
var int iCurrent;						// current tree
var bool bIsInSession;					// dialog session is currently active


//------------------------------------------------------------------------------
// Triggers Interface
//
event Touch( Actor Other )
{
	if( Other.Speaker != "" )
	{
		Add( Other );
		if( !bIsInSession )
			StartSession();
	}
}

//-----------------------------------------------------------------------------

event UnTouch( Actor Other )
{
	if( bEnforceTalkRadius )
	{
		Remove(Other);
		if( bIsInSession )
			class'DialogEngine'.static.NotifyDialogWalkedAway( Other );
	}
}

//------------------------------------------------------------------------------
// Init
//
event PostBeginPlay()
{
	Super.PostBeginPlay();
	GetTouchingActors();
}

//------------------------------------------------------------------------------
// Add/Remove Participants
//
function Add( Actor NewActor )
{
	local int i;
	for( i=0; i < Participants.Length; i++ )
		if( Participants[i] == NewActor.Speaker )
			ActorsInRange[i] = NewActor;
}

//------------------------------------------------------------------------------

function Remove( Actor OldActor )
{
	local int i;
	for( i=0; i < ActorsInRange.Length; i++ )
		if( ActorsInRange[i] == OldActor )
			ActorsInRange[i] = None;
}

//------------------------------------------------------------------------------

function Clear()
{
	local int i;
	for( i=0; i < ActorsInRange.Length; i++ )
		ActorsInRange[i] = None;
}

//------------------------------------------------------------------------------
// Start/End dialog
//
function StartSession()
{
	// verify that all participants are in trigger radius and, if so, initiate dialog
	if( !bIsInSession && AllCanTalk() && SelectTopic() )
	{
		if( class'DialogEngine'.static.GetInstance(Self).InitiateTrigger(Self) )
			bIsInSession = true;
		else
		{
			// Dialog engine couldn't open a dialog session, disable this topic
			DialogList[iCurrent].bEnabled = false;
			DialogList[iCurrent].bLeaveEnabled = false;
		}
	}
}

//------------------------------------------------------------------------------

function SessionFinished()
{
	// Leave Enabled/Disable for next time
	if( DialogList[iCurrent].bLeaveEnabled == false )
		DialogList[iCurrent].bEnabled = false;

	// Cache the current time
	LastDialogTime = Level.TimeSeconds;

	// Resync with actors within radius (in case radius wasn't enforced during dialog)
	GetTouchingActors();

	// Triggered session is over
	bIsInSession = false;
}

//------------------------------------------------------------------------------
// Participant Helpers
//
function GetTouchingActors()
{
	local Actor A;
	
	Clear();

	ForEach TouchingActors( class'Actor', A )
		if( A.Speaker != "" )
			Add( A );
}

//------------------------------------------------------------------------------
// Verify that each participants actor is within the trigger and they can talk
//
function bool AllCanTalk()
{
	local int i;
	for( i=0; i < Participants.Length; i++ )
		if( i >= ActorsInRange.Length ||			// actor is not in the radius
			!CanTalk( ActorsInRange[i] ) )			// actor can't talk right now
			return false;
	return true;
}

//------------------------------------------------------------------------------

function bool CanTalk( Actor Who )
{
	local int i;

	if( Who == None ) return false;
	if( Who.Speaker == "Player" ) return true;

	// mib-tbd Can he be used by all the others?
	for( i=0; i < ActorsInRange.Length; i++ )
		if( ActorsInRange[i] != None &&
			ActorsInRange[i] != Who &&
			!ActorsInRange[i].IsUsable( Who ) )
			return false;

	return true;
}

//------------------------------------------------------------------------------
// Topic Helpers
//
function name CurrentTopic()
{
	return DialogList[iCurrent].Topic;
}

//------------------------------------------------------------------------------
	
function bool SelectTopic()
{
	local int i;

	// search from starting point to end of list
	for( i = iCurrent+1; i < DialogList.Length; i++ )
		if( CheckTopic( i ) ) { iCurrent = i;  return true; }

	// search begining of list to starting point
	for( i=0; i <= iCurrent; i++ )
		if( CheckTopic( i ) ) { iCurrent = i;  return true; }

	// no topics available not even the previously current one.
	// MIB - tbr
	//DMDLG(Self @ "couldn't find an enabled topic" );
	return false;
}

//------------------------------------------------------------------------------

function bool CheckTopic( int Which )
{
	// Check topic, enabled, and delay time
	if( DialogList[Which].Topic != ''	&&
		DialogList[Which].bEnabled		&&
		DialogList[Which].Delay < Level.TimeSeconds - LastDialogTime )
		return true;

	return false;
}

//------------------------------------------------------------------------------

defaultproperties
{
	iCurrent=-1
	TriggerType=TT_AnyProximity
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}