U2.SoundTable

//=============================================================================
// SoundTable.uc
// $Author: Mfox $
// $Date: 12/14/02 8:36p $
// $Revision: 19 $
//=============================================================================

class SoundTable extends Object
	native;

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

struct SoundInfoT
{
	var() string						  SoundString;		// name for actual sound to play
	var() SoundSlotInterf.ESoundTableSlot SoundTableSlot;	// sound category (can have multiple sounds per slot)
	var bool							  bPlayed;			// this sound has been already played (for LRU)
};

var(Sounds) array<SoundInfoT> SoundList;					// list of all sounds for this class

var Actor.ESoundSlot DefaultSoundSlot;						// sound slot used by SoundTable (mainly for vocals)

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

native function bool Initialize( string VoicePackage );
native function bool StringToSlot( string SlotString, SoundSlotInterf.ESoundTableSlot SlotEnum );

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

function SetupAndPlaySound( U2Pawn U2P, Sound SelectedSound, Actor.ESoundSlot SelectedSoundSlot )
{			 
	//U2P.DMTNS( "Sound: " $ SelectedSound $ " Slot:" $  EnumStr( enum'ESoundSlot', TSoundSlot ) $ ", Vol:" $ TSoundVolume $ ", NoOver:" $ bTSoundNoOverride $ ", Radius: " $ TSoundRadius $ ", Pitch:" $ TSoundPitch );
	U2P.PlaySound( SelectedSound, SelectedSoundSlot );

	// make sure pawns 'hear' this noise if close enough
	if( U2P.Level.NetMode == NM_StandAlone )
		U2P.MakeNoise( 1.0 );
}

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

function Sound LoadAndPlaySound( U2Pawn U2P, int SelectedIndex, Actor.ESoundSlot SelectedSoundSlot )
{
	local Sound SelectedSound;

	//U2P.DMT( "LoadAndPlaySound: " $ U2P.VoicePackage $ "." $ EnumStr( enum'ESoundTableSlot', SoundList[ SelectedIndex ].SoundTableSlot ) $ "." $ SoundList[ SelectedIndex ].SoundString );
	SelectedSound = Sound( DynamicLoadObject( U2P.VoicePackage $ "." $ SoundList[ SelectedIndex ].SoundTableSlot $ "." $ SoundList[ SelectedIndex ].SoundString, class'Sound' ) );

	if( SelectedSound != None )
	{
		SetupAndPlaySound( U2P, SelectedSound, SelectedSoundSlot );
	}
	else if( !U2P.bDisableErrorMessages )
	{
		// DynamicLoadObject should never fail
		Warn( "error loading sound: " $ U2P.VoicePackage $ "." $ EnumStr( enum'ESoundTableSlot', SoundList[ SelectedIndex ].SoundTableSlot ) $ "." $ SoundList[ SelectedIndex ].SoundString $ " (" $ U2P.Tag $ ")" );
		class'UIConsole'.static.BroadcastStatusMessage( 
			U2P, 
			U2P $ " missing " @ SoundList[ SelectedIndex ].SoundString,
			1.0 );
	}
	return SelectedSound;
}

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

function Sound PlayRandomSlotSound( U2Pawn U2P, SoundSlotInterf.ESoundTableSlot SoundTableSlot, Actor.ESoundSlot SelectedSoundSlot )
{
	local int SoundSlotIndex;
	local int NumMatchingSounds;
	local float RandVal;
	local array<int> MatchingEntries;
	local SoundSlotInterf.ESoundTableSlot ThisSoundSlot;
	local int SelectedIndex;
	local Sound Result;

	NumMatchingSounds = 0;
	for( SoundSlotIndex=0; SoundSlotIndex<SoundList.Length; SoundSlotIndex++ )
	{
		ThisSoundSlot = SoundList[SoundSlotIndex].SoundTableSlot;

		if( ThisSoundSlot == SoundTableSlot && !SoundList[SoundSlotIndex].bPlayed )
		{
			// slot name isn't empty and it matches given slot name and
			// sound is allowed for the current type of game
			if( SoundList[SoundSlotIndex].SoundString == "" )
			{
				Warn( "Sound #" $ SoundSlotIndex $ " isn't set for slot " $ SoundTableSlot $ " (" $ U2P.Tag $ ")" );
			}
			else
			{
				MatchingEntries[NumMatchingSounds] = SoundSlotIndex;
				NumMatchingSounds++;
			}
		}
	}

	if( NumMatchingSounds >= 1 )
	{
		if( NumMatchingSounds == 1 )
		{
			// Special case: if only 1 sound, it's odds determine whether it
			// is played at all. This makes a SoundSlotTimerList unnecessary.
			SelectedIndex = MatchingEntries[0];

			// the last sound is being played, reset the flags
			for( SoundSlotIndex=0; SoundSlotIndex<SoundList.Length; SoundSlotIndex++ )
				if( SoundList[SoundSlotIndex].SoundTableSlot == SoundTableSlot )
					SoundList[SoundSlotIndex].bPlayed = false;
		}
		else
		{
			RandVal = Rand( NumMatchingSounds );
			SelectedIndex = MatchingEntries[RandVal];
			SoundList[SelectedIndex].bPlayed = true;
		}

		Result = LoadAndPlaySound( U2P, SelectedIndex, SelectedSoundSlot );
	}

	// SoundTables do not have to have every slot defined
	// this just means that no sound will be played for the slot.

	return Result;
}

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

function Sound PlaySlotSound( U2Pawn U2P, SoundSlotInterf.ESoundTableSlot SoundTableSlot, optional bool bSpecialSoundSlot, optional Actor.ESoundSlot SpecialSoundSlot )
{
	local int TimeIsUpSlotIndex;
	local Sound Result;
	local Actor.ESoundSlot SelectedSoundSlot;
	
	if( SoundTableSlot != STS_None )
	{
		if( bSpecialSoundSlot )
			SelectedSoundSlot = SpecialSoundSlot;
		else
			SelectedSoundSlot = DefaultSoundSlot;
		
		if( U2P.bUseSoundSlotTimers && U2P.SoundSlotTimers != None )
		{
			if( U2P.SoundSlotTimers.TimeToDoSound( U2P, SoundTableSlot, TimeIsUpSlotIndex ) )
			{
				Result = PlayRandomSlotSound( U2P, SoundTableSlot, SelectedSoundSlot );

				if( TimeIsUpSlotIndex != U2P.SoundSlotTimers.NullSlotIndex )
				{
					U2P.SoundSlotTimers.RandomizeSoundSlotTimer( U2P, TimeIsUpSlotIndex );
				}
			}
		}
		else
		{
		 	Result = PlayRandomSlotSound( U2P, SoundTableSlot, SelectedSoundSlot );
		}
	}
	else
	{
		Warn( "slot is NULL " $ " (" $ U2P.Tag $ ")" );
	}
	return Result;
}

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

function StopSlotSound( U2Pawn U2P, SoundSlotInterf.ESoundTableSlot SoundTableSlot )
{
	U2P.StopSoundSlot( DefaultSoundSlot );
}

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

function Dump( Actor Helper )
{
	local int i;
	Helper.DM("SoundList Entries:" @ SoundList.Length );
	for( i=0; i < SoundList.Length; i++ )
		Helper.DM( "SoundList(" $ i $ ")=(SoundTableSlot='" $ EnumStr(enum'ESoundTableSlot', SoundList[i].SoundTableSlot) $ "',SoundString=\"" $ SoundList[i].SoundString $ "\")" );
}

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

function int GetNumSounds( SoundSlotInterf.ESoundTableSlot InSlot )
{
	local int i, Count;
	for( i=0; i < SoundList.Length; i++ )
		if( SoundList[i].SoundTableSlot == InSlot )
			Count++;
	return Count;
}

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

static function SoundTable GetInstance( Actor ContextActor, string InVoicePackage )
{
	local SoundTable Result;
	local U2Pawn P;
	local Controller C;

	if( ContextActor != None && InVoicePackage != "" )
	{
		// reference an existing sound table for this voice package
		for( C=ContextActor.Level.ControllerList; C!=None; C=C.NextController )
		{
			P = U2Pawn(C.Pawn);
			if( P != None &&
				P.VoicePackage == InVoicePackage &&
				P.SoundTable != None )
			{
				Result = P.SoundTable;
				break;
			}
		}

		// create the sound table from scratch
		if( Result == None )
		{
			Result = new(ContextActor.XLevel) default.Class;
			Result.Initialize( InVoicePackage );
		}
	}
	return Result;
}

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

defaultproperties
{
	DefaultSoundSlot=SLOT_Talk
}