809 lines
22 KiB
C++
809 lines
22 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include "soundent.h"
|
|
#include "game.h"
|
|
#include "world.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Some enumerations needed by CSoundEnt
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// identifiers passed to functions that can operate on either list, to indicate which list to operate on.
|
|
#define SOUNDLISTTYPE_FREE 1
|
|
#define SOUNDLISTTYPE_ACTIVE 2
|
|
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( soundent, CSoundEnt );
|
|
|
|
static CSoundEnt *g_pSoundEnt = NULL;
|
|
|
|
BEGIN_SIMPLE_DATADESC( CSound )
|
|
|
|
DEFINE_FIELD( m_hOwner, FIELD_EHANDLE ),
|
|
DEFINE_FIELD( m_iVolume, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_flOcclusionScale, FIELD_FLOAT ),
|
|
DEFINE_FIELD( m_iType, FIELD_INTEGER ),
|
|
// DEFINE_FIELD( m_iNextAudible, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_bNoExpirationTime, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_flExpireTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_iNext, FIELD_SHORT ),
|
|
DEFINE_FIELD( m_ownerChannelIndex, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_vecOrigin, FIELD_POSITION_VECTOR ),
|
|
DEFINE_FIELD( m_bHasOwner, FIELD_BOOLEAN ),
|
|
// DEFINE_FIELD( m_iMyIndex, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_hTarget, FIELD_EHANDLE ),
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
//=========================================================
|
|
// CSound - Clear - zeros all fields for a sound
|
|
//=========================================================
|
|
void CSound::Clear ( void )
|
|
{
|
|
m_vecOrigin = vec3_origin;
|
|
m_iType = 0;
|
|
m_iVolume = 0;
|
|
m_flOcclusionScale = 0;
|
|
m_flExpireTime = 0;
|
|
m_bNoExpirationTime = false;
|
|
m_iNext = SOUNDLIST_EMPTY;
|
|
m_iNextAudible = 0;
|
|
}
|
|
|
|
//=========================================================
|
|
// Reset - clears the volume, origin, and type for a sound,
|
|
// but doesn't expire or unlink it.
|
|
//=========================================================
|
|
void CSound::Reset ( void )
|
|
{
|
|
m_vecOrigin = vec3_origin;
|
|
m_iType = 0;
|
|
m_iVolume = 0;
|
|
m_iNext = SOUNDLIST_EMPTY;
|
|
}
|
|
|
|
//=========================================================
|
|
// FIsSound - returns true if the sound is an Audible sound
|
|
//=========================================================
|
|
bool CSound::FIsSound ( void )
|
|
{
|
|
switch( SoundTypeNoContext() )
|
|
{
|
|
case SOUND_COMBAT:
|
|
case SOUND_WORLD:
|
|
case SOUND_PLAYER:
|
|
case SOUND_DANGER:
|
|
case SOUND_DANGER_SNIPERONLY:
|
|
case SOUND_THUMPER:
|
|
case SOUND_BULLET_IMPACT:
|
|
case SOUND_BUGBAIT:
|
|
case SOUND_PHYSICS_DANGER:
|
|
case SOUND_MOVE_AWAY:
|
|
case SOUND_PLAYER_VEHICLE:
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// FIsScent - returns true if the sound is actually a scent
|
|
// do we really need this function? If a sound isn't a sound,
|
|
// it must be a scent. (sjb)
|
|
//=========================================================
|
|
bool CSound::FIsScent ( void )
|
|
{
|
|
switch( m_iType )
|
|
{
|
|
case SOUND_CARCASS:
|
|
case SOUND_MEAT:
|
|
case SOUND_GARBAGE:
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------
|
|
// This function returns the spot the listener should be
|
|
// interested in if he hears the sound. MOST of the time,
|
|
// this spot is the same as the sound's origin. But sometimes
|
|
// (like with bullet impacts) the entity that owns the
|
|
// sound is more interesting than the actual location of the
|
|
// sound effect.
|
|
//---------------------------------------------------------
|
|
const Vector &CSound::GetSoundReactOrigin( void )
|
|
{
|
|
|
|
// Check pure types.
|
|
switch( m_iType )
|
|
{
|
|
case SOUND_BULLET_IMPACT:
|
|
case SOUND_PHYSICS_DANGER:
|
|
if( m_hOwner.Get() != NULL )
|
|
{
|
|
// We really want the origin of this sound's
|
|
// owner.
|
|
return m_hOwner->GetAbsOrigin();
|
|
}
|
|
else
|
|
{
|
|
// If the owner is somehow invalid, we'll settle
|
|
// for the sound's origin rather than a crash.
|
|
return GetSoundOrigin();
|
|
}
|
|
break;
|
|
}
|
|
|
|
if( m_iType & SOUND_CONTEXT_REACT_TO_SOURCE )
|
|
{
|
|
if( m_hOwner.Get() != NULL )
|
|
{
|
|
return m_hOwner->GetAbsOrigin();
|
|
}
|
|
}
|
|
|
|
// Check for types with additional context.
|
|
if( m_iType & SOUND_DANGER )
|
|
{
|
|
if( (m_iType & SOUND_CONTEXT_FROM_SNIPER) )
|
|
{
|
|
if( m_hOwner.Get() != NULL )
|
|
{
|
|
// Be afraid of the sniper's location, not where the bullet will hit.
|
|
return m_hOwner->GetAbsOrigin();
|
|
}
|
|
else
|
|
{
|
|
return GetSoundOrigin();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return GetSoundOrigin();
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Save/load
|
|
//-----------------------------------------------------------------------------
|
|
BEGIN_DATADESC( CSoundEnt )
|
|
|
|
DEFINE_FIELD( m_iFreeSound, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_iActiveSound, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_cLastActiveSounds, FIELD_INTEGER ),
|
|
DEFINE_EMBEDDED_ARRAY( m_SoundPool, MAX_WORLD_SOUNDS_SP ),
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Class factory methods
|
|
//-----------------------------------------------------------------------------
|
|
bool CSoundEnt::InitSoundEnt()
|
|
{
|
|
///!!!LATER - do we want a sound ent in deathmatch? (sjb)
|
|
g_pSoundEnt = (CSoundEnt*)CBaseEntity::Create( "soundent", vec3_origin, vec3_angle, GetWorldEntity() );
|
|
if ( !g_pSoundEnt )
|
|
{
|
|
Warning( "**COULD NOT CREATE SOUNDENT**\n" );
|
|
return false;
|
|
}
|
|
g_pSoundEnt->AddEFlags( EFL_KEEP_ON_RECREATE_ENTITIES );
|
|
return true;
|
|
}
|
|
|
|
void CSoundEnt::ShutdownSoundEnt()
|
|
{
|
|
if ( g_pSoundEnt )
|
|
{
|
|
g_pSoundEnt->FreeList();
|
|
g_pSoundEnt = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Construction, destruction
|
|
//-----------------------------------------------------------------------------
|
|
CSoundEnt::CSoundEnt()
|
|
{
|
|
}
|
|
|
|
CSoundEnt::~CSoundEnt()
|
|
{
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// Spawn
|
|
//=========================================================
|
|
void CSoundEnt::Spawn( void )
|
|
{
|
|
SetSolid( SOLID_NONE );
|
|
Initialize();
|
|
|
|
SetNextThink( gpGlobals->curtime + 1 );
|
|
}
|
|
|
|
void CSoundEnt::OnRestore()
|
|
{
|
|
BaseClass::OnRestore();
|
|
|
|
// Make sure the singleton points to the restored version of this.
|
|
if ( g_pSoundEnt )
|
|
{
|
|
Assert( g_pSoundEnt != this );
|
|
UTIL_Remove( g_pSoundEnt );
|
|
}
|
|
g_pSoundEnt = this;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// Think - at interval, the entire active sound list is checked
|
|
// for sounds that have ExpireTimes less than or equal
|
|
// to the current world time, and these sounds are deallocated.
|
|
//=========================================================
|
|
void CSoundEnt::Think ( void )
|
|
{
|
|
int iSound;
|
|
int iPreviousSound;
|
|
|
|
SetNextThink( gpGlobals->curtime + 0.1 );// how often to check the sound list.
|
|
|
|
iPreviousSound = SOUNDLIST_EMPTY;
|
|
iSound = m_iActiveSound;
|
|
|
|
while ( iSound != SOUNDLIST_EMPTY )
|
|
{
|
|
if ( (m_SoundPool[ iSound ].m_flExpireTime <= gpGlobals->curtime && (!m_SoundPool[ iSound ].m_bNoExpirationTime)) || !m_SoundPool[iSound].ValidateOwner() )
|
|
{
|
|
int iNext = m_SoundPool[ iSound ].m_iNext;
|
|
|
|
if( displaysoundlist.GetInt() == 1 )
|
|
{
|
|
Msg(" Removed Sound: %d (Time:%f)\n", m_SoundPool[ iSound ].SoundType(), gpGlobals->curtime );
|
|
}
|
|
if( displaysoundlist.GetInt() == 2 && m_SoundPool[ iSound ].IsSoundType( SOUND_DANGER ) )
|
|
{
|
|
Msg(" Removed Danger Sound: %d (time:%f)\n", m_SoundPool[ iSound ].SoundType(), gpGlobals->curtime );
|
|
}
|
|
|
|
// move this sound back into the free list
|
|
FreeSound( iSound, iPreviousSound );
|
|
|
|
iSound = iNext;
|
|
}
|
|
else
|
|
{
|
|
if( displaysoundlist.GetBool() )
|
|
{
|
|
Vector forward, right, up;
|
|
GetVectors( &forward, &right, &up );
|
|
byte r, g, b;
|
|
|
|
// Default to yellow.
|
|
r = 255;
|
|
g = 255;
|
|
b = 0;
|
|
|
|
CSound *pSound = &m_SoundPool[ iSound ];
|
|
|
|
if( pSound->IsSoundType( SOUND_DANGER ) )
|
|
{
|
|
r = 255;
|
|
g = 0;
|
|
b = 0;
|
|
}
|
|
|
|
if( displaysoundlist.GetInt() == 1 || (displaysoundlist.GetInt() == 2 && pSound->IsSoundType( SOUND_DANGER ) ) )
|
|
{
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() + forward * pSound->Volume(), r,g,b, false, 0.1 );
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() - forward * pSound->Volume(), r,g,b, false, 0.1 );
|
|
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() + right * pSound->Volume(), r,g,b, false, 0.1 );
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() - right * pSound->Volume(), r,g,b, false, 0.1 );
|
|
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() + up * pSound->Volume(), r,g,b, false, 0.1 );
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() - up * pSound->Volume(), r,g,b, false, 0.1 );
|
|
|
|
if( pSound->m_flOcclusionScale != 1.0 )
|
|
{
|
|
// Draw the occluded radius, too.
|
|
r = 0; g = 150; b = 255;
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() + forward * pSound->OccludedVolume(), r,g,b, false, 0.1 );
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() - forward * pSound->OccludedVolume(), r,g,b, false, 0.1 );
|
|
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() + right * pSound->OccludedVolume(), r,g,b, false, 0.1 );
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() - right * pSound->OccludedVolume(), r,g,b, false, 0.1 );
|
|
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() + up * pSound->OccludedVolume(), r,g,b, false, 0.1 );
|
|
NDebugOverlay::Line( pSound->GetSoundOrigin(), pSound->GetSoundOrigin() - up * pSound->OccludedVolume(), r,g,b, false, 0.1 );
|
|
}
|
|
}
|
|
|
|
DevMsg( 2, "Soundlist: %d / %d (%d)\n", ISoundsInList( SOUNDLISTTYPE_ACTIVE ),ISoundsInList( SOUNDLISTTYPE_FREE ), ISoundsInList( SOUNDLISTTYPE_ACTIVE ) - m_cLastActiveSounds );
|
|
m_cLastActiveSounds = ISoundsInList ( SOUNDLISTTYPE_ACTIVE );
|
|
}
|
|
|
|
iPreviousSound = iSound;
|
|
iSound = m_SoundPool[ iSound ].m_iNext;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//=========================================================
|
|
// Precache - dummy function
|
|
//=========================================================
|
|
void CSoundEnt::Precache ( void )
|
|
{
|
|
}
|
|
|
|
//=========================================================
|
|
// FreeSound - clears the passed active sound and moves it
|
|
// to the top of the free list. TAKE CARE to only call this
|
|
// function for sounds in the Active list!!
|
|
//=========================================================
|
|
void CSoundEnt::FreeSound ( int iSound, int iPrevious )
|
|
{
|
|
if ( !g_pSoundEnt )
|
|
{
|
|
// no sound ent!
|
|
return;
|
|
}
|
|
|
|
if ( iPrevious != SOUNDLIST_EMPTY )
|
|
{
|
|
// iSound is not the head of the active list, so
|
|
// must fix the index for the Previous sound
|
|
g_pSoundEnt->m_SoundPool[ iPrevious ].m_iNext = g_pSoundEnt->m_SoundPool[ iSound ].m_iNext;
|
|
}
|
|
else
|
|
{
|
|
// the sound we're freeing IS the head of the active list.
|
|
g_pSoundEnt->m_iActiveSound = g_pSoundEnt->m_SoundPool [ iSound ].m_iNext;
|
|
}
|
|
|
|
// make iSound the head of the Free list.
|
|
g_pSoundEnt->m_SoundPool[ iSound ].m_iNext = g_pSoundEnt->m_iFreeSound;
|
|
g_pSoundEnt->m_iFreeSound = iSound;
|
|
}
|
|
|
|
//=========================================================
|
|
// IAllocSound - moves a sound from the Free list to the
|
|
// Active list returns the index of the alloc'd sound
|
|
//=========================================================
|
|
int CSoundEnt::IAllocSound( void )
|
|
{
|
|
int iNewSound;
|
|
|
|
if ( m_iFreeSound == SOUNDLIST_EMPTY )
|
|
{
|
|
// no free sound!
|
|
if ( developer.GetInt() >= 2 )
|
|
Msg( "Free Sound List is full!\n" );
|
|
|
|
return SOUNDLIST_EMPTY;
|
|
}
|
|
|
|
// there is at least one sound available, so move it to the
|
|
// Active sound list, and return its SoundPool index.
|
|
|
|
iNewSound = m_iFreeSound;// copy the index of the next free sound
|
|
|
|
m_iFreeSound = m_SoundPool[ m_iFreeSound ].m_iNext;// move the index down into the free list.
|
|
|
|
m_SoundPool[ iNewSound ].m_iNext = m_iActiveSound;// point the new sound at the top of the active list.
|
|
|
|
m_iActiveSound = iNewSound;// now make the new sound the top of the active list. You're done.
|
|
|
|
#ifdef DEBUG
|
|
m_SoundPool[ iNewSound ].m_iMyIndex = iNewSound;
|
|
#endif // DEBUG
|
|
|
|
return iNewSound;
|
|
}
|
|
|
|
//=========================================================
|
|
// InsertSound - Allocates a free sound and fills it with
|
|
// sound info.
|
|
//=========================================================
|
|
void CSoundEnt::InsertSound ( int iType, const Vector &vecOrigin, int iVolume, float flDuration, CBaseEntity *pOwner, int soundChannelIndex, CBaseEntity *pSoundTarget )
|
|
{
|
|
int iThisSound;
|
|
|
|
if ( !g_pSoundEnt )
|
|
return;
|
|
|
|
if( soundChannelIndex == SOUNDENT_CHANNEL_UNSPECIFIED )
|
|
{
|
|
// No sound channel specified. So just make a new sound.
|
|
iThisSound = g_pSoundEnt->IAllocSound();
|
|
}
|
|
else
|
|
{
|
|
// If this entity has already got a sound in the soundlist that's on this
|
|
// channel, update that sound. Otherwise add a new one.
|
|
iThisSound = g_pSoundEnt->FindOrAllocateSound( pOwner, soundChannelIndex );
|
|
}
|
|
|
|
if ( iThisSound == SOUNDLIST_EMPTY )
|
|
{
|
|
DevMsg( "Could not AllocSound() for InsertSound() (Game DLL)\n" );
|
|
return;
|
|
}
|
|
|
|
CSound *pSound;
|
|
|
|
pSound = &g_pSoundEnt->m_SoundPool[ iThisSound ];
|
|
|
|
pSound->SetSoundOrigin( vecOrigin );
|
|
pSound->m_iType = iType;
|
|
pSound->m_iVolume = iVolume;
|
|
pSound->m_flOcclusionScale = 0.5;
|
|
pSound->m_flExpireTime = gpGlobals->curtime + flDuration;
|
|
pSound->m_bNoExpirationTime = false;
|
|
pSound->m_hOwner.Set( pOwner );
|
|
pSound->m_hTarget.Set( pSoundTarget );
|
|
pSound->m_ownerChannelIndex = soundChannelIndex;
|
|
|
|
// Keep track of whether this sound had an owner when it was made. If the sound has a long duration,
|
|
// the owner could disappear by the time someone hears this sound, so we have to look at this boolean
|
|
// and throw out sounds who have a NULL owner but this field set to true. (sjb) 12/2/2005
|
|
if( pOwner )
|
|
{
|
|
pSound->m_bHasOwner = true;
|
|
}
|
|
else
|
|
{
|
|
pSound->m_bHasOwner = false;
|
|
}
|
|
|
|
if( displaysoundlist.GetInt() == 1 )
|
|
{
|
|
Msg(" Added Sound! Type:%d Duration:%f (Time:%f)\n", pSound->SoundType(), flDuration, gpGlobals->curtime );
|
|
}
|
|
if( displaysoundlist.GetInt() == 2 && (iType & SOUND_DANGER) )
|
|
{
|
|
Msg(" Added Danger Sound! Duration:%f (Time:%f)\n", flDuration, gpGlobals->curtime );
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
//---------------------------------------------------------
|
|
int CSoundEnt::FindOrAllocateSound( CBaseEntity *pOwner, int soundChannelIndex )
|
|
{
|
|
int iSound = m_iActiveSound;
|
|
|
|
while ( iSound != SOUNDLIST_EMPTY )
|
|
{
|
|
CSound &sound = m_SoundPool[iSound];
|
|
|
|
if ( sound.m_ownerChannelIndex == soundChannelIndex && sound.m_hOwner == pOwner )
|
|
{
|
|
return iSound;
|
|
}
|
|
|
|
iSound = sound.m_iNext;
|
|
}
|
|
|
|
return IAllocSound();
|
|
}
|
|
|
|
//=========================================================
|
|
// Initialize - clears all sounds and moves them into the
|
|
// free sound list.
|
|
//=========================================================
|
|
void CSoundEnt::Initialize ( void )
|
|
{
|
|
int i;
|
|
int iSound;
|
|
|
|
m_cLastActiveSounds;
|
|
m_iFreeSound = 0;
|
|
m_iActiveSound = SOUNDLIST_EMPTY;
|
|
|
|
// In SP, we should only use the first 64 slots so save/load works right.
|
|
// In MP, have one for each player and 32 extras.
|
|
int nTotalSoundsInPool = MAX_WORLD_SOUNDS_SP;
|
|
if ( gpGlobals->maxClients > 1 )
|
|
nTotalSoundsInPool = MIN( MAX_WORLD_SOUNDS_MP, gpGlobals->maxClients + 32 );
|
|
|
|
if ( gpGlobals->maxClients+16 > nTotalSoundsInPool )
|
|
{
|
|
Warning( "CSoundEnt pool is low on sounds due to high number of clients.\n" );
|
|
}
|
|
|
|
for ( i = 0 ; i < nTotalSoundsInPool ; i++ )
|
|
{
|
|
// clear all sounds, and link them into the free sound list.
|
|
m_SoundPool[ i ].Clear();
|
|
m_SoundPool[ i ].m_iNext = i + 1;
|
|
}
|
|
|
|
m_SoundPool[ i - 1 ].m_iNext = SOUNDLIST_EMPTY;// terminate the list here.
|
|
|
|
|
|
// now reserve enough sounds for each client
|
|
for ( i = 0 ; i < gpGlobals->maxClients ; i++ )
|
|
{
|
|
iSound = IAllocSound();
|
|
|
|
if ( iSound == SOUNDLIST_EMPTY )
|
|
{
|
|
DevMsg( "Could not AllocSound() for Client Reserve! (DLL)\n" );
|
|
return;
|
|
}
|
|
|
|
m_SoundPool[ iSound ].m_bNoExpirationTime = true;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// ISoundsInList - returns the number of sounds in the desired
|
|
// sound list.
|
|
//=========================================================
|
|
int CSoundEnt::ISoundsInList ( int iListType )
|
|
{
|
|
int i;
|
|
int iThisSound = SOUNDLIST_EMPTY;
|
|
|
|
if ( iListType == SOUNDLISTTYPE_FREE )
|
|
{
|
|
iThisSound = m_iFreeSound;
|
|
}
|
|
else if ( iListType == SOUNDLISTTYPE_ACTIVE )
|
|
{
|
|
iThisSound = m_iActiveSound;
|
|
}
|
|
else
|
|
{
|
|
Msg( "Unknown Sound List Type!\n" );
|
|
}
|
|
|
|
if ( iThisSound == SOUNDLIST_EMPTY )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
i = 0;
|
|
|
|
while ( iThisSound != SOUNDLIST_EMPTY )
|
|
{
|
|
i++;
|
|
|
|
iThisSound = m_SoundPool[ iThisSound ].m_iNext;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
//=========================================================
|
|
// ActiveList - returns the head of the active sound list
|
|
//=========================================================
|
|
int CSoundEnt::ActiveList ( void )
|
|
{
|
|
if ( !g_pSoundEnt )
|
|
{
|
|
return SOUNDLIST_EMPTY;
|
|
}
|
|
|
|
return g_pSoundEnt->m_iActiveSound;
|
|
}
|
|
|
|
//=========================================================
|
|
// FreeList - returns the head of the free sound list
|
|
//=========================================================
|
|
int CSoundEnt::FreeList ( void )
|
|
{
|
|
if ( !g_pSoundEnt )
|
|
{
|
|
return SOUNDLIST_EMPTY;
|
|
}
|
|
|
|
return g_pSoundEnt->m_iFreeSound;
|
|
}
|
|
|
|
//=========================================================
|
|
// SoundPointerForIndex - returns a pointer to the instance
|
|
// of CSound at index's position in the sound pool.
|
|
//=========================================================
|
|
CSound* CSoundEnt::SoundPointerForIndex( int iIndex )
|
|
{
|
|
if ( !g_pSoundEnt )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
if ( iIndex > ( MAX_WORLD_SOUNDS_MP - 1 ) )
|
|
{
|
|
Msg( "SoundPointerForIndex() - Index too large!\n" );
|
|
return NULL;
|
|
}
|
|
|
|
if ( iIndex < 0 )
|
|
{
|
|
Msg( "SoundPointerForIndex() - Index < 0!\n" );
|
|
return NULL;
|
|
}
|
|
|
|
return &g_pSoundEnt->m_SoundPool[ iIndex ];
|
|
}
|
|
|
|
//=========================================================
|
|
// Clients are numbered from 1 to MAXCLIENTS, but the client
|
|
// reserved sounds in the soundlist are from 0 to MAXCLIENTS - 1,
|
|
// so this function ensures that a client gets the proper index
|
|
// to his reserved sound in the soundlist.
|
|
//=========================================================
|
|
int CSoundEnt::ClientSoundIndex ( edict_t *pClient )
|
|
{
|
|
int iReturn = ENTINDEX( pClient ) - 1;
|
|
|
|
#ifdef _DEBUG
|
|
if ( iReturn < 0 || iReturn >= gpGlobals->maxClients )
|
|
{
|
|
Msg( "** ClientSoundIndex returning a bogus value! **\n" );
|
|
}
|
|
#endif // _DEBUG
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the loudest sound of the specified type at "earposition"
|
|
//-----------------------------------------------------------------------------
|
|
CSound* CSoundEnt::GetLoudestSoundOfType( int iType, const Vector &vecEarPosition )
|
|
{
|
|
CSound *pLoudestSound = NULL;
|
|
|
|
int iThisSound;
|
|
int iBestSound = SOUNDLIST_EMPTY;
|
|
float flBestDist = MAX_COORD_RANGE*MAX_COORD_RANGE;// so first nearby sound will become best so far.
|
|
float flDist;
|
|
CSound *pSound;
|
|
|
|
iThisSound = ActiveList();
|
|
|
|
while ( iThisSound != SOUNDLIST_EMPTY )
|
|
{
|
|
pSound = SoundPointerForIndex( iThisSound );
|
|
|
|
if ( pSound && pSound->m_iType == iType && pSound->ValidateOwner() )
|
|
{
|
|
flDist = ( pSound->GetSoundOrigin() - vecEarPosition ).Length();
|
|
|
|
//FIXME: This doesn't match what's in Listen()
|
|
//flDist = UTIL_DistApprox( pSound->GetSoundOrigin(), vecEarPosition );
|
|
|
|
if ( flDist <= pSound->m_iVolume && flDist < flBestDist )
|
|
{
|
|
pLoudestSound = pSound;
|
|
|
|
iBestSound = iThisSound;
|
|
flBestDist = flDist;
|
|
}
|
|
}
|
|
|
|
iThisSound = pSound->m_iNext;
|
|
}
|
|
|
|
return pLoudestSound;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Inserts an AI sound into the world sound list.
|
|
//-----------------------------------------------------------------------------
|
|
class CAISound : public CPointEntity
|
|
{
|
|
public:
|
|
CAISound()
|
|
{
|
|
// Initialize these new keyvalues appropriately
|
|
// in order to support legacy instances of ai_sound.
|
|
m_iSoundContext = 0x00000000;
|
|
m_iVolume = 0;
|
|
m_flDuration = 0.3;
|
|
}
|
|
|
|
DECLARE_CLASS( CAISound, CPointEntity );
|
|
|
|
DECLARE_DATADESC();
|
|
|
|
// data
|
|
int m_iSoundType;
|
|
int m_iSoundContext;
|
|
int m_iVolume;
|
|
float m_flDuration;
|
|
string_t m_iszProxyEntityName;
|
|
|
|
// Input handlers
|
|
void InputInsertSound( inputdata_t &inputdata );
|
|
void InputEmitAISound( inputdata_t &inputdata );
|
|
};
|
|
|
|
LINK_ENTITY_TO_CLASS( ai_sound, CAISound );
|
|
|
|
BEGIN_DATADESC( CAISound )
|
|
|
|
DEFINE_KEYFIELD( m_iSoundType, FIELD_INTEGER, "soundtype" ),
|
|
DEFINE_KEYFIELD( m_iSoundContext, FIELD_INTEGER, "soundcontext" ),
|
|
DEFINE_KEYFIELD( m_iVolume, FIELD_INTEGER, "volume" ),
|
|
DEFINE_KEYFIELD( m_flDuration, FIELD_FLOAT, "duration" ),
|
|
DEFINE_KEYFIELD( m_iszProxyEntityName, FIELD_STRING, "locationproxy" ),
|
|
|
|
DEFINE_INPUTFUNC( FIELD_INTEGER, "InsertSound", InputInsertSound ),
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "EmitAISound", InputEmitAISound ),
|
|
|
|
END_DATADESC()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: *** OBSOLETE **** Here for legacy support only!
|
|
//-----------------------------------------------------------------------------
|
|
void CAISound::InputInsertSound( inputdata_t &inputdata )
|
|
{
|
|
int iVolume;
|
|
|
|
iVolume = inputdata.value.Int();
|
|
|
|
Vector vecLocation = GetAbsOrigin();
|
|
|
|
if( m_iszProxyEntityName != NULL_STRING )
|
|
{
|
|
CBaseEntity *pProxy = gEntList.FindEntityByName( NULL, m_iszProxyEntityName );
|
|
|
|
if( pProxy )
|
|
{
|
|
vecLocation = pProxy->GetAbsOrigin();
|
|
}
|
|
else
|
|
{
|
|
DevWarning("Warning- ai_sound cannot find proxy entity named '%s'. Using self.\n", STRING(m_iszProxyEntityName) );
|
|
}
|
|
}
|
|
|
|
g_pSoundEnt->InsertSound( m_iSoundType, vecLocation, iVolume, m_flDuration, this );
|
|
}
|
|
|
|
void CAISound::InputEmitAISound( inputdata_t &inputdata )
|
|
{
|
|
Vector vecLocation = GetAbsOrigin();
|
|
|
|
if( m_iszProxyEntityName != NULL_STRING )
|
|
{
|
|
CBaseEntity *pProxy = gEntList.FindEntityByName( NULL, m_iszProxyEntityName );
|
|
|
|
if( pProxy )
|
|
{
|
|
vecLocation = pProxy->GetAbsOrigin();
|
|
}
|
|
else
|
|
{
|
|
DevWarning("Warning- ai_sound cannot find proxy entity named '%s'. Using self.\n", STRING(m_iszProxyEntityName) );
|
|
}
|
|
}
|
|
|
|
g_pSoundEnt->InsertSound( m_iSoundType | m_iSoundContext, vecLocation, m_iVolume, m_flDuration, this );
|
|
}
|
|
|
|
|