U2.SoundSlotTimerListImpl

//=============================================================================
// SoundSlotTimerListImpl.uc
// $Author: Mbaldwin $
// $Date: 9/21/02 5:28p $
// $Revision: 2 $
//=============================================================================

class SoundSlotTimerListImpl extends SoundSlotTimerListInterf 
	abstract;

// See SoundSlotTimerListInterf.uc for information on how this class works.

#exec Texture Import File=Textures\S_SoundSlotTimer.pcx GROUP=Icons Name=S_SoundSlotTimer Mips=Off Masked=1

var(Sounds) array<SoundSlotTimerT> SlotTimers;

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

function Initialize( Actor ContextActor )
{
	RandomizeSoundSlotTimerList( ContextActor );
}

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

function bool TimeToDoSoundRandom( Actor ContextActor, int SlotIndex )
{
	local bool bOkToDoSound;

	bOkToDoSound = false;

	// FRand determines whether slot played
	if( FDecision( SlotTimers[SlotIndex].SlotOdds ) )
	{
		// odds met
		if( SlotTimers[SlotIndex].bReset )
		{
			// play the slot and we will switch to timed control from now on
			bOkToDoSound = true;
		}
		else 
		{
			// make sure any time constraint is met
			if( SlotTimers[SlotIndex].MinSecsToNextSound != 0.0 )
			{
				// have to make sure some minimum time has passed since last time sound played
				if( ContextActor.Level.TimeSeconds >= SlotTimers[SlotIndex].NextSoundTime )
				{
					// play the slot
					bOkToDoSound = true;
				
					// make sure odds are reset to default
					SlotTimers[SlotIndex].SlotOdds = default.SlotTimers[SlotIndex].SlotOdds;
				}
				else
				{
					// make sure odds met next time we check if sound should be played
					SlotTimers[SlotIndex].SlotOdds = 1.0;
				}
			}
			else
			{
				// no time constraint -- play the sound
				bOkToDoSound = true;
			}
		}
	}
	
	if( SlotTimers[SlotIndex].bReset )
	{
		// from now on min/max times will be used (even if odds not met above)
		SlotTimers[SlotIndex].SlotOdds = 0.0;
	}

	return bOkToDoSound;
}

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

function bool TimeToDoSoundTimed( Actor ContextActor, int SlotIndex )
{
	local bool bOkToDoSound;

	bOkToDoSound = false;

	if( ContextActor.Level.TimeSeconds >= SlotTimers[SlotIndex].NextSoundTime )
	{
		// time is up, return index of slot to reset
		bOkToDoSound = true;
	}

	return bOkToDoSound;
}

//-----------------------------------------------------------------------------
// Returns true if the slot isn't in the timer list. If the slot is in the 
// timer list, returns false if not enough time has passed to play a sound from
// the slot, otherwise returns true and sets SlotIndex to the index of the slot
// in the timer list (so this can be used later to reset the timer without 
// having to search for the correct slot a 2nd time).

//function bool TimeToDoSound( Actor ContextActor, name SoundSlot, out int ReturnedSlotIndex )
function bool TimeToDoSound( Actor ContextActor, SoundSlotInterf.ESoundTableSlot SoundSlot, out int ReturnedSlotIndex )
{
	local int SoundSlotIndex;
	local SoundSlotInterf.ESoundTableSlot ThisSoundSlot;
	local bool bMatch;
	local bool bRetVal;

	// scan the list of slots for the first matching one:
	bMatch = false;
	ReturnedSlotIndex = NullSlotIndex;
	for( SoundSlotIndex=0; SoundSlotIndex<SlotTimers.Length; SoundSlotIndex++ )
	{
		ThisSoundSlot = SlotTimers[SoundSlotIndex].SoundSlot;

		if( ThisSoundSlot == SoundSlot )
		{
			bMatch=true;
			break;
		}
	}
	
	bRetVal = false;
	if( !bMatch )
	{
		// slot odds not controlled by SoundSlotTimerList
		bRetVal = true;
	}
	else 
	{
		// slot is controlled by this SoundSlotTimerList
		if( SlotTimers[SoundSlotIndex].SlotOdds != 0.0 )
		{
			bRetVal = TimeToDoSoundRandom( ContextActor, SoundSlotIndex );
		}
		else
		{
			bRetVal = TimeToDoSoundTimed( ContextActor, SoundSlotIndex );
		}

		if( bRetVal )
		{
			// caller can pass slot to set next sound time
			ReturnedSlotIndex = SoundSlotIndex;
		}
	}

	return bRetVal;
}

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

function RandomizeSoundSlotTimer( Actor ContextActor, int SoundSlotIndex )
{
	local float TimeToWait;

	// set up next sound time even if SlotOdds aren't 0.0 in case time is also to be used
	TimeToWait = RandRange( SlotTimers[SoundSlotIndex].MinSecsToNextSound, SlotTimers[SoundSlotIndex].MaxSecsToNextSound );

	SlotTimers[SoundSlotIndex].NextSoundTime = ContextActor.Level.TimeSeconds + TimeToWait;
}

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

function RandomizeSoundSlotTimerList( Actor ContextActor )
{
	local int SoundSlotIndex;

	for( SoundSlotIndex=0; SoundSlotIndex<SlotTimers.Length; SoundSlotIndex++ )
	{
		if( SlotTimers[SoundSlotIndex].SoundSlot != STS_None )
		{
			RandomizeSoundSlotTimer( ContextActor, SoundSlotIndex );
		}
	}
}

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

function Dump( Actor Helper )
{
	local int i;
	Helper.DM("SoundSlotTimer (Tag=" $ Tag $ ") Entries:" @ SlotTimers.Length );
	for( i=0; i < SlotTimers.Length; i++ )
		Helper.DM( "SlotTimers(" $ i $ ")=(SoundSlot='" $ EnumStr(enum'ESoundTableSlot', SlotTimers[i].SoundSlot) $ "',SlotOdds=" $ SlotTimers[i].SlotOdds $ ",MinSecsToNextSound=" $ SlotTimers[i].MinSecsToNextSound $ ",MaxSecsToNextSound=" $ SlotTimers[i].MaxSecsToNextSound $ ")" );
}

//-----------------------------------------------------------------------------
// only those sound slots which aren't to be played every time need be changed

defaultproperties
{
	bHidden=true
	Texture=Texture'U2.Icons.S_SoundSlotTimer'
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}