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.
153 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: ae8b73626e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ae8b73626e'
${ noResults }
source-engine/game/server/scripted.cpp

2245 lines
70 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implementation of entities that cause NPCs to participate in
// scripted events. These entities find and temporarily possess NPCs
// within a given search radius.
//
// Multiple scripts with the same targetname will start frame-synchronized.
//
// Scripts will find available NPCs by name or class name and grab them
// to play the script. If the NPC is already playing a script, the
// new script may enqueue itself unless there is already a non critical
// script in the queue.
//
//=============================================================================//
#include "cbase.h"
#include "ai_schedule.h"
#include "ai_default.h"
#include "ai_motor.h"
#include "ai_hint.h"
#include "ai_networkmanager.h"
#include "ai_network.h"
#include "engine/IEngineSound.h"
#include "animation.h"
#include "scripted.h"
#include "entitylist.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
ConVar ai_task_pre_script( "ai_task_pre_script", "0", FCVAR_NONE );
//
// targetname "me" - there can be more than one with the same name, and they act in concert
// target "the_entity_I_want_to_start_playing" or "class entity_classname" will pick the closest inactive scientist
// play "name_of_sequence"
// idle "name of idle sequence to play before starting"
// moveto - if set the NPC first moves to this nodes position
// range # - only search this far to find the target
// spawnflags - (stop if blocked, stop if player seen)
//
BEGIN_DATADESC( CAI_ScriptedSequence )
DEFINE_KEYFIELD( m_iszEntry, FIELD_STRING, "m_iszEntry" ),
DEFINE_KEYFIELD( m_iszPreIdle, FIELD_STRING, "m_iszIdle" ),
DEFINE_KEYFIELD( m_iszPlay, FIELD_STRING, "m_iszPlay" ),
DEFINE_KEYFIELD( m_iszPostIdle, FIELD_STRING, "m_iszPostIdle" ),
DEFINE_KEYFIELD( m_iszCustomMove, FIELD_STRING, "m_iszCustomMove" ),
DEFINE_KEYFIELD( m_iszNextScript, FIELD_STRING, "m_iszNextScript" ),
DEFINE_KEYFIELD( m_iszEntity, FIELD_STRING, "m_iszEntity" ),
DEFINE_KEYFIELD( m_fMoveTo, FIELD_INTEGER, "m_fMoveTo" ),
DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "m_flRadius" ),
DEFINE_KEYFIELD( m_flRepeat, FIELD_FLOAT, "m_flRepeat" ),
DEFINE_FIELD( m_bIsPlayingEntry, FIELD_BOOLEAN ),
DEFINE_KEYFIELD( m_bLoopActionSequence, FIELD_BOOLEAN, "m_bLoopActionSequence" ),
DEFINE_KEYFIELD( m_bSynchPostIdles, FIELD_BOOLEAN, "m_bSynchPostIdles" ),
DEFINE_KEYFIELD( m_bIgnoreGravity, FIELD_BOOLEAN, "m_bIgnoreGravity" ),
DEFINE_KEYFIELD( m_bDisableNPCCollisions, FIELD_BOOLEAN, "m_bDisableNPCCollisions" ),
DEFINE_FIELD( m_iDelay, FIELD_INTEGER ),
DEFINE_FIELD( m_bDelayed, FIELD_BOOLEAN ),
DEFINE_FIELD( m_startTime, FIELD_TIME ),
DEFINE_FIELD( m_bWaitForBeginSequence, FIELD_BOOLEAN ),
DEFINE_FIELD( m_saved_effects, FIELD_INTEGER ),
DEFINE_FIELD( m_savedFlags, FIELD_INTEGER ),
DEFINE_FIELD( m_savedCollisionGroup, FIELD_INTEGER ),
DEFINE_FIELD( m_interruptable, FIELD_BOOLEAN ),
DEFINE_FIELD( m_sequenceStarted, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hTargetEnt, FIELD_EHANDLE ),
DEFINE_FIELD( m_hNextCine, FIELD_EHANDLE ),
DEFINE_FIELD( m_hLastFoundEntity, FIELD_EHANDLE ),
DEFINE_FIELD( m_hForcedTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_bDontCancelOtherSequences, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bForceSynch, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bThinking, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bInitiatedSelfDelete, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bIsTeleportingDueToMoveTo, FIELD_BOOLEAN ),
DEFINE_FIELD( m_matInteractionPosition, FIELD_VMATRIX ),
DEFINE_FIELD( m_hInteractionRelativeEntity, FIELD_EHANDLE ),
DEFINE_FIELD( m_bTargetWasAsleep, FIELD_BOOLEAN ),
// Function Pointers
DEFINE_THINKFUNC( ScriptThink ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "MoveToPosition", InputMoveToPosition ),
DEFINE_INPUTFUNC( FIELD_VOID, "BeginSequence", InputBeginSequence ),
DEFINE_INPUTFUNC( FIELD_VOID, "CancelSequence", InputCancelSequence ),
DEFINE_KEYFIELD( m_iPlayerDeathBehavior, FIELD_INTEGER, "onplayerdeath" ),
DEFINE_INPUTFUNC( FIELD_VOID, "ScriptPlayerDeath", InputScriptPlayerDeath ),
// Outputs
DEFINE_OUTPUT(m_OnBeginSequence, "OnBeginSequence"),
DEFINE_OUTPUT(m_OnEndSequence, "OnEndSequence"),
DEFINE_OUTPUT(m_OnPostIdleEndSequence, "OnPostIdleEndSequence"),
DEFINE_OUTPUT(m_OnCancelSequence, "OnCancelSequence"),
DEFINE_OUTPUT(m_OnCancelFailedSequence, "OnCancelFailedSequence"),
DEFINE_OUTPUT(m_OnScriptEvent[0], "OnScriptEvent01"),
DEFINE_OUTPUT(m_OnScriptEvent[1], "OnScriptEvent02"),
DEFINE_OUTPUT(m_OnScriptEvent[2], "OnScriptEvent03"),
DEFINE_OUTPUT(m_OnScriptEvent[3], "OnScriptEvent04"),
DEFINE_OUTPUT(m_OnScriptEvent[4], "OnScriptEvent05"),
DEFINE_OUTPUT(m_OnScriptEvent[5], "OnScriptEvent06"),
DEFINE_OUTPUT(m_OnScriptEvent[6], "OnScriptEvent07"),
DEFINE_OUTPUT(m_OnScriptEvent[7], "OnScriptEvent08"),
END_DATADESC()
LINK_ENTITY_TO_CLASS( scripted_sequence, CAI_ScriptedSequence );
#define CLASSNAME "scripted_sequence"
//-----------------------------------------------------------------------------
// Purpose: Cancels the given scripted sequence.
// Input : pentCine -
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::ScriptEntityCancel( CBaseEntity *pentCine, bool bPretendSuccess )
{
// make sure they are a scripted_sequence
if ( FClassnameIs( pentCine, CLASSNAME ) )
{
CAI_ScriptedSequence *pCineTarget = (CAI_ScriptedSequence *)pentCine;
// make sure they have a NPC in mind for the script
CBaseEntity *pEntity = pCineTarget->GetTarget();
CAI_BaseNPC *pTarget = NULL;
if ( pEntity )
pTarget = pEntity->MyNPCPointer();
if (pTarget)
{
// make sure their NPC is actually playing a script
if ( pTarget->m_NPCState == NPC_STATE_SCRIPT )
{
// tell them do die
pTarget->m_scriptState = CAI_BaseNPC::SCRIPT_CLEANUP;
// We have to save off the flags here, because the NPC's m_hCine is cleared in CineCleanup()
int iSavedFlags = (pTarget->m_hCine ? pTarget->m_hCine->m_savedFlags : 0);
#ifdef HL1_DLL
//if we didn't have FL_FLY before the script, remove it
// for some reason hl2 doesn't have to do this *before*
// restoring the position ( which checks FL_FLY ) in CineCleanup
// Let's not risk breaking anything at this stage and just remove it.
pCineTarget->FixFlyFlag( pTarget, iSavedFlags );
#endif
// do it now
pTarget->CineCleanup( );
pCineTarget->FixScriptNPCSchedule( pTarget, iSavedFlags );
}
else
{
// Robin HACK: If a script is started and then cancelled before an NPC gets to
// think, we have to manually clear it out of scripted state, or it'll never recover.
pCineTarget->SetTarget( NULL );
pTarget->SetEffects( pCineTarget->m_saved_effects );
pTarget->m_hCine = NULL;
pTarget->SetTarget( NULL );
pTarget->SetGoalEnt( NULL );
pTarget->SetIdealState( NPC_STATE_IDLE );
}
}
// FIXME: this needs to be done in a cine cleanup function
pCineTarget->m_iDelay = 0;
if ( bPretendSuccess )
{
// We need to pretend that this sequence actually finished fully
pCineTarget->m_OnEndSequence.FireOutput(NULL, pCineTarget);
pCineTarget->m_OnPostIdleEndSequence.FireOutput(NULL, pCineTarget);
}
else
{
// Fire the cancel
pCineTarget->m_OnCancelSequence.FireOutput(NULL, pCineTarget);
if ( pCineTarget->m_startTime == 0 )
{
// If start time is 0, this sequence never actually ran. Fire the failed output.
pCineTarget->m_OnCancelFailedSequence.FireOutput(NULL, pCineTarget);
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called before spawning, after keyvalues have been parsed.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::Spawn( void )
{
SetSolid( SOLID_NONE );
//
// If we have no name or we are set to start immediately, find the NPC and
// have them move to their script position now.
//
if ( !GetEntityName() || ( m_spawnflags & SF_SCRIPT_START_ON_SPAWN ) )
{
StartThink();
SetNextThink( gpGlobals->curtime + 1.0f );
//
// If we have a name, wait for a BeginSequence input to play the
// action animation. Otherwise, we'll play the action animation
// as soon as the NPC reaches the script position.
//
if ( GetEntityName() != NULL_STRING )
{
m_bWaitForBeginSequence = true;
}
}
if ( m_spawnflags & SF_SCRIPT_NOINTERRUPT )
{
m_interruptable = false;
}
else
{
m_interruptable = true;
}
m_sequenceStarted = false;
m_startTime = 0;
m_hNextCine = NULL;
m_hLastFoundEntity = NULL;
}
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::UpdateOnRemove(void)
{
ScriptEntityCancel( this );
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::StartThink()
{
m_sequenceStarted = false;
m_bThinking = true;
SetThink( &CAI_ScriptedSequence::ScriptThink );
}
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::StopThink()
{
if ( m_bThinking )
{
Assert( !m_bInitiatedSelfDelete );
SetThink( NULL);
m_bThinking = false;
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if this scripted sequence can possess entities
// regardless of state.
//-----------------------------------------------------------------------------
bool CAI_ScriptedSequence::FCanOverrideState( void )
{
if ( m_spawnflags & SF_SCRIPT_OVERRIDESTATE )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Fires a script event by number.
// Input : nEvent - One based index of the script event from the , from 1 to 8.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::FireScriptEvent( int nEvent )
{
if ( ( nEvent >= 1 ) && ( nEvent <= MAX_SCRIPT_EVENTS ) )
{
m_OnScriptEvent[nEvent - 1].FireOutput( this, this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that causes the NPC to move to the script position.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::InputMoveToPosition( inputdata_t &inputdata )
{
if ( m_bInitiatedSelfDelete )
return;
// Have I already grabbed an NPC?
CBaseEntity *pEntity = GetTarget();
CAI_BaseNPC *pTarget = NULL;
if ( pEntity )
{
pTarget = pEntity->MyNPCPointer();
}
if ( pTarget != NULL )
{
// Yes, are they already playing this script?
if ( pTarget->m_scriptState == CAI_BaseNPC::SCRIPT_PLAYING || pTarget->m_scriptState == CAI_BaseNPC::SCRIPT_POST_IDLE )
{
// Yes, see if we can enqueue ourselves.
if ( pTarget->CanPlaySequence( FCanOverrideState(), SS_INTERRUPT_BY_NAME ) )
{
StartScript();
m_bWaitForBeginSequence = true;
}
}
// No, presumably they are moving to position or waiting for the BeginSequence input.
}
else
{
// No, grab the NPC but make them wait until BeginSequence is fired. They'll play
// their pre-action idle animation until BeginSequence is fired.
StartThink();
SetNextThink( gpGlobals->curtime );
m_bWaitForBeginSequence = true;
}
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that activates the scripted sequence.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::InputBeginSequence( inputdata_t &inputdata )
{
if ( m_bInitiatedSelfDelete )
return;
// Start the script as soon as possible.
m_bWaitForBeginSequence = false;
// do I already know who I should use?
CBaseEntity *pEntity = GetTarget();
CAI_BaseNPC *pTarget = NULL;
if ( !pEntity && m_hForcedTarget )
{
if ( FindEntity() )
{
pEntity = GetTarget();
}
}
if ( pEntity )
{
pTarget = pEntity->MyNPCPointer();
}
if ( pTarget )
{
// Are they already playing a script?
if ( pTarget->m_scriptState == CAI_BaseNPC::SCRIPT_PLAYING || pTarget->m_scriptState == CAI_BaseNPC::SCRIPT_POST_IDLE )
{
// See if we can enqueue ourselves after the current script.
if ( pTarget->CanPlaySequence( FCanOverrideState(), SS_INTERRUPT_BY_NAME ) )
{
StartScript();
}
}
}
else
{
// if not, try finding them
StartThink();
// Because we are directly calling the new "think" function ScriptThink, assume we're done
// This fixes the following bug (along with the WokeThisTick() code herein:
// A zombie is created in the asleep state and then, the mapper fires both Wake and BeginSequence
// messages to have it jump up out of the slime, e.g. What happens before this change is that
// the Wake code removed EF_NODRAW, but so the zombie is transmitted to the client, but the script
// hasn't started and won't start until the next Think time (2 ticks on xbox) at which time the
// actual sequence starts causing the zombie to quickly lie down.
// The changes here are to track what tick we "awoke" on and get rid of the lag between Wake and
// ScriptThink by actually calling ScriptThink directly on the same frame and checking for the
// zombie having woken up and been instructed to play a sequence in the same frame.
SetNextThink( TICK_NEVER_THINK );
ScriptThink();
}
}
//-----------------------------------------------------------------------------
// Purpose: Input handler that activates the scripted sequence.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::InputCancelSequence( inputdata_t &inputdata )
{
if ( m_bInitiatedSelfDelete )
return;
//
// We don't call CancelScript because entity I/O will handle dispatching
// this input to all other scripts with our same name.
//
DevMsg( 2, "InputCancelScript: Cancelling script '%s'\n", STRING( m_iszPlay ));
StopThink();
ScriptEntityCancel( this );
}
void CAI_ScriptedSequence::InputScriptPlayerDeath( inputdata_t &inputdata )
{
if ( m_iPlayerDeathBehavior == SCRIPT_CANCEL )
{
if ( m_bInitiatedSelfDelete )
return;
//
// We don't call CancelScript because entity I/O will handle dispatching
// this input to all other scripts with our same name.
//
DevMsg( 2, "InputCancelScript: Cancelling script '%s'\n", STRING( m_iszPlay ));
StopThink();
ScriptEntityCancel( this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if it is time for this script to start, false if the
// NPC should continue waiting.
//
// Scripts wait for two reasons:
//
// 1. To frame-syncronize with other scripts of the same name.
// 2. To wait indefinitely for the BeginSequence input after the NPC
// moves to the script position.
//-----------------------------------------------------------------------------
bool CAI_ScriptedSequence::IsTimeToStart( void )
{
Assert( !m_bWaitForBeginSequence );
return ( m_iDelay == 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if the script is still waiting to call StartScript()
//-----------------------------------------------------------------------------
bool CAI_ScriptedSequence::IsWaitingForBegin( void )
{
return m_bWaitForBeginSequence;
}
//-----------------------------------------------------------------------------
// Purpose: This doesn't really make sense since only MOVETYPE_PUSH get 'Blocked' events
// Input : pOther - The entity blocking us.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::Blocked( CBaseEntity *pOther )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pOther - The entity touching us.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::Touch( CBaseEntity *pOther )
{
/*
DevMsg( 2, "Cine Touch\n" );
if (m_pentTarget && OFFSET(pOther->pev) == OFFSET(m_pentTarget))
{
CAI_BaseNPC *pTarget = GetClassPtr((CAI_BaseNPC *)VARS(m_pentTarget));
pTarget->m_NPCState == NPC_STATE_SCRIPT;
}
*/
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::Die( void )
{
SetThink( &CAI_ScriptedSequence::SUB_Remove );
m_bThinking = false;
m_bInitiatedSelfDelete = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::Pain( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : eMode -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
CAI_BaseNPC *CAI_ScriptedSequence::FindScriptEntity( )
{
CAI_BaseNPC *pEnqueueNPC = NULL;
CBaseEntity *pEntity;
int interrupt;
if ( m_hForcedTarget )
{
interrupt = SS_INTERRUPT_BY_NAME;
pEntity = m_hForcedTarget;
}
else
{
interrupt = SS_INTERRUPT_BY_NAME;
pEntity = gEntList.FindEntityByNameWithin( m_hLastFoundEntity, STRING( m_iszEntity ), GetAbsOrigin(), m_flRadius );
if (!pEntity)
{
pEntity = gEntList.FindEntityByClassnameWithin( m_hLastFoundEntity, STRING( m_iszEntity ), GetAbsOrigin(), m_flRadius );
interrupt = SS_INTERRUPT_BY_CLASS;
}
}
while ( pEntity != NULL )
{
CAI_BaseNPC *pNPC = pEntity->MyNPCPointer( );
if ( pNPC )
{
//
// If they can play the sequence...
//
CanPlaySequence_t eCanPlay = pNPC->CanPlaySequence( FCanOverrideState(), interrupt );
if ( eCanPlay == CAN_PLAY_NOW )
{
// If they can play it now, we're done!
return pNPC;
}
else if ( eCanPlay == CAN_PLAY_ENQUEUED )
{
// They can play it, but only enqueued. We'll use them as a last resort.
pEnqueueNPC = pNPC;
}
else if (!(m_spawnflags & SF_SCRIPT_NO_COMPLAINTS))
{
// They cannot play the script.
DevMsg( "Found %s, but can't play!\n", STRING( m_iszEntity ));
}
}
if ( m_hForcedTarget )
{
Warning( "Code forced %s(%s), to be the target of scripted sequence %s, but it can't play it.\n",
pEntity->GetClassname(), pEntity->GetDebugName(), GetDebugName() );
pEntity = NULL;
UTIL_Remove( this );
return NULL;
}
else
{
if ( interrupt == SS_INTERRUPT_BY_NAME )
pEntity = gEntList.FindEntityByNameWithin( pEntity, STRING( m_iszEntity ), GetAbsOrigin(), m_flRadius );
else
pEntity = gEntList.FindEntityByClassnameWithin( pEntity, STRING( m_iszEntity ), GetAbsOrigin(), m_flRadius );
}
}
//
// If we found an NPC that will enqueue the script, use them.
//
if ( pEnqueueNPC != NULL )
{
return pEnqueueNPC;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ScriptedSequence::FindEntity( void )
{
CAI_BaseNPC *pTarget = FindScriptEntity( );
if ( (m_spawnflags & SF_SCRIPT_SEARCH_CYCLICALLY))
{
// next time this is called, start searching from the one found last time
m_hLastFoundEntity = pTarget;
}
SetTarget( pTarget );
return pTarget != NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Make the entity enter a scripted sequence.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::StartScript( void )
{
CBaseEntity *pEntity = GetTarget();
CAI_BaseNPC *pTarget = NULL;
if ( pEntity )
pTarget = pEntity->MyNPCPointer();
if ( pTarget )
{
pTarget->RemoveSpawnFlags( SF_NPC_WAIT_FOR_SCRIPT );
//
// If the NPC is in another script, just enqueue ourselves and bail out.
// We'll possess the NPC when the current script finishes with the NPC.
// Note that we only enqueue one deep currently, so if there is someone
// else in line we'll stomp them.
//
if ( pTarget->m_hCine != NULL )
{
if ( pTarget->m_hCine->m_hNextCine != NULL )
{
//
// Kicking another script out of the queue.
//
CAI_ScriptedSequence *pCine = ( CAI_ScriptedSequence * )pTarget->m_hCine->m_hNextCine.Get();
if (pTarget->m_hCine->m_hNextCine != pTarget->m_hCine)
{
// Don't clear the currently playing script's target!
pCine->SetTarget( NULL );
}
DevMsg( 2, "script \"%s\" kicking script \"%s\" out of the queue\n", GetDebugName(), pCine->GetDebugName() );
}
pTarget->m_hCine->m_hNextCine = this;
return;
}
//
// If no next script is specified, clear it out so other scripts can enqueue themselves
// after us.
//
if ( !m_iszNextScript )
{
m_hNextCine = NULL;
}
// UNDONE: Do this to sync up multi-entity scripts?
//pTarget->SetNextThink( gpGlobals->curtime );
pTarget->SetGoalEnt( this );
pTarget->ForceDecisionThink();
pTarget->m_hCine = this;
pTarget->SetTarget( this );
// Notify the NPC tat we're stomping them into a scene!
pTarget->OnStartScene();
{
m_bTargetWasAsleep = ( pTarget->GetSleepState() != AISS_AWAKE ) ? true : false;
bool justAwoke = pTarget->WokeThisTick();
if ( m_bTargetWasAsleep || justAwoke )
{
// Note, Wake() will remove the EF_NODRAW flag, but if we are starting a seq on a hidden entity
// we don't want it to draw on the client until the sequence actually starts to play
// Make sure it stays hidden!!!
if ( m_bTargetWasAsleep )
{
pTarget->Wake();
}
m_bTargetWasAsleep = true;
// Even if awakened this frame, temporarily keep the entity hidden for now
pTarget->AddEffects( EF_NODRAW );
}
}
// If the entity was asleep at the start, make sure we don't make it invisible
// AFTER the script finishes (can't think of a case where you'd want that to happen)
m_saved_effects = pTarget->GetEffects() & ~EF_NODRAW;
pTarget->AddEffects( GetEffects() );
m_savedFlags = pTarget->GetFlags();
m_savedCollisionGroup = pTarget->GetCollisionGroup();
if ( m_bDisableNPCCollisions )
{
pTarget->SetCollisionGroup( COLLISION_GROUP_NPC_SCRIPTED );
}
switch (m_fMoveTo)
{
case CINE_MOVETO_WAIT:
case CINE_MOVETO_WAIT_FACING:
pTarget->m_scriptState = CAI_BaseNPC::SCRIPT_WAIT;
if ( m_bIgnoreGravity )
{
pTarget->AddFlag( FL_FLY );
pTarget->SetGroundEntity( NULL );
}
break;
case CINE_MOVETO_WALK:
pTarget->m_scriptState = CAI_BaseNPC::SCRIPT_WALK_TO_MARK;
break;
case CINE_MOVETO_RUN:
pTarget->m_scriptState = CAI_BaseNPC::SCRIPT_RUN_TO_MARK;
break;
case CINE_MOVETO_CUSTOM:
pTarget->m_scriptState = CAI_BaseNPC::SCRIPT_CUSTOM_MOVE_TO_MARK;
break;
case CINE_MOVETO_TELEPORT:
m_bIsTeleportingDueToMoveTo = true;
pTarget->Teleport( &GetAbsOrigin(), NULL, &vec3_origin );
m_bIsTeleportingDueToMoveTo = false;
pTarget->GetMotor()->SetIdealYaw( GetLocalAngles().y );
pTarget->SetLocalAngularVelocity( vec3_angle );
pTarget->IncrementInterpolationFrame();
QAngle angles = pTarget->GetLocalAngles();
angles.y = GetLocalAngles().y;
pTarget->SetLocalAngles( angles );
pTarget->m_scriptState = CAI_BaseNPC::SCRIPT_WAIT;
if ( m_bIgnoreGravity )
{
pTarget->AddFlag( FL_FLY );
pTarget->SetGroundEntity( NULL );
}
// UNDONE: Add a flag to do this so people can fixup physics after teleporting NPCs
//pTarget->SetGroundEntity( NULL );
break;
}
//DevMsg( 2, "\"%s\" found and used (INT: %s)\n", STRING( pTarget->m_iName ), FBitSet(m_spawnflags, SF_SCRIPT_NOINTERRUPT)?"No":"Yes" );
// Wait until all scripts of the same name are ready to play.
m_bDelayed = false;
DelayStart( true );
pTarget->SetIdealState(NPC_STATE_SCRIPT);
// FIXME: not sure why this is happening, or what to do about truely dormant NPCs
if ( pTarget->IsEFlagSet( EFL_NO_THINK_FUNCTION ) && pTarget->GetNextThink() != TICK_NEVER_THINK )
{
DevWarning( "scripted_sequence %d:%s - restarting dormant entity %d:%s : %.1f:%.1f\n", entindex(), GetDebugName(), pTarget->entindex(), pTarget->GetDebugName(), gpGlobals->curtime, pTarget->GetNextThink() );
pTarget->SetNextThink( gpGlobals->curtime );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: First think after activation. Grabs an NPC and makes it do things.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::ScriptThink( void )
{
if ( g_pAINetworkManager && !g_pAINetworkManager->IsInitialized() )
{
SetNextThink( gpGlobals->curtime + 0.1f );
}
else if (FindEntity())
{
StartScript( );
DevMsg( 2, "scripted_sequence %d:\"%s\" using NPC %d:\"%s\"(%s)\n", entindex(), GetDebugName(), GetTarget()->entindex(), GetTarget()->GetEntityName().ToCStr(), STRING( m_iszEntity ) );
}
else
{
CancelScript( );
DevMsg( 2, "scripted_sequence %d:\"%s\" can't find NPC \"%s\"\n", entindex(), GetDebugName(), STRING( m_iszEntity ) );
// FIXME: just trying again is bad. This should fire an output instead.
// FIXME: Think about puting output triggers in both StartScript() and CancelScript().
SetNextThink( gpGlobals->curtime + 1.0f );
}
}
//-----------------------------------------------------------------------------
// Purpose: Callback for firing the begin sequence output. Called by the NPC that
// is running the script as it starts the action seqeunce.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::OnBeginSequence( void )
{
m_OnBeginSequence.FireOutput( this, this );
}
//-----------------------------------------------------------------------------
// Purpose: Look up a sequence name and setup the target NPC to play it.
// Input : pTarget -
// iszSeq -
// completeOnEmpty -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ScriptedSequence::StartSequence( CAI_BaseNPC *pTarget, string_t iszSeq, bool completeOnEmpty )
{
Assert( pTarget );
m_sequenceStarted = true;
m_bIsPlayingEntry = (iszSeq == m_iszEntry);
if ( !iszSeq && completeOnEmpty )
{
SequenceDone( pTarget );
return false;
}
int nSequence = pTarget->LookupSequence( STRING( iszSeq ) );
if (nSequence == -1)
{
Warning( "%s: unknown scripted sequence \"%s\"\n", pTarget->GetDebugName(), STRING( iszSeq ));
nSequence = 0;
}
// look for the activity that this represents
Activity act = pTarget->GetSequenceActivity( nSequence );
if (act == ACT_INVALID)
act = ACT_IDLE;
pTarget->SetActivityAndSequence( act, nSequence, act, act );
// If the target was hidden even though we woke it up, only make it drawable if we're not still on the preidle seq...
if ( m_bTargetWasAsleep &&
iszSeq != m_iszPreIdle )
{
m_bTargetWasAsleep = false;
// Show it
pTarget->RemoveEffects( EF_NODRAW );
// Don't blend...
pTarget->IncrementInterpolationFrame();
}
//DevMsg( 2, "%s (%s): started \"%s\":INT:%s\n", STRING( pTarget->m_iName ), pTarget->GetClassname(), STRING( iszSeq), (m_spawnflags & SF_SCRIPT_NOINTERRUPT) ? "No" : "Yes" );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Called when a scripted sequence is ready to start playing the sequence
// Input : pNPC - Pointer to the NPC that the sequence possesses.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::SynchronizeSequence( CAI_BaseNPC *pNPC )
{
//Msg("%s (for %s) called SynchronizeSequence() at %0.2f\n", GetTarget()->GetDebugName(), GetDebugName(), gpGlobals->curtime);
Assert( m_iDelay == 0 );
Assert( m_bWaitForBeginSequence == false );
m_bForceSynch = false;
// Reset cycle position
float flCycleRate = pNPC->GetSequenceCycleRate( pNPC->GetSequence() );
float flInterval = gpGlobals->curtime - m_startTime;
// Msg("%.2f \"%s\" %s : %f (%f): interval %f\n", gpGlobals->curtime, GetEntityName().ToCStr(), pNPC->GetClassname(), pNPC->m_flAnimTime.Get(), m_startTime, flInterval );
//Assert( flInterval >= 0.0 && flInterval <= 0.15 );
flInterval = clamp( flInterval, 0.f, 0.15f );
if (flInterval == 0)
return;
// do the movement for the missed portion of the sequence
pNPC->SetCycle( 0.0f );
pNPC->AutoMovement( flInterval );
// reset the cycle to a common basis
pNPC->SetCycle( flInterval * flCycleRate );
}
//-----------------------------------------------------------------------------
// Purpose: Moves to the next action sequence if the scripted_sequence wants to,
// or returns true if it wants to leave the action sequence
//-----------------------------------------------------------------------------
bool CAI_ScriptedSequence::FinishedActionSequence( CAI_BaseNPC *pNPC )
{
// Restart the action sequence when the entry finishes, or when the action
// finishes and we're set to loop it.
if ( IsPlayingEntry() )
{
if ( GetEntityName() != NULL_STRING )
{
// Force all matching ss's to synchronize their action sequences
SynchNewSequence( CAI_BaseNPC::SCRIPT_PLAYING, m_iszPlay, true );
}
else
{
StartSequence( pNPC, m_iszPlay, true );
}
return false;
}
// Let the core action sequence continue to loop
if ( ShouldLoopActionSequence() )
{
// If the NPC has reached post idle state, we need to stop looping the action sequence
if ( pNPC->m_scriptState == CAI_BaseNPC::SCRIPT_POST_IDLE )
return true;
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Called when a scripted sequence animation sequence is done playing
// (or when an AI Scripted Sequence doesn't supply an animation sequence
// to play).
// Input : pNPC - Pointer to the NPC that the sequence possesses.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::SequenceDone( CAI_BaseNPC *pNPC )
{
//DevMsg( 2, "Sequence %s finished\n", STRING( pNPC->m_hCine->m_iszPlay ) );
//Msg("%s SequenceDone() at %0.2f\n", pNPC->GetDebugName(), gpGlobals->curtime );
// If we're part of a synchronised post-idle sequence, we need to do things differently
if ( m_bSynchPostIdles && GetEntityName() != NULL_STRING )
{
// If we're already in POST_IDLE state, then one of the other scripted
// sequences we're synching with has already kicked us into running
// the post idle sequence, so we do nothing.
if ( pNPC->m_scriptState != CAI_BaseNPC::SCRIPT_POST_IDLE )
{
if ( ( m_iszPostIdle != NULL_STRING ) && ( m_hNextCine == NULL ) )
{
SynchNewSequence( CAI_BaseNPC::SCRIPT_POST_IDLE, m_iszPostIdle, true );
}
else
{
PostIdleDone( pNPC );
}
}
}
else
{
//
// If we have a post idle set, and no other script is in the queue for this
// NPC, start playing the idle now.
//
if ( ( m_iszPostIdle != NULL_STRING ) && ( m_hNextCine == NULL ) )
{
//
// First time we've gotten here for this script. Start playing the post idle
// if one is specified.
//
pNPC->m_scriptState = CAI_BaseNPC::SCRIPT_POST_IDLE;
StartSequence( pNPC, m_iszPostIdle, false ); // false to prevent recursion here!
}
else
{
PostIdleDone( pNPC );
}
}
m_OnEndSequence.FireOutput(NULL, this);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::SynchNewSequence( CAI_BaseNPC::SCRIPTSTATE newState, string_t iszSequence, bool bSynchOtherScenes )
{
// Do we need to synchronize all our matching scripted scenes?
if ( bSynchOtherScenes )
{
//Msg("%s (for %s) forcing synch of %s at %0.2f\n", GetTarget()->GetDebugName(), GetDebugName(), iszSequence, gpGlobals->curtime);
CBaseEntity *pentCine = gEntList.FindEntityByName( NULL, GetEntityName(), NULL );
while ( pentCine )
{
CAI_ScriptedSequence *pScene = dynamic_cast<CAI_ScriptedSequence *>(pentCine);
if ( pScene && pScene != this )
{
pScene->SynchNewSequence( newState, iszSequence, false );
}
pentCine = gEntList.FindEntityByName( pentCine, GetEntityName(), NULL );
}
}
// Now force this one to start the post idle?
if ( !GetTarget() )
return;
CAI_BaseNPC *pNPC = GetTarget()->MyNPCPointer();
if ( !pNPC )
return;
//Msg("%s (for %s) starting %s seq at %0.2f\n", pNPC->GetDebugName(), GetDebugName(), iszSequence, gpGlobals->curtime);
m_startTime = gpGlobals->curtime;
pNPC->m_scriptState = newState;
StartSequence( pNPC, iszSequence, false );
// Force the NPC to synchronize animations on their next think
m_bForceSynch = true;
}
//-----------------------------------------------------------------------------
// Purpose: Called when a scripted sequence animation sequence is done playing
// (or when an AI Scripted Sequence doesn't supply an animation sequence
// to play).
// Input : pNPC - Pointer to the NPC that the sequence possesses.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::PostIdleDone( CAI_BaseNPC *pNPC )
{
//
// If we're set to keep the NPC in a scripted idle, hack them back into the script,
// but allow another scripted sequence to take control of the NPC if it wants to,
// unless another script has stolen them from us.
//
if ( ( m_iszPostIdle != NULL_STRING ) && ( m_spawnflags & SF_SCRIPT_LOOP_IN_POST_IDLE ) && ( m_hNextCine == NULL ) )
{
//
// First time we've gotten here for this script. Start playing the post idle
// if one is specified.
// Only do so if we're selected, to prevent spam
if ( pNPC->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
{
DevMsg( 2, "Post Idle %s finished for %s\n", STRING( pNPC->m_hCine->m_iszPostIdle ), pNPC->GetDebugName() );
}
pNPC->m_scriptState = CAI_BaseNPC::SCRIPT_POST_IDLE;
StartSequence( pNPC, m_iszPostIdle, false );
}
else
{
if ( !( m_spawnflags & SF_SCRIPT_REPEATABLE ) )
{
SetThink( &CAI_ScriptedSequence::SUB_Remove );
SetNextThink( gpGlobals->curtime + 0.1f );
m_bThinking = false;
m_bInitiatedSelfDelete = true;
}
//
// This is done so that another sequence can take over the NPC when triggered
// by the first.
//
pNPC->CineCleanup();
// We have to pass in the flags here, because the NPC's m_hCine was cleared in CineCleanup()
FixScriptNPCSchedule( pNPC, m_savedFlags );
//
// If another script is waiting to grab this NPC, start the next script
// immediately.
//
if ( m_hNextCine != NULL )
{
CAI_ScriptedSequence *pNextCine = ( CAI_ScriptedSequence * )m_hNextCine.Get();
//
// Don't link ourselves in if we are going to be deleted.
// TODO: use EHANDLEs instead of pointers to scripts!
//
if ( ( pNextCine != this ) || ( m_spawnflags & SF_SCRIPT_REPEATABLE ) )
{
pNextCine->SetTarget( pNPC );
pNextCine->StartScript();
}
}
}
//Msg("%s finished post idle at %0.2f\n", pNPC->GetDebugName(), gpGlobals->curtime );
m_OnPostIdleEndSequence.FireOutput(NULL, this);
}
//-----------------------------------------------------------------------------
// Purpose: When a NPC finishes a scripted sequence, we have to fix up its state
// and schedule for it to return to a normal AI NPC.
// Scripted sequences just dirty the Schedule and drop the NPC in Idle State.
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::FixScriptNPCSchedule( CAI_BaseNPC *pNPC, int iSavedCineFlags )
{
if ( pNPC->GetIdealState() != NPC_STATE_DEAD )
{
pNPC->SetIdealState( NPC_STATE_IDLE );
}
if ( pNPC == NULL )
return;
FixFlyFlag( pNPC, iSavedCineFlags );
pNPC->ClearSchedule( "Finished scripted sequence" );
}
void CAI_ScriptedSequence::FixFlyFlag( CAI_BaseNPC *pNPC, int iSavedCineFlags )
{
//Adrian: We NEED to clear this or the NPC's FL_FLY flag will never be removed cause of ClearSchedule!
if ( pNPC->GetTask() && ( pNPC->GetTask()->iTask == TASK_PLAY_SCRIPT || pNPC->GetTask()->iTask == TASK_PLAY_SCRIPT_POST_IDLE ) )
{
if ( !(iSavedCineFlags & FL_FLY) )
{
if ( pNPC->GetFlags() & FL_FLY )
{
pNPC->RemoveFlag( FL_FLY );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : fAllow -
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::AllowInterrupt( bool fAllow )
{
if ( m_spawnflags & SF_SCRIPT_NOINTERRUPT )
return;
m_interruptable = fAllow;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ScriptedSequence::CanInterrupt( void )
{
if ( !m_interruptable )
return false;
CBaseEntity *pTarget = GetTarget();
if ( pTarget != NULL && pTarget->IsAlive() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::RemoveIgnoredConditions( void )
{
if ( CanInterrupt() )
{
return;
}
CBaseEntity *pEntity = GetTarget();
if ( pEntity == NULL )
{
return;
}
CAI_BaseNPC *pTarget = pEntity->MyNPCPointer();
if ( pTarget == NULL )
{
return;
}
if ( pTarget )
{
pTarget->ClearCondition(COND_LIGHT_DAMAGE);
pTarget->ClearCondition(COND_HEAVY_DAMAGE);
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if another script is allowed to enqueue itself after
// this script. The enqueued script will begin immediately after the
// current script without dropping the NPC into AI.
//-----------------------------------------------------------------------------
bool CAI_ScriptedSequence::CanEnqueueAfter( void )
{
if ( m_hNextCine == NULL )
{
return true;
}
if ( m_iszNextScript != NULL_STRING )
{
DevMsg( 2, "%s is specified as the 'Next Script' and cannot be kicked out of the queue\n", m_hNextCine->GetDebugName() );
return false;
}
if ( !m_hNextCine->HasSpawnFlags( SF_SCRIPT_HIGH_PRIORITY ) )
{
return true;
}
DevMsg( 2, "%s is a priority script and cannot be kicked out of the queue\n", m_hNextCine->GetDebugName() );
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::StopActionLoop( bool bStopSynchronizedScenes )
{
// Stop looping our action sequence. Next time the loop finishes,
// we'll move to the post idle sequence instead.
m_bLoopActionSequence = false;
// If we have synchronized scenes, and we're supposed to stop them, do so
if ( !bStopSynchronizedScenes || GetEntityName() == NULL_STRING )
return;
CBaseEntity *pentCine = gEntList.FindEntityByName( NULL, GetEntityName(), NULL );
while ( pentCine )
{
CAI_ScriptedSequence *pScene = dynamic_cast<CAI_ScriptedSequence *>(pentCine);
if ( pScene && pScene != this )
{
pScene->StopActionLoop( false );
}
pentCine = gEntList.FindEntityByName( pentCine, GetEntityName(), NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose: Code method of forcing a scripted sequence entity to use a particular NPC.
// Useful when you don't know if the NPC has a unique targetname.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::ForceSetTargetEntity( CAI_BaseNPC *pTarget, bool bDontCancelOtherSequences )
{
m_hForcedTarget = pTarget;
m_iszEntity = m_hForcedTarget->GetEntityName(); // Not guaranteed to be unique
m_bDontCancelOtherSequences = bDontCancelOtherSequences;
}
//-----------------------------------------------------------------------------
// Purpose: Setup this scripted sequence to maintain the desired position offset
// to the other NPC in the scripted interaction.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::SetupInteractionPosition( CBaseEntity *pRelativeEntity, VMatrix &matDesiredLocalToWorld )
{
m_matInteractionPosition = matDesiredLocalToWorld;
m_hInteractionRelativeEntity = pRelativeEntity;
}
extern ConVar ai_debug_dyninteractions;
//-----------------------------------------------------------------------------
// Purpose: Modify the target AutoMovement() position before the NPC moves.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::ModifyScriptedAutoMovement( Vector *vecNewPos )
{
if ( m_hInteractionRelativeEntity )
{
// If we have an entry animation, only do it on the entry
if ( m_iszEntry != NULL_STRING && !m_bIsPlayingEntry )
return;
Vector vecRelativeOrigin = m_hInteractionRelativeEntity->GetAbsOrigin();
QAngle angRelativeAngles = m_hInteractionRelativeEntity->GetAbsAngles();
CAI_BaseNPC *pNPC = m_hInteractionRelativeEntity->MyNPCPointer();
if ( pNPC )
{
angRelativeAngles[YAW] = pNPC->GetInteractionYaw();
}
bool bDebug = ai_debug_dyninteractions.GetInt() == 2;
if ( bDebug )
{
Msg("--\n%s current org: %f %f\n", m_hTargetEnt->GetDebugName(), m_hTargetEnt->GetAbsOrigin().x, m_hTargetEnt->GetAbsOrigin().y );
Msg("%s current org: %f %f", m_hInteractionRelativeEntity->GetDebugName(), vecRelativeOrigin.x, vecRelativeOrigin.y );
}
CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating*>(m_hInteractionRelativeEntity.Get());
if ( pAnimating )
{
Vector vecDeltaPos;
QAngle vecDeltaAngles;
pAnimating->GetSequenceMovement( pAnimating->GetSequence(), 0.0f, pAnimating->GetCycle(), vecDeltaPos, vecDeltaAngles );
VectorYawRotate( vecDeltaPos, pAnimating->GetLocalAngles().y, vecDeltaPos );
if ( bDebug )
{
NDebugOverlay::Box( vecRelativeOrigin, -Vector(2,2,2), Vector(2,2,2), 0,255,0, 8, 0.1 );
}
vecRelativeOrigin -= vecDeltaPos;
if ( bDebug )
{
Msg(", relative to sequence start: %f %f\n", vecRelativeOrigin.x, vecRelativeOrigin.y );
NDebugOverlay::Box( vecRelativeOrigin, -Vector(3,3,3), Vector(3,3,3), 255,0,0, 8, 0.1 );
}
}
// We've been asked to maintain a specific position relative to the other NPC
// we're interacting with. Lerp towards the relative position.
VMatrix matMeToWorld, matLocalToWorld;
matMeToWorld.SetupMatrixOrgAngles( vecRelativeOrigin, angRelativeAngles );
MatrixMultiply( matMeToWorld, m_matInteractionPosition, matLocalToWorld );
// Get the desired NPC position in worldspace
Vector vecOrigin;
QAngle angAngles;
vecOrigin = matLocalToWorld.GetTranslation();
MatrixToAngles( matLocalToWorld, angAngles );
if ( bDebug )
{
Msg("Desired Origin for %s: %f %f\n", m_hTargetEnt->GetDebugName(), vecOrigin.x, vecOrigin.y );
NDebugOverlay::Axis( vecOrigin, angAngles, 5, true, 0.1 );
}
// Lerp to it over time
Vector vecToTarget = (vecOrigin - *vecNewPos);
if ( bDebug )
{
Msg("Automovement's output origin: %f %f\n", (*vecNewPos).x, (*vecNewPos).y );
Msg("Vector from automovement to desired: %f %f\n", vecToTarget.x, vecToTarget.y );
}
*vecNewPos += (vecToTarget * pAnimating->GetCycle());
}
}
//-----------------------------------------------------------------------------
// Purpose: Find all the cinematic entities with my targetname and stop them
// from playing.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::CancelScript( void )
{
DevMsg( 2, "Cancelling script: %s\n", STRING( m_iszPlay ));
// Don't cancel matching sequences if we're asked not to, unless we didn't actually
// succeed in starting, in which case we should always cancel. This fixes
// dynamic interactions where an NPC was killed the same frame another NPC
// started a dynamic interaction with him.
bool bDontCancelOther = ((m_bDontCancelOtherSequences || HasSpawnFlags( SF_SCRIPT_ALLOW_DEATH ) )&& (m_startTime != 0));
if ( bDontCancelOther || !GetEntityName() )
{
ScriptEntityCancel( this );
return;
}
CBaseEntity *pentCineTarget = gEntList.FindEntityByName( NULL, GetEntityName() );
while ( pentCineTarget )
{
ScriptEntityCancel( pentCineTarget );
pentCineTarget = gEntList.FindEntityByName( pentCineTarget, GetEntityName() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Find all the cinematic entities with my targetname and tell them to
// wait before starting. This ensures that all scripted sequences with
// the same name are frame-synchronized.
//
// When triggered, scripts call this first with a state of 1 to indicate that
// they are not ready to play (while NPCs move to their cue positions, etc).
// Once they are ready to play, they call it with a state of 0. When all
// the scripts are ready, they all are told to start.
//
// Input : bDelay - true means this script is not ready, false means it is ready.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::DelayStart( bool bDelay )
{
//Msg("SSEQ: %.2f \"%s\" (%d) DelayStart( %d ). Current m_iDelay is: %d\n", gpGlobals->curtime, GetDebugName(), entindex(), bDelay, m_iDelay );
if ( ai_task_pre_script.GetBool() )
{
if ( bDelay == m_bDelayed )
return;
m_bDelayed = bDelay;
}
// Without a name, we cannot synchronize with anything else
if ( GetEntityName() == NULL_STRING )
{
m_iDelay = bDelay;
m_startTime = gpGlobals->curtime;
return;
}
CBaseEntity *pentCine = gEntList.FindEntityByName( NULL, GetEntityName() );
while ( pentCine )
{
if ( FClassnameIs( pentCine, "scripted_sequence" ) )
{
CAI_ScriptedSequence *pTarget = (CAI_ScriptedSequence *)pentCine;
if (bDelay)
{
// if delaying, add up the number of other scripts in the group
m_iDelay++;
//Msg("SSEQ: (%d) Found matching SS (%d). Incrementing MY m_iDelay to %d.\n", entindex(), pTarget->entindex(), m_iDelay );
}
else
{
// if ready, decrement each of other scripts in the group
// members not yet delayed will decrement below zero.
pTarget->m_iDelay--;
//Msg("SSEQ: (%d) Found matching SS (%d). Decrementing THEIR m_iDelay to %d.\n", entindex(), pTarget->entindex(), pTarget->m_iDelay );
// once everything is balanced, everyone will start.
if (pTarget->m_iDelay == 0)
{
pTarget->m_startTime = gpGlobals->curtime;
//Msg("SSEQ: STARTING SEQUENCE for \"%s\" (%d) (m_iDelay reached 0).\n", pTarget->GetDebugName(), pTarget->entindex() );
}
}
}
pentCine = gEntList.FindEntityByName( pentCine, GetEntityName() );
}
//Msg("SSEQ: Exited DelayStart() with m_iDelay of: %d.\n", m_iDelay );
}
//-----------------------------------------------------------------------------
// Purpose: Find an entity that I'm interested in and precache the sounds he'll
// need in the sequence.
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::Activate( void )
{
BaseClass::Activate();
//
// See if there is another script specified to run immediately after this one.
//
m_hNextCine = gEntList.FindEntityByName( NULL, m_iszNextScript );
if ( m_hNextCine == NULL )
{
m_iszNextScript = NULL_STRING;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSequence::DrawDebugGeometryOverlays( void )
{
BaseClass::DrawDebugGeometryOverlays();
if ( m_debugOverlays & OVERLAY_TEXT_BIT )
{
if ( GetTarget() )
{
NDebugOverlay::HorzArrow( GetAbsOrigin(), GetTarget()->GetAbsOrigin(), 16, 0, 255, 0, 64, true, 0.0f );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Draw any debug text overlays
// Input :
// Output : Current text offset from the top
//-----------------------------------------------------------------------------
int CAI_ScriptedSequence::DrawDebugTextOverlays( void )
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char tempstr[512];
Q_snprintf(tempstr,sizeof(tempstr),"Target: %s", GetTarget() ? GetTarget()->GetDebugName() : "None" ) ;
EntityText(text_offset,tempstr,0);
text_offset++;
switch (m_fMoveTo)
{
case CINE_MOVETO_WAIT:
Q_snprintf(tempstr,sizeof(tempstr),"Moveto: Wait" );
break;
case CINE_MOVETO_WAIT_FACING:
Q_snprintf(tempstr,sizeof(tempstr),"Moveto: Wait Facing" );
break;
case CINE_MOVETO_WALK:
Q_snprintf(tempstr,sizeof(tempstr),"Moveto: Walk to Mark" );
break;
case CINE_MOVETO_RUN:
Q_snprintf(tempstr,sizeof(tempstr),"Moveto: Run to Mark" );
break;
case CINE_MOVETO_CUSTOM:
Q_snprintf(tempstr,sizeof(tempstr),"Moveto: Custom move to Mark" );
break;
case CINE_MOVETO_TELEPORT:
Q_snprintf(tempstr,sizeof(tempstr),"Moveto: Teleport to Mark" );
break;
}
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf(tempstr,sizeof(tempstr),"Thinking: %s", m_bThinking ? "Yes" : "No" ) ;
EntityText(text_offset,tempstr,0);
text_offset++;
if ( GetEntityName() != NULL_STRING )
{
Q_snprintf(tempstr,sizeof(tempstr),"Delay: %d", m_iDelay ) ;
EntityText(text_offset,tempstr,0);
text_offset++;
}
Q_snprintf(tempstr,sizeof(tempstr),"Start Time: %f", m_startTime ) ;
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf(tempstr,sizeof(tempstr),"Sequence has started: %s", m_sequenceStarted ? "Yes" : "No" ) ;
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf(tempstr,sizeof(tempstr),"Cancel Other Sequences: %s", m_bDontCancelOtherSequences ? "No" : "Yes" ) ;
EntityText(text_offset,tempstr,0);
text_offset++;
if ( m_bWaitForBeginSequence )
{
Q_snprintf(tempstr,sizeof(tempstr),"Is waiting for BeingSequence" );
EntityText(text_offset,tempstr,0);
text_offset++;
}
if ( m_bIsPlayingEntry )
{
Q_snprintf(tempstr,sizeof(tempstr),"Is playing entry" );
EntityText(text_offset,tempstr,0);
text_offset++;
}
if ( m_bLoopActionSequence )
{
Q_snprintf(tempstr,sizeof(tempstr),"Will loop action sequence" );
EntityText(text_offset,tempstr,0);
text_offset++;
}
if ( m_bSynchPostIdles )
{
Q_snprintf(tempstr,sizeof(tempstr),"Will synch post idles" );
EntityText(text_offset,tempstr,0);
text_offset++;
}
}
return text_offset;
}
//-----------------------------------------------------------------------------
// Purpose: Modifies an NPC's AI state without taking it out of its AI.
//-----------------------------------------------------------------------------
class CAI_ScriptedSchedule : public CBaseEntity
{
DECLARE_CLASS( CAI_ScriptedSchedule, CBaseEntity );
public:
CAI_ScriptedSchedule( void );
private:
void StartSchedule( CAI_BaseNPC *pTarget );
void StopSchedule( CAI_BaseNPC *pTarget );
void ScriptThink( void );
// Input handlers
void InputStartSchedule( inputdata_t &inputdata );
void InputStopSchedule( inputdata_t &inputdata );
CAI_BaseNPC *FindScriptEntity( bool bCyclic );
//---------------------------------
enum Schedule_t
{
SCHED_SCRIPT_NONE = 0,
SCHED_SCRIPT_WALK_TO_GOAL,
SCHED_SCRIPT_RUN_TO_GOAL,
SCHED_SCRIPT_ENEMY_IS_GOAL,
SCHED_SCRIPT_WALK_PATH_GOAL,
SCHED_SCRIPT_RUN_PATH_GOAL,
SCHED_SCRIPT_ENEMY_IS_GOAL_AND_RUN_TO_GOAL,
};
//---------------------------------
EHANDLE m_hLastFoundEntity;
EHANDLE m_hActivator; // Held from the input to allow procedural calls
string_t m_iszEntity; // Entity that is wanted for this script
float m_flRadius; // Range to search for an NPC to possess.
string_t m_sGoalEnt;
Schedule_t m_nSchedule;
int m_nForceState;
bool m_bGrabAll;
Interruptability_t m_Interruptability;
bool m_bDidFireOnce;
//---------------------------------
DECLARE_DATADESC();
};
BEGIN_DATADESC( CAI_ScriptedSchedule )
DEFINE_FIELD( m_hLastFoundEntity, FIELD_EHANDLE ),
DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "m_flRadius" ),
DEFINE_KEYFIELD( m_iszEntity, FIELD_STRING, "m_iszEntity" ),
DEFINE_KEYFIELD( m_nSchedule, FIELD_INTEGER, "schedule" ),
DEFINE_KEYFIELD( m_nForceState, FIELD_INTEGER, "forcestate" ),
DEFINE_KEYFIELD( m_sGoalEnt, FIELD_STRING, "goalent" ),
DEFINE_KEYFIELD( m_bGrabAll, FIELD_BOOLEAN, "graball" ),
DEFINE_KEYFIELD( m_Interruptability, FIELD_INTEGER, "interruptability"),
DEFINE_FIELD( m_bDidFireOnce, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hActivator, FIELD_EHANDLE ),
DEFINE_THINKFUNC( ScriptThink ),
DEFINE_INPUTFUNC( FIELD_VOID, "StartSchedule", InputStartSchedule ),
DEFINE_INPUTFUNC( FIELD_VOID, "StopSchedule", InputStopSchedule ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( aiscripted_schedule, CAI_ScriptedSchedule );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAI_ScriptedSchedule::CAI_ScriptedSchedule( void ) : m_hActivator( NULL )
{
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_ScriptedSchedule::ScriptThink( void )
{
bool success = false;
CAI_BaseNPC *pTarget;
if ( !m_bGrabAll )
{
pTarget = FindScriptEntity( (m_spawnflags & SF_SCRIPT_SEARCH_CYCLICALLY) != 0 );
if ( pTarget )
{
DevMsg( 2, "scripted_schedule \"%s\" using NPC \"%s\"(%s)\n", GetDebugName(), STRING( m_iszEntity ), pTarget->GetEntityName().ToCStr() );
StartSchedule( pTarget );
success = true;
}
}
else
{
m_hLastFoundEntity = NULL;
while ( ( pTarget = FindScriptEntity( true ) ) != NULL )
{
DevMsg( 2, "scripted_schedule \"%s\" using NPC \"%s\"(%s)\n", GetDebugName(), pTarget->GetEntityName().ToCStr(), STRING( m_iszEntity ) );
StartSchedule( pTarget );
success = true;
}
}
if ( !success )
{
DevMsg( 2, "scripted_schedule \"%s\" can't find NPC \"%s\"\n", GetDebugName(), STRING( m_iszEntity ) );
// FIXME: just trying again is bad. This should fire an output instead.
// FIXME: Think about puting output triggers on success true and sucess false
// FIXME: also needs to check the result of StartSchedule(), which can fail and not complain
SetNextThink( gpGlobals->curtime + 1.0f );
}
else
{
m_bDidFireOnce = true;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CAI_BaseNPC *CAI_ScriptedSchedule::FindScriptEntity( bool bCyclic )
{
CBaseEntity *pEntity = gEntList.FindEntityGenericWithin( m_hLastFoundEntity, STRING( m_iszEntity ), GetAbsOrigin(), m_flRadius, this, m_hActivator );
while ( pEntity != NULL )
{
CAI_BaseNPC *pNPC = pEntity->MyNPCPointer();
if ( pNPC && pNPC->IsAlive() && pNPC->IsInterruptable())
{
if ( bCyclic )
{
// next time this is called, start searching from the one found last time
m_hLastFoundEntity = pNPC;
}
return pNPC;
}
pEntity = gEntList.FindEntityGenericWithin( pEntity, STRING( m_iszEntity ), GetAbsOrigin(), m_flRadius, this, NULL );
}
m_hLastFoundEntity = NULL;
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Make the entity carry out the scripted instructions, but without
// destroying the NPC's state.
//-----------------------------------------------------------------------------
void CAI_ScriptedSchedule::StartSchedule( CAI_BaseNPC *pTarget )
{
if ( pTarget == NULL )
return;
CBaseEntity *pGoalEnt = gEntList.FindEntityGeneric( NULL, STRING( m_sGoalEnt ), this, NULL );
// NOTE: !!! all possible choices require a goal ent currently
if ( !pGoalEnt )
{
CHintCriteria hintCriteria;
hintCriteria.SetGroup( m_sGoalEnt );
hintCriteria.SetHintType( HINT_ANY );
hintCriteria.AddIncludePosition( pTarget->GetAbsOrigin(), FLT_MAX );
CAI_Hint *pHint = CAI_HintManager::FindHint( pTarget->GetAbsOrigin(), hintCriteria );
if ( !pHint )
{
DevMsg( 1, "Can't find goal entity %s\nCan't execute script %s\n", STRING(m_sGoalEnt), GetDebugName() );
return;
}
pGoalEnt = pHint;
}
static NPC_STATE forcedStatesMap[] =
{
NPC_STATE_NONE,
NPC_STATE_IDLE,
NPC_STATE_ALERT,
NPC_STATE_COMBAT
};
if ( pTarget->GetSleepState() > AISS_AWAKE )
pTarget->Wake();
pTarget->ForceDecisionThink();
Assert( m_nForceState >= 0 && m_nForceState < ARRAYSIZE(forcedStatesMap) );
NPC_STATE forcedState = forcedStatesMap[m_nForceState];
// trap if this isn't a legal thing to do
Assert( pTarget->IsInterruptable() );
if ( forcedState != NPC_STATE_NONE )
pTarget->SetState( forcedState );
//
// Set enemy and make the NPC aware of the enemy's current position.
//
if ( m_nSchedule == SCHED_SCRIPT_ENEMY_IS_GOAL || m_nSchedule == SCHED_SCRIPT_ENEMY_IS_GOAL_AND_RUN_TO_GOAL )
{
if ( pGoalEnt && pGoalEnt->MyCombatCharacterPointer() )
{
pTarget->SetEnemy( pGoalEnt );
pTarget->UpdateEnemyMemory( pGoalEnt, pGoalEnt->GetAbsOrigin() );
pTarget->SetCondition( COND_SCHEDULE_DONE );
}
else
DevMsg( "Scripted schedule %s specified an invalid enemy %s\n", STRING( GetEntityName() ), STRING( m_sGoalEnt ) );
}
bool bDidSetSchedule = false;
switch ( m_nSchedule )
{
//
// Walk or run to position.
//
case SCHED_SCRIPT_WALK_TO_GOAL:
case SCHED_SCRIPT_RUN_TO_GOAL:
case SCHED_SCRIPT_ENEMY_IS_GOAL_AND_RUN_TO_GOAL:
{
Activity movementActivity = ( m_nSchedule == SCHED_SCRIPT_WALK_TO_GOAL ) ? ACT_WALK : ACT_RUN;
bool bIsFlying = (pTarget->GetMoveType() == MOVETYPE_FLY) || (pTarget->GetMoveType() == MOVETYPE_FLYGRAVITY);
if ( bIsFlying )
{
movementActivity = ACT_FLY;
}
if (!pTarget->ScheduledMoveToGoalEntity( SCHED_IDLE_WALK, pGoalEnt, movementActivity ))
{
if (!(m_spawnflags & SF_SCRIPT_NO_COMPLAINTS))
{
DevMsg( 1, "ScheduledMoveToGoalEntity to goal entity %s failed\nCan't execute script %s\n", STRING(m_sGoalEnt), GetDebugName() );
}
return;
}
bDidSetSchedule = true;
break;
}
case SCHED_SCRIPT_WALK_PATH_GOAL:
case SCHED_SCRIPT_RUN_PATH_GOAL:
{
Activity movementActivity = ( m_nSchedule == SCHED_SCRIPT_WALK_PATH_GOAL ) ? ACT_WALK : ACT_RUN;
bool bIsFlying = (pTarget->GetMoveType() == MOVETYPE_FLY) || (pTarget->GetMoveType() == MOVETYPE_FLYGRAVITY);
if ( bIsFlying )
{
movementActivity = ACT_FLY;
}
if (!pTarget->ScheduledFollowPath( SCHED_IDLE_WALK, pGoalEnt, movementActivity ))
{
if (!(m_spawnflags & SF_SCRIPT_NO_COMPLAINTS))
{
DevMsg( 1, "ScheduledFollowPath to goal entity %s failed\nCan't execute script %s\n", STRING(m_sGoalEnt), GetDebugName() );
}
return;
}
bDidSetSchedule = true;
break;
}
}
if ( bDidSetSchedule )
{
// Chain this to the target so that it can add the base and any custom interrupts to this
pTarget->SetScriptedScheduleIgnoreConditions( m_Interruptability );
}
}
//-----------------------------------------------------------------------------
// Purpose: Input handler to activate the scripted schedule. Finds the NPC to
// act on and sets a think for the near future to do the real work.
//-----------------------------------------------------------------------------
void CAI_ScriptedSchedule::InputStartSchedule( inputdata_t &inputdata )
{
if (( m_nForceState == 0 ) && ( m_nSchedule == 0 ))
{
DevMsg( 2, "aiscripted_schedule - no schedule or state has been set!\n" );
}
if ( !m_bDidFireOnce || ( m_spawnflags & SF_SCRIPT_REPEATABLE ) )
{
// DVS TODO: Is the NPC already playing the script?
m_hActivator = inputdata.pActivator;
SetThink( &CAI_ScriptedSchedule::ScriptThink );
SetNextThink( gpGlobals->curtime );
}
else
{
DevMsg( 2, "aiscripted_schedule - not playing schedule again: not flagged to repeat\n" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Input handler to stop a previously activated scripted schedule.
//-----------------------------------------------------------------------------
void CAI_ScriptedSchedule::InputStopSchedule( inputdata_t &inputdata )
{
if ( !m_bDidFireOnce )
{
DevMsg( 2, "aiscripted_schedule - StopSchedule called, but schedule's never started.\n" );
return;
}
CAI_BaseNPC *pTarget;
if ( !m_bGrabAll )
{
pTarget = FindScriptEntity( (m_spawnflags & SF_SCRIPT_SEARCH_CYCLICALLY) != 0 );
if ( pTarget )
{
StopSchedule( pTarget );
}
}
else
{
m_hLastFoundEntity = NULL;
while ( ( pTarget = FindScriptEntity( true ) ) != NULL )
{
StopSchedule( pTarget );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: If the target entity appears to be running this scripted schedule break it
//-----------------------------------------------------------------------------
void CAI_ScriptedSchedule::StopSchedule( CAI_BaseNPC *pTarget )
{
if ( pTarget->IsCurSchedule( SCHED_IDLE_WALK ) )
{
DevMsg( 2, "%s (%s): StopSchedule called on NPC %s.\n", GetClassname(), GetDebugName(), pTarget->GetDebugName() );
pTarget->ClearSchedule( "Stopping scripted schedule" );
}
}
class CAI_ScriptedSentence : public CPointEntity
{
public:
DECLARE_CLASS( CAI_ScriptedSentence, CPointEntity );
void Spawn( void );
bool KeyValue( const char *szKeyName, const char *szValue );
void FindThink( void );
void DelayThink( void );
int ObjectCaps( void ) { return (BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
// Input handlers
void InputBeginSentence( inputdata_t &inputdata );
DECLARE_DATADESC();
CAI_BaseNPC *FindEntity( void );
bool AcceptableSpeaker( CAI_BaseNPC *pNPC );
int StartSentence( CAI_BaseNPC *pTarget );
private:
string_t m_iszSentence; // string index for sentence name
string_t m_iszEntity; // entity that is wanted for this sentence
float m_flRadius; // range to search
float m_flDelay; // How long the sentence lasts
float m_flRepeat; // repeat rate
soundlevel_t m_iSoundLevel;
int m_TempAttenuation;
float m_flVolume;
bool m_active;
string_t m_iszListener; // name of entity to look at while talking
CBaseEntity *m_pActivator;
COutputEvent m_OnBeginSentence;
COutputEvent m_OnEndSentence;
};
#define SF_SENTENCE_ONCE 0x0001
#define SF_SENTENCE_FOLLOWERS 0x0002 // only say if following player
#define SF_SENTENCE_INTERRUPT 0x0004 // force talking except when dead
#define SF_SENTENCE_CONCURRENT 0x0008 // allow other people to keep talking
#define SF_SENTENCE_SPEAKTOACTIVATOR 0x0010
BEGIN_DATADESC( CAI_ScriptedSentence )
DEFINE_KEYFIELD( m_iszSentence, FIELD_STRING, "sentence" ),
DEFINE_KEYFIELD( m_iszEntity, FIELD_STRING, "entity" ),
DEFINE_KEYFIELD( m_flRadius, FIELD_FLOAT, "radius" ),
DEFINE_KEYFIELD( m_flDelay, FIELD_FLOAT, "delay" ),
DEFINE_KEYFIELD( m_flRepeat, FIELD_FLOAT, "refire" ),
DEFINE_KEYFIELD( m_iszListener, FIELD_STRING, "listener" ),
DEFINE_KEYFIELD( m_TempAttenuation, FIELD_INTEGER, "attenuation" ),
DEFINE_FIELD( m_iSoundLevel, FIELD_INTEGER ),
DEFINE_FIELD( m_flVolume, FIELD_FLOAT ),
DEFINE_FIELD( m_active, FIELD_BOOLEAN ),
DEFINE_FIELD( m_pActivator, FIELD_EHANDLE ),
// Function Pointers
DEFINE_FUNCTION( FindThink ),
DEFINE_FUNCTION( DelayThink ),
// Inputs
DEFINE_INPUTFUNC(FIELD_VOID, "BeginSentence", InputBeginSentence),
// Outputs
DEFINE_OUTPUT(m_OnBeginSentence, "OnBeginSentence"),
DEFINE_OUTPUT(m_OnEndSentence, "OnEndSentence"),
END_DATADESC()
LINK_ENTITY_TO_CLASS( scripted_sentence, CAI_ScriptedSentence );
//-----------------------------------------------------------------------------
// Purpose:
// Input : szKeyName -
// szValue -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ScriptedSentence::KeyValue( const char *szKeyName, const char *szValue )
{
if(FStrEq(szKeyName, "volume"))
{
m_flVolume = atof( szValue ) * 0.1;
}
else
{
return BaseClass::KeyValue( szKeyName, szValue );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Input handler for starting the scripted sentence.
//-----------------------------------------------------------------------------
void CAI_ScriptedSentence::InputBeginSentence( inputdata_t &inputdata )
{
if ( !m_active )
return;
m_pActivator = inputdata.pActivator;
//Msg( "Firing sentence: %s\n", STRING( m_iszSentence ));
SetThink( &CAI_ScriptedSentence::FindThink );
SetNextThink( gpGlobals->curtime );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSentence::Spawn( void )
{
SetSolid( SOLID_NONE );
m_active = true;
// if no targetname, start now
if ( !GetEntityName() )
{
SetThink( &CAI_ScriptedSentence::FindThink );
SetNextThink( gpGlobals->curtime + 1.0f );
}
switch( m_TempAttenuation )
{
case 1: // Medium radius
m_iSoundLevel = SNDLVL_80dB;
break;
case 2: // Large radius
m_iSoundLevel = SNDLVL_85dB;
break;
case 3: //EVERYWHERE
m_iSoundLevel = SNDLVL_NONE;
break;
default:
case 0: // Small radius
m_iSoundLevel = SNDLVL_70dB;
break;
}
m_TempAttenuation = 0;
// No volume, use normal
if ( m_flVolume <= 0 )
m_flVolume = 1.0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSentence::FindThink( void )
{
CAI_BaseNPC *pNPC = FindEntity();
if ( pNPC )
{
int index = StartSentence( pNPC );
float length = engine->SentenceLength(index);
m_OnEndSentence.FireOutput(NULL, this, length + m_flRepeat);
if ( m_spawnflags & SF_SENTENCE_ONCE )
UTIL_Remove( this );
float delay = m_flDelay + length + 0.1;
if ( delay < 0 )
delay = 0;
SetThink( &CAI_ScriptedSentence::DelayThink );
// calculate delay dynamically because this could play a sentence group
// rather than a single sentence.
// add 0.1 because the sound engine mixes ahead -- the sentence will actually start ~0.1 secs from now
SetNextThink( gpGlobals->curtime + delay + m_flRepeat );
m_active = false;
//Msg( "%s: found NPC %s\n", STRING(m_iszSentence), STRING(m_iszEntity) );
}
else
{
//Msg( "%s: can't find NPC %s\n", STRING(m_iszSentence), STRING(m_iszEntity) );
SetNextThink( gpGlobals->curtime + m_flRepeat + 0.5 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ScriptedSentence::DelayThink( void )
{
m_active = true;
if ( !GetEntityName() )
SetNextThink( gpGlobals->curtime + 0.1f );
SetThink( &CAI_ScriptedSentence::FindThink );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ScriptedSentence::AcceptableSpeaker( CAI_BaseNPC *pNPC )
{
if ( pNPC )
{
if ( m_spawnflags & SF_SENTENCE_FOLLOWERS )
{
if ( pNPC->GetTarget() == NULL || !pNPC->GetTarget()->IsPlayer() )
return false;
}
bool override;
if ( m_spawnflags & SF_SENTENCE_INTERRUPT )
override = true;
else
override = false;
if ( pNPC->CanPlaySentence( override ) )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
CAI_BaseNPC *CAI_ScriptedSentence::FindEntity( void )
{
CBaseEntity *pentTarget;
CAI_BaseNPC *pNPC;
pentTarget = gEntList.FindEntityByName( NULL, m_iszEntity );
pNPC = NULL;
while (pentTarget)
{
pNPC = pentTarget->MyNPCPointer();
if ( pNPC != NULL )
{
if ( AcceptableSpeaker( pNPC ) )
return pNPC;
//Msg( "%s (%s), not acceptable\n", pNPC->GetClassname(), pNPC->GetDebugName() );
}
pentTarget = gEntList.FindEntityByName( pentTarget, m_iszEntity );
}
CBaseEntity *pEntity = NULL;
for ( CEntitySphereQuery sphere( GetAbsOrigin(), m_flRadius, FL_NPC ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
{
if (FClassnameIs( pEntity, STRING(m_iszEntity)))
{
pNPC = pEntity->MyNPCPointer( );
if ( AcceptableSpeaker( pNPC ) )
return pNPC;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pTarget -
// Output :
//-----------------------------------------------------------------------------
int CAI_ScriptedSentence::StartSentence( CAI_BaseNPC *pTarget )
{
if ( !pTarget )
{
DevMsg( 2, "Not Playing sentence %s\n", STRING(m_iszSentence) );
return -1;
}
bool bConcurrent = false;
if ( !(m_spawnflags & SF_SENTENCE_CONCURRENT) )
bConcurrent = true;
CBaseEntity *pListener = NULL;
if ( m_spawnflags & SF_SENTENCE_SPEAKTOACTIVATOR )
{
pListener = m_pActivator;
}
else if (m_iszListener != NULL_STRING)
{
float radius = m_flRadius;
if ( FStrEq( STRING(m_iszListener ), "!player" ) )
radius = MAX_TRACE_LENGTH; // Always find the player
pListener = gEntList.FindEntityGenericNearest( STRING( m_iszListener ), pTarget->GetAbsOrigin(), radius, this, NULL );
}
int sentenceIndex = pTarget->PlayScriptedSentence( STRING(m_iszSentence), m_flDelay, m_flVolume, m_iSoundLevel, bConcurrent, pListener );
DevMsg( 2, "Playing sentence %s\n", STRING(m_iszSentence) );
m_OnBeginSentence.FireOutput(NULL, this);
return sentenceIndex;
}
// HACKHACK: This is a little expensive with the dynamic_cast<> and all, but it lets us solve
// the problem of matching scripts back to entities without new state.
const char *CAI_ScriptedSequence::GetSpawnPreIdleSequenceForScript( CBaseEntity *pEntity )
{
CAI_ScriptedSequence *pScript = gEntList.NextEntByClass( (CAI_ScriptedSequence *)NULL );
while ( pScript )
{
if ( pScript->HasSpawnFlags( SF_SCRIPT_START_ON_SPAWN ) && pScript->m_iszEntity == pEntity->GetEntityName() )
{
if ( pScript->m_iszPreIdle != NULL_STRING )
{
return STRING(pScript->m_iszPreIdle);
}
return NULL;
}
pScript = gEntList.NextEntByClass( pScript );
}
return NULL;
}