U2Dialog.DialogSession

//=============================================================================
// DialogSession.uc
// Created By: Mike Baldwin
// Created On: 2/23/2001
// $Author: Mbaldwin $
// $Date: 1/07/03 12:22p $
// $Revision: 94 $
//=============================================================================
class DialogSession extends Dialog
	native;

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

const NoInterruptTimeFinishedTimer	= 'NoInterruptTimeFinished';
const AudioFinishedTimer			= 'AudioFinished';

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

var DialogEngine			DE;					// reference to dialog singleton
var array<DialogTree>		Trees;				// set of dialog trees available for this session
var array<DialogController>	DControllers;		// participants (dialog controllers)
var DialogNode				CurNode;			// which node is being spoken?
var EDialogTone				Tone;				// tone set by the CurNode (DialogNode.ChangeTone)
var array<ExitEventInfo>	ExitEvents;			// Event to trigger when session is over
var array<NodeEnableInfo>	ExitEnables;		// Nodes to enable when session is over
var float					TimeElapsed;		// time since the audio file began
var bool					bAudioPlaying;		// is someone currently talking?
var bool					bCantInterrupt;		// cant butt in yet
var bool					bSessionFinished;	// session is done and is waiting deletion
var bool					bInitialized;		// all npc's are ready and dialog can begin
var	float					TalkRadius;			// maximum distance from center an actor can go before they'll be kicked from the session
var EDialogStatus			DialogStatus;		// currently status of the dialog session
var DialogController		SpeakingDC;			// current speaker
var float					SoundVolume;		// volume to use for PlaySound / PlayVoice
var float					SoundRadius;		// sound radius to use for PlaySound / PlayVoice

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

var DialogTrigger			Trigger;			// for sessions created by a DialogTrigger
var name					Topic;				// for sessions created for a specific topic
var bool					TopicEnabled;		// cached enabled-ness of the topic tree
var Actor					WaitingActor;		// actor to notify when session is over

//-----------------------------------------------------------------------------
// Interruption support
var actor					Interrupter;		// speaker who's doing the interrupting
var actor					InterruptTarget;	// speaker who the interrupter wants to talk to

//-----------------------------------------------------------------------------
// Natives
//
native function AddDialog(DialogTree NewTree );		// Add dialog tree to this session
native function NodeCompleted();					// Advance the conversation after a node has been spoken
native function bool Contains( string Speaker );	// Is this speaker a participant in the session?
native function string WhoIsSpeaking();				// Who's currently speaking?
native function float TimeSinceLastSpoken();		// Time since the audio file has completed (negative if sound still playing)

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

function AddParticipant( DialogController DC, Actor Other )
{
	DControllers[DControllers.Length] = DC;
	DC.DialogBegin( Other );
	SendSessionBeginEvent(DC);
	bInitialized = false;
}

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

function RemoveParticipant( DialogController DC )
{
	local int i;
	assert( DC != None );
	DMDLG("RemoveParticipant -- speaker:" @ DC.DCSpeaker);

	if( CurNode != None && Caps(CurNode.Speaker) == Caps(DC.DCSpeaker) )
	{
		DMDLG("Stopping audio file for:" @ DC.DCSpeaker @ "Filename:" @ CurNode.Filename);
		StopAudioFile();
	}

	SendSessionEndEvent(DC);
	DC.DialogEnd();
	for( i=DControllers.Length-1; i >= 0 ; i-- )
		if( DControllers[i] == DC )
			DControllers.Remove(i,1);
}

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

function bool FoundValidTopic()
{
	if( DControllers.Length > 0 )
	{
		if( TryResumeDialog() || TryNormalDialog() )
			return true;
		else DMDLG( "Error unable to resume or begin dialog" );
	}
	else DMDLG( "Can't find any speakers to begin conversation" );

	return false;
}

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

event Destroyed()
{
	RemoveAllTimers();
	
	// just to be sure
	AudioFinished();

	// carry out any pending node events
	ProcessActions();

	// pass the dialog status on to the controllers (dialog ending)
	UpdateDCDialogEnding();

	// toss any conversation-specific abort nodes
	ClearAbortNodes();
	
	// remove any leftover choice nodes
	ClearSelections();

	// fire off exit events
	SendExitEvents();

	// carry out all exit enables
	SendExitEnables();

	// everybody out
	while( DControllers.Length > 0 )
		RemoveParticipant( DControllers[0] );

	// inform trigger that dialog is over
	if( Trigger != None )
		Trigger.SessionFinished();

	// reset bookmark if the curnode has the option unset

	if( CurNode != None && CurNode.UseBookmark == DIALOGBOOLEAN_False )
		CurNode.Tree.Bookmark = None;

	// reset the enabled flag on topic dialogs
	ResetTopicEnabled();

	// notify waiting actor that the session is over
	if( WaitingActor != None )
		WaitingActor.DialogUnPause();

	Super.Destroyed();
}

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

function ResetTopicEnabled()
{
	local DialogTree TopicTree;

	if ( Topic != '' )			// dialog by topic
	{
		TopicTree = DE.GetDialogByTopic( Topic );
		if( TopicTree != None )
			TopicTree.bEnabled = TopicEnabled;
	}
}

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

function UpdateDCDialogEnding()
{
	local int i,j;

	if( DialogStatus == DIALOGSTATUS_Normal )
	{
		for( i=0; i < DControllers.Length; i++ )
		{
			for( j=0; j < DControllers.Length; j++ )
			{
				if( i != j )
				{
					DControllers[i].SetDialogEnding( DControllers[j].Actor, DIALOGENDING_Normal );
				}
			}
		}
	}
}

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

function SendSessionBeginEvent( DialogController DC )
{
	DC.Actor.Trigger( Self, None, DialogBeginEvent );
}

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

function SendSessionEndEvent( DialogController DC )
{
	switch( DialogStatus )
	{
	case DIALOGSTATUS_Normal:
		DC.Actor.Trigger( Self, None, DialogEndEvent );
		break;
	case DIALOGSTATUS_Aborting:
	case DIALOGSTATUS_InterruptRequest:
	case DIALOGSTATUS_InterruptResponse:
	case DIALOGSTATUS_InterruptWalkAway:
	case DIALOGSTATUS_SpeakerDamaged:
		DC.Actor.Trigger( Self, None, DialogAbortEndEvent );
		break;
	default:
		break;
	}
}

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

function SendExitEnables()
{
	local int i;
	local DialogNode DN;
	for( i=0; i < ExitEnables.Length; i++ )
	{
		DN = class'DialogEngine'.static.GetNode( Self, ExitEnables[i].Node );
		if( DN!=None ) DN.bEnabled = bool(ExitEnables[i].bEnable);
	}
}

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

function SendExitEvents()
{
	local int i;
	local Actor Receiver;

	for( i=0; i < ExitEvents.Length; i++ )
	{
		if( ExitEvents[i].Target != '' )
		{
			DMDLG("Sending exit event '" $ ExitEvents[i].EventName $ "' to" @ ExitEvents[i].Target);
			Receiver = class'DialogEngine'.static.NameToActor( Self, ExitEvents[i].Target );
			if( Receiver != None )
				Receiver.Trigger( Self, None, ExitEvents[i].EventName );
		}
		else
		{
			DMDLG("Sending global exit event '" $ ExitEvents[i].EventName $ "'");
			TriggerEvent( ExitEvents[i].EventName, Self, None );
		}
	}
}

//-----------------------------------------------------------------------------
// Resume --> Normal --> Abort Dialog functions
//-----------------------------------------------------------------------------

event bool TryResumeDialog()
{
	local int i,j;
	local DialogController DC1, DC2;
	local name ResumeTopic;
	local DialogTree ResumeTree;

	// clear out any existing trees
	RemoveAllTrees();

	// check for special handling dialog from previous conversation
	for( i=0; i < DControllers.Length && ResumeTopic == ''; i++ )
	{
		DC1 = DControllers[i];
		for( j=0; j < DControllers.Length && ResumeTopic == ''; j++ )
		{
			DC2 = DControllers[j];
			if( DC1 != DC2 )
			{
				ResumeTopic = DC1.GetResumeTopic( DC2.DCSpeaker );
			}
		}
	}

	if( ResumeTopic != '' )		// resume handling dialog
	{
		ResumeTree = DE.GetDialogByTopic( ResumeTopic );
		if( ResumeTree != None && ResumeTree.bSpecialEventTree )
			AddDialog( ResumeTree );
		else if( !ResumeTree.bSpecialEventTree )
			DMDLG( "Using a normal tree for resume dialog:" @ ResumeTree.Topic );
	}

	DialogStatus = DIALOGSTATUS_Resuming;
	return Trees.Length > 0;
		
}

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

event bool TryNormalDialog()
{
	local int i;
	local array<DialogTree> ValidDialog;
	local DialogController InterruptTargetDC;
	local DialogController InterruptingDC;

	// clear out any existing (resume) trees
	RemoveAllTrees();

	// toss any conversation-specific resumes leftover from the previous conversation
	ClearResumeNodes();

	// if this dialog interrupted someone talking, handle it
	if( Interrupter != None && InterruptTarget != None )
	{
		RemoveInterruptedSpeakers();

		// tell the interrupt target to headtrack and turn to us
		InterruptingDC = DE.GetDController( Interrupter );
		InterruptTargetDC = DE.GetDController( InterruptTarget );
		if( InterruptTargetDC != None )
		{
			InterruptTargetDC.DialogBegin( InterruptingDC.Actor );
			InterruptTargetDC.NotifyNPCReady();
		}
	}

	if ( Topic != '' )			// dialog by topic
	{
		ValidDialog[0] = DE.GetDialogByTopic( Topic );
		if( ValidDialog[0] != None )
		{
			TopicEnabled = ValidDialog[0].bEnabled;
			ValidDialog[0].bEnabled = true;
			AddDialog( ValidDialog[0] );
		}
	}
	else						// use all dialog b/w these speakers
	{
		DE.GetDialogByParticipants( DControllers, ValidDialog );
		for( i=0; i < ValidDialog.Length; i++ )
			if( ValidDialog[i] != None && !ValidDialog[i].bSpecialEventTree )
				AddDialog( ValidDialog[i] );
			else if( ValidDialog[i].bSpecialEventTree )
				DMDLG( "Using a abort/resume tree for normal dialog:" @ ValidDialog[i].Topic );
	}

	DialogStatus = DIALOGSTATUS_Normal;
	return Trees.Length > 0;
}

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

event bool TryAbortDialog()
{
	local int i,j;
	local DialogController DC1, DC2;
	local name AbortTopic;
	local DialogTree AbortTree;

	// allow abort nodes to interrupt the current node
	bCantInterrupt = false;
	bAudioPlaying = false;
	TimeElapsed = 0;

	// clear out any existing (normal) trees
	RemoveAllTrees();

	// cut off audio
	AudioFinished();

	// check for special handling dialog from previous conversation
	for( i=0; i < DControllers.Length && AbortTopic == ''; i++ )
	{
		DC1 = DControllers[i];
		for( j=0; j < DControllers.Length && AbortTopic == ''; j++ )
		{
			DC2 = DControllers[j];
			if( DC1 != DC2 )
			{
				AbortTopic = DC1.GetAbortTopic( DC2.DCSpeaker );
				DMDLG("Got Topic from abort map of" @ DC1.DCSpeaker @ "with" @ DC2.DCSpeaker @ "Topic:" @ AbortTopic );
			}
		}
	}

	if( AbortTopic != '' )		// abort handling dialog
	{
		AbortTree = DE.GetDialogByTopic( AbortTopic );
		if( AbortTree != None && AbortTree.bSpecialEventTree )
			AddDialog( AbortTree );
		else if( !AbortTree.bSpecialEventTree )
			DMDLG( "Using a normal tree for abort dialog:" @ AbortTree.Topic );
	}

	DialogStatus = DIALOGSTATUS_Aborting;

	for( i=0; i < DControllers.Length; i++ )
		if( DControllers[i].Actor != Interrupter &&
			DControllers[i].Actor != InterruptTarget )
			DControllers[i].Actor.Trigger( Self, None, DialogAbortEvent );
	return Trees.Length > 0;
}

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

event bool TryInterruptRequestDialog()
{
	local int i,j;
	local DialogEngine DE;
	local DialogController InterruptingDC;
	local name InterruptRequestTopic;
	local DialogTree InterruptRequestTree;

	// allow abort nodes to interrupt the current node
	bCantInterrupt = false;
	bAudioPlaying = false;
	TimeElapsed = 0;

	// clear out any existing (normal) trees
	RemoveAllTrees();

	// cut off audio
	AudioFinished();

	// check for interrupt request dialog
	InterruptingDC = DE.GetDController( Interrupter );
	DMDLG("Search for interrupt request dialog with" @ InterruptTarget.Speaker @ "using abort map of" @ InterruptingDC.DCSpeaker );
	InterruptRequestTopic = InterruptingDC.GetInterruptRequestTopic( InterruptTarget.Speaker );

	if( InterruptRequestTopic != '' )		// interrupt request dialog
	{
		InterruptRequestTree = DE.GetDialogByTopic( InterruptRequestTopic );
		if( InterruptRequestTree != None && InterruptRequestTree.bSpecialEventTree )
			AddDialog( InterruptRequestTree );
		else if( !InterruptRequestTree.bSpecialEventTree )
			DMDLG( "Using a normal tree for interrupt request dialog:" @ InterruptRequestTree.Topic );
	}

	ClearEnding( DIALOGENDING_InterruptRequest );

	DialogStatus = DIALOGSTATUS_InterruptRequest;
	return Trees.Length > 0;	
}

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

event bool TryInterruptResponseDialog()
{
	local int i,j;
	local DialogController InterruptTargetDC, InterruptedDC;
	local name InterruptResponseTopic;
	local DialogTree InterruptResponseTree;

	// clear out any existing (normal) trees
	RemoveAllTrees();

	// check for interrupt response dialog
	InterruptTargetDC = DE.GetDController( InterruptTarget );
	for( i=0; i < DControllers.Length; i++ )
		if( DControllers[i].Actor != Interrupter &&
			DControllers[i].Actor != InterruptTarget )
			InterruptedDC = DControllers[i];
	DMDLG("Search for interrupt response dialog with" @ InterruptedDC.Speaker @ "using abort map of" @ InterruptTargetDC.DCSpeaker );
	InterruptResponseTopic = InterruptTargetDC.GetInterruptResponseTopic( InterruptedDC.DCSpeaker );

	if( InterruptResponseTopic != '' )		// interrupt request dialog
	{
		InterruptResponseTree = DE.GetDialogByTopic( InterruptResponseTopic );
		if( InterruptResponseTree != None && InterruptResponseTree.bSpecialEventTree )
			AddDialog( InterruptResponseTree );
		else if( !InterruptResponseTree.bSpecialEventTree )
			DMDLG( "Using a normal tree for interrupt response dialog:" @ InterruptResponseTree.Topic );
	}

	ClearEnding( DIALOGENDING_InterruptResponse );
	DialogStatus = DIALOGSTATUS_InterruptResponse;
	return Trees.Length > 0;	
}

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

event bool TryInterruptWalkAwayDialog()
{
	local int i,j;
	local DialogController InterruptingDC, InterruptTargetDC;
	local name InterruptWalkAwayTopic;
	local DialogTree InterruptWalkAwayTree;

	// clear out any existing (normal) trees
	RemoveAllTrees();

	// check for interrupt walkaway dialog
	InterruptingDC = DE.GetDController( Interrupter );
	InterruptTargetDC = DE.GetDController( InterruptTarget );
	for( i=0; i < DControllers.Length; i++ )
	{
		if( DControllers[i] != InterruptingDC &&
			DControllers[i] != InterruptTargetDC )
		{
			DMDLG("Search for interrupt walkaway dialog with" @ InterruptingDC.DCSpeaker @ "using abort map of" @ DControllers[i].DCSpeaker );
			InterruptWalkAwayTopic = DControllers[i].GetInterruptWalkAwayTopic( InterruptingDC.DCSpeaker );
			break;
		}
	}

	if( InterruptWalkAwayTopic != '' )		// interrupt request dialog
	{
		InterruptWalkAwayTree = DE.GetDialogByTopic( InterruptWalkAwayTopic );
		if( InterruptWalkAwayTree != None && InterruptWalkAwayTree.bSpecialEventTree )
		{
			AddDialog( InterruptWalkAwayTree );
		}
		else if( !InterruptWalkAwayTree.bSpecialEventTree )
			DMDLG( "Using a normal tree for interrupt walkaway dialog:" @ InterruptWalkAwayTree.Topic );
	}

	DialogStatus = DIALOGSTATUS_InterruptWalkAway;
	return Trees.Length > 0;	
}

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

function bool CanBeInterruptedBy( DialogNode InterruptingNode )
{
	if( InterruptingNode.Tone > CurNode.Tone ||
		InterruptingNode.Priority > CurNode.Priority )
		return true;
	return false;
}

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

function RemoveAllTrees()
{
	local int i;
	for( i=0; i < DControllers.Length; i++ )
		DControllers[i].Nodes.Remove( 0, DControllers[i].Nodes.Length );

	Trees.Remove( 0, Trees.Length );
}

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

function RemoveInterruptedSpeakers()
{
	local int i;
	local EDialogEnding Ending;

	for( i=0; i < DControllers.Length; i++ )
	{
		if( DControllers[i].GetDialogEnding( Interrupter.Speaker, Ending ) &&
			Ending == DIALOGENDING_InterruptWalkAway )
		{
			RemoveParticipant( DControllers[i] );
		}
	}
}

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

function ClearAbortNodes()
{
	local int i;
	for( i=0; i < DControllers.Length; i++ )
		DControllers[i].AbortMapCurrent.Remove( 0, DControllers[i].AbortMapCurrent.Length );
}

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

function ClearResumeNodes()
{
	local int i;
	for( i=0; i < DControllers.Length; i++ )
		DControllers[i].ResumeMapCurrent.Remove( 0, DControllers[i].ResumeMapCurrent.Length );
}

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

function ClearSelections()
{
	local int i;
	for( i=0; i < DControllers.Length; i++ )
		DControllers[i].Nodes.Remove( 0, DControllers[i].Nodes.Length );
}

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

function ClearEnding( EDialogEnding InEnding )
{
	local int i,j;
	local EDialogEnding CurrentEnding;
	
	for( i=0; i < DControllers.Length; i++ )
	{
		for( j=0; j < DControllers.Length; j++ )
		{
			if( i != j )
			{
				DControllers[i].GetDialogEnding( DControllers[j].DCSpeaker, CurrentEnding );
				if( CurrentEnding == InEnding )
					DControllers[i].SetDialogEnding( DControllers[j].Actor, DIALOGENDING_Normal );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Talk event (main node processing function)
//-----------------------------------------------------------------------------

event Talk()
{
	local int i;
	local float AudioLen;
	local Actor SpeakingActor;

	bAudioPlaying = true;													// keep track of when speaker's audio is playing
	bCantInterrupt = true;													// keep track of when someone can interrupt speaker
	
	SpeakingDC = class'DialogEngine'.static.StringToDC( Self, CurNode.Speaker );	// find the speaking actor and dialog controller
	SpeakingActor = SpeakingDC.Actor;

	PlaySoundFile( SpeakingDC, SpeakingActor );								// load and play audio file

	DoLipSync(SpeakingActor);												// play lip sync animations

	AdjustMoods();															// change speaker moods as authored
	
	TurnToFaceSpeaker( SpeakingDC );										// Turn to face speaker

	ProcessNodeProperties();												// copy current node properties to session variables

	ProcessHandlingNodes( SpeakingDC );										// pass any abort / resume nodes to their controllers

	CurNode.SetEndingFocus();

	AudioLen = CurNode.GetAudioLength();									// Get time when audio will have finished
	TimeElapsed = -AudioLen;												// set elapsed time to a negative countdown
	
	DisplayText( SpeakingDC, AudioLen );									// wake up when audio is done playing

	AddTimer( NoInterruptTimeFinishedTimer, AudioLen + CurNode.PostDelay );	// wake up when others can speak (interruptions)
	AddTimer( AudioFinishedTimer, AudioLen );								// wake up when audio is done playing

	CurNode.MakeAllPending();												// mark all of this node's actions as pending
	ProcessActions();														// Send out any node actions (events/animations)

	SpeakingDC.SetTalking( DIALOGBOOLEAN_True );
}

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

function ProcessHandlingNodes( DialogController SpeakingDC )
{
	local int i;

	for( i=0; i < CurNode.AbortMap.Length; i++ )
	{
		SpeakingDC.SetAbortTopic( CurNode.AbortMap[i] );
		DMDLG("Caching abort node" @ CurNode.AbortMap[i].AbortNodeName @ "for speaker" @ SpeakingDC.DCSpeaker @ "for abort type" @ EnumStr( enum'EDialogEnding', CurNode.AbortMap[i].Ending ) );
	}

	for( i=0; i < CurNode.ResumeMap.Length; i++ )
	{
		SpeakingDC.SetResumeTopic( CurNode.ResumeMap[i] );
		DMDLG("Caching resume node" @ CurNode.ResumeMap[i].ResumeNodeName @ "for speaker" @ SpeakingDC.DCSpeaker @ "for abort type" @ EnumStr( enum'EDialogEnding', CurNode.AbortMap[i].Ending ) );
	}
}

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

function PlaySoundFile( DialogController SpeakingDC, actor SpeakingActor )
{
	local int i;
	local actor SourceActor;

	if( CurNode.Filename == "" )
		return;

	for( i=0; i < CurNode.SoundSourceActors.Length; i++ )
	{
		if( CurNode.SoundSourceActors[i] != "" )
		{
			DMDLG("Sound source actor(" $ i $ ") = '" $ CurNode.SoundSourceActors[i] $ "'");

			if( Caps(CurNode.SoundSourceActors[i]) == PlayerSpeakerString )
			{
				// if the player pawn is unpossessed (ie. during matinee)
				// play sound out of the player controller (controlling the camera)
				if( Level.PlayerControllerList.Pawn != None )
					SourceActor = Level.PlayerControllerList.Pawn;
				else
					SourceActor = Level.PlayerControllerList;
				DMDLG("Playing sound out of the player:" @ SourceActor );
			}
			else
			{
				SourceActor = class'DialogEngine'.static.StringToActor(Self, CurNode.SoundSourceActors[i]);
				DMDLG("Playing sound out of:" @ SourceActor );
			}

			if( SourceActor == None )
			{
		        SourceActor = class'UtilGame'.static.GetNamedActor(Self, StringToName(CurNode.SoundSourceActors[i]));
				DMDLG("Searched for named actor for:" @ CurNode.SoundSourceActors[i] @ "result:" @ SourceActor );
			}
			if( CurNode.SoundSourceActors[i] != "" && SourceActor == None )
				DMDLG("Warning: PlaySoundFile -- unable to find dialog sound actor" @ CurNode.SoundSourceActors[i] );
		}

		LoadAndPlayAudioFile( CurNode, SourceActor );
	}

	if( CurNode.SoundSourceActors.Length == 0 )
		LoadAndPlayAudioFile( CurNode, SpeakingActor );
}

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

function LoadAndPlayAudioFile( DialogNode DN, actor SourceActor )
{
	local string OggFilename;

	// get sound parameters from node
	if( DN.SoundRadius	> 0 ) SoundRadius = DN.SoundRadius;
	if( DN.Volume		> 0 ) SoundVolume = DN.Volume;

	// use defaults as a fallback
	if( SoundRadius ~= 0.0 ) SoundRadius = SourceActor.TransientSoundRadius;
	if( SoundVolume ~= 0.0 ) SoundVolume = SourceActor.TransientSoundVolume;

	// Ogg files are stored relative to the Voice subdirectory (a standard defined within the ALAudioSubsystem implementation)
	OggFilename = GetOggFilename( DN.Filename );
	if( GetOggDuration( OggFilename ) > 0.0 )
	{
		DN.bUseOggVoice = true;
		DN.Voice = SourceActor.PlayVoice( OggFilename, SoundVolume, SoundRadius, 1.0 /*pitch*/ );
		DMDLG( "Play dialog sound (ogg) file:" @ OggFilename @ "through actor:" @ SourceActor );
	}
	else
	{
		DN.Voice = sound( DynamicLoadObject( CurNode.Filename, class'Sound' ) );
		SourceActor.PlaySound( DN.Voice, SLOT_Dialog, SoundVolume, true /*bNoOverride*/, SoundRadius, 1.0 /*pitch*/, true /*attenuate*/ );
		DMDLG( "Play dialog sound (wav) file:" @ CurNode.Filename @ "through actor:" @ SourceActor );
	}

	// cache the sound duration while we have the transient sound object handy
	if( DN.Voice != None )
		DN.AudioDuration = GetSoundDuration( DN.Voice );
}
	
//-----------------------------------------------------------------------------

function StopAudioFile()
{
	local int i;
	local actor A;

	if( CurNode != None )
	{
		for( i=0; i < CurNode.SoundSourceActors.Length; i++ )
		{
			A = class'UtilGame'.static.GetNamedActor( Self, StringToName(CurNode.SoundSourceActors[i]) );
			DoStopAudio( A, CurNode );
		}
		if( CurNode.SoundSourceActors.Length == 0 )
			DoStopAudio( SpeakingDC.Actor, CurNode );
	}
}

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

function DoStopAudio( Actor A, DialogNode DN )
{
	local string OggFilename;

	if( A != None )
	{
		if( DN.bUseOggVoice )
		{
			OggFilename = GetOggFilename( DN.Filename );
			A.StopVoiceFile( OggFilename );
		}
		else
			A.StopSoundSlot( SLOT_Dialog );
		
		DMDLG( "Stopping dialog audio for:" @ A @ "(" $ A.Speaker $ ")");
	}
}

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

function TurnToFaceSpeaker( DialogController SpeakingDC )
{
	local int i;

	switch( CurNode.TurnToSpeaker )
	{
	case DIALOGBOOLEAN_True:
		for( i=0; i < DControllers.Length; i++ )
			if( DControllers[i] != SpeakingDC )
			{
				SpeakingDC.TurnToFace( DControllers[i].Actor );
				break;
			}
		break;
	case DIALOGBOOLEAN_False:
		SpeakingDC.TurnToFace( None );
		break;
	default:
		break;
	}
}

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

function DisplayText( DialogController SpeakingDC, float TimeToDisplay )
{
	local float W, H, WrapX;
	local Console Console;
	local DialogController TempDC;
	local DialogControllerPlayer PlayerDC;
	local string SubtitleText;
	local color SubtitleColor;
	local bool bPlayerIsTalking;
	local actor Listener;

	if( CurNode.LongText == "" )
	{
		//DMDLG("DisplayText -- No long text");
		return;
	}

	if( SpeakingDC == None )
	{
		//DMDLG("DisplayText -- No speaker" @ CurNode.LongText );
		return;
	}

	Console = class'UIConsole'.static.GetConsole();
	if( Console == None )
	{
		//DMDLG("DisplayText -- no console" @ CurNode.LongText );
		return;
	}

	if( !class'UIConsole'.static.GetPlayerOwner().ShowSubtitles )
	{
		//DMDLG("DisplayText -- player's subtitles are off" @ CurNode.LongText );
		return;
	}

	PlayerDC = DialogControllerPlayer( DE.StringToDC( Self, PlayerSpeakerString ));
	if( PlayerDC == None )
	{
		//DMDLG("DisplayText -- can't get player dc" @ CurNode.LongText );
		return;
	}

	bPlayerIsTalking = Contains( PlayerSpeakerString );

	// don't display 3rd party subtitles if player is too far away
	if( !bPlayerIsTalking && CurNode.SubtitleRadius > 0 )
	{
		// compensate for dispossessed players (ie. during matinee)
		Listener = Level.PlayerControllerList;
		if( Level.PlayerControllerList.Pawn != None )
			Listener = Level.PlayerControllerList.Pawn;

		if( VSize( Listener.Location - Location ) > CurNode.SubtitleRadius )
		{
			DMDLG("DisplayText -- player is not withing subtitle radius:" @ CurNode.SubtitleRadius);
			return;
		}
	}

	// only display subtitles for the player's conversation or to an outside conversation when he's not talking
	if( bPlayerIsTalking || !class'DialogEngine'.static.IsAlreadyTalking( Level.PlayerControllerList.Pawn ) )
	{
		SubtitleText = CurNode.LongText;

		// compute wrapping width of text
		Console.TextSize( DE.SubtitleFont, SubtitleText, W, H );
		WrapX = W + DE.SubtitlePadding;
		if( WrapX > DE.SubtitleBoxWidth )
			WrapX = DE.SubtitleBoxWidth;

		if( bPlayerIsTalking || class'UtilGame'.static.CutSceneIsRunning( Self ) )
			SubtitleColor = DE.SubtitleColorPlayer;
		else
			SubtitleColor = DE.SubtitleColorOther;

		class'UIConsole'.static.BroadcastStatusMessage( Self, SubtitleText, TimeToDisplay, DE.SubtitleFont, SubtitleColor,/*sound*/,/*volume*/,/*pitch*/, "DialogSubtitlesHolder", true, WrapX );
	}

	// echo to log in debug mode
	DMDLG( SubtitleText );
}

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

function ProcessNodeProperties()
{
	local int i;

	// make any tone changes
	if( CurNode.ToneChange != 0 /*DIALOGTONE_None*/ )
		Tone = CurNode.ToneChange;

	// Update talk radius
	TalkRadius = CurNode.TalkRadius;

	// Add exit events to this session
	for( i=0; i < CurNode.ExitEvents.Length; i++ )
		ExitEvents[ExitEvents.Length] = CurNode.ExitEvents[i];

	for( i=0; i < CurNode.NodeEnables.Length; i++ )
		// Add exit enables to this session
		if( CurNode.NodeEnables[i].bOnExit != 0 )
			ExitEnables[ExitEnables.Length] = CurNode.NodeEnables[i];
}

//-----------------------------------------------------------------------------
// Special Handling events
//-----------------------------------------------------------------------------

event NotifyDialogAborted( actor AbortingActor )
{
	local int i;

	DMDLG(AbortingActor @ "just exited from dialog by user request" );

	NoInterruptTimeFinished();

	if( DialogStatus != DIALOGSTATUS_Aborting )
	{
		// store this event in the status map of the affected DC
		for( i=0; i < DControllers.Length; i++ )
		{
			if( DControllers[i].Actor != AbortingActor )
			{
				DControllers[i].SetDialogEnding( AbortingActor, DIALOGENDING_SpeakerHitEscape);
			}
		}
		
		TryAbortDialog();
	}
}

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

event NotifyDialogWalkedAway( actor LeavingActor )
{
	local int i;

	DMDLG(LeavingActor @ "just walked away from dialog -- talk radius:" @ TalkRadius );

	if( DialogStatus != DIALOGSTATUS_Aborting )
	{
		// store this event in the status map of the affected DC
		for( i=0; i < DControllers.Length; i++ )
		{
			if( DControllers[i].Actor != LeavingActor )
			{
				DControllers[i].SetDialogEnding( LeavingActor, DIALOGENDING_SpeakerWalkedAway );
			}
		}
	
		TryAbortDialog();
	}
}

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

event NotifyDialogScriptedAbort( actor ScriptedActor )
{
	local int i;

	DMDLG(ScriptedActor @ "was scripted to leave dialog" );

	if( DialogStatus != DIALOGSTATUS_Aborting )
	{
		// store this event in the status map of the affected DC
		for( i=0; i < DControllers.Length; i++ )
		{
			if( DControllers[i].Actor != ScriptedActor )
			{
				DControllers[i].SetDialogEnding( ScriptedActor, DIALOGENDING_ScriptedAbort );
			}
		}
	
		TryAbortDialog();
	}
}

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

event NotifyInterruption( actor NewInterrupter, actor NewInterruptTarget, bool bInterrupterTalking )
{
	local int i;
	DMDLG( NewInterrupter @ "is interrupting" @ NewInterruptTarget );

	// cache the interrupt actors
	Interrupter = NewInterrupter;
	InterruptTarget = NewInterruptTarget;

	for( i=0; i < DControllers.Length; i++ )
	{
		if( DControllers[i].Actor == Interrupter )
		{
			if( !bInterrupterTalking )
			{
				DMDLG("Setting interrupt request ending for" @ DControllers[i].DCSpeaker @ "to" @ InterruptTarget );
				DControllers[i].SetDialogEnding( InterruptTarget, DIALOGENDING_InterruptRequest );
			}
		}
		else if( DControllers[i].Actor == InterruptTarget ) 
		{
			DMDLG("Setting interrupt response ending for" @ DControllers[i].DCSpeaker @ "to" @ Interrupter );
			DControllers[i].SetDialogEnding( Interrupter, DIALOGENDING_InterruptResponse );
		}
		else
		{
			DMDLG("Setting interrupt walkaway ending for" @ DControllers[i].DCSpeaker @ "to" @ Interrupter );
			DControllers[i].SetDialogEnding( Interrupter, DIALOGENDING_InterruptWalkAway );
		}
	}

	// process interrupt stages of dialog
	if( !TryInterruptRequestDialog() )
	{
		if( !TryInterruptResponseDialog() )
		{
			if( !TryInterruptWalkAwayDialog() )
			{
				TryNormalDialog();
			}
		}
	}
}

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

function NotifyDialogSpeakerDamaged( actor DamagedActor )
{
	// mib-tbd: other behavior?
	DMDLG("Speaker" @ DamagedActor.Speaker @ "has taken damage / been killed -- setting bSessionFinished to true and Status to SpaekerDamaged");
	bSessionFinished = true;
	DialogStatus = DIALOGSTATUS_SpeakerDamaged;
}

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

function RescaleTimer( name TimerFuncName, float ScaleFactor )
{
	local float RemainingSeconds;

	RemainingSeconds = TimeRemaining( TimerFuncName );
	if( RemainingSeconds > 0 )
	{
		RemoveTimer( TimerFuncName );
		AddTimer( TimerFuncName, RemainingSeconds * ScaleFactor );
	}
}

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

function NotifyLevelChangeEnd()
{
	// re-display the subtitle
	DisplayText( SpeakingDC, -TimeElapsed );
}

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

event NotifyGameSpeedChanged( float OldGameSpeed, float NewGameSpeed )
{
	if( OldGameSpeed > 0 && DE.AllowSlomo )
	{
		RescaleTimer( NoInterruptTimeFinishedTimer, NewGameSpeed / OldGameSpeed );
		RescaleTimer( AudioFinishedTimer, NewGameSpeed / OldGameSpeed );
	}
}

//-----------------------------------------------------------------------------
// callback when its okay for others to speak
//
function NoInterruptTimeFinished()
{
	RemoveTimer( 'NoInterruptTimeFinished' );
	NodeCompleted();
	bCantInterrupt = false;
}

//-----------------------------------------------------------------------------
// callback for when audio is completed/terminated
//
event AudioFinished()
{
	RemoveTimer( AudioFinishedTimer );
	bAudioPlaying = false;
	if( SpeakingDC != None )
		SpeakingDC.SetTalking( DIALOGBOOLEAN_False );
}

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

function AdjustMoods()
{
	local int i;
	local DialogController DC;
	for( i=0; i < CurNode.MoodChanges.Length; i++ )
	{
		if( CurNode.MoodChanges[i].Who != '' )
			DC = class'DialogEngine'.static.NameToDC( Self, CurNode.MoodChanges[i].Who );
		else
			DC = class'DialogEngine'.static.StringToDC( Self, CurNode.Speaker );

		DC.ChangeMood( CurNode.MoodChanges[i].Amount );
	}
}

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

function int GetLipSyncChannel( actor SpeakingActor )
{
	local int i, count;

	count = SpeakingActor.MeshAgentGetChannelCount();
	if (count==0)
		return 8; // non-agentized character, use the old hardcoded channel 8
	
	// try to find agent channel named LipSync, if it exists
	for (i=0;i<count;i++)
	{
		if (MeshAgentGetChannelName(i) == 'LipSync')
		{
			MeshAgentEnableChannel(i, false); // disable agent mode; we're controlling this manually
			return i;
		}
	}
	
	// lipsync channel not found; use channel immediately after agent channels
	return count;
}

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

function DoLipSync( actor SpeakingActor )
{
	local name Anim;
	local int TempInt;
	local string TempStr;

	if( CurNode.bDoLipSync )
	{
		// Lip-sync animation uses the same name as the audio file minus the package name
		// CDH... need to handle more than one dot (for group names)
		TempStr = CurNode.Filename;
		TempInt = InStr(TempStr, ".");
		while (TempInt >= 0)
		{
			TempStr = Mid(TempStr, TempInt + 1);
			TempInt = InStr(TempStr, ".");
		}
		Anim = StringToName(TempStr, true);
	
		if( SpeakingActor.Mesh != None &&
			SpeakingActor.GetAnimFrames( Anim ) > 0 )
			SpeakingActor.PlayAnim( Anim,,,GetLipSyncChannel(SpeakingActor) );
	}
}

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

function ProcessActions()
{
	local float SleepTime;

	if( CurNode != None )
	{
		// first carry out any actions that are ready to go
		CurNode.ProcessActions(Self);

		// sleep until the soonest action should happen
		if( CurNode.MinPendingPctDelay() > 0 )
		{
			SleepTime = (CurNode.MinPendingPctDelay() * CurNode.GetAudioLength()) - (TimeElapsed + CurNode.GetAudioLength());
			AddTimer( 'ProcessActions', SleepTime );
		}
	}
}

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

function DisplayDebugInfo( out int LineCount, out array<string> Text )
{
	local int i,j;

	Text[LineCount] = "Speakers:" @ DControllers.Length;	LineCount++;

	for( i=0; i < DControllers.Length; i++ )
	{
		if( DControllers[i] != None )
		{
			Text[LineCount] = DControllers[i].DisplayDebugInfo();
			LineCount++;
		}
	}

	Text[LineCount] = "Dialog Trees:" @ Trees.Length;		LineCount++;

	for( i=0; i < Trees.Length; i++ )
	{
		if( Trees[i].NextNodes[0] != None )
		{
			Text[LineCount] = "  Root:" @ Trees[i].Topic @ " bEnabled:" @ Trees[i].NextNodes[0].bEnabled @ "UseBookmark:" @ EnumStr( enum'EDialogBoolean', Trees[i].UseBookmark );
			LineCount++;

			for( j=0; j < Trees[i].NextNodes[0].NextNodes.Length; j++ )
			{
				Text[LineCount] = "  SubTopic:" @ Trees[i].NextNodes[0].NextNodes[j].Tag @ " bEnabled:" @ Trees[i].NextNodes[0].NextNodes[j].bEnabled @ "UseBookmark:" @ EnumStr( enum'EDialogBoolean', Trees[i].UseBookmark );
				LineCount++;
			}
		}
	}

	if( CurNode == None )
	{
		Text[LineCount] = "Current node: None";		LineCount++;
		Text[LineCount] = "Bookmarked node: None";	LineCount++;
	}
	else
	{
		Text[LineCount] = "Current node:" @ CurNode.ShortText @ "(" $ CurNode.SpokenCount $ "/" $ CurNode.SpokenMax $ ")";	LineCount++;
		if( CurNode.Tree == None ||
			CurNode.Tree.Bookmark == None )
		{
			Text[LineCount] = "Bookmarked node: None";	LineCount++;
		}
		else
		{
			Text[LineCount] = "Bookmarked node: " @ CurNode.Tree.Bookmark.ShortText @ "(" $ CurNode.SpokenCount $ "/" $ CurNode.SpokenMax $ ")";	LineCount++;
		}
	}
	
	Text[LineCount] = "Status:" @ EnumStr( enum'EDialogStatus', DialogStatus);			LineCount++;

	Text[LineCount] = "Time since audio finished:" @ TimeSinceLastSpoken();				LineCount++;
	Text[LineCount] = " ";	LineCount++;
}

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

defaultproperties
{
	Tone=DIALOGTONE_Formal
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}