d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
362 Commits
25 Branches
6 Tags
221 MiB
Tree: 8fbc002a37
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8fbc002a37'
${ noResults }
source-engine/game/server/sceneentity.cpp

5657 lines
154 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include <stdarg.h>
#include "baseflex.h"
#include "entitylist.h"
#include "choreoevent.h"
#include "choreoactor.h"
#include "choreochannel.h"
#include "choreoscene.h"
#include "studio.h"
#include "networkstringtable_gamedll.h"
#include "ai_basenpc.h"
#include "engine/IEngineSound.h"
#include "ai_navigator.h"
#include "saverestore_utlvector.h"
#include "ai_baseactor.h"
#include "AI_Criteria.h"
#include "tier1/strtools.h"
#include "checksum_crc.h"
#include "SoundEmitterSystem/isoundemittersystembase.h"
#include "utlbuffer.h"
#include "tier0/icommandline.h"
#include "sceneentity.h"
#include "datacache/idatacache.h"
#include "dt_utlvector_send.h"
#include "ichoreoeventcallback.h"
#include "scenefilecache/ISceneFileCache.h"
#include "SceneCache.h"
#include "scripted.h"
#include "env_debughistory.h"
#ifdef HL2_EPISODIC
#include "npc_alyx_episodic.h"
#endif // HL2_EPISODIC
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern ISoundEmitterSystemBase *soundemitterbase;
extern ISceneFileCache *scenefilecache;
class CSceneEntity;
class CBaseFlex;
// VCDS are loaded from their compiled/binary format (much faster)
// Requies vcds be saved as compiled assets
//#define COMPILED_VCDS 1
static ConVar scene_forcecombined( "scene_forcecombined", "0", 0, "When playing back, force use of combined .wav files even in english." );
static ConVar scene_maxcaptionradius( "scene_maxcaptionradius", "1200", 0, "Only show closed captions if recipient is within this many units of speaking actor (0==disabled)." );
// Assume sound system is 100 msec lagged (only used if we can't find snd_mixahead cvar!)
#define SOUND_SYSTEM_LATENCY_DEFAULT ( 0.1f )
// Think every 50 msec (FIXME: Try 10hz?)
#define SCENE_THINK_INTERVAL 0.001 // FIXME: make scene's think in concert with their npc's
#define FINDNAMEDENTITY_MAX_ENTITIES 32 // max number of entities to be considered for random entity selection in FindNamedEntity
// List of the last 5 lines of speech from NPCs for bug reports
static recentNPCSpeech_t speechListSounds[ SPEECH_LIST_MAX_SOUNDS ] = { { 0, "", "" }, { 0, "", "" }, { 0, "", "" }, { 0, "", "" }, { 0, "", "" } };
static int speechListIndex = 0;
// Only allow scenes to change their pitch within a range of values
#define SCENE_MIN_PITCH 0.25f
#define SCENE_MAX_PITCH 2.5f
//===========================================================================================================
// SCENE LIST MANAGER
//===========================================================================================================
#define SCENE_LIST_MANAGER_MAX_SCENES 16
//-----------------------------------------------------------------------------
// Purpose: Entity that manages a list of scenes
//-----------------------------------------------------------------------------
class CSceneListManager : public CLogicalEntity
{
DECLARE_CLASS( CSceneListManager, CLogicalEntity );
public:
DECLARE_DATADESC();
virtual void Activate( void );
void ShutdownList( void );
void SceneStarted( CBaseEntity *pSceneOrManager );
void AddListManager( CSceneListManager *pManager );
void RemoveScene( int iIndex );
// Inputs
void InputShutdown( inputdata_t &inputdata );
private:
CUtlVector< CHandle< CSceneListManager > > m_hListManagers;
string_t m_iszScenes[SCENE_LIST_MANAGER_MAX_SCENES];
EHANDLE m_hScenes[SCENE_LIST_MANAGER_MAX_SCENES];
};
//-----------------------------------------------------------------------------
// Purpose: This class exists solely to call think on all scene entities in a deterministic order
//-----------------------------------------------------------------------------
class CSceneManager : public CBaseEntity
{
DECLARE_CLASS( CSceneManager, CBaseEntity );
DECLARE_DATADESC();
public:
virtual void Spawn()
{
BaseClass::Spawn();
SetNextThink( gpGlobals->curtime );
}
virtual int ObjectCaps( void ) { return BaseClass::ObjectCaps() | FCAP_DONT_SAVE; }
virtual void Think();
void ClearAllScenes();
void AddSceneEntity( CSceneEntity *scene );
void RemoveSceneEntity( CSceneEntity *scene );
void QueueRestoredSound( CBaseFlex *actor, char const *soundname, soundlevel_t soundlevel, float time_in_past );
void OnClientActive( CBasePlayer *player );
void RemoveActorFromScenes( CBaseFlex *pActor, bool bInstancedOnly, bool bNonIdleOnly, const char *pszThisSceneOnly );
void RemoveScenesInvolvingActor( CBaseFlex *pActor );
void PauseActorsScenes( CBaseFlex *pActor, bool bInstancedOnly );
bool IsInInterruptableScenes( CBaseFlex *pActor );
void ResumeActorsScenes( CBaseFlex *pActor, bool bInstancedOnly );
void QueueActorsScenesToResume( CBaseFlex *pActor, bool bInstancedOnly );
bool IsRunningScriptedScene( CBaseFlex *pActor, bool bIgnoreInstancedScenes );
bool IsRunningScriptedSceneAndNotPaused( CBaseFlex *pActor, bool bIgnoreInstancedScenes );
bool IsRunningScriptedSceneWithSpeech( CBaseFlex *pActor, bool bIgnoreInstancedScenes );
bool IsRunningScriptedSceneWithSpeechAndNotPaused( CBaseFlex *pActor, bool bIgnoreInstancedScenes );
private:
struct CRestoreSceneSound
{
CRestoreSceneSound()
{
actor = NULL;
soundname[ 0 ] = NULL;
soundlevel = SNDLVL_NORM;
time_in_past = 0.0f;
}
CHandle< CBaseFlex > actor;
char soundname[ 128 ];
soundlevel_t soundlevel;
float time_in_past;
};
CUtlVector< CHandle< CSceneEntity > > m_ActiveScenes;
CUtlVector< CRestoreSceneSound > m_QueuedSceneSounds;
};
//---------------------------------------------------------
// Save/Restore
//---------------------------------------------------------
BEGIN_DATADESC( CSceneManager )
DEFINE_UTLVECTOR( m_ActiveScenes, FIELD_EHANDLE ),
// DEFINE_FIELD( m_QueuedSceneSounds, CUtlVector < CRestoreSceneSound > ), // Don't save/restore this, it's created and used by OnRestore only
END_DATADESC()
#ifdef DISABLE_DEBUG_HISTORY
#define LocalScene_Printf Scene_Printf
#else
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFormat -
// ... -
// Output : static void
//-----------------------------------------------------------------------------
void LocalScene_Printf( const char *pFormat, ... )
{
va_list marker;
char msg[8192];
va_start(marker, pFormat);
Q_vsnprintf(msg, sizeof(msg), pFormat, marker);
va_end(marker);
Scene_Printf( "%s", msg );
ADD_DEBUG_HISTORY( HISTORY_SCENE_PRINT, UTIL_VarArgs( "(%0.2f) %s", gpGlobals->curtime, msg ) );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
// **buffer -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CopySceneFileIntoMemory( char const *pFilename, void **pBuffer, int *pSize )
{
size_t bufSize = scenefilecache->GetSceneBufferSize( pFilename );
if ( bufSize > 0 )
{
*pBuffer = new byte[bufSize];
*pSize = bufSize;
return scenefilecache->GetSceneData( pFilename, (byte *)(*pBuffer), bufSize );
}
*pBuffer = 0;
*pSize = 0;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void FreeSceneFileMemory( void *buffer )
{
delete[] (byte*) buffer;
}
//-----------------------------------------------------------------------------
// Binary compiled VCDs get their strings from a pool
//-----------------------------------------------------------------------------
class CChoreoStringPool : public IChoreoStringPool
{
public:
short FindOrAddString( const char *pString )
{
// huh?, no compilation at run time, only fetches
Assert( 0 );
return -1;
}
bool GetString( short stringId, char *buff, int buffSize )
{
// fetch from compiled pool
const char *pString = scenefilecache->GetSceneString( stringId );
if ( !pString )
{
V_strncpy( buff, "", buffSize );
return false;
}
V_strncpy( buff, pString, buffSize );
return true;
}
};
CChoreoStringPool g_ChoreoStringPool;
//-----------------------------------------------------------------------------
// Purpose: Singleton scene manager. Created by first placed scene or recreated it it's deleted for some unknown reason
// Output : CSceneManager
//-----------------------------------------------------------------------------
CSceneManager *GetSceneManager()
{
// Create it if it doesn't exist
static CHandle< CSceneManager > s_SceneManager;
if ( s_SceneManager == NULL )
{
s_SceneManager = ( CSceneManager * )CreateEntityByName( "scene_manager" );
Assert( s_SceneManager );
if ( s_SceneManager )
{
s_SceneManager->Spawn();
}
}
Assert( s_SceneManager );
return s_SceneManager;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *player -
//-----------------------------------------------------------------------------
void SceneManager_ClientActive( CBasePlayer *player )
{
Assert( GetSceneManager() );
if ( GetSceneManager() )
{
GetSceneManager()->OnClientActive( player );
}
}
//-----------------------------------------------------------------------------
// Purpose: FIXME, need to deal with save/restore
//-----------------------------------------------------------------------------
class CSceneEntity : public CPointEntity, public IChoreoEventCallback
{
friend class CInstancedSceneEntity;
public:
enum
{
SCENE_ACTION_UNKNOWN = 0,
SCENE_ACTION_CANCEL,
SCENE_ACTION_RESUME,
};
enum
{
SCENE_BUSYACTOR_DEFAULT = 0,
SCENE_BUSYACTOR_WAIT,
SCENE_BUSYACTOR_INTERRUPT,
SCENE_BUSYACTOR_INTERRUPT_CANCEL,
};
DECLARE_CLASS( CSceneEntity, CPointEntity );
DECLARE_SERVERCLASS();
CSceneEntity( void );
~CSceneEntity( void );
// From IChoreoEventCallback
virtual void StartEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event );
virtual void EndEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event );
virtual void ProcessEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event );
virtual bool CheckEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event );
virtual int UpdateTransmitState();
virtual int ShouldTransmit( const CCheckTransmitInfo *pInfo );
void SetRecipientFilter( IRecipientFilter *filter );
virtual void Activate();
virtual void Precache( void );
virtual void Spawn( void );
virtual void UpdateOnRemove( void );
virtual void OnRestore();
virtual void OnLoaded();
DECLARE_DATADESC();
virtual void OnSceneFinished( bool canceled, bool fireoutput );
virtual void DoThink( float frametime );
virtual void PauseThink( void );
bool IsPlayingBack() const { return m_bIsPlayingBack; }
bool IsPaused() const { return m_bPaused; }
bool IsMultiplayer() const { return m_bMultiplayer; }
bool IsInterruptable();
virtual void ClearInterrupt();
virtual void CheckInterruptCompletion();
virtual bool InterruptThisScene( CSceneEntity *otherScene );
void RequestCompletionNotification( CSceneEntity *otherScene );
virtual void NotifyOfCompletion( CSceneEntity *interruptor );
void AddListManager( CSceneListManager *pManager );
void ClearActivatorTargets( void );
void SetBreakOnNonIdle( bool bBreakOnNonIdle ) { m_bBreakOnNonIdle = bBreakOnNonIdle; }
bool ShouldBreakOnNonIdle( void ) { return m_bBreakOnNonIdle; }
// Inputs
void InputStartPlayback( inputdata_t &inputdata );
void InputPausePlayback( inputdata_t &inputdata );
void InputResumePlayback( inputdata_t &inputdata );
void InputCancelPlayback( inputdata_t &inputdata );
void InputCancelAtNextInterrupt( inputdata_t &inputdata );
void InputPitchShiftPlayback( inputdata_t &inputdata );
void InputTriggerEvent( inputdata_t &inputdata );
// If the scene is playing, finds an actor in the scene who can respond to the specified concept token
void InputInterjectResponse( inputdata_t &inputdata );
// If this scene is waiting on an actor, give up and quit trying.
void InputStopWaitingForActor( inputdata_t &inputdata );
virtual void StartPlayback( void );
virtual void PausePlayback( void );
virtual void ResumePlayback( void );
virtual void CancelPlayback( void );
virtual void PitchShiftPlayback( float fPitch );
virtual void QueueResumePlayback( void );
bool ValidScene() const;
// Scene load/unload
static CChoreoScene *LoadScene( const char *filename, IChoreoEventCallback *pCallback );
void UnloadScene( void );
struct SpeakEventSound_t
{
CUtlSymbol m_Symbol;
float m_flStartTime;
};
static bool SpeakEventSoundLessFunc( const SpeakEventSound_t& lhs, const SpeakEventSound_t& rhs );
bool GetSoundNameForPlayer( CChoreoEvent *event, CBasePlayer *player, char *buf, size_t buflen, CBaseEntity *pActor );
void BuildSortedSpeakEventSoundsPrefetchList(
CChoreoScene *scene,
CUtlSymbolTable& table,
CUtlRBTree< SpeakEventSound_t >& soundnames,
float timeOffset );
void PrefetchSpeakEventSounds( CUtlSymbolTable& table, CUtlRBTree< SpeakEventSound_t >& soundnames );
// Event handlers
virtual void DispatchStartExpression( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchEndExpression( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartFlexAnimation( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchEndFlexAnimation( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartGesture( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchEndGesture( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartLookAt( CChoreoScene *scene, CBaseFlex *actor, CBaseEntity *actor2, CChoreoEvent *event );
virtual void DispatchEndLookAt( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartMoveTo( CChoreoScene *scene, CBaseFlex *actor, CBaseEntity *actor2, CChoreoEvent *event );
virtual void DispatchEndMoveTo( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartSpeak( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event, soundlevel_t iSoundlevel );
virtual void DispatchEndSpeak( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartFace( CChoreoScene *scene, CBaseFlex *actor, CBaseEntity *actor2, CChoreoEvent *event );
virtual void DispatchEndFace( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartSequence( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchEndSequence( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartSubScene( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchStartInterrupt( CChoreoScene *scene, CChoreoEvent *event );
virtual void DispatchEndInterrupt( CChoreoScene *scene, CChoreoEvent *event );
virtual void DispatchStartGeneric( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchEndGeneric( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
// NPC can play interstitial vcds (such as responding to the player doing something during a scene)
virtual void DispatchStartPermitResponses( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
virtual void DispatchEndPermitResponses( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event );
// Global events
virtual void DispatchProcessLoop( CChoreoScene *scene, CChoreoEvent *event );
virtual void DispatchPauseScene( CChoreoScene *scene, const char *parameters );
virtual void DispatchStopPoint( CChoreoScene *scene, const char *parameters );
virtual float EstimateLength( void );
void CancelIfSceneInvolvesActor( CBaseEntity *pActor );
bool InvolvesActor( CBaseEntity *pActor ); // NOTE: returns false if scene hasn't loaded yet
void GenerateSoundScene( CBaseFlex *pActor, const char *soundname );
virtual float GetPostSpeakDelay() { return 1.0; }
bool HasUnplayedSpeech( void );
bool HasFlexAnimation( void );
void SetCurrentTime( float t, bool forceClientSync );
void InputScriptPlayerDeath( inputdata_t &inputdata );
// Data
public:
string_t m_iszSceneFile;
string_t m_iszResumeSceneFile;
EHANDLE m_hWaitingForThisResumeScene;
bool m_bWaitingForResumeScene;
string_t m_iszTarget1;
string_t m_iszTarget2;
string_t m_iszTarget3;
string_t m_iszTarget4;
string_t m_iszTarget5;
string_t m_iszTarget6;
string_t m_iszTarget7;
string_t m_iszTarget8;
EHANDLE m_hTarget1;
EHANDLE m_hTarget2;
EHANDLE m_hTarget3;
EHANDLE m_hTarget4;
EHANDLE m_hTarget5;
EHANDLE m_hTarget6;
EHANDLE m_hTarget7;
EHANDLE m_hTarget8;
CNetworkVar( bool, m_bIsPlayingBack );
CNetworkVar( bool, m_bPaused );
CNetworkVar( bool, m_bMultiplayer );
CNetworkVar( float, m_flForceClientTime );
float m_flCurrentTime;
float m_flFrameTime;
bool m_bCancelAtNextInterrupt;
float m_fPitch;
bool m_bAutomated;
int m_nAutomatedAction;
float m_flAutomationDelay;
float m_flAutomationTime;
// A pause from an input requires another input to unpause (it's a hard pause)
bool m_bPausedViaInput;
// Waiting for the actor to be able to speak.
bool m_bWaitingForActor;
// Waiting for a point at which we can interrupt our actors
bool m_bWaitingForInterrupt;
bool m_bInterruptedActorsScenes;
bool m_bBreakOnNonIdle;
public:
virtual CBaseFlex *FindNamedActor( int index );
virtual CBaseFlex *FindNamedActor( CChoreoActor *pChoreoActor );
virtual CBaseFlex *FindNamedActor( const char *name );
virtual CBaseEntity *FindNamedEntity( const char *name, CBaseEntity *pActor = NULL, bool bBaseFlexOnly = false, bool bUseClear = false );
CBaseEntity *FindNamedTarget( string_t iszTarget, bool bBaseFlexOnly = false );
virtual CBaseEntity *FindNamedEntityClosest( const char *name, CBaseEntity *pActor = NULL, bool bBaseFlexOnly = false, bool bUseClear = false, const char *pszSecondary = NULL );
private:
CUtlVector< CHandle< CBaseFlex > > m_hActorList;
CUtlVector< CHandle< CBaseEntity > > m_hRemoveActorList;
private:
inline void SetRestoring( bool bRestoring );
// Prevent derived classed from using this!
virtual void Think( void ) {};
void ClearSceneEvents( CChoreoScene *scene, bool canceled );
void ClearSchedules( CChoreoScene *scene );
float GetSoundSystemLatency( void );
void PrecacheScene( CChoreoScene *scene );
CChoreoScene *GenerateSceneForSound( CBaseFlex *pFlexActor, const char *soundname );
bool CheckActors();
void PrefetchAnimBlocks( CChoreoScene *scene );
bool ShouldNetwork() const;
// Set if we tried to async the scene but the FS returned that the data was not loadable
bool m_bSceneMissing;
CChoreoScene *m_pScene;
CNetworkVar( int, m_nSceneStringIndex );
static const ConVar *m_pcvSndMixahead;
COutputEvent m_OnStart;
COutputEvent m_OnCompletion;
COutputEvent m_OnCanceled;
COutputEvent m_OnTrigger1;
COutputEvent m_OnTrigger2;
COutputEvent m_OnTrigger3;
COutputEvent m_OnTrigger4;
COutputEvent m_OnTrigger5;
COutputEvent m_OnTrigger6;
COutputEvent m_OnTrigger7;
COutputEvent m_OnTrigger8;
COutputEvent m_OnTrigger9;
COutputEvent m_OnTrigger10;
COutputEvent m_OnTrigger11;
COutputEvent m_OnTrigger12;
COutputEvent m_OnTrigger13;
COutputEvent m_OnTrigger14;
COutputEvent m_OnTrigger15;
COutputEvent m_OnTrigger16;
int m_nInterruptCount;
bool m_bInterrupted;
CHandle< CSceneEntity > m_hInterruptScene;
bool m_bCompletedEarly;
bool m_bInterruptSceneFinished;
CUtlVector< CHandle< CSceneEntity > > m_hNotifySceneCompletion;
CUtlVector< CHandle< CSceneListManager > > m_hListManagers;
bool m_bRestoring;
bool m_bGenerated;
string_t m_iszSoundName;
CHandle< CBaseFlex > m_hActor;
EHANDLE m_hActivator;
int m_BusyActor;
int m_iPlayerDeathBehavior;
CRecipientFilter *m_pRecipientFilter;
public:
void SetBackground( bool bIsBackground );
bool IsBackground( void );
};
LINK_ENTITY_TO_CLASS( logic_choreographed_scene, CSceneEntity );
LINK_ENTITY_TO_CLASS( scripted_scene, CSceneEntity );
IMPLEMENT_SERVERCLASS_ST_NOBASE( CSceneEntity, DT_SceneEntity )
SendPropInt(SENDINFO(m_nSceneStringIndex),MAX_CHOREO_SCENES_STRING_BITS,SPROP_UNSIGNED),
SendPropBool(SENDINFO(m_bIsPlayingBack)),
SendPropBool(SENDINFO(m_bPaused)),
SendPropBool(SENDINFO(m_bMultiplayer)),
SendPropFloat(SENDINFO(m_flForceClientTime)),
SendPropUtlVector(
SENDINFO_UTLVECTOR( m_hActorList ),
MAX_ACTORS_IN_SCENE, // max elements
SendPropEHandle( NULL, 0 ) ),
END_SEND_TABLE()
BEGIN_DATADESC( CSceneEntity )
// Keys
DEFINE_KEYFIELD( m_iszSceneFile, FIELD_STRING, "SceneFile" ),
DEFINE_KEYFIELD( m_iszResumeSceneFile, FIELD_STRING, "ResumeSceneFile" ),
DEFINE_FIELD( m_hWaitingForThisResumeScene, FIELD_EHANDLE ),
DEFINE_FIELD( m_bWaitingForResumeScene, FIELD_BOOLEAN ),
DEFINE_KEYFIELD( m_iszTarget1, FIELD_STRING, "target1" ),
DEFINE_KEYFIELD( m_iszTarget2, FIELD_STRING, "target2" ),
DEFINE_KEYFIELD( m_iszTarget3, FIELD_STRING, "target3" ),
DEFINE_KEYFIELD( m_iszTarget4, FIELD_STRING, "target4" ),
DEFINE_KEYFIELD( m_iszTarget5, FIELD_STRING, "target5" ),
DEFINE_KEYFIELD( m_iszTarget6, FIELD_STRING, "target6" ),
DEFINE_KEYFIELD( m_iszTarget7, FIELD_STRING, "target7" ),
DEFINE_KEYFIELD( m_iszTarget8, FIELD_STRING, "target8" ),
DEFINE_KEYFIELD( m_BusyActor, FIELD_INTEGER, "busyactor" ),
DEFINE_FIELD( m_hTarget1, FIELD_EHANDLE ),
DEFINE_FIELD( m_hTarget2, FIELD_EHANDLE ),
DEFINE_FIELD( m_hTarget3, FIELD_EHANDLE ),
DEFINE_FIELD( m_hTarget4, FIELD_EHANDLE ),
DEFINE_FIELD( m_hTarget5, FIELD_EHANDLE ),
DEFINE_FIELD( m_hTarget6, FIELD_EHANDLE ),
DEFINE_FIELD( m_hTarget7, FIELD_EHANDLE ),
DEFINE_FIELD( m_hTarget8, FIELD_EHANDLE ),
DEFINE_FIELD( m_bIsPlayingBack, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bPaused, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flCurrentTime, FIELD_FLOAT ), // relative, not absolute time
DEFINE_FIELD( m_flForceClientTime, FIELD_FLOAT ),
DEFINE_FIELD( m_flFrameTime, FIELD_FLOAT ), // last frametime
DEFINE_FIELD( m_bCancelAtNextInterrupt, FIELD_BOOLEAN ),
DEFINE_FIELD( m_fPitch, FIELD_FLOAT ),
DEFINE_FIELD( m_bAutomated, FIELD_BOOLEAN ),
DEFINE_FIELD( m_nAutomatedAction, FIELD_INTEGER ),
DEFINE_FIELD( m_flAutomationDelay, FIELD_FLOAT ),
DEFINE_FIELD( m_flAutomationTime, FIELD_FLOAT ), // relative, not absolute time
DEFINE_FIELD( m_bPausedViaInput, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bWaitingForActor, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bWaitingForInterrupt, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bInterruptedActorsScenes, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bBreakOnNonIdle, FIELD_BOOLEAN ),
DEFINE_UTLVECTOR( m_hActorList, FIELD_EHANDLE ),
DEFINE_UTLVECTOR( m_hRemoveActorList, FIELD_EHANDLE ),
// DEFINE_FIELD( m_pScene, FIELD_XXXX ) // Special processing used for this
// These are set up in the constructor
// DEFINE_FIELD( m_pcvSndMixahead, FIELD_XXXXX ),
// DEFINE_FIELD( m_bRestoring, FIELD_BOOLEAN ),
DEFINE_FIELD( m_nInterruptCount, FIELD_INTEGER ),
DEFINE_FIELD( m_bInterrupted, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hInterruptScene, FIELD_EHANDLE ),
DEFINE_FIELD( m_bCompletedEarly, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bInterruptSceneFinished, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bGenerated, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iszSoundName, FIELD_STRING ),
DEFINE_FIELD( m_hActor, FIELD_EHANDLE ),
DEFINE_FIELD( m_hActivator, FIELD_EHANDLE ),
// DEFINE_FIELD( m_bSceneMissing, FIELD_BOOLEAN ),
DEFINE_UTLVECTOR( m_hNotifySceneCompletion, FIELD_EHANDLE ),
DEFINE_UTLVECTOR( m_hListManagers, FIELD_EHANDLE ),
DEFINE_FIELD( m_bMultiplayer, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_nSceneStringIndex, FIELD_INTEGER ),
// DEFINE_FIELD( m_pRecipientFilter, IRecipientFilter* ), // Multiplayer only
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Start", InputStartPlayback ),
DEFINE_INPUTFUNC( FIELD_VOID, "Pause", InputPausePlayback ),
DEFINE_INPUTFUNC( FIELD_VOID, "Resume", InputResumePlayback ),
DEFINE_INPUTFUNC( FIELD_VOID, "Cancel", InputCancelPlayback ),
DEFINE_INPUTFUNC( FIELD_VOID, "CancelAtNextInterrupt", InputCancelAtNextInterrupt ),
DEFINE_INPUTFUNC( FIELD_FLOAT, "PitchShift", InputPitchShiftPlayback ),
DEFINE_INPUTFUNC( FIELD_STRING, "InterjectResponse", InputInterjectResponse ),
DEFINE_INPUTFUNC( FIELD_VOID, "StopWaitingForActor", InputStopWaitingForActor ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "Trigger", InputTriggerEvent ),
DEFINE_KEYFIELD( m_iPlayerDeathBehavior, FIELD_INTEGER, "onplayerdeath" ),
DEFINE_INPUTFUNC( FIELD_VOID, "ScriptPlayerDeath", InputScriptPlayerDeath ),
// Outputs
DEFINE_OUTPUT( m_OnStart, "OnStart"),
DEFINE_OUTPUT( m_OnCompletion, "OnCompletion"),
DEFINE_OUTPUT( m_OnCanceled, "OnCanceled"),
DEFINE_OUTPUT( m_OnTrigger1, "OnTrigger1"),
DEFINE_OUTPUT( m_OnTrigger2, "OnTrigger2"),
DEFINE_OUTPUT( m_OnTrigger3, "OnTrigger3"),
DEFINE_OUTPUT( m_OnTrigger4, "OnTrigger4"),
DEFINE_OUTPUT( m_OnTrigger5, "OnTrigger5"),
DEFINE_OUTPUT( m_OnTrigger6, "OnTrigger6"),
DEFINE_OUTPUT( m_OnTrigger7, "OnTrigger7"),
DEFINE_OUTPUT( m_OnTrigger8, "OnTrigger8"),
DEFINE_OUTPUT( m_OnTrigger9, "OnTrigger9"),
DEFINE_OUTPUT( m_OnTrigger10, "OnTrigger10"),
DEFINE_OUTPUT( m_OnTrigger11, "OnTrigger11"),
DEFINE_OUTPUT( m_OnTrigger12, "OnTrigger12"),
DEFINE_OUTPUT( m_OnTrigger13, "OnTrigger13"),
DEFINE_OUTPUT( m_OnTrigger14, "OnTrigger14"),
DEFINE_OUTPUT( m_OnTrigger15, "OnTrigger15"),
DEFINE_OUTPUT( m_OnTrigger16, "OnTrigger16"),
END_DATADESC()
const ConVar *CSceneEntity::m_pcvSndMixahead = NULL;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CSceneEntity::CSceneEntity( void )
{
m_bWaitingForActor = false;
m_bWaitingForInterrupt = false;
m_bInterruptedActorsScenes = false;
m_bIsPlayingBack = false;
m_bPaused = false;
m_bMultiplayer = false;
m_fPitch = 1.0f;
m_iszSceneFile = NULL_STRING;
m_iszResumeSceneFile = NULL_STRING;
m_hWaitingForThisResumeScene = NULL;
m_bWaitingForResumeScene = false;
SetCurrentTime( 0.0f, false );
m_bCancelAtNextInterrupt = false;
m_bAutomated = false;
m_nAutomatedAction = SCENE_ACTION_UNKNOWN;
m_flAutomationDelay = 0.0f;
m_flAutomationTime = 0.0f;
m_bPausedViaInput = false;
ClearInterrupt();
m_pScene = NULL;
m_bCompletedEarly = false;
if ( !m_pcvSndMixahead )
m_pcvSndMixahead = cvar->FindVar( "snd_mixahead" );
m_BusyActor = SCENE_BUSYACTOR_DEFAULT;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CSceneEntity::~CSceneEntity( void )
{
delete m_pRecipientFilter;
m_pRecipientFilter = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Resets time such that the client version of the .vcd is also updated, if appropriate
// Input : t -
// forceClientSync - forces new timestamp down to client .dll via networking
//-----------------------------------------------------------------------------
void CSceneEntity::SetCurrentTime( float t, bool bForceClientSync )
{
m_flCurrentTime = t;
if ( gpGlobals->maxClients == 1 || bForceClientSync )
{
m_flForceClientTime = t;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::UpdateOnRemove( void )
{
UnloadScene();
BaseClass::UpdateOnRemove();
if ( GetSceneManager() )
{
GetSceneManager()->RemoveSceneEntity( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *soundname -
// Output : CChoreoScene
//-----------------------------------------------------------------------------
CChoreoScene *CSceneEntity::GenerateSceneForSound( CBaseFlex *pFlexActor, const char *soundname )
{
float duration = CBaseEntity::GetSoundDuration( soundname, pFlexActor ? STRING( pFlexActor->GetModelName() ) : NULL );
if( duration <= 0.0f )
{
Warning( "CSceneEntity::GenerateSceneForSound: Couldn't determine duration of %s\n", soundname );
return NULL;
}
CChoreoScene *scene = new CChoreoScene( this );
if ( !scene )
{
Warning( "CSceneEntity::GenerateSceneForSound: Failed to allocated new scene!!!\n" );
}
else
{
scene->SetPrintFunc( LocalScene_Printf );
CChoreoActor *actor = scene->AllocActor();
CChoreoChannel *channel = scene->AllocChannel();
CChoreoEvent *event = scene->AllocEvent();
Assert( actor );
Assert( channel );
Assert( event );
if ( !actor || !channel || !event )
{
Warning( "CSceneEntity::GenerateSceneForSound: Alloc of actor, channel, or event failed!!!\n" );
delete scene;
return NULL;
}
// Set us up the actorz
actor->SetName( "!self" ); // Could be pFlexActor->GetName()?
actor->SetActive( true );
// Set us up the channelz
channel->SetName( STRING( m_iszSceneFile ) );
channel->SetActor( actor );
// Add to actor
actor->AddChannel( channel );
// Set us up the eventz
event->SetType( CChoreoEvent::SPEAK );
event->SetName( soundname );
event->SetParameters( soundname );
event->SetStartTime( 0.0f );
event->SetUsingRelativeTag( false );
event->SetEndTime( duration );
event->SnapTimes();
// Add to channel
channel->AddEvent( event );
// Point back to our owners
event->SetChannel( channel );
event->SetActor( actor );
}
return scene;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::Activate()
{
if ( m_bGenerated && !m_pScene )
{
m_pScene = GenerateSceneForSound( m_hActor, STRING( m_iszSoundName ) );
}
BaseClass::Activate();
if ( GetSceneManager() )
{
GetSceneManager()->AddSceneEntity( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CSceneEntity::GetSoundSystemLatency( void )
{
if ( m_pcvSndMixahead )
{
return m_pcvSndMixahead->GetFloat();
}
// Assume 100 msec sound system latency
return SOUND_SYSTEM_LATENCY_DEFAULT;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
//-----------------------------------------------------------------------------
void CSceneEntity::PrecacheScene( CChoreoScene *scene )
{
Assert( scene );
// Iterate events and precache necessary resources
for ( int i = 0; i < scene->GetNumEvents(); i++ )
{
CChoreoEvent *event = scene->GetEvent( i );
if ( !event )
continue;
// load any necessary data
switch (event->GetType() )
{
default:
break;
case CChoreoEvent::SPEAK:
{
// Defined in SoundEmitterSystem.cpp
// NOTE: The script entries associated with .vcds are forced to preload to avoid
// loading hitches during triggering
PrecacheScriptSound( event->GetParameters() );
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER &&
event->GetNumSlaves() > 0 )
{
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
if ( event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
{
PrecacheScriptSound( tok );
}
}
}
break;
case CChoreoEvent::SUBSCENE:
{
// Only allow a single level of subscenes for now
if ( !scene->IsSubScene() )
{
CChoreoScene *subscene = event->GetSubScene();
if ( !subscene )
{
subscene = LoadScene( event->GetParameters(), this );
subscene->SetSubScene( true );
event->SetSubScene( subscene );
// Now precache it's resources, if any
PrecacheScene( subscene );
}
}
}
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::Precache( void )
{
if ( m_bGenerated )
return;
if ( m_iszSceneFile == NULL_STRING )
return;
if ( m_iszResumeSceneFile != NULL_STRING )
{
PrecacheInstancedScene( STRING( m_iszResumeSceneFile ) );
}
PrecacheInstancedScene( STRING( m_iszSceneFile ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pActor -
// *soundname -
//-----------------------------------------------------------------------------
void CSceneEntity::GenerateSoundScene( CBaseFlex *pActor, const char *soundname )
{
m_bGenerated = true;
m_iszSoundName = MAKE_STRING( soundname );
m_hActor = pActor;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSceneEntity::HasUnplayedSpeech( void )
{
if ( m_pScene )
return m_pScene->HasUnplayedSpeech();
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSceneEntity::HasFlexAnimation( void )
{
if ( m_pScene )
return m_pScene->HasFlexAnimation();
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
void CSceneEntity::SetBackground( bool bIsBackground )
{
if ( m_pScene )
{
m_pScene->SetBackground( bIsBackground );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSceneEntity::IsBackground( void )
{
if ( m_pScene )
return m_pScene->IsBackground( );
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::OnRestore()
{
BaseClass::OnRestore();
// Fix saved games that have their pitch set to zero
if ( m_fPitch < SCENE_MIN_PITCH || m_fPitch > SCENE_MAX_PITCH )
m_fPitch = 1.0f;
if ( !m_bIsPlayingBack )
return;
if ( !m_pScene )
{
m_pScene = LoadScene( STRING( m_iszSceneFile ), this );
if ( !m_pScene )
{
m_bSceneMissing = true;
return;
}
OnLoaded();
if ( ShouldNetwork() )
{
m_nSceneStringIndex = g_pStringTableClientSideChoreoScenes->AddString( CBaseEntity::IsServer(), STRING( m_iszSceneFile ) );
}
UpdateTransmitState();
}
m_bSceneMissing = false;
int i;
for ( i = 0 ; i < m_pScene->GetNumActors(); i++ )
{
CBaseFlex *pTestActor = FindNamedActor( i );
if ( !pTestActor )
continue;
if ( !pTestActor->MyCombatCharacterPointer() )
continue;
// Needed?
//if ( !pTestActor->MyCombatCharacterPointer()->IsAlive() )
// return;
pTestActor->StartChoreoScene( m_pScene );
}
float dt = SCENE_THINK_INTERVAL;
bool paused = m_bPaused;
m_bPaused = false;
// roll back slightly so that pause events still trigger
m_pScene->ResetSimulation( true, m_flCurrentTime - SCENE_THINK_INTERVAL, m_flCurrentTime );
m_pScene->SetTime( m_flCurrentTime - SCENE_THINK_INTERVAL );
SetCurrentTime( m_flCurrentTime, true );
// Robin: This causes a miscount of any interrupt events in the scene.
// All the variables are saved/restored properly, so we can safely leave them alone.
//ClearInterrupt();
SetRestoring( true );
DoThink( dt );
SetRestoring( false );
if ( paused )
{
PausePlayback();
}
NetworkProp()->NetworkStateForceUpdate();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CSceneEntity::SetRestoring( bool bRestoring )
{
m_bRestoring = bRestoring;
if ( m_pScene )
{
m_pScene->SetRestoring( bRestoring );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::Spawn( void )
{
Precache();
}
void CSceneEntity::PauseThink( void )
{
if ( !m_pScene )
return;
// Stay paused if pause occurred from interrupt
if ( m_bInterrupted )
return;
// If entity I/O paused the scene, then it'll have to resume/cancel the scene...
if ( m_bPausedViaInput )
{
// If we're waiting for a resume scene to finish, continue when it's done
if ( m_bWaitingForResumeScene && !m_hWaitingForThisResumeScene )
{
// Resume scene has finished, stop waiting for it
m_bWaitingForResumeScene = false;
}
else
{
return;
}
}
if ( !m_bAutomated )
{
// FIXME: Game code should check for AI waiting conditions being met, etc.
//
//
//
bool bAllFinished = m_pScene->CheckEventCompletion( );
if ( bAllFinished )
{
// Perform action
switch ( m_nAutomatedAction )
{
case SCENE_ACTION_RESUME:
ResumePlayback();
break;
case SCENE_ACTION_CANCEL:
LocalScene_Printf( "%s : PauseThink canceling playback\n", STRING( m_iszSceneFile ) );
CancelPlayback();
break;
default:
ResumePlayback();
break;
}
// Reset
m_bAutomated = false;
m_nAutomatedAction = SCENE_ACTION_UNKNOWN;
m_flAutomationTime = 0.0f;
m_flAutomationDelay = 0.0f;
m_bPausedViaInput = false;
}
return;
}
// Otherwise, see if resume/cancel is automatic and act accordingly if enough time
// has passed
m_flAutomationTime += (gpGlobals->frametime);
if ( m_flAutomationDelay > 0.0f &&
m_flAutomationTime < m_flAutomationDelay )
return;
// Perform action
switch ( m_nAutomatedAction )
{
case SCENE_ACTION_RESUME:
LocalScene_Printf( "%s : Automatically resuming playback\n", STRING( m_iszSceneFile ) );
ResumePlayback();
break;
case SCENE_ACTION_CANCEL:
LocalScene_Printf( "%s : Automatically canceling playback\n", STRING( m_iszSceneFile ) );
CancelPlayback();
break;
default:
LocalScene_Printf( "%s : Unknown action %i, automatically resuming playback\n", STRING( m_iszSceneFile ), m_nAutomatedAction );
ResumePlayback();
break;
}
// Reset
m_bAutomated = false;
m_nAutomatedAction = SCENE_ACTION_UNKNOWN;
m_flAutomationTime = 0.0f;
m_flAutomationDelay = 0.0f;
m_bPausedViaInput = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchPauseScene( CChoreoScene *scene, const char *parameters )
{
// Don't pause during restore, since we'll be restoring the pause state already
if ( m_bRestoring )
return;
// FIXME: Hook this up to AI, etc. somehow, perhaps poll each actor for conditions using
// scene resume condition iterator
PausePlayback();
char token[1024];
m_bPausedViaInput = false;
m_bAutomated = false;
m_nAutomatedAction = SCENE_ACTION_UNKNOWN;
m_flAutomationDelay = 0.0f;
m_flAutomationTime = 0.0f;
// Check for auto resume/cancel
const char *buffer = parameters;
buffer = engine->ParseFile( buffer, token, sizeof( token ) );
if ( !stricmp( token, "automate" ) )
{
buffer = engine->ParseFile( buffer, token, sizeof( token ) );
if ( !stricmp( token, "Cancel" ) )
{
m_nAutomatedAction = SCENE_ACTION_CANCEL;
}
else if ( !stricmp( token, "Resume" ) )
{
m_nAutomatedAction = SCENE_ACTION_RESUME;
}
if ( m_nAutomatedAction != SCENE_ACTION_UNKNOWN )
{
buffer = engine->ParseFile( buffer, token, sizeof( token ) );
m_flAutomationDelay = (float)atof( token );
if ( m_flAutomationDelay > 0.0f )
{
// Success
m_bAutomated = true;
m_flAutomationTime = 0.0f;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchProcessLoop( CChoreoScene *scene, CChoreoEvent *event )
{
// Don't restore this event since it's implied in the current "state" of the scene timer, etc.
if ( m_bRestoring )
return;
Assert( scene );
Assert( event->GetType() == CChoreoEvent::LOOP );
float backtime = (float)atof( event->GetParameters() );
bool process = true;
int counter = event->GetLoopCount();
if ( counter != -1 )
{
int remaining = event->GetNumLoopsRemaining();
if ( remaining <= 0 )
{
process = false;
}
else
{
event->SetNumLoopsRemaining( --remaining );
}
}
if ( !process )
return;
scene->LoopToTime( backtime );
SetCurrentTime( backtime, true );
}
//-----------------------------------------------------------------------------
// Purpose: Flag the scene as already "completed"
// Input : *scene -
// *parameters -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStopPoint( CChoreoScene *scene, const char *parameters )
{
if ( m_bCompletedEarly )
{
Assert( 0 );
Warning( "Scene '%s' with two stop point events!\n", STRING( m_iszSceneFile ) );
return;
}
// Fire completion trigger early
m_bCompletedEarly = true;
m_OnCompletion.FireOutput( this, this, 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSceneEntity::IsInterruptable()
{
return ( m_nInterruptCount > 0 ) ? true : false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *actor -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartInterrupt( CChoreoScene *scene, CChoreoEvent *event )
{
// Don't re-interrupt during restore
if ( m_bRestoring )
return;
// If we're supposed to cancel at our next interrupt point, cancel now
if ( m_bCancelAtNextInterrupt )
{
m_bCancelAtNextInterrupt = false;
LocalScene_Printf( "%s : cancelled via interrupt\n", STRING( m_iszSceneFile ) );
CancelPlayback();
return;
}
++m_nInterruptCount;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *actor -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchEndInterrupt( CChoreoScene *scene, CChoreoEvent *event )
{
// Don't re-interrupt during restore
if ( m_bRestoring )
return;
--m_nInterruptCount;
if ( m_nInterruptCount < 0 )
{
m_nInterruptCount = 0;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartExpression( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->AddSceneEvent( scene, event );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchEndExpression( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->RemoveSceneEvent( scene, event, false );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartFlexAnimation( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->AddSceneEvent( scene, event );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchEndFlexAnimation( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->RemoveSceneEvent( scene, event, false );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartGesture( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
// Ingore null gestures
if ( !Q_stricmp( event->GetName(), "NULL" ) )
return;
actor->AddSceneEvent( scene, event);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchEndGesture( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
// Ingore null gestures
if ( !Q_stricmp( event->GetName(), "NULL" ) )
return;
actor->RemoveSceneEvent( scene, event, m_bRestoring );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartGeneric( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
CBaseEntity *pTarget = FindNamedEntity( event->GetParameters2( ) );
actor->AddSceneEvent( scene, event, pTarget );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchEndGeneric( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->RemoveSceneEvent( scene, event, m_bRestoring );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *actor2 -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartLookAt( CChoreoScene *scene, CBaseFlex *actor, CBaseEntity *actor2, CChoreoEvent *event )
{
actor->AddSceneEvent( scene, event, actor2 );
}
void CSceneEntity::DispatchEndLookAt( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->RemoveSceneEvent( scene, event, m_bRestoring );
}
//-----------------------------------------------------------------------------
// Purpose: Move to spot/actor
// FIXME: Need to allow this to take arbitrary amount of time and pause playback
// while waiting for actor to move into position
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartMoveTo( CChoreoScene *scene, CBaseFlex *actor, CBaseEntity *actor2, CChoreoEvent *event )
{
actor->AddSceneEvent( scene, event, actor2 );
}
void CSceneEntity::DispatchEndMoveTo( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->RemoveSceneEvent( scene, event, m_bRestoring );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *token -
// listener -
// soundorigins -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool AttenuateCaption( const char *token, const Vector& listener, CUtlVector< Vector >& soundorigins )
{
if ( scene_maxcaptionradius.GetFloat() <= 0.0f )
{
return false;
}
int c = soundorigins.Count();
if ( c <= 0 )
{
return false;
}
float maxdistSqr = scene_maxcaptionradius.GetFloat() * scene_maxcaptionradius.GetFloat();
for ( int i = 0; i < c; ++i )
{
const Vector& org = soundorigins[ i ];
float distSqr = ( org - listener ).LengthSqr();
if ( distSqr <= maxdistSqr )
{
return false;
}
}
// All sound sources too far, don't show caption...
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event - which event
// player - which recipient
// buf, buflen: where to put the data
// Output : Returns true if the sound should be played/prefetched
//-----------------------------------------------------------------------------
bool CSceneEntity::GetSoundNameForPlayer( CChoreoEvent *event, CBasePlayer *player, char *buf, size_t buflen, CBaseEntity *pActor )
{
Assert( event );
Assert( player );
Assert( buf );
Assert( buflen > 0 );
bool ismasterevent = true;
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
bool validtoken = false;
tok[ 0 ] = 0;
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_SLAVE ||
event->GetCloseCaptionType() == CChoreoEvent::CC_DISABLED )
{
ismasterevent = false;
}
else
{
validtoken = event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) );
}
const char* pchToken = "";
if ( pActor && pActor->IsPlayer() )
{
pchToken = dynamic_cast< CBasePlayer* >( pActor )->GetSceneSoundToken();
}
// Copy the sound name
CopySoundNameWithModifierToken( buf, event->GetParameters(), buflen, pchToken );
bool usingEnglish = true;
if ( !IsXbox() )
{
char const *cvarvalue = engine->GetClientConVarValue( player->entindex(), "english" );
if ( cvarvalue && *cvarvalue && Q_atoi( cvarvalue ) != 1 )
{
usingEnglish = false;
}
}
// This makes it like they are running in another language
if ( scene_forcecombined.GetBool() )
{
usingEnglish = false;
}
if ( usingEnglish )
{
// English sounds always play
return true;
}
if ( ismasterevent )
{
// Master event sounds always play too (master will be the combined .wav)
if ( validtoken )
{
Q_strncpy( buf, tok, buflen );
}
return true;
}
// Slave events don't play any sound...
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Playback sound file that contains phonemes
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartSpeak( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event, soundlevel_t iSoundlevel )
{
// Emit sound
if ( actor )
{
CPASAttenuationFilter filter( actor );
if ( m_pRecipientFilter )
{
int filterCount = filter.GetRecipientCount();
int recipientPlayerCount = m_pRecipientFilter->GetRecipientCount();
for ( int i = filterCount-1; i >= 0; --i )
{
int playerindex = filter.GetRecipientIndex( i );
bool bFound = false;
for ( int j = 0; j < recipientPlayerCount; ++j )
{
if ( m_pRecipientFilter->GetRecipientIndex(j) == playerindex )
{
bFound = true;
break;
}
}
if ( !bFound )
{
filter.RemoveRecipientByPlayerIndex( playerindex );
}
}
}
float time_in_past = m_flCurrentTime - event->GetStartTime() ;
float soundtime = gpGlobals->curtime - time_in_past;
if ( m_bRestoring )
{
// Need to queue sounds on restore because the player has not yet connected
GetSceneManager()->QueueRestoredSound( actor, event->GetParameters(), iSoundlevel, time_in_past );
return;
}
// Add padding to prevent any other talker talking right after I'm done, because I might
// be continuing speaking with another scene.
float flDuration = event->GetDuration() - time_in_past;
CAI_BaseActor *pBaseActor = dynamic_cast<CAI_BaseActor*>(actor);
if ( pBaseActor )
{
pBaseActor->NoteSpeaking( flDuration, GetPostSpeakDelay() );
}
else if ( actor->IsNPC() )
{
GetSpeechSemaphore( actor->MyNPCPointer() )->Acquire( flDuration + GetPostSpeakDelay(), actor );
}
EmitSound_t es;
es.m_nChannel = CHAN_VOICE;
es.m_flVolume = 1;
es.m_SoundLevel = iSoundlevel;
// Only specify exact delay in single player
es.m_flSoundTime = ( gpGlobals->maxClients == 1 ) ? soundtime : 0.0f;
if ( scene->ShouldIgnorePhonemes() )
{
es.m_nFlags |= SND_IGNORE_PHONEMES;
}
if ( actor->GetSpecialDSP() != 0 )
{
es.m_nSpecialDSP = actor->GetSpecialDSP();
}
// No CC since we do it manually
// FIXME: This will change
es.m_bEmitCloseCaption = false;
int c = filter.GetRecipientCount();
for ( int i = 0; i < c; ++i )
{
int playerindex = filter.GetRecipientIndex( i );
CBasePlayer *player = UTIL_PlayerByIndex( playerindex );
if ( !player )
continue;
CSingleUserRecipientFilter filter2( player );
char soundname[ 512 ];
if ( !GetSoundNameForPlayer( event, player, soundname, sizeof( soundname ), actor ) )
{
continue;
}
es.m_pSoundName = soundname;
// keep track of the last few sounds played for bug reports
speechListSounds[ speechListIndex ].time = gpGlobals->curtime;
Q_strncpy( speechListSounds[ speechListIndex ].name, soundname, sizeof( speechListSounds[ 0 ].name ) );
Q_strncpy( speechListSounds[ speechListIndex ].sceneName, ( scene ) ? scene->GetFilename() : "", sizeof( speechListSounds[ 0 ].sceneName ) );
speechListIndex++;
if ( speechListIndex >= SPEECH_LIST_MAX_SOUNDS )
{
speechListIndex = 0;
}
// Warning( "Speak %s\n", soundname );
if ( m_fPitch != 1.0f )
{
if ( es.m_nPitch )
es.m_nPitch = static_cast<float>( es.m_nPitch ) * m_fPitch;
else
es.m_nPitch = 100.0f * m_fPitch;
es.m_nFlags |= SND_CHANGE_PITCH;
}
EmitSound( filter2, actor->entindex(), es );
actor->AddSceneEvent( scene, event );
}
// Close captioning only on master token no matter what...
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
{
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
bool validtoken = event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) );
if ( validtoken )
{
char lowercase[ 256 ];
Q_strncpy( lowercase, tok, sizeof( lowercase ) );
Q_strlower( lowercase );
// Remove any players who don't want close captions
CBaseEntity::RemoveRecipientsIfNotCloseCaptioning( filter );
// Certain events are marked "don't attenuate", (breencast), skip those here
if ( !event->IsSuppressingCaptionAttenuation() &&
( filter.GetRecipientCount() > 0 ) )
{
int c = filter.GetRecipientCount();
for ( int i = c - 1 ; i >= 0; --i )
{
CBasePlayer *player = UTIL_PlayerByIndex( filter.GetRecipientIndex( i ) );
if ( !player )
continue;
Vector playerOrigin = player->GetAbsOrigin();
if ( AttenuateCaption( lowercase, playerOrigin, es.m_UtlVecSoundOrigin ) )
{
// If the player has a view entity, measure the distance to that
if ( !player->GetViewEntity() || AttenuateCaption( lowercase, player->GetViewEntity()->GetAbsOrigin(), es.m_UtlVecSoundOrigin ) )
{
filter.RemoveRecipient( player );
}
}
}
}
// Anyone left?
if ( filter.GetRecipientCount() > 0 )
{
float endtime = event->GetLastSlaveEndTime();
float durationShort = event->GetDuration();
float durationLong = endtime - event->GetStartTime();
float duration = MAX( durationShort, durationLong );
byte byteflags = CLOSE_CAPTION_WARNIFMISSING; // warnifmissing
/*
// Never for .vcds...
if ( fromplayer )
{
byteflags |= CLOSE_CAPTION_FROMPLAYER;
}
*/
char const *pszActorModel = STRING( actor->GetModelName() );
gender_t gender = soundemitterbase->GetActorGender( pszActorModel );
if ( gender == GENDER_MALE )
{
byteflags |= CLOSE_CAPTION_GENDER_MALE;
}
else if ( gender == GENDER_FEMALE )
{
byteflags |= CLOSE_CAPTION_GENDER_FEMALE;
}
// Send caption and duration hint down to client
UserMessageBegin( filter, "CloseCaption" );
WRITE_STRING( lowercase );
WRITE_SHORT( MIN( 255, (int)( duration * 10.0f ) ) );
WRITE_BYTE( byteflags ); // warn on missing
MessageEnd();
}
}
}
}
}
void CSceneEntity::DispatchEndSpeak( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->RemoveSceneEvent( scene, event, m_bRestoring );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *actor2 -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartFace( CChoreoScene *scene, CBaseFlex *actor, CBaseEntity *actor2, CChoreoEvent *event )
{
actor->AddSceneEvent( scene, event, actor2 );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *actor2 -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchEndFace( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->RemoveSceneEvent( scene, event, m_bRestoring );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartSequence( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->AddSceneEvent( scene, event );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchEndSequence( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->RemoveSceneEvent( scene, event, m_bRestoring );
}
//-----------------------------------------------------------------------------
// Purpose: NPC can play interstitial vcds (such as responding to the player doing something during a scene)
// Input : *scene -
// *actor -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartPermitResponses( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->SetPermitResponse( gpGlobals->curtime + event->GetDuration() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *actor -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchEndPermitResponses( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
actor->SetPermitResponse( 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CSceneEntity::EstimateLength( void )
{
if ( !m_pScene )
{
return GetSceneDuration( STRING( m_iszSceneFile ) );
}
return m_pScene->FindStopTime();
}
//-----------------------------------------------------------------------------
// Purpose:
// NOTE: returns false if scene hasn't loaded yet
//-----------------------------------------------------------------------------
void CSceneEntity::CancelIfSceneInvolvesActor( CBaseEntity *pActor )
{
if ( InvolvesActor( pActor ) )
{
LocalScene_Printf( "%s : cancelled for '%s'\n", STRING( m_iszSceneFile ), pActor->GetDebugName() );
CancelPlayback();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// NOTE: returns false if scene hasn't loaded yet
//-----------------------------------------------------------------------------
bool CSceneEntity::InvolvesActor( CBaseEntity *pActor )
{
if ( !m_pScene )
return false;
int i;
for ( i = 0 ; i < m_pScene->GetNumActors(); i++ )
{
CBaseFlex *pTestActor = FindNamedActor( i );
if ( !pTestActor )
continue;
if ( pTestActor == pActor )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::DoThink( float frametime )
{
CheckInterruptCompletion();
if ( m_bWaitingForActor || m_bWaitingForInterrupt )
{
// Try to start playback.
StartPlayback();
}
if ( !m_pScene )
return;
if ( !m_bIsPlayingBack )
return;
// catch bad pitch shifting from old save games
Assert( m_fPitch >= SCENE_MIN_PITCH && m_fPitch <= SCENE_MAX_PITCH );
m_fPitch = clamp( m_fPitch, SCENE_MIN_PITCH, SCENE_MAX_PITCH );
if ( m_bPaused )
{
PauseThink();
return;
}
// Msg("%.2f %s\n", gpGlobals->curtime, STRING( m_iszSceneFile ) );
//Msg( "SV: %d, %f for %s\n", gpGlobals->tickcount, m_flCurrentTime, m_pScene->GetFilename() );
m_flFrameTime = frametime;
m_pScene->SetSoundFileStartupLatency( GetSoundSystemLatency() );
// Tell scene to go
m_pScene->Think( m_flCurrentTime );
// Did we get to the end
if ( !m_bPaused )
{
// Drive simulation time for scene
SetCurrentTime( m_flCurrentTime + m_flFrameTime * m_fPitch, false );
if ( m_pScene->SimulationFinished() )
{
OnSceneFinished( false, true );
// Stop them from doing anything special
ClearSchedules( m_pScene );
}
}
else
{
// Drive simulation time for scene
SetCurrentTime( m_pScene->GetTime(), true );
}
}
//-----------------------------------------------------------------------------
// Purpose: Input handlers
//-----------------------------------------------------------------------------
void CSceneEntity::InputStartPlayback( inputdata_t &inputdata )
{
// Already playing, ignore
if ( m_bIsPlayingBack )
return;
// Already waiting on someone.
if ( m_bWaitingForActor || m_bWaitingForInterrupt )
return;
ClearActivatorTargets();
m_hActivator = inputdata.pActivator;
StartPlayback();
}
void CSceneEntity::InputPausePlayback( inputdata_t &inputdata )
{
PausePlayback();
m_bPausedViaInput = true;
}
void CSceneEntity::InputResumePlayback( inputdata_t &inputdata )
{
ResumePlayback();
}
void CSceneEntity::InputCancelPlayback( inputdata_t &inputdata )
{
LocalScene_Printf( "%s : cancelled via input\n", STRING( m_iszSceneFile ) );
CancelPlayback();
}
void CSceneEntity::InputScriptPlayerDeath( inputdata_t &inputdata )
{
if ( m_iPlayerDeathBehavior == SCRIPT_CANCEL )
{
LocalScene_Printf( "%s : cancelled via player death\n", STRING( m_iszSceneFile ) );
CancelPlayback();
}
}
void CSceneEntity::InputCancelAtNextInterrupt( inputdata_t &inputdata )
{
// If we're currently in an interruptable point, interrupt immediately
if ( IsInterruptable() )
{
LocalScene_Printf( "%s : cancelled via input at interrupt point\n", STRING( m_iszSceneFile ) );
CancelPlayback();
return;
}
// Otherwise, cancel when we next hit an interrupt point
m_bCancelAtNextInterrupt = true;
}
void CSceneEntity::InputPitchShiftPlayback( inputdata_t &inputdata )
{
PitchShiftPlayback( inputdata.value.Float() );
}
void CSceneEntity::InputTriggerEvent( inputdata_t &inputdata )
{
CBaseEntity *pActivator = this; // at some point, find this from the inputdata
switch ( inputdata.value.Int() )
{
case 1:
m_OnTrigger1.FireOutput( pActivator, this, 0 );
break;
case 2:
m_OnTrigger2.FireOutput( pActivator, this, 0 );
break;
case 3:
m_OnTrigger3.FireOutput( pActivator, this, 0 );
break;
case 4:
m_OnTrigger4.FireOutput( pActivator, this, 0 );
break;
case 5:
m_OnTrigger5.FireOutput( pActivator, this, 0 );
break;
case 6:
m_OnTrigger6.FireOutput( pActivator, this, 0 );
break;
case 7:
m_OnTrigger7.FireOutput( pActivator, this, 0 );
break;
case 8:
m_OnTrigger8.FireOutput( pActivator, this, 0 );
break;
case 9:
m_OnTrigger9.FireOutput( pActivator, this, 0 );
break;
case 10:
m_OnTrigger10.FireOutput( pActivator, this, 0 );
break;
case 11:
m_OnTrigger11.FireOutput( pActivator, this, 0 );
break;
case 12:
m_OnTrigger12.FireOutput( pActivator, this, 0 );
break;
case 13:
m_OnTrigger13.FireOutput( pActivator, this, 0 );
break;
case 14:
m_OnTrigger14.FireOutput( pActivator, this, 0 );
break;
case 15:
m_OnTrigger15.FireOutput( pActivator, this, 0 );
break;
case 16:
m_OnTrigger16.FireOutput( pActivator, this, 0 );
break;
}
}
add source-sdk-2013
3 years ago
struct NPCInterjection
{
AI_Response *response;
CAI_BaseActor *npc;
};
1
5 years ago
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CSceneEntity::InputInterjectResponse( inputdata_t &inputdata )
{
// Not currently playing a scene
if ( !m_pScene )
add source-sdk-2013
3 years ago
{
1
5 years ago
return;
add source-sdk-2013
3 years ago
}
1
5 years ago
add source-sdk-2013
3 years ago
CUtlVector< CAI_BaseActor * > candidates;
int i;
for ( i = 0 ; i < m_pScene->GetNumActors(); i++ )
1
5 years ago
{
CBaseFlex *pTestActor = FindNamedActor( i );
if ( !pTestActor )
continue;
add source-sdk-2013
3 years ago
CAI_BaseActor *pBaseActor = dynamic_cast<CAI_BaseActor*>(pTestActor);
if ( !pBaseActor )
continue;
if ( !pBaseActor->IsAlive() )
1
5 years ago
continue;
candidates.AddToTail( pBaseActor );
}
int c = candidates.Count();
add source-sdk-2013
3 years ago
1
5 years ago
if ( !c )
add source-sdk-2013
3 years ago
{
1
5 years ago
return;
add source-sdk-2013
3 years ago
}
int useIndex = 0;
1
5 years ago
if ( !m_bIsPlayingBack )
{
// Use any actor if not playing a scene
add source-sdk-2013
3 years ago
useIndex = RandomInt( 0, c - 1 );
1
5 years ago
}
else
{
add source-sdk-2013
3 years ago
CUtlVector< NPCInterjection > validResponses;
1
5 years ago
add source-sdk-2013
3 years ago
char modifiers[ 512 ];
Q_snprintf( modifiers, sizeof( modifiers ), "scene:%s", STRING( GetEntityName() ) );
for ( int i = 0; i < c; i++ )
1
5 years ago
{
add source-sdk-2013
3 years ago
CAI_BaseActor *npc = candidates[ i ];
Assert( npc );
1
5 years ago
add source-sdk-2013
3 years ago
AI_Response *response = npc->SpeakFindResponse( inputdata.value.String(), modifiers );
if ( !response )
continue;
1
5 years ago
add source-sdk-2013
3 years ago
float duration = npc->GetResponseDuration( response );
// Couldn't look it up
if ( duration <= 0.0f )
continue;
if ( !npc->PermitResponse( duration ) )
1
5 years ago
{
add source-sdk-2013
3 years ago
delete response;
continue;
}
1
5 years ago
add source-sdk-2013
3 years ago
//
NPCInterjection inter;
inter.response = response;
inter.npc = npc;
validResponses.AddToTail( inter );
}
int rcount = validResponses.Count();
if ( rcount >= 1 )
{
int slot = RandomInt( 0, rcount - 1 );
for ( int i = 0; i < rcount; i++ )
{
NPCInterjection *pInterjection = &validResponses[ i ];
if ( i == slot )
1
5 years ago
{
add source-sdk-2013
3 years ago
pInterjection->npc->SpeakDispatchResponse( inputdata.value.String(), pInterjection->response );
}
else
{
delete pInterjection->response;
1
5 years ago
}
}
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CSceneEntity::InputStopWaitingForActor( inputdata_t &inputdata )
{
if( m_bIsPlayingBack )
{
// Already started.
return;
}
m_bWaitingForActor = false;
}
bool CSceneEntity::CheckActors()
{
Assert( m_pScene );
if ( !m_pScene )
return false;
int i;
for ( i = 0 ; i < m_pScene->GetNumActors(); i++ )
{
CBaseFlex *pTestActor = FindNamedActor( i );
if ( !pTestActor )
continue;
if ( !pTestActor->MyCombatCharacterPointer() )
continue;
if ( !pTestActor->MyCombatCharacterPointer()->IsAlive() )
return false;
if ( m_BusyActor == SCENE_BUSYACTOR_WAIT )
{
CAI_BaseNPC *pActor = pTestActor->MyNPCPointer();
if ( pActor )
{
bool bShouldWait = false;
if ( hl2_episodic.GetBool() )
{
// Episodic waits until the NPC is fully finished with any .vcd with speech in it
if ( IsRunningScriptedSceneWithSpeech( pActor ) )
{
bShouldWait = true;
}
#ifdef HL2_EPISODIC
// HACK: Alyx cannot play scenes when she's in the middle of transitioning
if ( pActor->IsInAVehicle() )
{
CNPC_Alyx *pAlyx = dynamic_cast<CNPC_Alyx *>(pActor);
if ( pAlyx != NULL && ( pAlyx->GetPassengerState() == PASSENGER_STATE_ENTERING || pAlyx->GetPassengerState() == PASSENGER_STATE_EXITING ) )
{
bShouldWait = true;
}
}
#endif // HL2_EPISODIC
}
if ( pActor->GetExpresser() && pActor->GetExpresser()->IsSpeaking() )
{
bShouldWait = true;
}
if ( bShouldWait )
{
// One of the actors for this scene is talking already.
// Try again next think.
m_bWaitingForActor = true;
return false;
}
}
}
else if ( m_BusyActor == SCENE_BUSYACTOR_INTERRUPT || m_BusyActor == SCENE_BUSYACTOR_INTERRUPT_CANCEL )
{
CBaseCombatCharacter *pActor = pTestActor->MyCombatCharacterPointer();
if ( pActor && !IsInInterruptableScenes( pActor ) )
{
// One of the actors is in a scene that's not at an interrupt point.
// Wait until the scene finishes or an interrupt point is reached.
m_bWaitingForInterrupt = true;
return false;
}
if ( m_BusyActor == SCENE_BUSYACTOR_INTERRUPT_CANCEL )
{
// Cancel existing scenes
RemoveActorFromScriptedScenes( pActor, false );
}
else
{
// Pause existing scenes
PauseActorsScriptedScenes( pActor, false );
m_bInterruptedActorsScenes = true;
}
}
pTestActor->StartChoreoScene( m_pScene );
}
return true;
}
#if !defined( _RETAIL )
static ConVar scene_async_prefetch_spew( "scene_async_prefetch_spew", "0", 0, "Display async .ani file loading info." );
#endif
void CSceneEntity::PrefetchAnimBlocks( CChoreoScene *scene )
{
Assert( scene );
// Build a fast lookup, too
CUtlMap< CChoreoActor *, CBaseFlex *> actorMap( 0, 0, DefLessFunc( CChoreoActor * ) );
int spew =
#if !defined( _RETAIL )
scene_async_prefetch_spew.GetInt();
#else
0;
#endif
int resident = 0;
int checked = 0;
// Iterate events and precache necessary resources
for ( int i = 0; i < scene->GetNumEvents(); i++ )
{
CChoreoEvent *event = scene->GetEvent( i );
if ( !event )
continue;
// load any necessary data
switch ( event->GetType() )
{
default:
break;
case CChoreoEvent::SEQUENCE:
case CChoreoEvent::GESTURE:
{
CChoreoActor *actor = event->GetActor();
if ( actor )
{
CBaseFlex *pActor = NULL;
int idx = actorMap.Find( actor );
if ( idx == actorMap.InvalidIndex() )
{
pActor = FindNamedActor( actor );
idx = actorMap.Insert( actor, pActor );
}
else
{
pActor = actorMap[ idx ];
}
if ( pActor )
{
int seq = pActor->LookupSequence( event->GetParameters() );
if ( seq >= 0 )
{
CStudioHdr *pStudioHdr = pActor->GetModelPtr();
if ( pStudioHdr )
{
// Now look up the animblock
mstudioseqdesc_t &seqdesc = pStudioHdr->pSeqdesc( seq );
for ( int i = 0 ; i < seqdesc.groupsize[ 0 ] ; ++i )
{
for ( int j = 0; j < seqdesc.groupsize[ 1 ]; ++j )
{
int animation = seqdesc.anim( i, j );
int baseanimation = pStudioHdr->iRelativeAnim( seq, animation );
mstudioanimdesc_t &animdesc = pStudioHdr->pAnimdesc( baseanimation );
++checked;
if ( spew != 0 )
{
Msg( "%s checking block %d\n", pStudioHdr->pszName(), animdesc.animblock );
}
// Async load the animation
int iFrame = 0;
const mstudioanim_t *panim = animdesc.pAnim( &iFrame );
if ( panim )
{
++resident;
if ( spew > 1 )
{
Msg( "%s:%s[%i:%i] was resident\n", pStudioHdr->pszName(), animdesc.pszName(), i, j );
}
}
else
{
if ( spew != 0 )
{
Msg( "%s:%s[%i:%i] async load\n", pStudioHdr->pszName(), animdesc.pszName(), i, j );
}
}
}
}
}
}
}
}
}
break;
}
}
if ( !spew || checked <= 0 )
return;
Msg( "%d of %d animations resident\n", resident, checked );
}
void CSceneEntity::OnLoaded()
{
// Nothing
}
//-----------------------------------------------------------------------------
// Purpose: Initiate scene playback
//-----------------------------------------------------------------------------
void CSceneEntity::StartPlayback( void )
{
if ( !m_pScene )
{
if ( m_bSceneMissing )
return;
m_pScene = LoadScene( STRING( m_iszSceneFile ), this );
if ( !m_pScene )
{
DevMsg( "%s missing from scenes.image\n", STRING( m_iszSceneFile ) );
m_bSceneMissing = true;
return;
}
OnLoaded();
if ( ShouldNetwork() )
{
m_nSceneStringIndex = g_pStringTableClientSideChoreoScenes->AddString( CBaseEntity::IsServer(), STRING( m_iszSceneFile ) );
}
UpdateTransmitState();
}
if ( m_bIsPlayingBack )
return;
// Make sure actors are alive and able to handle this scene now, otherwise
// we'll wait for them to show up
if ( !CheckActors() )
{
return;
}
m_bCompletedEarly = false;
m_bWaitingForActor = false;
m_bWaitingForInterrupt = false;
m_bIsPlayingBack = true;
NetworkProp()->NetworkStateForceUpdate();
m_bPaused = false;
SetCurrentTime( 0.0f, true );
m_pScene->ResetSimulation();
ClearInterrupt();
// Put face back in neutral pose
ClearSceneEvents( m_pScene, false );
m_OnStart.FireOutput( this, this, 0 );
// Aysnchronously load speak sounds
CUtlSymbolTable prefetchSoundSymbolTable;
CUtlRBTree< SpeakEventSound_t > soundnames( 0, 0, SpeakEventSoundLessFunc );
BuildSortedSpeakEventSoundsPrefetchList( m_pScene, prefetchSoundSymbolTable, soundnames, 0.0f );
PrefetchSpeakEventSounds( prefetchSoundSymbolTable, soundnames );
// Tell any managers we're within that we've started
int c = m_hListManagers.Count();
for ( int i = 0; i < c; i++ )
{
if ( m_hListManagers[i] )
{
m_hListManagers[i]->SceneStarted( this );
}
}
PrefetchAnimBlocks( m_pScene );
}
//-----------------------------------------------------------------------------
// Purpose: Static method used to sort by event start time
//-----------------------------------------------------------------------------
bool CSceneEntity::SpeakEventSoundLessFunc( const SpeakEventSound_t& lhs, const SpeakEventSound_t& rhs )
{
return lhs.m_flStartTime < rhs.m_flStartTime;
}
//-----------------------------------------------------------------------------
// Purpose: Prefetches the list of sounds build by BuildSortedSpeakEventSoundsPrefetchList
//-----------------------------------------------------------------------------
void CSceneEntity::PrefetchSpeakEventSounds( CUtlSymbolTable& table, CUtlRBTree< SpeakEventSound_t >& soundnames )
{
for ( int i = soundnames.FirstInorder(); i != soundnames.InvalidIndex() ; i = soundnames.NextInorder( i ) )
{
SpeakEventSound_t& sound = soundnames[ i ];
// Look it up in the string table
char const *soundname = table.String( sound.m_Symbol );
// Warning( "Prefetch %s\n", soundname );
PrefetchScriptSound( soundname );
}
}
//-----------------------------------------------------------------------------
// Purpose: Builds list of sounds sorted by start time for prefetching
//-----------------------------------------------------------------------------
void CSceneEntity::BuildSortedSpeakEventSoundsPrefetchList(
CChoreoScene *scene,
CUtlSymbolTable& table,
CUtlRBTree< SpeakEventSound_t >& soundnames,
float timeOffset )
{
Assert( scene );
// Iterate events and precache necessary resources
for ( int i = 0; i < scene->GetNumEvents(); i++ )
{
CChoreoEvent *event = scene->GetEvent( i );
if ( !event )
continue;
// load any necessary data
switch (event->GetType() )
{
default:
break;
case CChoreoEvent::SPEAK:
{
// NOTE: The script entries associated with .vcds are forced to preload to avoid
// loading hitches during triggering
char soundname[ CChoreoEvent::MAX_CCTOKEN_STRING ];
Q_strncpy( soundname, event->GetParameters(), sizeof( soundname ) );
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
{
event->GetPlaybackCloseCaptionToken( soundname, sizeof( soundname ) );
}
// In single player, try to use the combined or regular .wav files as needed
if ( gpGlobals->maxClients == 1 )
{
CBasePlayer *player = UTIL_GetLocalPlayer();
if ( player && !GetSoundNameForPlayer( event, player, soundname, sizeof( soundname ), player ) )
{
// Skip to next event
continue;
}
}
/*
else
{
// UNDONE: Probably need some other solution in multiplayer... (not sure how to "prefetch" on certain players
// with one sound, but not prefetch the same sound for others...)
}
*/
SpeakEventSound_t ses;
ses.m_Symbol = table.AddString( soundname );
ses.m_flStartTime = timeOffset + event->GetStartTime();
soundnames.Insert( ses );
}
break;
case CChoreoEvent::SUBSCENE:
{
// Only allow a single level of subscenes for now
if ( !scene->IsSubScene() )
{
CChoreoScene *subscene = event->GetSubScene();
if ( !subscene )
{
subscene = LoadScene( event->GetParameters(), this );
subscene->SetSubScene( true );
event->SetSubScene( subscene );
// Now precache it's resources, if any
BuildSortedSpeakEventSoundsPrefetchList( subscene, table, soundnames, event->GetStartTime() );
}
}
}
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::PausePlayback( void )
{
if ( !m_bIsPlayingBack )
return;
if ( m_bPaused )
return;
m_bPaused = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::ResumePlayback( void )
{
if ( !m_bIsPlayingBack )
return;
if ( !m_bPaused )
return;
Assert( m_pScene );
if ( !m_pScene )
{
// This should never happen!!!!
return;
}
// FIXME: Iterate using m_pScene->IterateResumeConditionEvents and
// only resume if the event conditions have all been satisfied
// FIXME: Just resume for now
m_pScene->ResumeSimulation();
m_bPaused = false;
m_bPausedViaInput = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::CancelPlayback( void )
{
if ( !m_bIsPlayingBack )
return;
m_bIsPlayingBack = false;
m_bPaused = false;
m_OnCanceled.FireOutput( this, this, 0 );
LocalScene_Printf( "%s : %8.2f: canceled\n", STRING( m_iszSceneFile ), m_flCurrentTime );
OnSceneFinished( true, false );
}
void CSceneEntity::PitchShiftPlayback( float fPitch )
{
fPitch = clamp( fPitch, SCENE_MIN_PITCH, SCENE_MAX_PITCH );
m_fPitch = fPitch;
if ( !m_pScene )
return;
for ( int iActor = 0 ; iActor < m_pScene->GetNumActors(); ++iActor )
{
CBaseFlex *pTestActor = FindNamedActor( iActor );
if ( !pTestActor )
continue;
char szBuff[ 256 ];
if ( m_pScene->GetPlayingSoundName( szBuff, sizeof( szBuff ) ) )
{
CPASAttenuationFilter filter( pTestActor );
EmitSound_t params;
params.m_pSoundName = szBuff;
params.m_nPitch = 100.0f * fPitch;
params.m_nFlags = SND_CHANGE_PITCH;
pTestActor->EmitSound( filter, pTestActor->entindex(), params );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Start a resume scene, if we have one, and resume playing when it finishes
//-----------------------------------------------------------------------------
void CSceneEntity::QueueResumePlayback( void )
{
// Do we have a resume scene?
if ( m_iszResumeSceneFile != NULL_STRING )
{
bool bStartedScene = false;
// If it has ".vcd" somewhere in the string, try using it as a scene file first
if ( Q_stristr( STRING(m_iszResumeSceneFile), ".vcd" ) )
{
bStartedScene = InstancedScriptedScene( NULL, STRING(m_iszResumeSceneFile), &m_hWaitingForThisResumeScene, 0, false ) != 0;
}
// HACKHACK: For now, get the first target, and see if we can find a response for him
if ( !bStartedScene )
{
CBaseFlex *pActor = FindNamedActor( 0 );
if ( pActor )
{
CAI_BaseActor *pBaseActor = dynamic_cast<CAI_BaseActor*>(pActor);
if ( pBaseActor )
{
add source-sdk-2013
3 years ago
AI_Response *result = pBaseActor->SpeakFindResponse( STRING(m_iszResumeSceneFile), NULL );
1
5 years ago
if ( result )
{
add source-sdk-2013
3 years ago
char response[ 256 ];
result->GetResponse( response, sizeof( response ) );
bStartedScene = InstancedScriptedScene( NULL, response, &m_hWaitingForThisResumeScene, 0, false ) != 0;
1
5 years ago
}
}
}
}
// If we started a scene/response, wait for it to finish
if ( bStartedScene )
{
m_bWaitingForResumeScene = true;
}
else
{
// Failed to create the scene. Resume immediately.
ResumePlayback();
}
}
else
{
// No resume scene, so just resume immediately
ResumePlayback();
}
}
//-----------------------------------------------------------------------------
// Purpose: Query whether the scene actually loaded. Only meaninful after Spawn()
//-----------------------------------------------------------------------------
bool CSceneEntity::ValidScene() const
{
return ( m_pScene != NULL );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pActor -
// *scene -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::DispatchStartSubScene( CChoreoScene *scene, CBaseFlex *pActor, CChoreoEvent *event)
{
if ( !scene->IsSubScene() )
{
CChoreoScene *subscene = event->GetSubScene();
if ( !subscene )
{
Assert( 0 );
/*
subscene = LoadScene( event->GetParameters() );
subscene->SetSubScene( true );
event->SetSubScene( subscene );
*/
}
if ( subscene )
{
subscene->ResetSimulation();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: All events are leading edge triggered
// Input : currenttime -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::StartEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event );
if ( !Q_stricmp( event->GetName(), "NULL" ) )
{
LocalScene_Printf( "%s : %8.2f: ignored %s\n", STRING( m_iszSceneFile ), currenttime, event->GetDescription() );
return;
}
CBaseFlex *pActor = NULL;
CChoreoActor *actor = event->GetActor();
if ( actor )
{
pActor = FindNamedActor( actor );
if (pActor == NULL)
{
Warning( "CSceneEntity %s unable to find actor named \"%s\"\n", STRING(GetEntityName()), actor->GetName() );
return;
}
}
LocalScene_Printf( "%s : %8.2f: start %s\n", STRING( m_iszSceneFile ), currenttime, event->GetDescription() );
switch ( event->GetType() )
{
case CChoreoEvent::SUBSCENE:
{
if ( pActor && !IsMultiplayer() )
{
DispatchStartSubScene( scene, pActor, event );
}
}
break;
case CChoreoEvent::EXPRESSION:
{
if ( pActor && !IsMultiplayer() )
{
DispatchStartExpression( scene, pActor, event );
}
}
break;
case CChoreoEvent::FLEXANIMATION:
{
if ( pActor && !IsMultiplayer() )
{
DispatchStartFlexAnimation( scene, pActor, event );
}
}
break;
case CChoreoEvent::LOOKAT:
{
if ( pActor && !IsMultiplayer() )
{
CBaseEntity *pActor2 = FindNamedEntity( event->GetParameters( ), pActor );
if ( pActor2 )
{
// Huh?
DispatchStartLookAt( scene, pActor, pActor2, event );
}
else
{
Warning( "CSceneEntity %s unable to find actor named \"%s\"\n", STRING(GetEntityName()), event->GetParameters() );
}
}
}
break;
case CChoreoEvent::SPEAK:
{
if ( pActor )
{
// Speaking is edge triggered
// FIXME: dB hack. soundlevel needs to be moved into inside of wav?
soundlevel_t iSoundlevel = SNDLVL_TALKING;
if (event->GetParameters2())
{
iSoundlevel = (soundlevel_t)atoi( event->GetParameters2() );
if (iSoundlevel == SNDLVL_NONE)
iSoundlevel = SNDLVL_TALKING;
}
DispatchStartSpeak( scene, pActor, event, iSoundlevel );
}
}
break;
case CChoreoEvent::MOVETO:
{
// FIXME: make sure moveto's aren't edge triggered
if ( !event->HasEndTime() )
{
event->SetEndTime( event->GetStartTime() + 1.0 );
}
if ( pActor && !IsMultiplayer() )
{
CBaseEntity *pActor2 = NULL;
if ( event->GetParameters3( ) && strlen( event->GetParameters3( ) ) > 0 )
{
pActor2 = FindNamedEntityClosest( event->GetParameters( ), pActor, false, true, event->GetParameters3( ) );
}
else
{
pActor2 = FindNamedEntity( event->GetParameters( ), pActor, false, true );
}
if ( pActor2 )
{
DispatchStartMoveTo( scene, pActor, pActor2, event );
}
else
{
Warning( "CSceneEntity %s unable to find actor named \"%s\"\n", STRING(GetEntityName()), event->GetParameters() );
}
}
}
break;
case CChoreoEvent::FACE:
{
if ( pActor && !IsMultiplayer() )
{
CBaseEntity *pActor2 = FindNamedEntity( event->GetParameters( ), pActor );
if ( pActor2 )
{
DispatchStartFace( scene, pActor, pActor2, event );
}
else
{
Warning( "CSceneEntity %s unable to find actor named \"%s\"\n", STRING(GetEntityName()), event->GetParameters() );
}
}
}
break;
case CChoreoEvent::GESTURE:
{
if ( pActor )
{
DispatchStartGesture( scene, pActor, event );
}
}
break;
case CChoreoEvent::GENERIC:
{
// If the first token in the parameters is "debugtext", print the rest of the text
if ( event->GetParameters() && !Q_strncmp( event->GetParameters(), "debugtext", 9 ) )
{
const char *pszText = event->GetParameters() + 10;
hudtextparms_s tTextParam;
tTextParam.x = -1;
tTextParam.y = 0.65;
tTextParam.effect = 0;
tTextParam.r1 = 255;
tTextParam.g1 = 170;
tTextParam.b1 = 0;
tTextParam.a1 = 255;
tTextParam.r2 = 255;
tTextParam.g2 = 170;
tTextParam.b2 = 0;
tTextParam.a2 = 255;
tTextParam.fadeinTime = 0;
tTextParam.fadeoutTime = 0;
tTextParam.holdTime = 3.1;
tTextParam.fxTime = 0;
tTextParam.channel = 1;
UTIL_HudMessageAll( tTextParam, pszText );
break;
}
if ( pActor )
{
DispatchStartGeneric( scene, pActor, event );
}
}
break;
case CChoreoEvent::FIRETRIGGER:
{
if ( IsMultiplayer() )
break;
// Don't re-fire triggers during restore, the entities should already reflect all such state...
if ( m_bRestoring )
{
break;
}
CBaseEntity *pActivator = pActor;
if (!pActivator)
{
pActivator = this;
}
// FIXME: how do I decide who fired it??
switch( atoi( event->GetParameters() ) )
{
case 1:
m_OnTrigger1.FireOutput( pActivator, this, 0 );
break;
case 2:
m_OnTrigger2.FireOutput( pActivator, this, 0 );
break;
case 3:
m_OnTrigger3.FireOutput( pActivator, this, 0 );
break;
case 4:
m_OnTrigger4.FireOutput( pActivator, this, 0 );
break;
case 5:
m_OnTrigger5.FireOutput( pActivator, this, 0 );
break;
case 6:
m_OnTrigger6.FireOutput( pActivator, this, 0 );
break;
case 7:
m_OnTrigger7.FireOutput( pActivator, this, 0 );
break;
case 8:
m_OnTrigger8.FireOutput( pActivator, this, 0 );
break;
case 9:
m_OnTrigger9.FireOutput( pActivator, this, 0 );
break;
case 10:
m_OnTrigger10.FireOutput( pActivator, this, 0 );
break;
case 11:
m_OnTrigger11.FireOutput( pActivator, this, 0 );
break;
case 12:
m_OnTrigger12.FireOutput( pActivator, this, 0 );
break;
case 13:
m_OnTrigger13.FireOutput( pActivator, this, 0 );
break;
case 14:
m_OnTrigger14.FireOutput( pActivator, this, 0 );
break;
case 15:
m_OnTrigger15.FireOutput( pActivator, this, 0 );
break;
case 16:
m_OnTrigger16.FireOutput( pActivator, this, 0 );
break;
}
}
break;
case CChoreoEvent::SEQUENCE:
{
if ( pActor )
{
DispatchStartSequence( scene, pActor, event );
}
}
break;
case CChoreoEvent::SECTION:
{
if ( IsMultiplayer() )
break;
// Pauses scene playback
DispatchPauseScene( scene, event->GetParameters() );
}
break;
case CChoreoEvent::LOOP:
{
DispatchProcessLoop( scene, event );
}
break;
case CChoreoEvent::INTERRUPT:
{
if ( IsMultiplayer() )
break;
DispatchStartInterrupt( scene, event );
}
break;
case CChoreoEvent::STOPPOINT:
{
if ( IsMultiplayer() )
break;
DispatchStopPoint( scene, event->GetParameters() );
}
break;
case CChoreoEvent::PERMIT_RESPONSES:
{
if ( IsMultiplayer() )
break;
DispatchStartPermitResponses( scene, pActor, event );
}
break;
default:
{
// FIXME: Unhandeled event
// Assert(0);
}
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : currenttime -
// *event -
//-----------------------------------------------------------------------------
void CSceneEntity::EndEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event );
if ( !Q_stricmp( event->GetName(), "NULL" ) )
{
return;
}
CBaseFlex *pActor = NULL;
CChoreoActor *actor = event->GetActor();
if ( actor )
{
pActor = FindNamedActor( actor );
}
LocalScene_Printf( "%s : %8.2f: finish %s\n", STRING( m_iszSceneFile ), currenttime, event->GetDescription() );
switch ( event->GetType() )
{
case CChoreoEvent::EXPRESSION:
{
if ( pActor && !IsMultiplayer() )
{
DispatchEndExpression( scene, pActor, event );
}
}
break;
case CChoreoEvent::SPEAK:
{
if ( pActor )
{
DispatchEndSpeak( scene, pActor, event );
}
}
break;
case CChoreoEvent::FLEXANIMATION:
{
if ( pActor && !IsMultiplayer() )
{
DispatchEndFlexAnimation( scene, pActor, event );
}
}
break;
case CChoreoEvent::LOOKAT:
{
if ( pActor && !IsMultiplayer() )
{
DispatchEndLookAt( scene, pActor, event );
}
}
break;
case CChoreoEvent::GESTURE:
{
if ( pActor )
{
DispatchEndGesture( scene, pActor, event );
}
}
break;
case CChoreoEvent::GENERIC:
{
// If the first token in the parameters is "debugtext", we printed it and we're done
if ( event->GetParameters() && !Q_strncmp( event->GetParameters(), "debugtext", 9 ) )
break;
if ( pActor )
{
DispatchEndGeneric( scene, pActor, event );
}
}
break;
case CChoreoEvent::SEQUENCE:
{
if ( pActor )
{
DispatchEndSequence( scene, pActor, event );
}
}
break;
case CChoreoEvent::FACE:
{
if ( pActor && !IsMultiplayer() )
{
DispatchEndFace( scene, pActor, event );
}
}
break;
case CChoreoEvent::MOVETO:
{
if ( pActor && !IsMultiplayer() )
{
DispatchEndMoveTo( scene, pActor, event );
}
}
break;
case CChoreoEvent::SUBSCENE:
{
if ( IsMultiplayer() )
break;
CChoreoScene *subscene = event->GetSubScene();
if ( subscene )
{
subscene->ResetSimulation();
}
}
break;
case CChoreoEvent::INTERRUPT:
{
if ( IsMultiplayer() )
break;
DispatchEndInterrupt( scene, event );
}
break;
case CChoreoEvent::PERMIT_RESPONSES:
{
if ( IsMultiplayer() )
break;
DispatchEndPermitResponses( scene, pActor, event );
}
break;
default:
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Only spew one time per missing scene!!!
// Input : *scenename -
//-----------------------------------------------------------------------------
void MissingSceneWarning( char const *scenename )
{
static CUtlSymbolTable missing;
// Make sure we only show the message once
if ( UTL_INVAL_SYMBOL == missing.Find( scenename ) )
{
missing.AddString( scenename );
Warning( "Scene '%s' missing!\n", scenename );
}
}
bool CSceneEntity::ShouldNetwork() const
{
if ( m_bMultiplayer )
{
if ( m_pScene &&
( m_pScene->HasEventsOfType( CChoreoEvent::FLEXANIMATION ) ||
m_pScene->HasEventsOfType( CChoreoEvent::EXPRESSION )||
m_pScene->HasEventsOfType( CChoreoEvent::GESTURE ) ||
m_pScene->HasEventsOfType( CChoreoEvent::SEQUENCE ) ) )
{
return true;
}
}
else
{
if ( m_pScene &&
( m_pScene->HasEventsOfType( CChoreoEvent::FLEXANIMATION ) ||
m_pScene->HasEventsOfType( CChoreoEvent::EXPRESSION ) ) )
{
return true;
}
}
return false;
}
CChoreoScene *CSceneEntity::LoadScene( const char *filename, IChoreoEventCallback *pCallback )
{
DevMsg( 2, "Blocking load of scene from '%s'\n", filename );
char loadfile[MAX_PATH];
Q_strncpy( loadfile, filename, sizeof( loadfile ) );
Q_SetExtension( loadfile, ".vcd", sizeof( loadfile ) );
Q_FixSlashes( loadfile );
// binary compiled vcd
void *pBuffer;
int fileSize;
if ( !CopySceneFileIntoMemory( loadfile, &pBuffer, &fileSize ) )
{
MissingSceneWarning( loadfile );
return NULL;
}
CChoreoScene *pScene = new CChoreoScene( NULL );
CUtlBuffer buf( pBuffer, fileSize, CUtlBuffer::READ_ONLY );
if ( !pScene->RestoreFromBinaryBuffer( buf, loadfile, &g_ChoreoStringPool ) )
{
Warning( "CSceneEntity::LoadScene: Unable to load binary scene '%s'\n", loadfile );
delete pScene;
pScene = NULL;
}
else
{
pScene->SetPrintFunc( LocalScene_Printf );
pScene->SetEventCallbackInterface( pCallback );
}
FreeSceneFileMemory( pBuffer );
return pScene;
}
CChoreoScene *BlockingLoadScene( const char *filename )
{
return CSceneEntity::LoadScene( filename, NULL );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::UnloadScene( void )
{
if ( m_pScene )
{
ClearSceneEvents( m_pScene, false );
for ( int i = 0 ; i < m_pScene->GetNumActors(); i++ )
{
CBaseFlex *pTestActor = FindNamedActor( i );
if ( !pTestActor )
continue;
pTestActor->RemoveChoreoScene( m_pScene );
}
}
delete m_pScene;
m_pScene = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Called every frame that an event is active (Start/EndEvent as also
// called)
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CSceneEntity::ProcessEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
switch ( event->GetType() )
{
case CChoreoEvent::SUBSCENE:
{
Assert( event->GetType() == CChoreoEvent::SUBSCENE );
CChoreoScene *subscene = event->GetSubScene();
if ( !subscene )
return;
if ( subscene->SimulationFinished() )
return;
// Have subscenes think for appropriate time
subscene->Think( m_flFrameTime );
}
break;
default:
break;
}
return;
}
//-----------------------------------------------------------------------------
// Purpose: Called for events that are part of a pause condition
// Input : *event -
// Output : Returns true on event completed, false on non-completion.
//-----------------------------------------------------------------------------
bool CSceneEntity::CheckEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
switch ( event->GetType() )
{
case CChoreoEvent::SUBSCENE:
{
}
break;
default:
{
CBaseFlex *pActor = NULL;
CChoreoActor *actor = event->GetActor();
if ( actor )
{
pActor = FindNamedActor( actor );
if (pActor == NULL)
{
Warning( "CSceneEntity %s unable to find actor \"%s\"\n", STRING(GetEntityName()), actor->GetName() );
return true;
}
}
if (pActor)
{
return pActor->CheckSceneEvent( currenttime, scene, event );
}
}
break;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Get a sticky version of a named actor
// Input : CChoreoActor
// Output : CBaseFlex
//-----------------------------------------------------------------------------
CBaseFlex *CSceneEntity::FindNamedActor( int index )
{
if (m_hActorList.Count() == 0)
{
m_hActorList.SetCount( m_pScene->GetNumActors() );
NetworkProp()->NetworkStateForceUpdate();
}
if ( !m_hActorList.IsValidIndex( index ) )
{
DevWarning( "Scene %s has %d actors, but scene entity only has %d actors\n", m_pScene->GetFilename(), m_pScene->GetNumActors(), m_hActorList.Size() );
return NULL;
}
CBaseFlex *pActor = m_hActorList[ index ];
if (pActor == NULL || !pActor->IsAlive() )
{
CChoreoActor *pChoreoActor = m_pScene->GetActor( index );
if ( !pChoreoActor )
return NULL;
pActor = FindNamedActor( pChoreoActor->GetName() );
if (pActor)
{
// save who we found so we'll use them again
m_hActorList[ index ] = pActor;
NetworkProp()->NetworkStateForceUpdate();
}
}
return pActor;
}
//-----------------------------------------------------------------------------
// Purpose: Get a sticky version of a named actor
// Input : CChoreoActor
// Output : CBaseFlex
//-----------------------------------------------------------------------------
CBaseFlex *CSceneEntity::FindNamedActor( CChoreoActor *pChoreoActor )
{
int index = m_pScene->FindActorIndex( pChoreoActor );
if (index >= 0)
{
return FindNamedActor( index );
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Search for an actor by name, make sure it can do face poses
// Input : *name -
// Output : CBaseFlex
//-----------------------------------------------------------------------------
CBaseFlex *CSceneEntity::FindNamedActor( const char *name )
{
CBaseEntity *entity = FindNamedEntity( name, NULL, true );
if ( !entity )
{
// Couldn't find actor!
return NULL;
}
// Make sure it can actually do facial animation, etc.
CBaseFlex *flexEntity = dynamic_cast< CBaseFlex * >( entity );
if ( !flexEntity )
{
// That actor was not a CBaseFlex!
return NULL;
}
return flexEntity;
}
//-----------------------------------------------------------------------------
// Purpose: Find an entity specified by a target name
// Input : *name -
// Output : CBaseEntity
//-----------------------------------------------------------------------------
CBaseEntity *CSceneEntity::FindNamedTarget( string_t iszTarget, bool bBaseFlexOnly )
{
if ( !stricmp( STRING(iszTarget), "!activator" ) )
return m_hActivator;
// If we don't have a wildcard in the target, just return the first entity found
if ( !strchr( STRING(iszTarget), '*' ) )
return gEntList.FindEntityByName( NULL, iszTarget );
CBaseEntity *pTarget = NULL;
while ( (pTarget = gEntList.FindEntityByName( pTarget, iszTarget )) != NULL )
{
if ( bBaseFlexOnly )
{
// Make sure it can actually do facial animation, etc.
if ( dynamic_cast< CBaseFlex * >( pTarget ) )
return pTarget;
}
else
{
return pTarget;
}
}
// Failed to find one
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Filters entities only if they're clear
//-----------------------------------------------------------------------------
class CSceneFindMarkFilter : public IEntityFindFilter
{
public:
void SetActor( CBaseEntity *pActor )
{
m_hActor = pActor;
}
bool ShouldFindEntity( CBaseEntity *pEntity )
{
if ( !m_hActor )
return true;
// If we find no truly valid marks, we'll just use the first.
if ( !m_hEntityFound.Get() )
{
m_hEntityFound = pEntity;
}
// We only want marks that are clear
trace_t tr;
Vector vecOrigin = pEntity->GetAbsOrigin();
AI_TraceHull( vecOrigin, vecOrigin, m_hActor->WorldAlignMins(), m_hActor->WorldAlignMaxs(), MASK_SOLID, m_hActor, COLLISION_GROUP_NONE, &tr );
if ( tr.startsolid )
{
return false;
}
m_hEntityFound = pEntity;
return true;
}
CBaseEntity *GetFilterResult( void )
{
return m_hEntityFound;
}
private:
EHANDLE m_hActor;
// To maintain backwards compatability, store off the first mark
// we find. If we find no truly valid marks, we'll just use the first.
EHANDLE m_hEntityFound;
};
//-----------------------------------------------------------------------------
// Purpose: Finds the entity nearest to both entities, and is clear
//-----------------------------------------------------------------------------
class CSceneFindNearestMarkFilter : public IEntityFindFilter
{
public:
CSceneFindNearestMarkFilter( const CBaseEntity *pActor, const Vector &vecPos2, float flMaxRadius = MAX_TRACE_LENGTH )
{
m_vecPos2 = vecPos2;
m_flMaxSegmentDistance = flMaxRadius;
m_flNearestToTarget = flMaxRadius;
m_pNearestToTarget = NULL;
m_flNearestToActor = flMaxRadius;
m_pNearestToActor = NULL;
m_hActor = pActor;
if (pActor)
{
m_vecPos1 = pActor->GetAbsOrigin();
m_flMaxSegmentDistance = MIN( flMaxRadius, (m_vecPos1 - m_vecPos2).Length() + 1.0 );
if (m_flMaxSegmentDistance <= 1.0)
{
// must be closest to self
m_flMaxSegmentDistance = MIN( flMaxRadius, MAX_TRACE_LENGTH );
}
}
}
bool ShouldFindEntity( CBaseEntity *pEntity )
{
if ( !m_hActor )
return true;
// If we find no truly valid marks, we'll just use the first.
if ( m_pNearestToActor == NULL )
{
m_pNearestToActor = pEntity;
}
// We only want marks that are clear
trace_t tr;
Vector vecOrigin = pEntity->GetAbsOrigin();
AI_TraceHull( vecOrigin, vecOrigin, m_hActor->WorldAlignMins(), m_hActor->WorldAlignMaxs(), MASK_SOLID, m_hActor, COLLISION_GROUP_NONE, &tr );
if ( !tr.startsolid || tr.m_pEnt == m_hActor)
{
float dist1 = (m_vecPos1 - pEntity->GetAbsOrigin()).Length();
float dist2 = (m_vecPos2 - pEntity->GetAbsOrigin()).Length();
/*
char text[256];
Q_snprintf( text, sizeof( text ), "%.0f : %.0f", dist1, dist2 );
NDebugOverlay::Text( pEntity->GetAbsOrigin() + Vector( 0, 0, 8 ), text, false, 5.0f );
*/
// find the point closest to the actor
if (dist1 <= m_flNearestToActor)
{
m_pNearestToActor = pEntity;
m_flNearestToActor = dist2;
}
// find that node that's closest to both, but the distance to it from the actor isn't farther than
// the distance to the second node. This should keep the actor from walking past their point of interest
if (dist1 <= m_flMaxSegmentDistance && dist2 <= m_flMaxSegmentDistance && dist2 < m_flNearestToTarget)
{
m_pNearestToTarget = pEntity;
m_flNearestToTarget = dist2;
}
}
return false;
}
CBaseEntity *GetFilterResult( void )
{
if (m_pNearestToTarget)
return m_pNearestToTarget;
return m_pNearestToActor;
}
private:
EHANDLE m_hActor;
Vector m_vecPos1;
Vector m_vecPos2;
float m_flMaxSegmentDistance;
float m_flNearestToTarget;
CBaseEntity *m_pNearestToTarget;
float m_flNearestToActor;
CBaseEntity *m_pNearestToActor;
};
//-----------------------------------------------------------------------------
// Purpose: Search for an actor by name, make sure it can do face poses
// Input : *name -
// Output : CBaseFlex
//-----------------------------------------------------------------------------
CBaseEntity *CSceneEntity::FindNamedEntity( const char *name, CBaseEntity *pActor, bool bBaseFlexOnly, bool bUseClear )
{
CBaseEntity *entity = NULL;
if ( !stricmp( name, "Player" ) || !stricmp( name, "!player" ))
{
entity = ( gpGlobals->maxClients == 1 ) ? ( CBaseEntity * )UTIL_GetLocalPlayer() : NULL;
}
else if ( !stricmp( name, "!target1" ) )
{
if (m_hTarget1 == NULL)
{
m_hTarget1 = FindNamedTarget( m_iszTarget1, bBaseFlexOnly );
}
return m_hTarget1;
}
else if ( !stricmp( name, "!target2" ) )
{
if (m_hTarget2 == NULL)
{
m_hTarget2 = FindNamedTarget( m_iszTarget2, bBaseFlexOnly );
}
return m_hTarget2;
}
else if ( !stricmp( name, "!target3" ) )
{
if (m_hTarget3 == NULL)
{
m_hTarget3 = FindNamedTarget( m_iszTarget3, bBaseFlexOnly );
}
return m_hTarget3;
}
else if ( !stricmp( name, "!target4" ) )
{
if (m_hTarget4 == NULL)
{
m_hTarget4 = FindNamedTarget( m_iszTarget4, bBaseFlexOnly );
}
return m_hTarget4;
}
else if ( !stricmp( name, "!target5" ) )
{
if (m_hTarget5 == NULL)
{
m_hTarget5 = FindNamedTarget( m_iszTarget5, bBaseFlexOnly );
}
return m_hTarget5;
}
else if ( !stricmp( name, "!target6" ) )
{
if (m_hTarget6 == NULL)
{
m_hTarget6 = FindNamedTarget( m_iszTarget6, bBaseFlexOnly );
}
return m_hTarget6;
}
else if ( !stricmp( name, "!target7" ) )
{
if (m_hTarget7 == NULL)
{
m_hTarget7 = FindNamedTarget( m_iszTarget7, bBaseFlexOnly );
}
return m_hTarget7;
}
else if ( !stricmp( name, "!target8" ) )
{
if (m_hTarget8 == NULL)
{
m_hTarget8 = FindNamedTarget( m_iszTarget8, bBaseFlexOnly );
}
return m_hTarget8;
}
else if (pActor && pActor->MyNPCPointer())
{
CSceneFindMarkFilter *pFilter = NULL;
if ( bUseClear )
{
pFilter = new CSceneFindMarkFilter();
pFilter->SetActor( pActor );
}
entity = pActor->MyNPCPointer()->FindNamedEntity( name, pFilter );
if ( !entity && pFilter )
{
entity = pFilter->GetFilterResult();
}
}
else
{
// search for up to 32 entities with the same name and choose one randomly
CBaseEntity *entityList[ FINDNAMEDENTITY_MAX_ENTITIES ];
int iCount;
entity = NULL;
for( iCount = 0; iCount < FINDNAMEDENTITY_MAX_ENTITIES; iCount++ )
{
entity = gEntList.FindEntityByName( entity, name, NULL, pActor );
if ( !entity )
{
break;
}
entityList[ iCount ] = entity;
}
if ( iCount > 0 )
{
entity = entityList[ RandomInt( 0, iCount - 1 ) ];
}
else
{
entity = NULL;
}
}
return entity;
}
//-----------------------------------------------------------------------------
// Purpose: Search for an actor by name, make sure it can do face poses
// Input : *name -
// Output : CBaseFlex
//-----------------------------------------------------------------------------
CBaseEntity *CSceneEntity::FindNamedEntityClosest( const char *name, CBaseEntity *pActor, bool bBaseFlexOnly, bool bUseClear, const char *pszSecondary )
{
CBaseEntity *entity = NULL;
if ( !stricmp( name, "!activator" ) )
{
return m_hActivator;
}
else if ( !stricmp( name, "Player" ) || !stricmp( name, "!player" ))
{
entity = ( gpGlobals->maxClients == 1 ) ? ( CBaseEntity * )UTIL_GetLocalPlayer() : NULL;
return entity;
}
else if ( !stricmp( name, "!target1" ) )
{
name = STRING( m_iszTarget1 );
}
else if ( !stricmp( name, "!target2" ) )
{
name = STRING( m_iszTarget2 );
}
else if ( !stricmp( name, "!target3" ) )
{
name = STRING( m_iszTarget3 );
}
else if ( !stricmp( name, "!target4" ) )
{
name = STRING( m_iszTarget4 );
}
else if ( !stricmp( name, "!target5" ) )
{
name = STRING( m_iszTarget5 );
}
else if ( !stricmp( name, "!target6" ) )
{
name = STRING( m_iszTarget6 );
}
else if ( !stricmp( name, "!target7" ) )
{
name = STRING( m_iszTarget7 );
}
if (pActor && pActor->MyNPCPointer())
{
if (pszSecondary && strlen( pszSecondary ) > 0)
{
CBaseEntity *pActor2 = FindNamedEntityClosest( pszSecondary, pActor, false, false, NULL );
if (pActor2)
{
CSceneFindNearestMarkFilter *pFilter = new CSceneFindNearestMarkFilter( pActor, pActor2->GetAbsOrigin() );
entity = pActor->MyNPCPointer()->FindNamedEntity( name, pFilter );
if (!entity && pFilter)
{
entity = pFilter->GetFilterResult();
}
}
}
if (!entity)
{
CSceneFindMarkFilter *pFilter = NULL;
if ( bUseClear )
{
pFilter = new CSceneFindMarkFilter();
pFilter->SetActor( pActor );
}
entity = pActor->MyNPCPointer()->FindNamedEntity( name, pFilter );
if (!entity && pFilter)
{
entity = pFilter->GetFilterResult();
}
}
}
else
{
// search for up to 32 entities with the same name and choose one randomly
int iCount;
entity = NULL;
CBaseEntity *current = NULL;
for( iCount = 0; iCount < FINDNAMEDENTITY_MAX_ENTITIES; iCount++ )
{
current = gEntList.FindEntityByName( current, name, NULL, pActor );
if ( current )
{
if (RandomInt( 0, iCount ) == 0)
entity = current;
}
}
entity = NULL;
}
return entity;
}
//-----------------------------------------------------------------------------
// Purpose: Remove all "scene" expressions from all actors in this scene
//-----------------------------------------------------------------------------
void CSceneEntity::ClearSceneEvents( CChoreoScene *scene, bool canceled )
{
if ( !m_pScene )
return;
LocalScene_Printf( "%s : %8.2f: clearing events\n", STRING( m_iszSceneFile ), m_flCurrentTime );
int i;
for ( i = 0 ; i < m_pScene->GetNumActors(); i++ )
{
CBaseFlex *pActor = FindNamedActor( i );
if ( !pActor )
continue;
// Clear any existing expressions
pActor->ClearSceneEvents( scene, canceled );
}
// Iterate events and precache necessary resources
for ( i = 0; i < scene->GetNumEvents(); i++ )
{
CChoreoEvent *event = scene->GetEvent( i );
if ( !event )
continue;
// load any necessary data
switch (event->GetType() )
{
default:
break;
case CChoreoEvent::SUBSCENE:
{
// Only allow a single level of subscenes for now
if ( !scene->IsSubScene() )
{
CChoreoScene *subscene = event->GetSubScene();
if ( subscene )
{
ClearSceneEvents( subscene, canceled );
}
}
}
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Remove all imposed schedules from all actors in this scene
//-----------------------------------------------------------------------------
void CSceneEntity::ClearSchedules( CChoreoScene *scene )
{
if ( !m_pScene )
return;
int i;
for ( i = 0 ; i < m_pScene->GetNumActors(); i++ )
{
CBaseFlex *pActor = FindNamedActor( i );
if ( !pActor )
continue;
CAI_BaseNPC *pNPC = pActor->MyNPCPointer();
if ( pNPC )
{
/*
if ( pNPC->IsCurSchedule( SCHED_SCENE_GENERIC ) )
pNPC->ClearSchedule( "Scene entity clearing all actor schedules" );
*/
}
else
{
pActor->ResetSequence( pActor->SelectWeightedSequence( ACT_IDLE ) );
pActor->SetCycle( 0 );
}
// Clear any existing expressions
}
// Iterate events and precache necessary resources
for ( i = 0; i < scene->GetNumEvents(); i++ )
{
CChoreoEvent *event = scene->GetEvent( i );
if ( !event )
continue;
// load any necessary data
switch (event->GetType() )
{
default:
break;
case CChoreoEvent::SUBSCENE:
{
// Only allow a single level of subscenes for now
if ( !scene->IsSubScene() )
{
CChoreoScene *subscene = event->GetSubScene();
if ( subscene )
{
ClearSchedules( subscene );
}
}
}
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: If we are currently interruptable, pause this scene and wait for the other
// scene to finish
// Input : *otherScene -
//-----------------------------------------------------------------------------
bool CSceneEntity::InterruptThisScene( CSceneEntity *otherScene )
{
Assert( otherScene );
if ( !IsInterruptable() )
{
return false;
}
// Already interrupted
if ( m_bInterrupted )
{
return false;
}
m_bInterrupted = true;
m_hInterruptScene = otherScene;
// Ask other scene to tell us when it's finished or canceled
otherScene->RequestCompletionNotification( this );
PausePlayback();
return true;
}
/*
void scene_interrupt( const CCommand &args )
{
if ( args.ArgC() != 3 )
return;
const char *scene1 = args[1];
const char *scene2 = args[2];
CSceneEntity *s1 = dynamic_cast< CSceneEntity * >( gEntList.FindEntityByName( NULL, scene1 ) );
CSceneEntity *s2 = dynamic_cast< CSceneEntity * >( gEntList.FindEntityByName( NULL, scene2 ) );
if ( !s1 || !s2 )
return;
if ( s1->InterruptThisScene( s2 ) )
{
s2->StartPlayback();
}
}
static ConCommand interruptscene( "int", scene_interrupt, "interrupt scene 1 with scene 2.", FCVAR_CHEAT );
*/
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::CheckInterruptCompletion()
{
if ( !m_bInterrupted )
return;
// If the interruptor goes away it's the same as having that scene finish up...
if ( m_hInterruptScene != NULL &&
!m_bInterruptSceneFinished )
{
return;
}
m_bInterrupted = false;
m_hInterruptScene = NULL;
ResumePlayback();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::ClearInterrupt()
{
m_nInterruptCount = 0;
m_bInterrupted = false;
m_hInterruptScene = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Another scene is asking us to notify upon completion
// Input : *notify -
//-----------------------------------------------------------------------------
void CSceneEntity::RequestCompletionNotification( CSceneEntity *notify )
{
CHandle< CSceneEntity > h;
h = notify;
// Only add it once
if ( m_hNotifySceneCompletion.Find( h ) == m_hNotifySceneCompletion.InvalidIndex() )
{
m_hNotifySceneCompletion.AddToTail( h );
}
}
//-----------------------------------------------------------------------------
// Purpose: An interrupt scene has finished or been canceled, we can resume once we pick up this state in CheckInterruptCompletion
// Input : *interruptor -
//-----------------------------------------------------------------------------
void CSceneEntity::NotifyOfCompletion( CSceneEntity *interruptor )
{
Assert( m_bInterrupted );
Assert( m_hInterruptScene == interruptor );
m_bInterruptSceneFinished = true;
CheckInterruptCompletion();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneEntity::AddListManager( CSceneListManager *pManager )
{
CHandle< CSceneListManager > h;
h = pManager;
// Only add it once
if ( m_hListManagers.Find( h ) == m_hListManagers.InvalidIndex() )
{
m_hListManagers.AddToTail( h );
}
}
//-----------------------------------------------------------------------------
// Purpose: Clear any targets that a referencing !activator
//-----------------------------------------------------------------------------
void CSceneEntity::ClearActivatorTargets( void )
{
if ( !stricmp( STRING(m_iszTarget1), "!activator" ) )
{
// We need to clear out actors so they're re-evaluated
m_hActorList.Purge();
NetworkProp()->NetworkStateForceUpdate();
m_hTarget1 = NULL;
}
if ( !stricmp( STRING(m_iszTarget2), "!activator" ) )
{
// We need to clear out actors so they're re-evaluated
m_hActorList.Purge();
NetworkProp()->NetworkStateForceUpdate();
m_hTarget2 = NULL;
}
if ( !stricmp( STRING(m_iszTarget3), "!activator" ) )
{
// We need to clear out actors so they're re-evaluated
m_hActorList.Purge();
NetworkProp()->NetworkStateForceUpdate();
m_hTarget3 = NULL;
}
if ( !stricmp( STRING(m_iszTarget4), "!activator" ) )
{
// We need to clear out actors so they're re-evaluated
m_hActorList.Purge();
NetworkProp()->NetworkStateForceUpdate();
m_hTarget4 = NULL;
}
if ( !stricmp( STRING(m_iszTarget5), "!activator" ) )
{
// We need to clear out actors so they're re-evaluated
m_hActorList.Purge();
NetworkProp()->NetworkStateForceUpdate();
m_hTarget5 = NULL;
}
if ( !stricmp( STRING(m_iszTarget6), "!activator" ) )
{
// We need to clear out actors so they're re-evaluated
m_hActorList.Purge();
NetworkProp()->NetworkStateForceUpdate();
m_hTarget6 = NULL;
}
if ( !stricmp( STRING(m_iszTarget7), "!activator" ) )
{
// We need to clear out actors so they're re-evaluated
m_hActorList.Purge();
NetworkProp()->NetworkStateForceUpdate();
m_hTarget7 = NULL;
}
if ( !stricmp( STRING(m_iszTarget8), "!activator" ) )
{
// We need to clear out actors so they're re-evaluated
m_hActorList.Purge();
NetworkProp()->NetworkStateForceUpdate();
m_hTarget8 = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when a scene is completed or canceled
//-----------------------------------------------------------------------------
void CSceneEntity::OnSceneFinished( bool canceled, bool fireoutput )
{
if ( !m_pScene )
return;
LocalScene_Printf( "%s : %8.2f: finished\n", STRING( m_iszSceneFile ), m_flCurrentTime );
// Notify any listeners
int c = m_hNotifySceneCompletion.Count();
int i;
for ( i = 0; i < c; i++ )
{
CSceneEntity *ent = m_hNotifySceneCompletion[ i ].Get();
if ( !ent )
continue;
ent->NotifyOfCompletion( this );
}
m_hNotifySceneCompletion.RemoveAll();
// Clear simulation
m_pScene->ResetSimulation();
m_bIsPlayingBack = false;
m_bPaused = false;
SetCurrentTime( 0.0f, false );
// Clear interrupt state if we were interrupted for some reason
ClearInterrupt();
if ( fireoutput && !m_bCompletedEarly)
{
m_OnCompletion.FireOutput( this, this, 0 );
}
// Put face back in neutral pose
ClearSceneEvents( m_pScene, canceled );
for ( i = 0 ; i < m_pScene->GetNumActors(); i++ )
{
CBaseFlex *pTestActor = FindNamedActor( i );
if ( !pTestActor )
continue;
pTestActor->RemoveChoreoScene( m_pScene, canceled );
// If we interrupted the actor's previous scenes, resume them
if ( m_bInterruptedActorsScenes )
{
QueueActorsScriptedScenesToResume( pTestActor, false );
}
}
}
//-----------------------------------------------------------------------------
// Should we transmit it to the client?
//-----------------------------------------------------------------------------
int CSceneEntity::UpdateTransmitState()
{
if ( !ShouldNetwork() )
{
return SetTransmitState( FL_EDICT_DONTSEND );
}
if ( m_pRecipientFilter )
{
return SetTransmitState( FL_EDICT_FULLCHECK );
}
return SetTransmitState( FL_EDICT_ALWAYS );
}
//-----------------------------------------------------------------------------
// Purpose: Which clients should we be transmitting to?
//-----------------------------------------------------------------------------
int CSceneEntity::ShouldTransmit( const CCheckTransmitInfo *pInfo )
{
int result = BaseClass::ShouldTransmit( pInfo );
// if we have excluded them via our recipient filter, don't send
if ( m_pRecipientFilter && result != FL_EDICT_DONTSEND )
{
bool bFound = false;
// If we can't find them in the recipient list, exclude
int i;
for ( i=0; i<m_pRecipientFilter->GetRecipientCount();i++ )
{
int iRecipient = m_pRecipientFilter->GetRecipientIndex(i);
CBasePlayer *player = static_cast< CBasePlayer * >( CBaseEntity::Instance( iRecipient ) );
if ( player && player->edict() == pInfo->m_pClientEnt )
{
bFound = true;
break;
}
}
if ( !bFound )
{
result = FL_EDICT_DONTSEND;
}
}
return result;
}
void CSceneEntity::SetRecipientFilter( IRecipientFilter *filter )
{
// create a copy of this filter
if ( filter )
{
m_pRecipientFilter = new CRecipientFilter();
m_pRecipientFilter->CopyFrom( (CRecipientFilter &)( *filter ) );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
class CInstancedSceneEntity : public CSceneEntity
{
DECLARE_DATADESC();
DECLARE_CLASS( CInstancedSceneEntity, CSceneEntity );
public:
EHANDLE m_hOwner;
bool m_bHadOwner;
float m_flPostSpeakDelay;
float m_flPreDelay;
char m_szInstanceFilename[ CChoreoScene::MAX_SCENE_FILENAME ];
bool m_bIsBackground;
virtual void StartPlayback( void );
virtual void DoThink( float frametime );
virtual CBaseFlex *FindNamedActor( const char *name );
virtual CBaseEntity *FindNamedEntity( const char *name );
virtual float GetPostSpeakDelay() { return m_flPostSpeakDelay; }
virtual void SetPostSpeakDelay( float flDelay ) { m_flPostSpeakDelay = flDelay; }
virtual float GetPreDelay() { return m_flPreDelay; }
virtual void SetPreDelay( float flDelay ) { m_flPreDelay = flDelay; }
virtual void OnLoaded();
virtual void DispatchStartMoveTo( CChoreoScene *scene, CBaseFlex *actor, CBaseEntity *actor2, CChoreoEvent *event )
{
if (PassThrough( actor )) BaseClass::DispatchStartMoveTo( scene, actor, actor2, event );
};
virtual void DispatchEndMoveTo( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
if (PassThrough( actor )) BaseClass::DispatchEndMoveTo( scene, actor, event );
};
virtual void DispatchStartFace( CChoreoScene *scene, CBaseFlex *actor, CBaseEntity *actor2, CChoreoEvent *event )
{
if (PassThrough( actor )) BaseClass::DispatchStartFace( scene, actor, actor2, event );
};
virtual void DispatchEndFace( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
if (PassThrough( actor )) BaseClass::DispatchEndFace( scene, actor, event );
};
virtual void DispatchStartSequence( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
if ( IsMultiplayer() )
{
BaseClass::DispatchStartSequence( scene, actor, event );
}
};
virtual void DispatchEndSequence( CChoreoScene *scene, CBaseFlex *actor, CChoreoEvent *event )
{
if ( IsMultiplayer() )
{
BaseClass::DispatchEndSequence( scene, actor, event );
}
};
virtual void DispatchPauseScene( CChoreoScene *scene, const char *parameters ) { /* suppress */ };
void OnRestore();
virtual float EstimateLength( void );
private:
bool PassThrough( CBaseFlex *actor );
};
LINK_ENTITY_TO_CLASS( instanced_scripted_scene, CInstancedSceneEntity );
//---------------------------------------------------------
// Save/Restore
//---------------------------------------------------------
BEGIN_DATADESC( CInstancedSceneEntity )
DEFINE_FIELD( m_hOwner, FIELD_EHANDLE ),
DEFINE_FIELD( m_bHadOwner, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flPostSpeakDelay, FIELD_FLOAT ),
DEFINE_FIELD( m_flPreDelay, FIELD_FLOAT ),
DEFINE_AUTO_ARRAY( m_szInstanceFilename, FIELD_CHARACTER ),
DEFINE_FIELD( m_bIsBackground, FIELD_BOOLEAN ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose: create a one-shot scene, no movement, sequences, etc.
// Input :
// Output :
//-----------------------------------------------------------------------------
float InstancedScriptedScene( CBaseFlex *pActor, const char *pszScene, EHANDLE *phSceneEnt,
float flPostDelay, bool bIsBackground, AI_Response *response,
bool bMultiplayer, IRecipientFilter *filter /* = NULL */ )
{
VPROF( "InstancedScriptedScene" );
CInstancedSceneEntity *pScene = (CInstancedSceneEntity *)CBaseEntity::CreateNoSpawn( "instanced_scripted_scene", vec3_origin, vec3_angle );
// This code expands any $gender tags into male or female tags based on the gender of the actor (based on his/her .mdl)
if ( pActor )
{
pActor->GenderExpandString( pszScene, pScene->m_szInstanceFilename, sizeof( pScene->m_szInstanceFilename ) );
}
else
{
Q_strncpy( pScene->m_szInstanceFilename, pszScene, sizeof( pScene->m_szInstanceFilename ) );
}
pScene->m_iszSceneFile = MAKE_STRING( pScene->m_szInstanceFilename );
// FIXME: I should set my output to fire something that kills me....
// FIXME: add a proper initialization function
pScene->m_hOwner = pActor;
pScene->m_bHadOwner = pActor != NULL;
pScene->m_bMultiplayer = bMultiplayer;
pScene->SetPostSpeakDelay( flPostDelay );
DispatchSpawn( pScene );
pScene->Activate();
pScene->m_bIsBackground = bIsBackground;
pScene->SetBackground( bIsBackground );
pScene->SetRecipientFilter( filter );
if ( response )
{
float flPreDelay = response->GetPreDelay();
if ( flPreDelay )
{
pScene->SetPreDelay( flPreDelay );
}
}
pScene->StartPlayback();
if ( response )
{
// If the response wants us to abort on NPC state switch, remember that
pScene->SetBreakOnNonIdle( response->ShouldBreakOnNonIdle() );
}
if ( phSceneEnt )
{
*phSceneEnt = pScene;
}
return pScene->EstimateLength();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pActor -
// *soundnmame -
// *phSceneEnt -
// Output : float
//-----------------------------------------------------------------------------
float InstancedAutoGeneratedSoundScene( CBaseFlex *pActor, char const *soundname, EHANDLE *phSceneEnt /*= NULL*/ )
{
if ( !pActor )
{
Warning( "InstancedAutoGeneratedSoundScene: Expecting non-NULL pActor for sound %s\n", soundname );
return 0;
}
CInstancedSceneEntity *pScene = (CInstancedSceneEntity *)CBaseEntity::CreateNoSpawn( "instanced_scripted_scene", vec3_origin, vec3_angle );
Q_strncpy( pScene->m_szInstanceFilename, UTIL_VarArgs( "AutoGenerated(%s)", soundname ), sizeof( pScene->m_szInstanceFilename ) );
pScene->m_iszSceneFile = MAKE_STRING( pScene->m_szInstanceFilename );
pScene->m_hOwner = pActor;
pScene->m_bHadOwner = pActor != NULL;
pScene->GenerateSoundScene( pActor, soundname );
pScene->Spawn();
pScene->Activate();
pScene->StartPlayback();
if ( phSceneEnt )
{
*phSceneEnt = pScene;
}
return pScene->EstimateLength();
}
//-----------------------------------------------------------------------------
void StopScriptedScene( CBaseFlex *pActor, EHANDLE hSceneEnt )
{
CBaseEntity *pEntity = hSceneEnt;
CSceneEntity *pScene = dynamic_cast<CSceneEntity *>(pEntity);
if ( pScene )
{
LocalScene_Printf( "%s : stop scripted scene\n", STRING( pScene->m_iszSceneFile ) );
pScene->CancelPlayback();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pszScene -
// Output : float
//-----------------------------------------------------------------------------
float GetSceneDuration( char const *pszScene )
{
unsigned int msecs = 0;
SceneCachedData_t cachedData;
if ( scenefilecache->GetSceneCachedData( pszScene, &cachedData ) )
{
msecs = cachedData.msecs;
}
return (float)msecs * 0.001f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pszScene -
// Output : int
//-----------------------------------------------------------------------------
int GetSceneSpeechCount( char const *pszScene )
{
SceneCachedData_t cachedData;
if ( scenefilecache->GetSceneCachedData( pszScene, &cachedData ) )
{
return cachedData.numSounds;
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Used for precaching instanced scenes
// Input : *pszScene -
//-----------------------------------------------------------------------------
void PrecacheInstancedScene( char const *pszScene )
{
static int nMakingReslists = -1;
if ( nMakingReslists == -1 )
{
nMakingReslists = CommandLine()->FindParm( "-makereslists" ) > 0 ? 1 : 0;
}
if ( nMakingReslists == 1 )
{
// Just stat the file to add to reslist
g_pFullFileSystem->Size( pszScene );
}
// verify existence, cache is pre-populated, should be there
SceneCachedData_t sceneData;
if ( !scenefilecache->GetSceneCachedData( pszScene, &sceneData ) )
{
// Scenes are sloppy and don't always exist.
// A scene that is not in the pre-built cache image, but on disk, is a true error.
if ( developer.GetInt() && ( IsX360() && ( g_pFullFileSystem->GetDVDMode() != DVDMODE_STRICT ) && g_pFullFileSystem->FileExists( pszScene, "GAME" ) ) )
{
Warning( "PrecacheInstancedScene: Missing scene '%s' from scene image cache.\nRebuild scene image cache!\n", pszScene );
}
}
else
{
for ( int i = 0; i < sceneData.numSounds; ++i )
{
short stringId = scenefilecache->GetSceneCachedSound( sceneData.sceneId, i );
CBaseEntity::PrecacheScriptSound( scenefilecache->GetSceneString( stringId ) );
}
}
g_pStringTableClientSideChoreoScenes->AddString( CBaseEntity::IsServer(), pszScene );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CInstancedSceneEntity::StartPlayback( void )
{
// Wait until our pre delay is over
if ( GetPreDelay() )
return;
BaseClass::StartPlayback();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CInstancedSceneEntity::DoThink( float frametime )
{
CheckInterruptCompletion();
if ( m_flPreDelay > 0 )
{
m_flPreDelay = MAX( 0, m_flPreDelay - frametime );
StartPlayback();
if ( !m_bIsPlayingBack )
return;
}
if ( !m_pScene || !m_bIsPlayingBack || ( m_bHadOwner && m_hOwner == NULL ) )
{
UTIL_Remove( this );
return;
}
// catch bad pitch shifting from old save games
Assert( m_fPitch >= SCENE_MIN_PITCH && m_fPitch <= SCENE_MAX_PITCH );
m_fPitch = clamp( m_fPitch, SCENE_MIN_PITCH, SCENE_MAX_PITCH );
if ( m_bPaused )
{
PauseThink();
return;
}
float dt = frametime;
m_pScene->SetSoundFileStartupLatency( GetSoundSystemLatency() );
// Tell scene to go
m_pScene->Think( m_flCurrentTime );
// Drive simulation time for scene
SetCurrentTime( m_flCurrentTime + dt * m_fPitch, false );
// Did we get to the end
if ( m_pScene->SimulationFinished() )
{
OnSceneFinished( false, false );
UTIL_Remove( this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Search for an actor by name, make sure it can do face poses
// Input : *name -
// Output : CBaseFlex
//-----------------------------------------------------------------------------
CBaseFlex *CInstancedSceneEntity::FindNamedActor( const char *name )
{
if ( m_pScene->GetNumActors() == 1 || stricmp( name, "!self" ) == 0 )
{
if ( m_hOwner != NULL )
{
CBaseCombatCharacter *pCharacter = m_hOwner->MyCombatCharacterPointer();
if ( pCharacter )
{
return pCharacter;
}
}
}
return BaseClass::FindNamedActor( name );
}
//-----------------------------------------------------------------------------
// Purpose: Search for an actor by name, make sure it can do face poses
// Input : *name -
// Output : CBaseFlex
//-----------------------------------------------------------------------------
CBaseEntity *CInstancedSceneEntity::FindNamedEntity( const char *name )
{
CBaseEntity *pOther = NULL;
if (m_hOwner != NULL)
{
CAI_BaseNPC *npc = m_hOwner->MyNPCPointer();
if (npc)
{
pOther = npc->FindNamedEntity( name );
}
else if ( m_hOwner->MyCombatCharacterPointer() )
{
pOther = m_hOwner;
}
}
if (!pOther)
{
pOther = BaseClass::FindNamedEntity( name );
}
return pOther;
}
//-----------------------------------------------------------------------------
// Purpose: Suppress certain events when it's instanced since they're can cause odd problems
// Input : actor
// Output : true - the event should happen, false - it shouldn't
//-----------------------------------------------------------------------------
bool CInstancedSceneEntity::PassThrough( CBaseFlex *actor )
{
if (!actor)
return false;
CAI_BaseNPC *myNpc = actor->MyNPCPointer( );
if (!myNpc)
return false;
if (myNpc->IsCurSchedule( SCHED_SCENE_GENERIC ))
{
return true;
}
if (myNpc->GetCurSchedule())
{
CAI_ScheduleBits testBits;
myNpc->GetCurSchedule()->GetInterruptMask( &testBits );
if (testBits.IsBitSet( COND_IDLE_INTERRUPT ))
{
return true;
}
}
LocalScene_Printf( "%s : event suppressed\n", STRING( m_iszSceneFile ) );
return false;
}
//-----------------------------------------------------------------------------
void CInstancedSceneEntity::OnRestore()
{
if ( m_bHadOwner && !m_hOwner )
{
// probably just came back from a level transition
UTIL_Remove( this );
return;
}
// reset background state
if ( m_pScene )
{
m_pScene->SetBackground( m_bIsBackground );
}
BaseClass::OnRestore();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CInstancedSceneEntity::EstimateLength( void )
{
return (BaseClass::EstimateLength() + GetPreDelay());
}
void CInstancedSceneEntity::OnLoaded()
{
BaseClass::OnLoaded();
SetBackground( m_bIsBackground );
}
bool g_bClientFlex = true;
LINK_ENTITY_TO_CLASS( scene_manager, CSceneManager );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneManager::Think()
{
// Latch this only once per frame...
g_bClientFlex = scene_clientflex.GetBool();
// The manager is always thinking at 20 hz
SetNextThink( gpGlobals->curtime + SCENE_THINK_INTERVAL );
float frameTime = ( gpGlobals->curtime - GetLastThink() );
frameTime = MIN( 0.1, frameTime );
// stop if AI is diabled
if (CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI)
return;
bool needCleanupPass = false;
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *scene = m_ActiveScenes[ i ].Get();
if ( !scene )
{
needCleanupPass = true;
continue;
}
scene->DoThink( frameTime );
if ( m_ActiveScenes.Count() < c )
{
// Scene removed self while thinking. Adjust iteration.
c = m_ActiveScenes.Count();
i--;
}
}
// Now delete any invalid ones
if ( needCleanupPass )
{
for ( int i = c - 1; i >= 0; i-- )
{
CSceneEntity *scene = m_ActiveScenes[ i ].Get();
if ( scene )
continue;
m_ActiveScenes.Remove( i );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneManager::ClearAllScenes()
{
m_ActiveScenes.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
//-----------------------------------------------------------------------------
void CSceneManager::AddSceneEntity( CSceneEntity *scene )
{
CHandle< CSceneEntity > h;
h = scene;
// Already added/activated
if ( m_ActiveScenes.Find( h ) != m_ActiveScenes.InvalidIndex() )
{
return;
}
m_ActiveScenes.AddToTail( h );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
//-----------------------------------------------------------------------------
void CSceneManager::RemoveSceneEntity( CSceneEntity *scene )
{
CHandle< CSceneEntity > h;
h = scene;
m_ActiveScenes.FindAndRemove( h );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *player -
//-----------------------------------------------------------------------------
void CSceneManager::OnClientActive( CBasePlayer *player )
{
int c = m_QueuedSceneSounds.Count();
for ( int i = 0; i < c; i++ )
{
CRestoreSceneSound *sound = &m_QueuedSceneSounds[ i ];
if ( sound->actor == NULL )
continue;
// Blow off sounds too far in past to encode over networking layer
if ( fabs( 1000.0f * sound->time_in_past ) > MAX_SOUND_DELAY_MSEC )
continue;
CPASAttenuationFilter filter( sound->actor );
EmitSound_t es;
es.m_nChannel = CHAN_VOICE;
es.m_flVolume = 1;
es.m_pSoundName = sound->soundname;
es.m_SoundLevel = sound->soundlevel;
es.m_flSoundTime = gpGlobals->curtime - sound->time_in_past;
EmitSound( filter, sound->actor->entindex(), es );
}
m_QueuedSceneSounds.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose: Deletes scenes involving the specified actor
//-----------------------------------------------------------------------------
void CSceneManager::RemoveScenesInvolvingActor( CBaseFlex *pActor )
{
if ( !pActor )
return;
int c = m_ActiveScenes.Count();
add source-sdk-2013
3 years ago
for ( int i = 0; i < c; i++ )
1
5 years ago
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene )
{
continue;
}
if ( pScene->InvolvesActor( pActor ) ) // NOTE: returns false if scene hasn't loaded yet
{
LocalScene_Printf( "%s : removed for '%s'\n", STRING( pScene->m_iszSceneFile ), pActor ? pActor->GetDebugName() : "NULL" );
pScene->CancelPlayback();
}
else
{
CInstancedSceneEntity *pInstancedScene = dynamic_cast< CInstancedSceneEntity * >( pScene );
if ( pInstancedScene && pInstancedScene->m_hOwner )
{
if ( pInstancedScene->m_hOwner == pActor )
{
if ( pInstancedScene->m_bIsPlayingBack )
{
pInstancedScene->OnSceneFinished( true, false );
}
LocalScene_Printf( "%s : removed for '%s'\n", STRING( pInstancedScene->m_iszSceneFile ), pActor ? pActor->GetDebugName() : "NULL" );
UTIL_Remove( pInstancedScene );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Stops scenes involving the specified actor
//-----------------------------------------------------------------------------
void CSceneManager::RemoveActorFromScenes( CBaseFlex *pActor, bool bInstancedOnly, bool bNonIdleOnly, const char *pszThisSceneOnly )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene )
{
continue;
}
// If only stopping instanced scenes, then skip it if it can't cast to an instanced scene
if ( bInstancedOnly &&
( dynamic_cast< CInstancedSceneEntity * >( pScene ) == NULL ) )
{
continue;
}
if ( bNonIdleOnly && !pScene->ShouldBreakOnNonIdle() )
continue;
if ( pScene->InvolvesActor( pActor ) )
{
if ( pszThisSceneOnly && pszThisSceneOnly[0] )
{
if ( Q_strcmp( pszThisSceneOnly, STRING(pScene->m_iszSceneFile) ) )
continue;
}
LocalScene_Printf( "%s : removed for '%s'\n", STRING( pScene->m_iszSceneFile ), pActor ? pActor->GetDebugName() : "NULL" );
pScene->CancelPlayback();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Pause scenes involving the specified actor
//-----------------------------------------------------------------------------
void CSceneManager::PauseActorsScenes( CBaseFlex *pActor, bool bInstancedOnly )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene )
{
continue;
}
// If only stopping instanced scenes, then skip it if it can't cast to an instanced scene
if ( bInstancedOnly &&
( dynamic_cast< CInstancedSceneEntity * >( pScene ) == NULL ) )
{
continue;
}
if ( pScene->InvolvesActor( pActor ) && pScene->IsPlayingBack() )
{
LocalScene_Printf( "Pausing actor %s scripted scene: %s\n", pActor->GetDebugName(), STRING(pScene->m_iszSceneFile) );
variant_t emptyVariant;
pScene->AcceptInput( "Pause", pScene, pScene, emptyVariant, 0 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this Actor is only in scenes that are interruptable right now
//-----------------------------------------------------------------------------
bool CSceneManager::IsInInterruptableScenes( CBaseFlex *pActor )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene )
continue;
//Ignore background scenes since they're harmless.
if ( pScene->IsBackground() == true )
continue;
if ( pScene->InvolvesActor( pActor ) && pScene->IsPlayingBack() )
{
if ( pScene->IsInterruptable() == false )
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Resume any paused scenes involving the specified actor
//-----------------------------------------------------------------------------
void CSceneManager::ResumeActorsScenes( CBaseFlex *pActor, bool bInstancedOnly )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene )
{
continue;
}
// If only stopping instanced scenes, then skip it if it can't cast to an instanced scene
if ( bInstancedOnly &&
( dynamic_cast< CInstancedSceneEntity * >( pScene ) == NULL ) )
{
continue;
}
if ( pScene->InvolvesActor( pActor ) && pScene->IsPlayingBack() )
{
LocalScene_Printf( "Resuming actor %s scripted scene: %s\n", pActor->GetDebugName(), STRING(pScene->m_iszSceneFile) );
variant_t emptyVariant;
pScene->AcceptInput( "Resume", pScene, pScene, emptyVariant, 0 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Set all paused, in-playback scenes to resume when the actor is ready
//-----------------------------------------------------------------------------
void CSceneManager::QueueActorsScenesToResume( CBaseFlex *pActor, bool bInstancedOnly )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene )
{
continue;
}
// If only stopping instanced scenes, then skip it if it can't cast to an instanced scene
if ( bInstancedOnly &&
( dynamic_cast< CInstancedSceneEntity * >( pScene ) == NULL ) )
{
continue;
}
if ( pScene->InvolvesActor( pActor ) && pScene->IsPlayingBack() && pScene->IsPaused() )
{
pScene->QueueResumePlayback();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: returns if there are scenes involving the specified actor
//-----------------------------------------------------------------------------
bool CSceneManager::IsRunningScriptedScene( CBaseFlex *pActor, bool bIgnoreInstancedScenes )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene ||
!pScene->IsPlayingBack() ||
( bIgnoreInstancedScenes && dynamic_cast<CInstancedSceneEntity *>(pScene) != NULL )
)
{
continue;
}
if ( pScene->InvolvesActor( pActor ) )
{
return true;
}
}
return false;
}
bool CSceneManager::IsRunningScriptedSceneAndNotPaused( CBaseFlex *pActor, bool bIgnoreInstancedScenes )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene ||
!pScene->IsPlayingBack() ||
pScene->IsPaused() ||
( bIgnoreInstancedScenes && dynamic_cast<CInstancedSceneEntity *>(pScene) != NULL )
)
{
continue;
}
if ( pScene->InvolvesActor( pActor ) )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pActor -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSceneManager::IsRunningScriptedSceneWithSpeech( CBaseFlex *pActor, bool bIgnoreInstancedScenes )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene ||
!pScene->IsPlayingBack() ||
( bIgnoreInstancedScenes && dynamic_cast<CInstancedSceneEntity *>(pScene) != NULL )
)
{
continue;
}
if ( pScene->InvolvesActor( pActor ) )
{
if ( pScene->HasUnplayedSpeech() )
return true;
}
}
return false;
}
bool CSceneManager::IsRunningScriptedSceneWithSpeechAndNotPaused( CBaseFlex *pActor, bool bIgnoreInstancedScenes )
{
int c = m_ActiveScenes.Count();
for ( int i = 0; i < c; i++ )
{
CSceneEntity *pScene = m_ActiveScenes[ i ].Get();
if ( !pScene ||
!pScene->IsPlayingBack() ||
pScene->IsPaused() ||
( bIgnoreInstancedScenes && dynamic_cast<CInstancedSceneEntity *>(pScene) != NULL )
)
{
continue;
}
if ( pScene->InvolvesActor( pActor ) )
{
if ( pScene->HasUnplayedSpeech() )
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *soundname -
// soundlevel -
// soundtime -
//-----------------------------------------------------------------------------
void CSceneManager::QueueRestoredSound( CBaseFlex *actor, char const *soundname, soundlevel_t soundlevel, float time_in_past )
{
CRestoreSceneSound e;
e.actor = actor;
Q_strncpy( e.soundname, soundname, sizeof( e.soundname ) );
e.soundlevel = soundlevel;
e.time_in_past = time_in_past;
m_QueuedSceneSounds.AddToTail( e );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void RemoveActorFromScriptedScenes( CBaseFlex *pActor, bool instancedscenesonly, bool nonidlescenesonly, const char *pszThisSceneOnly )
{
GetSceneManager()->RemoveActorFromScenes( pActor, instancedscenesonly, nonidlescenesonly, pszThisSceneOnly );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void RemoveAllScenesInvolvingActor( CBaseFlex *pActor )
{
GetSceneManager()->RemoveScenesInvolvingActor( pActor );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void PauseActorsScriptedScenes( CBaseFlex *pActor, bool instancedscenesonly )
{
GetSceneManager()->PauseActorsScenes( pActor, instancedscenesonly );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool IsInInterruptableScenes( CBaseFlex *pActor )
{
return GetSceneManager()->IsInInterruptableScenes( pActor );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void ResumeActorsScriptedScenes( CBaseFlex *pActor, bool instancedscenesonly )
{
GetSceneManager()->ResumeActorsScenes( pActor, instancedscenesonly );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void QueueActorsScriptedScenesToResume( CBaseFlex *pActor, bool instancedscenesonly )
{
GetSceneManager()->QueueActorsScenesToResume( pActor, instancedscenesonly );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool IsRunningScriptedScene( CBaseFlex *pActor, bool bIgnoreInstancedScenes )
{
return GetSceneManager()->IsRunningScriptedScene( pActor, bIgnoreInstancedScenes );
}
bool IsRunningScriptedSceneAndNotPaused( CBaseFlex *pActor, bool bIgnoreInstancedScenes )
{
return GetSceneManager()->IsRunningScriptedSceneAndNotPaused( pActor, bIgnoreInstancedScenes );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool IsRunningScriptedSceneWithSpeech( CBaseFlex *pActor, bool bIgnoreInstancedScenes )
{
return GetSceneManager()->IsRunningScriptedSceneWithSpeech( pActor, bIgnoreInstancedScenes );
}
bool IsRunningScriptedSceneWithSpeechAndNotPaused( CBaseFlex *pActor, bool bIgnoreInstancedScenes )
{
return GetSceneManager()->IsRunningScriptedSceneWithSpeechAndNotPaused( pActor, bIgnoreInstancedScenes );
}
//===========================================================================================================
// SCENE LIST MANAGER
//===========================================================================================================
LINK_ENTITY_TO_CLASS( logic_scene_list_manager, CSceneListManager );
BEGIN_DATADESC( CSceneListManager )
DEFINE_UTLVECTOR( m_hListManagers, FIELD_EHANDLE ),
// Keys
DEFINE_KEYFIELD( m_iszScenes[0], FIELD_STRING, "scene0" ),
DEFINE_KEYFIELD( m_iszScenes[1], FIELD_STRING, "scene1" ),
DEFINE_KEYFIELD( m_iszScenes[2], FIELD_STRING, "scene2" ),
DEFINE_KEYFIELD( m_iszScenes[3], FIELD_STRING, "scene3" ),
DEFINE_KEYFIELD( m_iszScenes[4], FIELD_STRING, "scene4" ),
DEFINE_KEYFIELD( m_iszScenes[5], FIELD_STRING, "scene5" ),
DEFINE_KEYFIELD( m_iszScenes[6], FIELD_STRING, "scene6" ),
DEFINE_KEYFIELD( m_iszScenes[7], FIELD_STRING, "scene7" ),
DEFINE_KEYFIELD( m_iszScenes[8], FIELD_STRING, "scene8" ),
DEFINE_KEYFIELD( m_iszScenes[9], FIELD_STRING, "scene9" ),
DEFINE_KEYFIELD( m_iszScenes[10], FIELD_STRING, "scene10" ),
DEFINE_KEYFIELD( m_iszScenes[11], FIELD_STRING, "scene11" ),
DEFINE_KEYFIELD( m_iszScenes[12], FIELD_STRING, "scene12" ),
DEFINE_KEYFIELD( m_iszScenes[13], FIELD_STRING, "scene13" ),
DEFINE_KEYFIELD( m_iszScenes[14], FIELD_STRING, "scene14" ),
DEFINE_KEYFIELD( m_iszScenes[15], FIELD_STRING, "scene15" ),
DEFINE_FIELD( m_hScenes[0], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[1], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[2], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[3], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[4], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[5], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[6], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[7], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[8], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[9], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[10], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[11], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[12], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[13], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[14], FIELD_EHANDLE ),
DEFINE_FIELD( m_hScenes[15], FIELD_EHANDLE ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "Shutdown", InputShutdown ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneListManager::Activate( void )
{
BaseClass::Activate();
// Hook up scenes, but not after loading a game because they're saved.
if ( gpGlobals->eLoadType != MapLoad_LoadGame )
{
for ( int i = 0; i < SCENE_LIST_MANAGER_MAX_SCENES; i++ )
{
if ( m_iszScenes[i] != NULL_STRING )
{
m_hScenes[i] = gEntList.FindEntityByName( NULL, STRING(m_iszScenes[i]) );
if ( m_hScenes[i] )
{
CSceneEntity *pScene = dynamic_cast<CSceneEntity*>(m_hScenes[i].Get());
if ( pScene )
{
pScene->AddListManager( this );
}
else
{
CSceneListManager *pList = dynamic_cast<CSceneListManager*>(m_hScenes[i].Get());
if ( pList )
{
pList->AddListManager( this );
}
else
{
Warning( "%s(%s) found an entity that wasn't a logic_choreographed_scene or logic_scene_list_manager in slot %d, named %s\n", GetDebugName(), GetClassname(), i, STRING(m_iszScenes[i]) );
m_hScenes[i] = NULL;
}
}
}
else
{
Warning( "%s(%s) could not find scene %d, named %s\n", GetDebugName(), GetClassname(), i, STRING(m_iszScenes[i]) );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: A scene or manager in our list has started playing.
// Remove all scenes earlier in the list.
//-----------------------------------------------------------------------------
void CSceneListManager::SceneStarted( CBaseEntity *pSceneOrManager )
{
// Move backwards and call remove on all scenes / managers earlier in the list to the fired one
bool bFoundStart = false;
for ( int i = SCENE_LIST_MANAGER_MAX_SCENES-1; i >= 0; i-- )
{
if ( !m_hScenes[i] )
continue;
if ( bFoundStart )
{
RemoveScene( i );
}
else if ( m_hScenes[i] == pSceneOrManager )
{
bFoundStart = true;
}
}
// Tell any managers we're within that we've started a scene
if ( bFoundStart )
{
int c = m_hListManagers.Count();
for ( int i = 0; i < c; i++ )
{
if ( m_hListManagers[i] )
{
m_hListManagers[i]->SceneStarted( this );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneListManager::AddListManager( CSceneListManager *pManager )
{
CHandle< CSceneListManager > h;
h = pManager;
// Only add it once
if ( m_hListManagers.Find( h ) == m_hListManagers.InvalidIndex() )
{
m_hListManagers.AddToTail( h );
}
}
//-----------------------------------------------------------------------------
// Purpose: Shut down all scenes, and then remove this entity
//-----------------------------------------------------------------------------
void CSceneListManager::InputShutdown( inputdata_t &inputdata )
{
ShutdownList();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneListManager::ShutdownList( void )
{
for ( int i = 0; i < SCENE_LIST_MANAGER_MAX_SCENES; i++ )
{
if ( m_hScenes[i] )
{
RemoveScene(i);
}
}
UTIL_Remove( this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSceneListManager::RemoveScene( int iIndex )
{
CSceneEntity *pScene = dynamic_cast<CSceneEntity*>(m_hScenes[iIndex].Get());
if ( pScene )
{
// Remove the scene
UTIL_Remove( pScene );
return;
}
// Tell the list manager to shut down all scenes
CSceneListManager *pList = dynamic_cast<CSceneListManager*>(m_hScenes[iIndex].Get());
if ( pList )
{
pList->ShutdownList();
}
}
void ReloadSceneFromDisk( CBaseEntity *ent )
{
CSceneEntity *scene = dynamic_cast< CSceneEntity * >( ent );
if ( !scene )
return;
Assert( 0 );
}
// Purpose:
// Input : *ent -
// Output : char const
//-----------------------------------------------------------------------------
char const *GetSceneFilename( CBaseEntity *ent )
{
CSceneEntity *scene = dynamic_cast< CSceneEntity * >( ent );
if ( !scene )
return "";
return STRING( scene->m_iszSceneFile );
}
//-----------------------------------------------------------------------------
// Purpose: Return a list of the last 5 lines of speech from NPCs for bug reports
// Input :
// Output : speech - last 5 sound files played as speech
// returns the number of sounds in the returned list
//-----------------------------------------------------------------------------
int GetRecentNPCSpeech( recentNPCSpeech_t speech[ SPEECH_LIST_MAX_SOUNDS ] )
{
int i;
int num;
int index;
// clear out the output list
for( i = 0; i < SPEECH_LIST_MAX_SOUNDS; i++ )
{
speech[ i ].time = 0.0f;
speech[ i ].name[ 0 ] = 0;
speech[ i ].sceneName[ 0 ] = 0;
}
// copy the sound names into the list in order they were played
num = 0;
index = speechListIndex;
for( i = 0; i < SPEECH_LIST_MAX_SOUNDS; i++ )
{
if ( speechListSounds[ index ].name[ 0 ] )
{
// only copy names that are not zero length
speech[ num ] = speechListSounds[ index ];
num++;
}
index++;
if ( index >= SPEECH_LIST_MAX_SOUNDS )
{
index = 0;
}
}
return num;
}
//-----------------------------------------------------------------------------
// Purpose: Displays a list of the last 5 lines of speech from NPCs
// Input :
// Output :
//-----------------------------------------------------------------------------
static void ListRecentNPCSpeech( void )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
recentNPCSpeech_t speech[ SPEECH_LIST_MAX_SOUNDS ];
int num;
int i;
// get any sounds that were spoken by NPCs recently
num = GetRecentNPCSpeech( speech );
Msg( "Recent NPC speech:\n" );
for( i = 0; i < num; i++ )
{
Msg( " time: %6.3f sound name: %s scene: %s\n", speech[ i ].time, speech[ i ].name, speech[ i ].sceneName );
}
Msg( "Current time: %6.3f\n", gpGlobals->curtime );
}
static ConCommand ListRecentNPCSpeechCmd( "listRecentNPCSpeech", ListRecentNPCSpeech, "Displays a list of the last 5 lines of speech from NPCs.", FCVAR_DONTRECORD|FCVAR_GAMEDLL );
CON_COMMAND( scene_flush, "Flush all .vcds from the cache and reload from disk." )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
Msg( "Reloading\n" );
scenefilecache->Reload();
Msg( " done\n" );
}