archive
/
csgo
mirror of https://github.com/sr2echa/CSGO-Source-Code
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Counter Strike : Global Offensive Source Code
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.
11 Commits
1 Branch
0 Tags
504 MiB
 
 
 
 
 
 
Tree: 47a548a4fc
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '47a548a4fc'
${ noResults }
csgo/cstrike15_src/game/server/baseflex.cpp

2887 lines
81 KiB
Raw Blame History

//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "animation.h"
#include "baseflex.h"
#include "filesystem.h"
#include "studio.h"
#include "choreoevent.h"
#include "choreoscene.h"
#include "choreoactor.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "tier1/strtools.h"
#include "keyvalues.h"
#include "ai_basenpc.h"
#include "ai_navigator.h"
#include "ai_moveprobe.h"
#include "sceneentity.h"
#include "ai_baseactor.h"
#include "datacache/imdlcache.h"
#include "tier1/byteswap.h"
#include "toolframework/itoolframework.h"
#include "flexcycler.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static ConVar scene_showlook( "scene_showlook", "0", FCVAR_ARCHIVE, "When playing back, show the directions of look events." );
static ConVar scene_showmoveto( "scene_showmoveto", "0", FCVAR_ARCHIVE, "When moving, show the end location." );
static ConVar scene_showunlock( "scene_showunlock", "0", FCVAR_ARCHIVE, "Show when a vcd is playing but normal AI is running." );
// static ConVar scene_checktagposition( "scene_checktagposition", "0", FCVAR_ARCHIVE, "When playing back a choreographed scene, check the current position of the tags relative to where they were authored." );
// Fake layer # to force HandleProcessSceneEvent to actually allocate the layer during npc think time instead of in between.
#define REQUEST_DEFERRED_LAYER_ALLOCATION -2
extern bool g_bClientFlex;
// ---------------------------------------------------------------------
//
// CBaseFlex -- physically simulated brush rectangular solid
//
// ---------------------------------------------------------------------
void* SendProxy_FlexWeights( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
{
// Don't any flexweights to client unless scene_clientflex.GetBool() is false
if ( !g_bClientFlex )
return (void*)pVarData;
else
return NULL;
}
REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_FlexWeights );
// SendTable stuff.
IMPLEMENT_SERVERCLASS_ST(CBaseFlex, DT_BaseFlex)
// Note we can't totally disabled flexweights transmission since some things like blink and eye tracking are still done by the server
SendPropArray3 (SENDINFO_ARRAY3(m_flexWeight), SendPropFloat(SENDINFO_ARRAY(m_flexWeight), 12, SPROP_ROUNDDOWN, 0.0f, 1.0f ) /*, SendProxy_FlexWeights*/ ),
SendPropInt (SENDINFO(m_blinktoggle), 1, SPROP_UNSIGNED ),
SendPropVector (SENDINFO(m_viewtarget), -1, SPROP_COORD),
#ifdef HL2_DLL
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 0), 0, SPROP_NOSCALE ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 1), 0, SPROP_NOSCALE ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 2), 0, SPROP_NOSCALE ),
SendPropVector ( SENDINFO(m_vecLean), -1, SPROP_COORD ),
SendPropVector ( SENDINFO(m_vecShift), -1, SPROP_COORD ),
#endif
END_SEND_TABLE()
BEGIN_DATADESC( CBaseFlex )
// m_blinktoggle
DEFINE_ARRAY( m_flexWeight, FIELD_FLOAT, MAXSTUDIOFLEXCTRL ),
DEFINE_FIELD( m_viewtarget, FIELD_POSITION_VECTOR ),
// m_SceneEvents
// m_FileList
DEFINE_FIELD( m_flAllowResponsesEndTime, FIELD_TIME ),
// m_ActiveChoreoScenes
// DEFINE_FIELD( m_LocalToGlobal, CUtlRBTree < FS_LocalToGlobal_t , unsigned short > ),
// m_bUpdateLayerPriorities
DEFINE_FIELD( m_flLastFlexAnimationTime, FIELD_TIME ),
#ifdef HL2_DLL
//DEFINE_FIELD( m_vecPrevOrigin, FIELD_POSITION_VECTOR ),
//DEFINE_FIELD( m_vecPrevVelocity, FIELD_VECTOR ),
DEFINE_FIELD( m_vecLean, FIELD_VECTOR ),
DEFINE_FIELD( m_vecShift, FIELD_VECTOR ),
#endif
END_DATADESC()
BEGIN_ENT_SCRIPTDESC( CBaseFlex, CBaseAnimating, "Animated characters who have vertex flex capability." )
DEFINE_SCRIPTFUNC_NAMED( ScriptGetOldestScene, "GetCurrentScene", "Returns the instance of the oldest active scene entity (if any)." )
DEFINE_SCRIPTFUNC_NAMED( ScriptGetSceneByIndex, "GetSceneByIndex", "Returns the instance of the scene entity at the specified index." )
END_SCRIPTDESC();
LINK_ENTITY_TO_CLASS( funCBaseFlex, CBaseFlex ); // meaningless independant class!!
CBaseFlex::CBaseFlex( void ) :
m_LocalToGlobal( 0, 0, FlexSettingLessFunc )
{
#ifdef _DEBUG
// default constructor sets the viewtarget to NAN
m_viewtarget.Init();
#endif
m_bUpdateLayerPriorities = true;
m_flLastFlexAnimationTime = 0.0;
}
CBaseFlex::~CBaseFlex( void )
{
m_LocalToGlobal.RemoveAll();
// If a player is forcibly removed while speaking a response .vcd we can get into here w/ some events waiting to
// be closed out. It's benign and we just discard the events. The CSceneEntity uses EHANDLEs so it'll wipe the
// scene out on next think anyway.
m_SceneEvents.RemoveAll();
}
void CBaseFlex::SetModel( const char *szModelName )
{
MDLCACHE_CRITICAL_SECTION();
BaseClass::SetModel( szModelName );
for (LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
{
SetFlexWeight( i, 0.0f );
}
}
CStudioHdr* CBaseFlex::OnNewModel()
{
return BaseClass::OnNewModel();
}
void CBaseFlex::SetViewtarget( const Vector &viewtarget )
{
m_viewtarget = viewtarget; // bah
}
void CBaseFlex::SetFlexWeight( LocalFlexController_t index, float value )
{
if (index >= 0 && index < GetNumFlexControllers())
{
CStudioHdr *pstudiohdr = GetModelPtr( );
if (! pstudiohdr)
return;
mstudioflexcontroller_t *pflexcontroller = pstudiohdr->pFlexcontroller( index );
if (pflexcontroller->max != pflexcontroller->min)
{
value = (value - pflexcontroller->min) / (pflexcontroller->max - pflexcontroller->min);
value = clamp( value, 0.0, 1.0 );
}
m_flexWeight.Set( index, value );
}
}
float CBaseFlex::GetFlexWeight( LocalFlexController_t index )
{
if (index >= 0 && index < GetNumFlexControllers())
{
CStudioHdr *pstudiohdr = GetModelPtr( );
if (! pstudiohdr)
return 0;
mstudioflexcontroller_t *pflexcontroller = pstudiohdr->pFlexcontroller( index );
if (pflexcontroller->max != pflexcontroller->min)
{
return m_flexWeight[index] * (pflexcontroller->max - pflexcontroller->min) + pflexcontroller->min;
}
return m_flexWeight[index];
}
return 0.0;
}
LocalFlexController_t CBaseFlex::FindFlexController( const char *szName )
{
for (LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
{
if (stricmp( GetFlexControllerName( i ), szName ) == 0)
{
return i;
}
}
// AssertMsg( 0, UTIL_VarArgs( "flexcontroller %s couldn't be mapped!!!\n", szName ) );
return LocalFlexController_t(0);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFlex::StartChoreoScene( CChoreoScene *scene )
{
if ( m_ActiveChoreoScenes.Find( scene ) != m_ActiveChoreoScenes.InvalidIndex() )
{
return;
}
m_ActiveChoreoScenes.AddToTail( scene );
m_bUpdateLayerPriorities = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseFlex::RemoveChoreoScene( CChoreoScene *scene, bool canceled )
{
// Assert( m_ActiveChoreoScenes.Find( scene ) != m_ActiveChoreoScenes.InvalidIndex() );
m_ActiveChoreoScenes.FindAndRemove( scene );
m_bUpdateLayerPriorities = true;
if (canceled)
{
CAI_BaseNPC *myNpc = MyNPCPointer( );
if ( myNpc )
{
myNpc->ClearSceneLock( );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseFlex::GetScenePriority( CChoreoScene *scene )
{
int iPriority = 0;
int c = m_ActiveChoreoScenes.Count();
// count number of channels in scenes older than current
for ( int i = 0; i < c; i++ )
{
CChoreoScene *pScene = m_ActiveChoreoScenes[ i ];
if ( !pScene )
{
continue;
}
if ( pScene == scene )
{
break;
}
iPriority += pScene->GetNumChannels( );
}
return iPriority;
}
//-----------------------------------------------------------------------------
// Purpose: Remove all active SceneEvents
//-----------------------------------------------------------------------------
void CBaseFlex::ClearSceneEvents( CChoreoScene *scene, bool canceled )
{
if ( !scene )
{
m_SceneEvents.RemoveAll();
return;
}
for ( int i = m_SceneEvents.Count() - 1; i >= 0; i-- )
{
CSceneEventInfo *info = &m_SceneEvents[ i ];
Assert( info );
Assert( info->m_pScene );
Assert( info->m_pEvent );
if ( info->m_pScene != scene )
continue;
if ( !ClearSceneEvent( info, false, canceled ))
{
// unknown expression to clear!!
Assert( 0 );
}
// Free this slot
info->m_pEvent = NULL;
info->m_pScene = NULL;
info->m_bStarted = false;
m_SceneEvents.Remove( i );
}
}
//-----------------------------------------------------------------------------
// Purpose: Stop specifics of expression
//-----------------------------------------------------------------------------
bool CBaseFlex::ClearSceneEvent( CSceneEventInfo *info, bool fastKill, bool canceled )
{
Assert( info );
Assert( info->m_pScene );
Assert( info->m_pEvent );
// FIXME: this code looks duplicated
switch ( info->m_pEvent->GetType() )
{
case CChoreoEvent::GESTURE:
case CChoreoEvent::SEQUENCE:
{
if (info->m_iLayer >= 0)
{
if ( fastKill )
{
FastRemoveLayer( info->m_iLayer );
}
else if (info->m_pEvent->GetType() == CChoreoEvent::GESTURE)
{
if (canceled)
{
// remove slower if interrupted
RemoveLayer( info->m_iLayer, 0.5 );
}
else
{
RemoveLayer( info->m_iLayer, 0.1 );
}
}
else
{
RemoveLayer( info->m_iLayer, 0.3 );
}
}
}
return true;
case CChoreoEvent::MOVETO:
{
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (!myNpc)
return true;
// cancel moveto if it's distance based, of if the event was part of a canceled vcd
if (IsMoving() && (canceled || info->m_pEvent->GetDistanceToTarget() > 0.0))
{
if (!info->m_bHasArrived)
{
if (info->m_pScene)
{
Scene_Printf( "%s : %8.2f: MOVETO canceled but actor %s not at goal\n", info->m_pScene->GetFilename(), info->m_pScene->GetTime(), info->m_pEvent->GetActor()->GetName() );
}
}
myNpc->GetNavigator()->StopMoving( false ); // Stop moving
}
}
return true;
case CChoreoEvent::FACE:
case CChoreoEvent::FLEXANIMATION:
case CChoreoEvent::EXPRESSION:
case CChoreoEvent::LOOKAT:
case CChoreoEvent::GENERIC:
case CChoreoEvent::CAMERA:
case CChoreoEvent::SCRIPT:
{
// no special rules
}
return true;
case CChoreoEvent::SPEAK:
{
// Tracker 15420: Issue stopsound if we need to cut this short...
if ( canceled )
{
StopSound( info->m_pEvent->GetParameters() );
#ifdef HL2_EPISODIC
// If we were holding the semaphore because of this speech, release it
CAI_BaseActor *pBaseActor = dynamic_cast<CAI_BaseActor*>(this);
if ( pBaseActor )
{
pBaseActor->GetExpresser()->ForceNotSpeaking();
}
#endif
}
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Add string indexed scene/expression/duration to list of active SceneEvents
// Input : scenefile -
// expression -
// duration -
//-----------------------------------------------------------------------------
void CBaseFlex::AddSceneEvent( CChoreoScene *scene, CChoreoEvent *event, CBaseEntity *pTarget /*= NULL*/, CSceneEntity* pSceneEntity /*= NULL*/ )
{
if ( !scene || !event )
{
Msg( "CBaseFlex::AddSceneEvent: scene or event was NULL!!!\n" );
return;
}
CChoreoActor *actor = event->GetActor();
if ( !actor )
{
Msg( "CBaseFlex::AddSceneEvent: event->GetActor() was NULL!!!\n" );
return;
}
CSceneEventInfo info;
memset( (void *)&info, 0, sizeof( info ) );
info.m_pEvent = event;
info.m_pScene = scene;
info.m_hTarget = pTarget;
info.m_bStarted = false;
info.m_hSceneEntity = pSceneEntity;
if (StartSceneEvent( &info, scene, event, actor, pTarget ))
{
m_SceneEvents.AddToTail( info );
}
else
{
Scene_Printf( "CBaseFlex::AddSceneEvent: event failed\n" );
// Assert( 0 ); // expression failed to start
}
}
//-----------------------------------------------------------------------------
// Starting various expression types
//-----------------------------------------------------------------------------
bool CBaseFlex::RequestStartSequenceSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, CBaseEntity *pTarget )
{
info->m_nSequence = LookupSequence( event->GetParameters() );
// make sure sequence exists
if (info->m_nSequence < 0)
{
Warning( "CSceneEntity %s :\"%s\" unable to find sequence \"%s\"\n", STRING(GetEntityName()), actor->GetName(), event->GetParameters() );
return false;
}
// This is a bit of a hack, but we need to defer the actual allocation until Process which will sync the layer allocation
// to the NPCs think/m_flAnimTime instead of some arbitrary tick
info->m_iLayer = REQUEST_DEFERRED_LAYER_ALLOCATION;
info->m_pActor = actor;
return true;
}
bool CBaseFlex::RequestStartGestureSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, CBaseEntity *pTarget )
{
info->m_nSequence = LookupSequence( event->GetParameters() );
// make sure sequence exists
if (info->m_nSequence < 0)
{
Warning( "CSceneEntity %s :\"%s\" unable to find gesture \"%s\"\n", STRING(GetEntityName()), actor->GetName(), event->GetParameters() );
return false;
}
// This is a bit of a hack, but we need to defer the actual allocation until Process which will sync the layer allocation
// to the NPCs think/m_flAnimTime instead of some arbitrary tick
info->m_iLayer = REQUEST_DEFERRED_LAYER_ALLOCATION;
info->m_pActor = actor;
return true;
}
bool CBaseFlex::HandleStartSequenceSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor )
{
Assert( info->m_iLayer == REQUEST_DEFERRED_LAYER_ALLOCATION );
info->m_nSequence = LookupSequence( event->GetParameters() );
info->m_iLayer = -1;
if (info->m_nSequence < 0)
{
Warning( "CSceneEntity %s :\"%s\" unable to find sequence \"%s\"\n", STRING(GetEntityName()), actor->GetName(), event->GetParameters() );
return false;
}
if (!EnterSceneSequence( scene, event ))
{
if (!event->GetPlayOverScript())
{
// this has failed to start
Warning( "CSceneEntity %s :\"%s\" failed to start sequence \"%s\"\n", STRING(GetEntityName()), actor->GetName(), event->GetParameters() );
return false;
}
// Start anyways, just use normal no-movement, must be in IDLE rules
}
info->m_iPriority = actor->FindChannelIndex( event->GetChannel() );
info->m_iLayer = AddLayeredSequence( info->m_nSequence, info->m_iPriority + GetScenePriority( scene ) );
SetLayerNoRestore( info->m_iLayer, true );
SetLayerWeight( info->m_iLayer, 0.0 );
bool looping = ((GetSequenceFlags( GetModelPtr(), info->m_nSequence ) & STUDIO_LOOPING) != 0);
if (!looping)
{
// figure out the animtime when this was frame 0
float dt = scene->GetTime() - event->GetStartTime();
float seq_duration = SequenceDuration( info->m_nSequence );
float flCycle = dt / seq_duration;
flCycle = flCycle - (int)flCycle; // loop
SetLayerCycle( info->m_iLayer, flCycle, flCycle );
SetLayerPlaybackRate( info->m_iLayer, 0.0 );
}
else
{
SetLayerPlaybackRate( info->m_iLayer, 1.0 );
}
if (IsMoving())
{
info->m_flWeight = 0.0;
}
else
{
info->m_flWeight = 1.0;
}
return true;
}
bool CBaseFlex::HandleStartGestureSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor )
{
Assert( info->m_iLayer == REQUEST_DEFERRED_LAYER_ALLOCATION );
info->m_nSequence = LookupSequence( event->GetParameters() );
info->m_iLayer = -1;
if (info->m_nSequence < 0)
{
Warning( "CSceneEntity %s :\"%s\" unable to find gesture \"%s\"\n", STRING(GetEntityName()), actor->GetName(), event->GetParameters() );
return false;
}
// FIXME: this seems like way too much code
info->m_bIsGesture = false;
KeyValues *seqKeyValues = GetSequenceKeyValues( info->m_nSequence );
if (seqKeyValues)
{
// Do we have a build point section?
KeyValues *pkvAllFaceposer = seqKeyValues->FindKey("faceposer");
if ( pkvAllFaceposer )
{
KeyValues *pkvType = pkvAllFaceposer->FindKey("type");
if (pkvType)
{
info->m_bIsGesture = (stricmp( pkvType->GetString(), "gesture" ) == 0) ? true : false;
}
}
// FIXME: fixup tags that should be set as "linear", should be done in faceposer
char szStartLoop[CEventAbsoluteTag::MAX_EVENTTAG_LENGTH] = { "loop" };
char szEndLoop[CEventAbsoluteTag::MAX_EVENTTAG_LENGTH] = { "end" };
// check in the tag indexes
KeyValues *pkvFaceposer;
for ( pkvFaceposer = pkvAllFaceposer->GetFirstSubKey(); pkvFaceposer; pkvFaceposer = pkvFaceposer->GetNextKey() )
{
if (!stricmp( pkvFaceposer->GetName(), "startloop" ))
{
strcpy( szStartLoop, pkvFaceposer->GetString() );
}
else if (!stricmp( pkvFaceposer->GetName(), "endloop" ))
{
strcpy( szEndLoop, pkvFaceposer->GetString() );
}
}
CEventAbsoluteTag *ptag;
ptag = event->FindAbsoluteTag( CChoreoEvent::ORIGINAL, szStartLoop );
if (ptag)
{
ptag->SetLinear( true );
}
ptag = event->FindAbsoluteTag( CChoreoEvent::PLAYBACK, szStartLoop );
if (ptag)
{
ptag->SetLinear( true );
}
ptag = event->FindAbsoluteTag( CChoreoEvent::ORIGINAL, szEndLoop );
if (ptag)
{
ptag->SetLinear( true );
}
ptag = event->FindAbsoluteTag( CChoreoEvent::PLAYBACK, szEndLoop );
if (ptag)
{
ptag->SetLinear( true );
}
if ( pkvAllFaceposer )
{
CStudioHdr *pstudiohdr = GetModelPtr();
mstudioseqdesc_t &seqdesc = pstudiohdr->pSeqdesc( info->m_nSequence );
mstudioanimdesc_t &animdesc = pstudiohdr->pAnimdesc( pstudiohdr->iRelativeAnim( info->m_nSequence, seqdesc.anim(0,0) ) );
// check in the tag indexes
KeyValues *pkvFaceposer;
for ( pkvFaceposer = pkvAllFaceposer->GetFirstSubKey(); pkvFaceposer; pkvFaceposer = pkvFaceposer->GetNextKey() )
{
if (!stricmp( pkvFaceposer->GetName(), "tags" ))
{
KeyValues *pkvTags;
for ( pkvTags = pkvFaceposer->GetFirstSubKey(); pkvTags; pkvTags = pkvTags->GetNextKey() )
{
int maxFrame = animdesc.numframes - 2; // FIXME: this is off by one!
if ( maxFrame > 0)
{
float percentage = (float)pkvTags->GetInt() / maxFrame;
CEventAbsoluteTag *ptag = event->FindAbsoluteTag( CChoreoEvent::ORIGINAL, pkvTags->GetName() );
if (ptag)
{
if (fabs(ptag->GetPercentage() - percentage) > 0.05)
{
DevWarning("%s repositioned tag: %s : %.3f -> %.3f (%s:%s:%s)\n", scene->GetFilename(), pkvTags->GetName(), ptag->GetPercentage(), percentage, scene->GetFilename(), actor->GetName(), event->GetParameters() );
// reposition tag
ptag->SetPercentage( percentage );
}
}
}
}
}
}
if (!event->VerifyTagOrder())
{
DevWarning("out of order tags : %s : (%s:%s:%s)\n", scene->GetFilename(), actor->GetName(), event->GetName(), event->GetParameters() );
}
}
seqKeyValues->deleteThis();
}
// initialize posture suppression
// FIXME: move priority of base animation so that layers can be inserted before
// FIXME: query stopping, post idle layer to figure out correct weight
// GetIdleLayerWeight()?
if (!info->m_bIsGesture && IsMoving())
{
info->m_flWeight = 0.0;
}
else
{
info->m_flWeight = 1.0;
}
// this happens before StudioFrameAdvance()
info->m_iPriority = actor->FindChannelIndex( event->GetChannel() );
info->m_iLayer = AddLayeredSequence( info->m_nSequence, info->m_iPriority + GetScenePriority( scene ) );
SetLayerNoRestore( info->m_iLayer, true );
SetLayerDuration( info->m_iLayer, event->GetDuration() );
SetLayerWeight( info->m_iLayer, 0.0 );
bool looping = ((GetSequenceFlags( GetModelPtr(), info->m_nSequence ) & STUDIO_LOOPING) != 0);
if ( looping )
{
DevMsg( 1, "vcd error, gesture %s of model %s is marked as STUDIO_LOOPING!\n",
event->GetParameters(), STRING(GetModelName()) );
}
SetLayerLooping( info->m_iLayer, false ); // force to not loop
float duration = event->GetDuration( );
// figure out the animtime when this was frame 0
float flEventCycle = (scene->GetTime() - event->GetStartTime()) / duration;
float flCycle = event->GetOriginalPercentageFromPlaybackPercentage( flEventCycle );
SetLayerCycle( info->m_iLayer, flCycle, 0.0 );
SetLayerPlaybackRate( info->m_iLayer, 0.0 );
return true;
}
bool CBaseFlex::StartFacingSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, CBaseEntity *pTarget )
{
if ( pTarget )
{
// Don't allow FACE commands while sitting in the vehicle
CAI_BaseNPC *myNpc = MyNPCPointer();
if ( myNpc && myNpc->IsInAVehicle() )
return false;
info->m_bIsMoving = false;
return true;
}
return false;
}
bool CBaseFlex::StartMoveToSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, CBaseEntity *pTarget )
{
if (pTarget)
{
info->m_bIsMoving = false;
info->m_bHasArrived = false;
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (!myNpc)
{
return false;
}
EnterSceneSequence( scene, event, true );
// If they're already moving, stop them
//
// Don't stop them during restore because that will set a stopping path very
// nearby, causing us to signal arrival prematurely in CheckSceneEventCompletion.
// BEWARE: the behavior of this bug depended on the order in which the entities were restored!!
if ( myNpc->IsMoving() && !scene->IsRestoring() )
{
myNpc->GetNavigator()->StopMoving( false );
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseFlex::StartSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, CBaseEntity *pTarget )
{
switch ( event->GetType() )
{
case CChoreoEvent::SEQUENCE:
return RequestStartSequenceSceneEvent( info, scene, event, actor, pTarget );
case CChoreoEvent::GESTURE:
return RequestStartGestureSceneEvent( info, scene, event, actor, pTarget );
case CChoreoEvent::FACE:
return StartFacingSceneEvent( info, scene, event, actor, pTarget );
// FIXME: move this to an CBaseActor
case CChoreoEvent::MOVETO:
return StartMoveToSceneEvent( info, scene, event, actor, pTarget );
case CChoreoEvent::LOOKAT:
info->m_hTarget = pTarget;
return true;
case CChoreoEvent::FLEXANIMATION:
info->InitWeight( this );
return true;
case CChoreoEvent::SPEAK:
return true;
case CChoreoEvent::EXPRESSION: // These are handled client-side
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Remove expression
// Input : scenefile -
// expression -
//-----------------------------------------------------------------------------
void CBaseFlex::RemoveSceneEvent( CChoreoScene *scene, CChoreoEvent *event, bool fastKill )
{
Assert( event );
for ( int i = 0 ; i < m_SceneEvents.Count(); i++ )
{
CSceneEventInfo *info = &m_SceneEvents[ i ];
Assert( info );
Assert( info->m_pEvent );
if ( info->m_pScene != scene )
continue;
if ( info->m_pEvent != event)
continue;
if (ClearSceneEvent( info, fastKill, false ))
{
// Free this slot
info->m_pEvent = NULL;
info->m_pScene = NULL;
info->m_bStarted = false;
m_SceneEvents.Remove( i );
return;
}
}
// many events refuse to start due to bogus parameters
}
//-----------------------------------------------------------------------------
// Purpose: Checks to see if the event should be considered "completed"
//-----------------------------------------------------------------------------
bool CBaseFlex::CheckSceneEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
for ( int i = 0 ; i < m_SceneEvents.Count(); i++ )
{
CSceneEventInfo *info = &m_SceneEvents[ i ];
Assert( info );
Assert( info->m_pEvent );
if ( info->m_pScene != scene )
continue;
if ( info->m_pEvent != event)
continue;
return CheckSceneEventCompletion( info, currenttime, scene, event );
}
return true;
}
bool CBaseFlex::CheckSceneEventCompletion( CSceneEventInfo *info, float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
switch ( event->GetType() )
{
case CChoreoEvent::MOVETO:
{
CAI_BaseNPC *npc = MyNPCPointer( );
if (npc)
{
// check movement, check arrival
if (npc->GetNavigator()->IsGoalActive())
{
const Task_t *pCurTask = npc->GetTask();
if ( pCurTask && (pCurTask->iTask == TASK_PLAY_SCENE || pCurTask->iTask == TASK_WAIT_FOR_MOVEMENT ) )
{
float preload = event->GetEndTime() - currenttime;
if (preload < 0)
{
//Msg("%.1f: no preload\n", currenttime );
return false;
}
float t = npc->GetTimeToNavGoal();
// Msg("%.1f: preload (%s:%.1f) %.1f %.1f\n", currenttime, event->GetName(), event->GetEndTime(), preload, t );
// FIXME: t is zero if no path can be built!
if (t > 0.0f && t <= preload)
{
return true;
}
return false;
}
}
else if (info->m_bHasArrived)
{
return true;
}
else if (info->m_bStarted && !npc->IsCurSchedule( SCHED_SCENE_GENERIC ))
{
// FIXME: There's still a hole in the logic is the save happens immediately after the SS steals the npc but before their AI has run again
Warning( "%s : %8.2f: waiting for actor %s to complete MOVETO but actor not in SCHED_SCENE_GENERIC\n", scene->GetFilename(), scene->GetTime(), event->GetActor()->GetName() );
// no longer in a scene :P
return true;
}
// still trying
return false;
}
}
break;
default:
break;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Default implementation
//-----------------------------------------------------------------------------
void CBaseFlex::ProcessSceneEvents( void )
{
VPROF( "CBaseFlex::ProcessSceneEvents" );
// slowly decay to netural expression
for ( LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
{
SetFlexWeight( i, GetFlexWeight( i ) * 0.95 );
}
bool bHasForegroundEvents = false;
// Iterate SceneEvents and look for active slots
for ( int i = 0; i < m_SceneEvents.Count(); i++ )
{
CSceneEventInfo *info = &m_SceneEvents[ i ];
Assert( info );
// FIXME: Need a safe handle to m_pEvent in case of memory deletion?
CChoreoEvent *event = info->m_pEvent;
Assert( event );
CChoreoScene *scene = info->m_pScene;
Assert( scene );
if ( scene && !scene->IsBackground() )
{
bHasForegroundEvents = true;
}
if (ProcessSceneEvent( info, scene, event ))
{
info->m_bStarted = true;
}
}
if ( bHasForegroundEvents && scene_showunlock.GetBool())
{
CAI_BaseNPC *myNpc = MyNPCPointer( );
if ( myNpc && !(myNpc->GetState() == NPC_STATE_SCRIPT || myNpc->IsCurSchedule( SCHED_SCENE_GENERIC )) )
{
Vector p0 = myNpc->GetHullMins();
Vector p1 = myNpc->GetHullMaxs();
p0.z = p1.z + 2;
p1.z = p1.z + 2;
NDebugOverlay::Box( myNpc->GetAbsOrigin(), p0, p1, 255, 0, 0, 0, 0.12 );
}
}
// any needed layer priorites have now been reset
m_bUpdateLayerPriorities = false;
}
class CFlexSceneFileManager : CAutoGameSystem
{
public:
CFlexSceneFileManager( char const *name ) : CAutoGameSystem( name )
{
}
virtual bool InitRecursive( const char *pFolder )
{
if ( pFolder == NULL )
{
pFolder = "expressions";
#if defined( PORTAL2 )
if ( IsGameConsole() )
{
return false;
}
#endif
}
char directory[ MAX_PATH ];
Q_snprintf( directory, sizeof( directory ), "%s/*.*", pFolder );
FileFindHandle_t fh;
const char *fn;
for (fn = g_pFullFileSystem->FindFirst( directory, &fh ); fn; fn = g_pFullFileSystem->FindNext( fh ) )
{
if ( !stricmp( fn, ".") || !stricmp( fn, "..") )
{
continue;
}
if ( g_pFullFileSystem->FindIsDirectory( fh ) )
{
char folderpath[MAX_PATH];
Q_snprintf( folderpath, sizeof( folderpath ), "%s/%s", pFolder, fn );
InitRecursive( folderpath );
continue;
}
const char *pExt = Q_GetFileExtension( fn );
if ( pExt && Q_stricmp( pExt, "vfe" ) )
{
continue;
}
char fullFileName[MAX_PATH];
Q_snprintf( fullFileName, sizeof(fullFileName), "%s/%s", pFolder, fn );
// strip default folder and extension
int index = V_strlen( "expressions/" );
char vfeName[ MAX_PATH ];
V_StripExtension( &fullFileName[index], vfeName, sizeof( vfeName ) );
V_FixSlashes( vfeName );
FindSceneFile( NULL, vfeName, true );
}
return true;
}
virtual bool Init()
{
// Trakcer 16692: Preload these at startup to avoid hitch first time we try to load them during actual gameplay
FindSceneFile( NULL, "phonemes", true );
FindSceneFile( NULL, "phonemes_weak", true );
FindSceneFile( NULL, "phonemes_strong", true );
#if defined( HL2_DLL )
FindSceneFile( NULL, "random", true );
FindSceneFile( NULL, "randomAlert", true );
#endif
InitRecursive( NULL );
return true;
}
// Tracker 14992: We used to load 18K of .vfes for every CBaseFlex who lipsynced, but now we only load those files once globally.
// Note, we could wipe these between levels, but they don't ever load more than the weak/normal/strong phoneme classes that I can tell
// so I'll just leave them loaded forever for now
virtual void Shutdown()
{
DeleteSceneFiles();
}
//-----------------------------------------------------------------------------
// Purpose: Sets up translations
// Input : *instance -
// *pSettinghdr -
// Output : void
//-----------------------------------------------------------------------------
void EnsureTranslations( CBaseFlex *instance, const flexsettinghdr_t *pSettinghdr )
{
// The only time instance is NULL is in Init() above, where we're just loading the .vfe files off of the hard disk.
if ( instance )
{
instance->EnsureTranslations( pSettinghdr );
}
}
const void *FindSceneFile( CBaseFlex *instance, const char *filename, bool allowBlockingIO )
{
char szFilename[MAX_PATH];
Assert( V_strlen( filename ) < MAX_PATH );
V_strcpy( szFilename, filename );
Q_FixSlashes( szFilename );
// See if it's already loaded
int i;
for ( i = 0; i < m_FileList.Count(); i++ )
{
CFlexSceneFile *file = m_FileList[ i ];
if ( file && !V_stricmp( file->filename, szFilename ) )
{
// Make sure translations (local to global flex controller) are set up for this instance
EnsureTranslations( instance, ( const flexsettinghdr_t * )file->buffer );
return file->buffer;
}
}
if ( !allowBlockingIO )
{
return NULL;
}
// Load file into memory
void *buffer = NULL;
int len = filesystem->ReadFileEx( UTIL_VarArgs( "expressions/%s.vfe", szFilename ), "GAME", &buffer, false, true );
if ( !len )
return NULL;
// Create scene entry
CFlexSceneFile *pfile = new CFlexSceneFile;
// Remember filename
Q_strncpy( pfile->filename, szFilename, sizeof( pfile->filename ) );
// Remember data pointer
pfile->buffer = buffer;
// Add to list
m_FileList.AddToTail( pfile );
// Swap the entire file
if ( IsGameConsole() )
{
CByteswap swap;
swap.ActivateByteSwapping( true );
byte *pData = (byte*)buffer;
flexsettinghdr_t *pHdr = (flexsettinghdr_t*)pData;
swap.SwapFieldsToTargetEndian( pHdr );
// Flex Settings
flexsetting_t *pFlexSetting = (flexsetting_t*)((byte*)pHdr + pHdr->flexsettingindex);
for ( int i = 0; i < pHdr->numflexsettings; ++i, ++pFlexSetting )
{
swap.SwapFieldsToTargetEndian( pFlexSetting );
flexweight_t *pWeight = (flexweight_t*)(((byte*)pFlexSetting) + pFlexSetting->settingindex );
for ( int j = 0; j < pFlexSetting->numsettings; ++j, ++pWeight )
{
swap.SwapFieldsToTargetEndian( pWeight );
}
}
// indexes
pData = (byte*)pHdr + pHdr->indexindex;
swap.SwapBufferToTargetEndian( (int*)pData, (int*)pData, pHdr->numindexes );
// keymappings
pData = (byte*)pHdr + pHdr->keymappingindex;
swap.SwapBufferToTargetEndian( (int*)pData, (int*)pData, pHdr->numkeys );
// keyname indices
pData = (byte*)pHdr + pHdr->keynameindex;
swap.SwapBufferToTargetEndian( (int*)pData, (int*)pData, pHdr->numkeys );
}
// Fill in translation table
EnsureTranslations( instance, ( const flexsettinghdr_t * )pfile->buffer );
// Return data
return pfile->buffer;
}
private:
void DeleteSceneFiles()
{
while ( m_FileList.Count() > 0 )
{
CFlexSceneFile *file = m_FileList[ 0 ];
m_FileList.Remove( 0 );
filesystem->FreeOptimalReadBuffer( file->buffer );
delete file;
}
}
CUtlVector< CFlexSceneFile * > m_FileList;
};
// Singleton manager
CFlexSceneFileManager g_FlexSceneFileManager( "CFlexSceneFileManager" );
//-----------------------------------------------------------------------------
// Purpose: Each CBaseFlex maintains a UtlRBTree of mappings, one for each loaded flex scene file it uses. This is used to
// sort the entries in the RBTree
// Input : lhs -
// rhs -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseFlex::FlexSettingLessFunc( const FS_LocalToGlobal_t& lhs, const FS_LocalToGlobal_t& rhs )
{
return lhs.m_Key < rhs.m_Key;
}
//-----------------------------------------------------------------------------
// Purpose: Since everyone shared a pSettinghdr now, we need to set up the localtoglobal mapping per entity, but
// we just do this in memory with an array of integers (could be shorts, I suppose)
// Input : *pSettinghdr -
//-----------------------------------------------------------------------------
void CBaseFlex::EnsureTranslations( const flexsettinghdr_t *pSettinghdr )
{
Assert( pSettinghdr );
FS_LocalToGlobal_t entry( pSettinghdr );
unsigned short idx = m_LocalToGlobal.Find( entry );
if ( idx != m_LocalToGlobal.InvalidIndex() )
return;
entry.SetCount( pSettinghdr->numkeys );
for ( int i = 0; i < pSettinghdr->numkeys; ++i )
{
entry.m_Mapping[ i ] = FindFlexController( pSettinghdr->pLocalName( i ) );
}
m_LocalToGlobal.Insert( entry );
}
//-----------------------------------------------------------------------------
// Purpose: Look up instance specific mapping
// Input : *pSettinghdr -
// key -
// Output : int
//-----------------------------------------------------------------------------
LocalFlexController_t CBaseFlex::FlexControllerLocalToGlobal( const flexsettinghdr_t *pSettinghdr, int key )
{
FS_LocalToGlobal_t entry( pSettinghdr );
int idx = m_LocalToGlobal.Find( entry );
if ( idx == m_LocalToGlobal.InvalidIndex() )
{
// This should never happen!!!
Assert( 0 );
Warning( "Unable to find mapping for flexcontroller %i, settings %p on %i/%s\n", key, pSettinghdr, entindex(), GetClassname() );
EnsureTranslations( pSettinghdr );
idx = m_LocalToGlobal.Find( entry );
if ( idx == m_LocalToGlobal.InvalidIndex() )
{
Error( "CBaseFlex::FlexControllerLocalToGlobal failed!\n" );
}
}
FS_LocalToGlobal_t& result = m_LocalToGlobal[ idx ];
// Validate lookup
Assert( result.m_nCount != 0 && key < result.m_nCount );
LocalFlexController_t index = result.m_Mapping[ key ];
return index;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
//-----------------------------------------------------------------------------
const void *CBaseFlex::FindSceneFile( const char *filename )
{
// Ask manager to get the globally cached scene instead.
// hunt up the tree for the filename starting with our model name prepended as the path
static char szExtendedPath[MAX_PATH];
if ( StringHasPrefix( STRING( GetModelName() ), "models" ) )
{
strcpy( szExtendedPath, StringAfterPrefix( STRING( GetModelName() ), "models" ) + 1 );
}
else
{
strcpy( szExtendedPath, STRING( GetModelName() ) );
}
V_StripExtension( szExtendedPath, szExtendedPath, sizeof( szExtendedPath ) );
V_FixupPathName( szExtendedPath, sizeof( szExtendedPath ), szExtendedPath );
const void *pSceneFile = NULL;
// FIXME: V_StripLastDir returns "./" path when it strips out the last one. That don't resolve on FindSceneFile
while ( V_strlen( szExtendedPath ) > 2 )
{
static char szExtendedName[MAX_PATH];
V_ComposeFileName( szExtendedPath, filename, szExtendedName, sizeof( szExtendedName ) );
pSceneFile = g_FlexSceneFileManager.FindSceneFile( this, szExtendedName, false );
if ( pSceneFile )
break;
if ( !V_StripLastDir( szExtendedPath, sizeof( szExtendedPath ) ) )
break;
}
if ( !pSceneFile )
{
// just ask for it by name
pSceneFile = g_FlexSceneFileManager.FindSceneFile( this, filename, false );
}
return pSceneFile;
}
ConVar ai_expression_optimization( "ai_expression_optimization", "0", FCVAR_NONE, "Disable npc background expressions when you can't see them." );
ConVar ai_expression_frametime( "ai_expression_frametime", "0.05", FCVAR_NONE, "Maximum frametime to still play background expressions." );
//-----------------------------------------------------------------------------
// Various methods to process facial SceneEvents:
//-----------------------------------------------------------------------------
bool CBaseFlex::ProcessFlexAnimationSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
VPROF( "CBaseFlex::ProcessFlexAnimationSceneEvent" );
if ( event->HasEndTime() )
{
// don't bother with flex animation if the player can't see you
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (myNpc)
{
if (!myNpc->HasCondition( COND_IN_PVS ))
return true;
if (ai_expression_optimization.GetBool())
{
if (scene->IsBackground())
{
// if framerate too slow, disable
if (gpGlobals->frametime > ai_expression_frametime.GetFloat())
{
info->m_bHasArrived = true;
info->m_flNext = gpGlobals->curtime + RandomFloat( 0.7, 1.2 );
}
// only check occasionally
else if (info->m_flNext <= gpGlobals->curtime)
{
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
// if not in view, disable
info->m_bHasArrived = (pPlayer && !pPlayer->FInViewCone( this ) );
info->m_flNext = gpGlobals->curtime + RandomFloat( 0.7, 1.2 );
}
if (info->m_bHasArrived)
{
// NDebugOverlay::Box( myNpc->GetAbsOrigin(), myNpc->GetHullMins(), myNpc->GetHullMaxs(), 255, 0, 0, 0, 0.22 );
return true;
}
// NDebugOverlay::Box( myNpc->GetAbsOrigin(), myNpc->GetHullMins(), myNpc->GetHullMaxs(), 0, 255, 0, 0, 0.22 );
}
}
}
AddFlexAnimation( info );
}
return true;
}
bool CBaseFlex::ProcessFlexSettingSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
// Flexanimations have to have an end time!!!
if ( !event->HasEndTime() )
return true;
VPROF( "CBaseFlex::ProcessFlexSettingSceneEvent" );
// Look up the actual strings
const char *scenefile = event->GetParameters();
const char *name = event->GetParameters2();
// Have to find both strings
if ( scenefile && name )
{
if ( info->m_pExpHdr == NULL)
{
info->m_pExpHdr = ( const flexsettinghdr_t * )FindSceneFile( scenefile );
}
if ( info->m_pExpHdr )
{
float scenetime = scene->GetTime();
float scale = event->GetIntensity( scenetime );
// Add the named expression
AddFlexSetting( name, scale, info->m_pExpHdr, !info->m_bStarted );
}
}
return true;
}
bool CBaseFlex::ProcessFacingSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
// make sure target exists
if (info->m_hTarget == NULL)
return false;
VPROF( "CBaseFlex::ProcessFacingSceneEvent" );
// make sure we're still able to play this command
if (!EnterSceneSequence( scene, event, true ))
{
return false;
}
if (!info->m_bStarted)
{
info->m_flInitialYaw = GetLocalAngles().y;
}
// lock in place if aiming at self
if (info->m_hTarget == this)
{
return true;
}
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (myNpc)
{
if (info->m_bIsMoving != IsMoving())
{
info->m_flInitialYaw = GetLocalAngles().y;
}
info->m_bIsMoving = IsMoving();
// Msg("%f : %f - %f\n", scene->GetTime(), event->GetStartTime(), event->GetEndTime() );
// FIXME: why are the splines ill behaved at the end?
float intensity = event->GetIntensity( scene->GetTime() );
if (info->m_bIsMoving)
{
myNpc->AddFacingTarget( info->m_hTarget, intensity, 0.2 );
}
else
{
float goalYaw = myNpc->CalcIdealYaw( info->m_hTarget->EyePosition() );
float diff = UTIL_AngleDiff( goalYaw, info->m_flInitialYaw );
float idealYaw = UTIL_AngleMod( info->m_flInitialYaw + diff * intensity );
// Msg("yaw %.1f : %.1f (%.1f)\n", info->m_flInitialYaw, idealYaw, intensity );
myNpc->GetMotor()->SetIdealYawAndUpdate( idealYaw );
}
return true;
}
return false;
}
static Activity DetermineExpressionMoveActivity( CChoreoEvent *event, CAI_BaseNPC *pNPC )
{
Activity activity = ACT_WALK;
const char *sParam2 = event->GetParameters2();
if ( !sParam2 || !sParam2[0] )
return activity;
// Custom distance styles are appended to param2 with a space as a separator
const char *pszAct = Q_strstr( sParam2, " " );
if ( pszAct )
{
char szActName[256];
Q_strncpy( szActName, sParam2, sizeof(szActName) );
szActName[ (pszAct-sParam2) ] = '\0';
pszAct = szActName;
}
else
{
pszAct = sParam2;
}
if ( !Q_stricmp( pszAct, "Walk" ) )
{
activity = ACT_WALK;
}
else if ( !Q_stricmp( pszAct, "Run" ) )
{
activity = ACT_RUN;
}
else if ( !Q_stricmp( pszAct, "CrouchWalk" ) )
{
activity = ACT_WALK_CROUCH;
}
else
{
// Try and resolve the activity name
activity = (Activity)ActivityList_IndexForName( pszAct );
if ( activity == ACT_INVALID )
{
// Assume it's a sequence name
pNPC->m_iszSceneCustomMoveSeq = AllocPooledString( pszAct );
activity = ACT_SCRIPT_CUSTOM_MOVE;
}
}
return activity;
}
bool CBaseFlex::ProcessMoveToSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
// make sure target exists
if (info->m_hTarget == NULL)
return false;
// FIXME: move to CBaseActor or BaseNPC
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (!myNpc)
return false;
VPROF( "CBaseFlex::ProcessMoveToSceneEvent" );
// make sure we're still able to play this command
if (!EnterSceneSequence( scene, event, true ))
{
return false;
}
// lock in place if aiming at self
if (info->m_hTarget == this)
{
return true;
}
// If we're in a vehicle, make us exit and *then* begin the run
if ( myNpc->IsInAVehicle() )
{
// Make us exit and wait
myNpc->ExitVehicle();
return false;
}
const Task_t *pCurTask = myNpc->GetTask();
if (!info->m_bIsMoving && (!IsMoving() || pCurTask->iTask == TASK_STOP_MOVING) )
{
if ( pCurTask && (pCurTask->iTask == TASK_PLAY_SCENE || pCurTask->iTask == TASK_WAIT_FOR_MOVEMENT || pCurTask->iTask == TASK_STOP_MOVING ) )
{
Activity moveActivity = DetermineExpressionMoveActivity( event, myNpc );
// AI_NavGoal_t goal( info->m_hTarget->EyePosition(), moveActivity, AIN_HULL_TOLERANCE );
myNpc->SetTarget( info->m_hTarget );
float flDistTolerance;
flDistTolerance = myNpc->GetHullWidth() / 2.0;
// flDistTolerance = AIN_HULL_TOLERANCE;
if (event->m_bForceShortMovement)
{
flDistTolerance = 0.1f;
}
AI_NavGoal_t goal( GOALTYPE_TARGETENT, moveActivity, flDistTolerance, AIN_UPDATE_TARGET_POS );
float flDist = (info->m_hTarget->EyePosition() - GetAbsOrigin()).Length2D();
if (flDist > MAX( MAX( flDistTolerance, 0.1 ), event->GetDistanceToTarget()))
{
// Msg("flDist %.1f\n", flDist );
int result = false;
if ( !myNpc->IsUnreachable( info->m_hTarget ) )
{
result = myNpc->GetNavigator()->SetGoal( goal, AIN_CLEAR_TARGET );
if ( !result )
{
myNpc->RememberUnreachable( info->m_hTarget, 1.5 );
}
}
if (result)
{
myNpc->GetNavigator()->SetMovementActivity( moveActivity );
myNpc->GetNavigator()->SetArrivalDistance( event->GetDistanceToTarget() );
info->m_bIsMoving = true;
}
else
{
// need route build failure case
// Msg("actor %s unable to build route\n", STRING( myNpc->GetEntityName() ) );
// Assert(0);
if (developer.GetInt() > 0 && scene_showmoveto.GetBool())
{
Vector vTestPoint;
myNpc->GetMoveProbe()->FloorPoint( info->m_hTarget->EyePosition(), myNpc->GetAITraceMask(), 0, -64, &vTestPoint );
NDebugOverlay::HorzArrow( GetAbsOrigin() + Vector( 0, 0, 1 ), vTestPoint + Vector( 0, 0, 1 ), 4, 255, 0, 255, 0, false, 0.12 );
NDebugOverlay::Box( vTestPoint, myNpc->GetHullMins(), myNpc->GetHullMaxs(), 255, 0, 255, 0, 0.12 );
}
}
}
else
{
info->m_bHasArrived = true;
}
}
}
else if (IsMoving())
{
// float flDist = (myNpc->GetNavigator()->GetGoalPos() - GetAbsOrigin()).Length2D();
float flDist = (info->m_hTarget->EyePosition() - GetAbsOrigin()).Length2D();
if (flDist <= event->GetDistanceToTarget())
{
myNpc->GetNavigator()->StopMoving( false ); // Stop moving
info->m_bHasArrived = true;
}
}
else
{
info->m_bIsMoving = false;
}
// show movement target
if (developer.GetInt() > 0 && scene_showmoveto.GetBool() && IsMoving())
{
Vector vecStart, vTestPoint;
vecStart = myNpc->GetNavigator()->GetGoalPos();
myNpc->GetMoveProbe()->FloorPoint( vecStart, myNpc->GetAITraceMask(), 0, -64, &vTestPoint );
int r, g, b;
r = b = g = 0;
if ( myNpc->GetNavigator()->CanFitAtPosition( vTestPoint, myNpc->GetAITraceMask() ) )
{
if ( myNpc->GetMoveProbe()->CheckStandPosition( vTestPoint, myNpc->GetAITraceMask() ) )
{
if (event->IsResumeCondition())
{
g = 255;
}
else
{
r = 255; g = 255;
}
}
else
{
b = 255; g = 255;
}
}
else
{
r = 255;
}
NDebugOverlay::HorzArrow( GetAbsOrigin() + Vector( 0, 0, 1 ), vTestPoint + Vector( 0, 0, 1 ), 4, r, g, b, 0, false, 0.12 );
NDebugOverlay::Box( vTestPoint, myNpc->GetHullMins(), myNpc->GetHullMaxs(), r, g, b, 0, 0.12 );
}
// handled in task
return true;
}
bool CBaseFlex::ProcessLookAtSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
VPROF( "CBaseFlex::ProcessLookAtSceneEvent" );
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (myNpc && info->m_hTarget != NULL)
{
float intensity = event->GetIntensity( scene->GetTime() );
// clamp in-ramp to 0.3 seconds
float flDuration = scene->GetTime() - event->GetStartTime();
float flMaxIntensity = flDuration < 0.3f ? SimpleSpline( flDuration / 0.3f ) : 1.0f;
intensity = clamp( intensity, 0.0f, flMaxIntensity );
myNpc->AddLookTarget( info->m_hTarget, intensity, 0.1 );
if (developer.GetInt() > 0 && scene_showlook.GetBool() && info->m_hTarget)
{
Vector tmp = info->m_hTarget->EyePosition() - myNpc->EyePosition();
VectorNormalize( tmp );
Vector p0 = myNpc->EyePosition();
NDebugOverlay::VertArrow( p0, p0 + tmp * (4 + 16 * intensity ), 4, 255, 255, 255, 0, true, 0.12 );
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseFlex::ProcessSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
VPROF( "CBaseFlex::ProcessSceneEvent" );
switch ( event->GetType() )
{
case CChoreoEvent::FLEXANIMATION:
return ProcessFlexAnimationSceneEvent( info, scene, event );
case CChoreoEvent::EXPRESSION:
return ProcessFlexSettingSceneEvent( info, scene, event );
case CChoreoEvent::SEQUENCE:
return ProcessSequenceSceneEvent( info, scene, event );
case CChoreoEvent::GESTURE:
return ProcessGestureSceneEvent( info, scene, event );
case CChoreoEvent::FACE:
return ProcessFacingSceneEvent( info, scene, event );
case CChoreoEvent::MOVETO:
return ProcessMoveToSceneEvent( info, scene, event );
case CChoreoEvent::LOOKAT:
return ProcessLookAtSceneEvent( info, scene, event );
case CChoreoEvent::SPEAK:
return true;
default:
{
Msg( "unknown type %d in ProcessSceneEvent()\n", event->GetType() );
Assert( 0 );
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseFlex::IsRunningSceneMoveToEvent()
{
for ( int i = m_SceneEvents.Count() - 1; i >= 0; i-- )
{
CSceneEventInfo *info = &m_SceneEvents[ i ];
CChoreoEvent *event = info->m_pEvent;
if ( event && event->GetType() == CChoreoEvent::MOVETO )
return true;
}
return false;
}
flexsetting_t const *CBaseFlex::FindNamedSetting( flexsettinghdr_t const *pSettinghdr, const char *expr )
{
int i;
const flexsetting_t *pSetting = NULL;
for ( i = 0; i < pSettinghdr->numflexsettings; i++ )
{
pSetting = pSettinghdr->pSetting( i );
if ( !pSetting )
continue;
const char *name = pSetting->pszName();
if ( !stricmp( name, expr ) )
break;
}
if ( i>=pSettinghdr->numflexsettings )
{
return NULL;
}
return pSetting;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
//-----------------------------------------------------------------------------
void CBaseFlex::AddFlexAnimation( CSceneEventInfo *info )
{
if ( !info )
return;
// don't bother with flex animation if the player can't see you
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (myNpc && !myNpc->HasCondition( COND_IN_PVS ))
return;
CChoreoEvent *event = info->m_pEvent;
if ( !event )
return;
CChoreoScene *scene = info->m_pScene;
if ( !scene )
return;
if ( !event->GetTrackLookupSet() )
{
// Create lookup data
for ( int i = 0; i < event->GetNumFlexAnimationTracks(); i++ )
{
CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
if ( !track )
continue;
if ( track->IsComboType() )
{
char name[ 512 ];
Q_strncpy( name, "right_" ,sizeof(name));
Q_strncat( name, track->GetFlexControllerName(),sizeof(name), COPY_ALL_CHARACTERS );
track->SetFlexControllerIndex( FindFlexController( name ), 0, 0 );
if ( CAI_BaseActor::IsServerSideFlexController( name ) )
{
Assert( !"Should stereo controllers ever be server side only?" );
track->SetServerSide( true );
}
Q_strncpy( name, "left_" ,sizeof(name));
Q_strncat( name, track->GetFlexControllerName(),sizeof(name), COPY_ALL_CHARACTERS );
track->SetFlexControllerIndex( FindFlexController( name ), 0, 1 );
if ( CAI_BaseActor::IsServerSideFlexController( name ) )
{
Assert( !"Should stereo controllers ever be server side only?" );
track->SetServerSide( true );
}
}
else
{
track->SetFlexControllerIndex( FindFlexController( (char *)track->GetFlexControllerName() ), 0 );
// Only non-combo tracks can be server side
track->SetServerSide( CAI_BaseActor::IsServerSideFlexController( track->GetFlexControllerName() ) );
}
}
event->SetTrackLookupSet( true );
}
float scenetime = scene->GetTime();
// decay if this is a background scene and there's other flex animations playing
float weight = event->GetIntensity( scenetime ) * info->UpdateWeight( this );
{
VPROF( "AddFlexAnimation_SetFlexWeight" );
// Compute intensity for each track in animation and apply
// Iterate animation tracks
for ( int i = 0; i < event->GetNumFlexAnimationTracks(); i++ )
{
CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
if ( !track )
continue;
// Disabled
if ( !track->IsTrackActive() )
continue;
// If we are doing client side flexing, skip all tracks which are not server side
if ( g_bClientFlex && !track->IsServerSide() )
continue;
// Map track flex controller to global name
if ( track->IsComboType() )
{
for ( int side = 0; side < 2; side++ )
{
LocalFlexController_t controller = track->GetRawFlexControllerIndex( side );
// Get spline intensity for controller
float flIntensity = track->GetIntensity( scenetime, side );
if ( controller >= LocalFlexController_t(0) )
{
float orig = GetFlexWeight( controller );
SetFlexWeight( controller, orig * (1 - weight) + flIntensity * weight );
}
}
}
else
{
LocalFlexController_t controller = track->GetRawFlexControllerIndex( 0 );
// Get spline intensity for controller
float flIntensity = track->GetIntensity( scenetime, 0 );
if ( controller >= LocalFlexController_t(0) )
{
float orig = GetFlexWeight( controller );
SetFlexWeight( controller, orig * (1 - weight) + flIntensity * weight );
}
}
}
}
info->m_bStarted = true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *expr -
// scale -
// *pSettinghdr -
// newexpression -
//-----------------------------------------------------------------------------
void CBaseFlex::AddFlexSetting( const char *expr, float scale,
const flexsettinghdr_t *pSettinghdr, bool newexpression )
{
int i;
const flexsetting_t *pSetting = NULL;
// Find the named setting in the base
for ( i = 0; i < pSettinghdr->numflexsettings; i++ )
{
pSetting = pSettinghdr->pSetting( i );
if ( !pSetting )
continue;
const char *name = pSetting->pszName();
if ( !stricmp( name, expr ) )
break;
}
if ( i>=pSettinghdr->numflexsettings )
{
return;
}
flexweight_t *pWeights = NULL;
int truecount = pSetting->psetting( (byte *)pSettinghdr, 0, &pWeights );
if ( !pWeights )
return;
for (i = 0; i < truecount; i++, pWeights++)
{
// Translate to local flex controller
// this is translating from the settings's local index to the models local index
LocalFlexController_t index = FlexControllerLocalToGlobal( pSettinghdr, pWeights->key );
// blend scaled weighting in to total
float s = clamp( scale * pWeights->influence, 0.0f, 1.0f );
float value = GetFlexWeight( index ) * (1.0f - s ) + pWeights->weight * s;
SetFlexWeight( index, value );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
bool CBaseFlex::ProcessGestureSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
if ( !info || !event || !scene )
return false;
if ( info->m_iLayer == REQUEST_DEFERRED_LAYER_ALLOCATION )
{
HandleStartGestureSceneEvent( info, scene, event, info->m_pActor );
}
if (info->m_iLayer >= 0)
{
// this happens after StudioFrameAdvance()
// FIXME; this needs to be adjusted by npc offset to scene time? Known?
// FIXME: what should this do when the scene loops?
float duration = event->GetDuration( );
float flEventCycle = (scene->GetTime() - event->GetStartTime()) / duration;
float flCycle = event->GetOriginalPercentageFromPlaybackPercentage( flEventCycle );
SetLayerCycle( info->m_iLayer, flCycle );
float flWeight = event->GetIntensity( scene->GetTime() );
/*
if (stricmp( event->GetParameters(), "m_g_arms_crossed" ) == 0)
{
Msg("%.2f (%.2f) : %s : %.3f (%.3f) %.2f\n", scene->GetTime(), scene->GetTime() - event->GetStartTime(), event->GetParameters(), flCycle, flEventCycle, flWeight );
}
*/
// fade out/in if npc is moving
if (!info->m_bIsGesture)
{
if (IsMoving())
{
info->m_flWeight = MAX( info->m_flWeight - 0.2, 0.0 );
}
else
{
info->m_flWeight = MIN( info->m_flWeight + 0.2, 1.0 );
}
}
// 3x^2-2x^3
float spline = 3 * info->m_flWeight * info->m_flWeight - 2 * info->m_flWeight * info->m_flWeight * info->m_flWeight;
SetLayerWeight( info->m_iLayer, flWeight * spline );
// update layer priority
if (m_bUpdateLayerPriorities)
{
SetLayerPriority( info->m_iLayer, info->m_iPriority + GetScenePriority( scene ) );
}
/*
Msg( "%d : %.2f (%.2f) : %.3f %.3f : %.3f\n",
info->m_iLayer,
scene->GetTime(),
(scene->GetTime() - event->GetStartTime()) / duration,
flCycle,
flNextCycle,
rate );
*/
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// *parameters -
//-----------------------------------------------------------------------------
bool CBaseFlex::ProcessSequenceSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
if ( !info || !event || !scene )
return false;
bool bNewlyAllocated = false;
if ( info->m_iLayer == REQUEST_DEFERRED_LAYER_ALLOCATION )
{
bool result = HandleStartSequenceSceneEvent( info, scene, event, info->m_pActor );
if (!result)
return false;
bNewlyAllocated = true;
}
if (info->m_iLayer >= 0)
{
float flWeight = event->GetIntensity( scene->GetTime() );
// force layer to zero weight in newly allocated, fixed bug with inter-think spawned sequences blending in badly
if (bNewlyAllocated)
flWeight = 0.0;
// fade out/in if npc is moving
bool bFadeOut = IsMoving();
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (myNpc && !(myNpc->IsCurSchedule( SCHED_SCENE_GENERIC ) || myNpc->GetActivity() == ACT_IDLE_ANGRY || myNpc->GetActivity() == ACT_IDLE) )
{
bFadeOut = true;
if (info->m_flWeight == 1.0)
{
Warning( "%s playing CChoreoEvent::SEQUENCE but AI has forced them to do something different\n", STRING(GetEntityName()) );
}
}
if (bFadeOut)
{
info->m_flWeight = MAX( info->m_flWeight - 0.2, 0.0 );
}
else
{
info->m_flWeight = MIN( info->m_flWeight + 0.2, 1.0 );
}
float spline = 3 * info->m_flWeight * info->m_flWeight - 2 * info->m_flWeight * info->m_flWeight * info->m_flWeight;
SetLayerWeight( info->m_iLayer, flWeight * spline );
bool looping = ((GetSequenceFlags( GetModelPtr(), info->m_nSequence ) & STUDIO_LOOPING) != 0);
if (!looping)
{
float dt = scene->GetTime() - event->GetStartTime();
float seq_duration = SequenceDuration( info->m_nSequence );
float flCycle = dt / seq_duration;
flCycle = clamp( flCycle, 0, 1.0 );
SetLayerCycle( info->m_iLayer, flCycle );
}
if (myNpc)
{
myNpc->AddSceneLock( 0.2 );
}
// update layer priority
if (m_bUpdateLayerPriorities)
{
SetLayerPriority( info->m_iLayer, info->m_iPriority + GetScenePriority( scene ) );
}
}
// FIXME: clean up cycle index from restart
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if the actor is not currently in a scene OR if the actor
// is in a scene (checked externally), but a PERMIT_RESPONSES event is active and
// the permit time period has enough time remaining to handle the response in full.
// Input : response_length -
//-----------------------------------------------------------------------------
bool CBaseFlex::PermitResponse( float response_length )
{
// Nothing set, disallow it
if ( m_flAllowResponsesEndTime <= 0.0f )
{
return false;
}
// If response ends before end of allow time, then that's okay
if ( gpGlobals->curtime + response_length <= m_flAllowResponsesEndTime )
{
return true;
}
// Disallow responses for now
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Set response end time (0 to clear response blocking)
// Input : endtime -
//-----------------------------------------------------------------------------
void CBaseFlex::SetPermitResponse( float endtime )
{
// Mark time after which we'll be occupied again (if in a scene)
// Note a value of <= 0.0f means unset (always allow actor to speak if not in a scene,
// and always disallow if in a scene)
m_flAllowResponsesEndTime = endtime;
}
//-----------------------------------------------------------------------------
// Purpose: Play a one-shot scene
// Input :
// Output :
//-----------------------------------------------------------------------------
float CBaseFlex::PlayScene( const char *pszScene, float flDelay, AI_Response *response, IRecipientFilter *filter /* = NULL */ )
{
return InstancedScriptedScene( this, pszScene, NULL, flDelay, false, response, false, filter );
}
float CBaseFlex::ScriptPlayScene( const char* pszScene, float flDelay )
{
return InstancedScriptedScene( this, pszScene, NULL, flDelay );
}
//-----------------------------------------------------------------------------
// Purpose: Generate a one-shot scene in memory with one track which is to play the named sound on the actor
// Input : *soundname -
// Output : float
//-----------------------------------------------------------------------------
float CBaseFlex::PlayAutoGeneratedSoundScene( const char *soundname )
{
return InstancedAutoGeneratedSoundScene( this, soundname );
}
//--------------------------------------------------------------------------------------------------
// Returns the script instance of the scene entity associated with our oldest ("top level") scene event
//--------------------------------------------------------------------------------------------------
HSCRIPT CBaseFlex::ScriptGetOldestScene( void )
{
if ( m_SceneEvents.Count() > 0 )
{
CSceneEventInfo curScene = m_SceneEvents.Head();
return ToHScript( (CBaseEntity*)(curScene.m_hSceneEntity.Get()) );
}
else
{
return NULL;
}
}
//--------------------------------------------------------------------------------------------------
// Returns the script instance of the scene at the specified index, or null if index >= count
//--------------------------------------------------------------------------------------------------
HSCRIPT CBaseFlex::ScriptGetSceneByIndex( int index )
{
if ( m_SceneEvents.IsValidIndex( index ) )
{
CSceneEventInfo curScene = m_SceneEvents.Element( index );
return ToHScript( (CBaseEntity*)(curScene.m_hSceneEntity.Get()) );
}
else
{
return NULL;
}
}
// FIXME: move to CBaseActor
bool CBaseFlex::EnterSceneSequence( CChoreoScene *scene, CChoreoEvent *event, bool bRestart )
{
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (!myNpc)
return false;
// 2 seconds past current event, or 0.2 seconds past end of scene, whichever is shorter
float flDuration = MIN( 2.0, MIN( event->GetEndTime() - scene->GetTime() + 2.0, scene->FindStopTime() - scene->GetTime() + 0.2 ) );
if (myNpc->IsCurSchedule( SCHED_SCENE_GENERIC ))
{
myNpc->AddSceneLock( flDuration );
return true;
}
// for now, don't interrupt sequences that don't understand being interrupted
if (myNpc->GetCurSchedule())
{
CAI_ScheduleBits testBits;
myNpc->GetCurSchedule()->GetInterruptMask( &testBits );
testBits.Clear( COND_PROVOKED );
if (testBits.IsAllClear())
{
return false;
}
}
if (myNpc->IsInterruptable())
{
if (myNpc->m_hCine)
{
// Assert( !(myNpc->GetFlags() & FL_FLY ) );
myNpc->ExitScriptedSequence( );
}
myNpc->OnStartScene();
myNpc->SetSchedule( SCHED_SCENE_GENERIC );
myNpc->AddSceneLock( flDuration );
return true;
}
return false;
}
bool CBaseFlex::ExitSceneSequence( void )
{
return true;
}
//-----------------------------------------------------------------------------
// Purpose: keep track of last valid flex animation time and returns if the current info should play theirs
//-----------------------------------------------------------------------------
bool CBaseFlex::IsSuppressedFlexAnimation( CSceneEventInfo *info )
{
// check for suppression if the current info is a background
if (info->m_pScene && info->m_pScene->IsBackground())
{
// allow for slight jitter
return m_flLastFlexAnimationTime > gpGlobals->curtime - GetAnimTimeInterval() * 1.5;
}
// keep track of last non-suppressable flex animation
m_flLastFlexAnimationTime = gpGlobals->curtime;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Clear out body lean states that are invalidated with Teleport
//-----------------------------------------------------------------------------
void CBaseFlex::Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity, bool bUseSlowHighAccuracyContacts )
{
BaseClass::Teleport( newPosition, newAngles, newVelocity, bUseSlowHighAccuracyContacts );
#ifdef HL2_DLL
// clear out Body Lean
m_vecPrevOrigin = vec3_origin;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: keep track of accel/decal and lean the body
//-----------------------------------------------------------------------------
void CBaseFlex::DoBodyLean( void )
{
#ifdef HL2_DLL
CAI_BaseNPC *myNpc = MyNPCPointer( );
if (myNpc)
{
Vector vecDelta;
Vector vecPos;
Vector vecOrigin = GetAbsOrigin();
if (m_vecPrevOrigin == vec3_origin)
{
m_vecPrevOrigin = vecOrigin;
}
vecDelta = vecOrigin - m_vecPrevOrigin;
vecDelta.x = clamp( vecDelta.x, -50, 50 );
vecDelta.y = clamp( vecDelta.y, -50, 50 );
vecDelta.z = clamp( vecDelta.z, -50, 50 );
float dt = gpGlobals->curtime - GetLastThink();
bool bSkip = ((GetFlags() & (FL_FLY | FL_SWIM)) != 0) || (GetMoveParent() != NULL) || (GetGroundEntity() == NULL) || (GetGroundEntity()->IsMoving());
bSkip |= myNpc->TaskRanAutomovement() || (myNpc->GetVehicleEntity() != NULL);
if (!bSkip)
{
if (vecDelta.LengthSqr() > m_vecPrevVelocity.LengthSqr())
{
float decay = ExponentialDecay( 0.6, 0.1, dt );
m_vecPrevVelocity = m_vecPrevVelocity * (decay) + vecDelta * (1.f - decay);
}
else
{
float decay = ExponentialDecay( 0.4, 0.1, dt );
m_vecPrevVelocity = m_vecPrevVelocity * (decay) + vecDelta * (1.f - decay);
}
vecPos = m_vecPrevOrigin + m_vecPrevVelocity;
float decay = ExponentialDecay( 0.5, 0.1, dt );
m_vecShift = m_vecShift * (decay) + (vecOrigin - vecPos) * (1.f - decay); // FIXME: Scale this
m_vecLean = (vecOrigin - vecPos) * 1.0; // FIXME: Scale this
}
else
{
m_vecPrevVelocity = vecDelta;
float decay = ExponentialDecay( 0.5, 0.1, dt );
m_vecShift = m_vecShift * decay;
m_vecLean = m_vecLean * decay;
}
m_vecPrevOrigin = vecOrigin;
/*
DevMsg( "%.2f %.2f %.2f (%.2f %.2f %.2f)\n",
m_vecLean.Get().x, m_vecLean.Get().y, m_vecLean.Get().z,
vecDelta.x, vecDelta.y, vecDelta.z );
*/
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: initialize weight for background events
//-----------------------------------------------------------------------------
void CSceneEventInfo::InitWeight( CBaseFlex *pActor )
{
if (pActor->IsSuppressedFlexAnimation( this ))
{
m_flWeight = 0.0;
}
else
{
m_flWeight = 1.0;
}
}
//-----------------------------------------------------------------------------
// Purpose: update weight for background events. Only call once per think
//-----------------------------------------------------------------------------
float CSceneEventInfo::UpdateWeight( CBaseFlex *pActor )
{
// decay if this is a background scene and there's other flex animations playing
if (pActor->IsSuppressedFlexAnimation( this ))
{
m_flWeight = MAX( m_flWeight - 0.2, 0.0 );
}
else
{
m_flWeight = MIN( m_flWeight + 0.1, 1.0 );
}
return m_flWeight;
}
BEGIN_DATADESC( CFlexCycler )
DEFINE_FIELD( m_flextime, FIELD_TIME ),
DEFINE_FIELD( m_flexnum, FIELD_INTEGER ),
DEFINE_ARRAY( m_flextarget, FIELD_FLOAT, 64 ),
DEFINE_FIELD( m_blinktime, FIELD_TIME ),
DEFINE_FIELD( m_looktime, FIELD_TIME ),
DEFINE_FIELD( m_lookTarget, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_speaktime, FIELD_TIME ),
DEFINE_FIELD( m_istalking, FIELD_INTEGER ),
DEFINE_FIELD( m_phoneme, FIELD_INTEGER ),
DEFINE_KEYFIELD( m_iszSentence, FIELD_STRING, "Sentence" ),
DEFINE_FIELD( m_sentence, FIELD_INTEGER ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( cycler_flex, CGenericFlexCycler );
ConVar flex_expression( "flex_expression","-" );
ConVar flex_talk( "flex_talk","0" );
// Cycler member functions
void CFlexCycler::GenericCyclerSpawn(char *szModel, Vector vecMin, Vector vecMax)
{
if (!szModel || !*szModel)
{
Warning( "cycler at %.0f %.0f %0.f missing modelname\n", GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z );
UTIL_Remove( this );
return;
}
PrecacheModel( szModel );
SetModel( szModel );
CFlexCycler::Spawn( );
UTIL_SetSize(this, vecMin, vecMax);
Vector vecEyeOffset;
GetEyePosition( GetModelPtr(), vecEyeOffset );
SetViewOffset( vecEyeOffset );
InitBoneControllers();
if (GetNumFlexControllers() < 5)
Warning( "cycler_flex used on model %s without enough flexes.\n", szModel );
}
void CFlexCycler::Spawn( )
{
Precache();
/*
if ( m_spawnflags & FCYCLER_NOTSOLID )
{
SetSolid( SOLID_NOT );
}
else
{
SetSolid( SOLID_SLIDEBOX );
}
*/
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_NOT_STANDABLE );
SetMoveType( MOVETYPE_NONE );
m_takedamage = DAMAGE_YES;
m_iHealth = 80000;// no cycler should die
m_flPlaybackRate = 1.0f;
m_flGroundSpeed = 0;
SetNextThink( gpGlobals->curtime + 1.0f );
ResetSequenceInfo( );
m_flCycle = random->RandomFloat( 0, 1.0 );
}
const char *predef_flexcontroller_names[] = {
"right_lid_raiser",
"left_lid_raiser",
"right_lid_tightener",
"left_lid_tightener",
"right_lid_droop",
"left_lid_droop",
"right_inner_raiser",
"left_inner_raiser",
"right_outer_raiser",
"left_outer_raiser",
"right_lowerer",
"left_lowerer",
"right_cheek_raiser",
"left_cheek_raiser",
"wrinkler",
"right_upper_raiser",
"left_upper_raiser",
"right_corner_puller",
"left_corner_puller",
"corner_depressor",
"chin_raiser",
"right_puckerer",
"left_puckerer",
"right_funneler",
"left_funneler",
"tightener",
"jaw_clencher",
"jaw_drop",
"right_mouth_drop",
"left_mouth_drop",
NULL };
float predef_flexcontroller_values[7][30] = {
/* 0 */ { 0.700,0.560,0.650,0.650,0.650,0.585,0.000,0.000,0.400,0.040,0.000,0.000,0.450,0.450,0.000,0.000,0.000,0.750,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.150,1.000,0.000,0.000,0.000 },
/* 1 */ { 0.450,0.450,0.450,0.450,0.000,0.000,0.000,0.000,0.300,0.300,0.000,0.000,0.250,0.250,0.000,0.000,0.000,0.750,0.750,0.000,0.000,0.000,0.000,0.400,0.400,0.000,1.000,0.000,0.050,0.050 },
/* 2 */ { 0.200,0.200,0.500,0.500,0.150,0.150,0.100,0.100,0.150,0.150,0.000,0.000,0.700,0.700,0.000,0.000,0.000,0.750,0.750,0.000,0.200,0.000,0.000,0.000,0.000,0.000,0.850,0.000,0.000,0.000 },
/* 3 */ { 0.000,0.000,0.000,0.000,0.000,0.000,0.300,0.300,0.000,0.000,0.000,0.000,0.000,0.000,0.100,0.000,0.000,0.000,0.000,0.700,0.300,0.000,0.000,0.200,0.200,0.000,0.000,0.300,0.000,0.000 },
/* 4 */ { 0.450,0.450,0.000,0.000,0.450,0.450,0.000,0.000,0.000,0.000,0.450,0.450,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.300,0.000,0.000,0.000,0.000 },
/* 5 */ { 0.000,0.000,0.350,0.350,0.150,0.150,0.300,0.300,0.450,0.450,0.000,0.000,0.200,0.200,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.200,0.200,0.000,0.000,0.300,0.000,0.000,0.000,0.000 },
/* 6 */ { 0.000,0.000,0.650,0.650,0.750,0.750,0.000,0.000,0.000,0.000,0.300,0.300,0.000,0.000,0.000,0.250,0.250,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000,0.000 }
};
//-----------------------------------------------------------------------------
// Purpose: Changes sequences when shot
//-----------------------------------------------------------------------------
int CFlexCycler::OnTakeDamage( const CTakeDamageInfo &info )
{
int nSequence = GetSequence() + 1;
if (!IsValidSequence( nSequence ))
{
nSequence = 0;
}
ResetSequence( nSequence );
m_flCycle = 0;
return 0;
}
void CFlexCycler::SetFlexTarget( LocalFlexController_t flexnum )
{
m_flextarget[flexnum] = random->RandomFloat( 0.5, 1.0 );
const char *pszType = GetFlexControllerType( flexnum );
// zero out all other flexes of the same type
for (LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
{
if (i != flexnum)
{
const char *pszOtherType = GetFlexControllerType( i );
if (stricmp( pszType, pszOtherType ) == 0)
{
m_flextarget[i] = 0;
}
}
}
// HACK, for now, consider then linked is named "right_" or "left_"
if ( StringHasPrefixCaseSensitive( GetFlexControllerName( flexnum ), "right_" ) )
{
m_flextarget[flexnum+1] = m_flextarget[flexnum];
}
else if ( StringHasPrefixCaseSensitive( GetFlexControllerName( flexnum ), "left_" ) )
{
m_flextarget[flexnum-1] = m_flextarget[flexnum];
}
}
LocalFlexController_t CFlexCycler::LookupFlex( const char *szTarget )
{
for (LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
{
const char *pszFlex = GetFlexControllerName( i );
if (stricmp( szTarget, pszFlex ) == 0)
{
return i;
}
}
return LocalFlexController_t(-1);
}
void CFlexCycler::Think( void )
{
SetNextThink( gpGlobals->curtime + 0.1f );
StudioFrameAdvance ( );
if (IsSequenceFinished() && !SequenceLoops())
{
// ResetSequenceInfo();
// hack to avoid reloading model every frame
m_flAnimTime = gpGlobals->curtime;
m_flPlaybackRate = 1.0;
m_bSequenceFinished = false;
m_flLastEventCheck = 0;
m_flCycle = 0;
}
// only do this if they have more than eyelid movement
if (GetNumFlexControllers() > 2)
{
const char *pszExpression = flex_expression.GetString();
if (pszExpression && pszExpression[0] == '+' && pszExpression[1] != '\0')
{
int i;
int j = atoi( &pszExpression[1] );
for ( i = 0; i < GetNumFlexControllers(); i++)
{
m_flextarget[m_flexnum] = 0;
}
for (i = 0; i < 35 && predef_flexcontroller_names[i]; i++)
{
m_flexnum = LookupFlex( predef_flexcontroller_names[i] );
m_flextarget[m_flexnum] = predef_flexcontroller_values[j][i];
// Msg( "%s %.3f\n", predef_flexcontroller_names[i], predef_flexcontroller_values[j][i] );
}
}
else if ( pszExpression && (pszExpression[0] == '1') && (pszExpression[1] == '\0') ) // 1 for maxed controller values
{
for ( LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++ )
{
// Max everything out...
m_flextarget[i] = 1.0f;
SetFlexWeight( i, m_flextarget[i] );
}
}
else if ( pszExpression && (pszExpression[0] == '^') && (pszExpression[1] == '\0') ) // ^ for sine wave
{
for ( LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++ )
{
// Throw a differently offset sine wave on all of the flex controllers
float fFlexTime = i * (1.0f / (float)GetNumFlexControllers()) + gpGlobals->curtime;
m_flextarget[i] = sinf( fFlexTime ) * 0.5f + 0.5f;
SetFlexWeight( i, m_flextarget[i] );
}
}
else if (pszExpression && pszExpression[0] != '\0' && strcmp(pszExpression, "+") != 0)
{
char szExpression[128];
char szTemp[32];
Q_strncpy( szExpression, pszExpression ,sizeof(szExpression));
char *pszExpression = szExpression;
while (*pszExpression != '\0')
{
if (*pszExpression == '+')
*pszExpression = ' ';
pszExpression++;
}
pszExpression = szExpression;
while (*pszExpression)
{
if (*pszExpression != ' ')
{
if (*pszExpression == '-')
{
for (LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
{
m_flextarget[i] = 0;
}
}
else if (*pszExpression == '?')
{
for (LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
{
Msg( "\"%s\" ", GetFlexControllerName( i ) );
}
Msg( "\n" );
flex_expression.SetValue( "" );
}
else
{
if (sscanf( pszExpression, "%31s", szTemp ) == 1)
{
m_flexnum = LookupFlex( szTemp );
if (m_flexnum != -1 && m_flextarget[m_flexnum] != 1)
{
m_flextarget[m_flexnum] = 1.0;
// SetFlexTarget( m_flexnum );
}
pszExpression += strlen( szTemp ) - 1;
}
}
}
pszExpression++;
}
}
else if (m_flextime < gpGlobals->curtime)
{
// m_flextime = gpGlobals->curtime + 1.0; // RandomFloat( 0.1, 0.5 );
m_flextime = gpGlobals->curtime + random->RandomFloat( 0.3, 0.5 ) * (30.0 / GetNumFlexControllers());
m_flexnum = (LocalFlexController_t)random->RandomInt( 0, GetNumFlexControllers() - 1 );
// m_flexnum = (pflex->num + 1) % r_psubmodel->numflexes;
if (m_flextarget[m_flexnum] == 1)
{
m_flextarget[m_flexnum] = 0;
// pflex->time = cl.time + 0.1;
}
else if (stricmp( GetFlexControllerType( m_flexnum ), "phoneme" ) != 0)
{
if (strstr( GetFlexControllerName( m_flexnum ), "upper_raiser" ) == NULL)
{
Msg( "%s:%s\n", GetFlexControllerType( m_flexnum ), GetFlexControllerName( m_flexnum ) );
SetFlexTarget( m_flexnum );
}
}
#if 0
char szWhat[256];
szWhat[0] = '\0';
for (int i = 0; i < GetNumFlexControllers(); i++)
{
if (m_flextarget[i] == 1.0)
{
if (stricmp( GetFlexFacs( i ), "upper") != 0 && stricmp( GetFlexFacs( i ), "lower") != 0)
{
if (szWhat[0] == '\0')
Q_strncat( szWhat, "-", sizeof( szWhat ), COPY_ALL_CHARACTERS );
else
Q_strncat( szWhat, "+", sizeof( szWhat ), COPY_ALL_CHARACTERS );
Q_strncat( szWhat, GetFlexFacs( i ), sizeof( szWhat ), COPY_ALL_CHARACTERS );
}
}
}
Msg( "%s\n", szWhat );
#endif
}
// slide it up.
for (LocalFlexController_t i = LocalFlexController_t(0); i < GetNumFlexControllers(); i++)
{
float weight = GetFlexWeight( i );
if (weight != m_flextarget[i])
{
weight = weight + (m_flextarget[i] - weight) / random->RandomFloat( 2.0, 4.0 );
}
weight = clamp( weight, 0.0f, 1.0f );
SetFlexWeight( i, weight );
}
#if 1
if (flex_talk.GetInt() == -1)
{
m_istalking = 1;
char pszSentence[256];
Q_snprintf( pszSentence,sizeof(pszSentence), "%s%d", STRING(m_iszSentence), m_sentence++ );
int sentenceIndex = engine->SentenceIndexFromName( pszSentence );
if (sentenceIndex >= 0)
{
Msg( "%d : %s\n", sentenceIndex, pszSentence );
CPASAttenuationFilter filter( this );
CBaseEntity::EmitSentenceByIndex( filter, entindex(), CHAN_VOICE, sentenceIndex, 1, SNDLVL_TALKING, 0, PITCH_NORM );
}
else
{
m_sentence = 0;
}
flex_talk.SetValue( "0" );
}
else if (!FStrEq( flex_talk.GetString(), "0") )
{
int sentenceIndex = engine->SentenceIndexFromName( flex_talk.GetString() );
if (sentenceIndex >= 0)
{
CPASAttenuationFilter filter( this );
CBaseEntity::EmitSentenceByIndex( filter, entindex(), CHAN_VOICE, sentenceIndex, 1, SNDLVL_TALKING, 0, PITCH_NORM );
}
flex_talk.SetValue( "0" );
}
#else
if (flex_talk.GetInt())
{
if (m_speaktime < gpGlobals->curtime)
{
if (m_phoneme == 0)
{
for (m_phoneme = 0; m_phoneme < GetNumFlexControllers(); m_phoneme++)
{
if (stricmp( GetFlexFacs( m_phoneme ), "27") == 0)
break;
}
}
m_istalking = !m_istalking;
if (m_istalking)
{
m_looktime = gpGlobals->curtime - 1.0;
m_speaktime = gpGlobals->curtime + random->RandomFloat( 0.5, 2.0 );
}
else
{
m_speaktime = gpGlobals->curtime + random->RandomFloat( 1.0, 3.0 );
}
}
for (i = m_phoneme; i < GetNumFlexControllers(); i++)
{
SetFlexWeight( i, 0.0f );
}
if (m_istalking)
{
m_flextime = gpGlobals->curtime + random->RandomFloat( 0.0, 0.2 );
m_flexWeight[random->RandomInt(m_phoneme, GetNumFlexControllers()-1)] = random->RandomFloat( 0.5, 1.0 );
float mouth = random->RandomFloat( 0.0, 1.0 );
float jaw = random->RandomFloat( 0.0, 1.0 );
m_flexWeight[m_phoneme - 2] = jaw * (mouth);
m_flexWeight[m_phoneme - 1] = jaw * (1.0 - mouth);
}
}
else
{
m_istalking = 0;
}
#endif
// blink
if (m_blinktime < gpGlobals->curtime)
{
Blink();
m_blinktime = gpGlobals->curtime + random->RandomFloat( 1.5, 4.5 );
}
}
Vector forward, right, up;
GetVectors( &forward, &right, &up );
CBaseEntity *pPlayer = (CBaseEntity *)UTIL_GetLocalPlayer();
if (pPlayer)
{
if (pPlayer->GetSmoothedVelocity().Length() != 0 && DotProduct( forward, pPlayer->EyePosition() - EyePosition()) > 0.5)
{
m_lookTarget = pPlayer->EyePosition();
m_looktime = gpGlobals->curtime + random->RandomFloat(2.0,4.0);
}
else if (m_looktime < gpGlobals->curtime)
{
if ((!m_istalking) && random->RandomInt( 0, 1 ) == 0)
{
m_lookTarget = EyePosition() + forward * 128 + right * random->RandomFloat(-64,64) + up * random->RandomFloat(-32,32);
m_looktime = gpGlobals->curtime + random->RandomFloat(0.3,1.0);
if (m_blinktime - 0.5 < gpGlobals->curtime)
{
Blink();
}
}
else
{
m_lookTarget = pPlayer->EyePosition();
m_looktime = gpGlobals->curtime + random->RandomFloat(1.0,4.0);
}
}
#if 0
float dt = acos( DotProduct( (m_lookTarget - EyePosition()).Normalize(), (m_viewtarget - EyePosition()).Normalize() ) );
if (dt > M_PI / 4)
{
dt = (M_PI / 4) * dt;
m_viewtarget = ((1 - dt) * m_viewtarget + dt * m_lookTarget);
}
#endif
SetViewtarget( m_lookTarget );
}
// Handle any facial animation from scene playback
// FIXME: do we still actually need flex cyclers?
// AddSceneSceneEvents();
}
void CFlexCycler::ProcessSceneEvents( void )
{
// Don't do anything since we handle facial stuff in Think()
}
BEGIN_BYTESWAP_DATADESC( flexsettinghdr_t )
DEFINE_FIELD( id, FIELD_INTEGER ),
DEFINE_FIELD( version, FIELD_INTEGER ),
DEFINE_ARRAY( name, FIELD_CHARACTER, 64 ),
DEFINE_FIELD( length, FIELD_INTEGER ),
DEFINE_FIELD( numflexsettings, FIELD_INTEGER ),
DEFINE_FIELD( flexsettingindex, FIELD_INTEGER ),
DEFINE_FIELD( nameindex, FIELD_INTEGER ),
DEFINE_FIELD( numindexes, FIELD_INTEGER ),
DEFINE_FIELD( indexindex, FIELD_INTEGER ),
DEFINE_FIELD( numkeys, FIELD_INTEGER ),
DEFINE_FIELD( keynameindex, FIELD_INTEGER ),
DEFINE_FIELD( keymappingindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( flexsetting_t )
DEFINE_FIELD( nameindex, FIELD_INTEGER ),
DEFINE_FIELD( obsolete1, FIELD_INTEGER ),
DEFINE_FIELD( numsettings, FIELD_INTEGER ),
DEFINE_FIELD( index, FIELD_INTEGER ),
DEFINE_FIELD( obsolete2, FIELD_INTEGER ),
DEFINE_FIELD( settingindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( flexweight_t )
DEFINE_FIELD( key, FIELD_INTEGER ),
DEFINE_FIELD( weight, FIELD_FLOAT ),
DEFINE_FIELD( influence, FIELD_FLOAT ),
END_BYTESWAP_DATADESC()