1354 lines
35 KiB
C++
1354 lines
35 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
|
|
#include "npc_talker.h"
|
|
#include "npcevent.h"
|
|
#include "scriptevent.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
|
|
BEGIN_SIMPLE_DATADESC( CNPCSimpleTalkerExpresser )
|
|
// m_pSink (reconnected on load)
|
|
DEFINE_AUTO_ARRAY( m_szMonologSentence, FIELD_CHARACTER ),
|
|
DEFINE_FIELD( m_iMonologIndex, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_fMonologSuspended, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_hMonologTalkTarget, FIELD_EHANDLE ),
|
|
END_DATADESC()
|
|
|
|
BEGIN_DATADESC( CNPCSimpleTalker )
|
|
DEFINE_FIELD( m_useTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_flNextIdleSpeechTime, FIELD_TIME ),
|
|
DEFINE_FIELD( m_nSpeak, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_iszUse, FIELD_STRING ),
|
|
DEFINE_FIELD( m_iszUnUse, FIELD_STRING ),
|
|
// m_FollowBehavior (auto saved by AI)
|
|
// Function Pointers
|
|
DEFINE_USEFUNC( FollowerUse ),
|
|
|
|
END_DATADESC()
|
|
|
|
// array of friend names
|
|
char *CNPCSimpleTalker::m_szFriends[TLK_CFRIENDS] =
|
|
{
|
|
"NPC_barney",
|
|
"NPC_scientist",
|
|
"NPC_sitting_scientist",
|
|
NULL,
|
|
};
|
|
|
|
bool CNPCSimpleTalker::KeyValue( const char *szKeyName, const char *szValue )
|
|
{
|
|
if (FStrEq(szKeyName, "UseSentence"))
|
|
{
|
|
m_iszUse = AllocPooledString(szValue);
|
|
}
|
|
else if (FStrEq(szKeyName, "UnUseSentence"))
|
|
{
|
|
m_iszUnUse = AllocPooledString(szValue);
|
|
}
|
|
else
|
|
return BaseClass::KeyValue( szKeyName, szValue );
|
|
|
|
return true;
|
|
}
|
|
|
|
void CNPCSimpleTalker::Precache( void )
|
|
{
|
|
/*
|
|
// FIXME: Need to figure out how to hook these...
|
|
if ( m_iszUse != NULL_STRING )
|
|
GetExpresser()->ModifyConcept( TLK_STARTFOLLOW, STRING( m_iszUse ) );
|
|
if ( m_iszUnUse != NULL_STRING )
|
|
GetExpresser()->ModifyConcept( TLK_STOPFOLLOW, STRING( m_iszUnUse ) );
|
|
|
|
*/
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Allows for modification of the interrupt mask for the current schedule.
|
|
// In the most cases the base implementation should be called first.
|
|
//-----------------------------------------------------------------------------
|
|
void CNPCSimpleTalker::BuildScheduleTestBits( void )
|
|
{
|
|
BaseClass::BuildScheduleTestBits();
|
|
|
|
// Assume that if I move from the player, I can respond to a question
|
|
if ( ConditionInterruptsCurSchedule( COND_PLAYER_PUSHING ) || ConditionInterruptsCurSchedule( COND_PROVOKED ) )
|
|
{
|
|
SetCustomInterruptCondition( COND_TALKER_RESPOND_TO_QUESTION );
|
|
}
|
|
}
|
|
|
|
void CNPCSimpleTalker::PrescheduleThink( void )
|
|
{
|
|
BaseClass::PrescheduleThink();
|
|
|
|
(assert_cast<CNPCSimpleTalkerExpresser *>(GetExpresser()))->SpeakMonolog();
|
|
}
|
|
|
|
bool CNPCSimpleTalker::ShouldSuspendMonolog( void )
|
|
{
|
|
float flDist;
|
|
|
|
flDist = ((assert_cast<CNPCSimpleTalkerExpresser *>(GetExpresser()))->GetMonologueTarget()->GetAbsOrigin() - GetAbsOrigin()).Length();
|
|
|
|
if( flDist >= 384 )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CNPCSimpleTalker::ShouldResumeMonolog( void )
|
|
{
|
|
float flDist;
|
|
|
|
if( HasCondition( COND_SEE_PLAYER ) )
|
|
{
|
|
flDist = ((assert_cast<CNPCSimpleTalkerExpresser *>(GetExpresser()))->GetMonologueTarget()->GetAbsOrigin() - GetAbsOrigin()).Length();
|
|
|
|
if( flDist <= 256 )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int CNPCSimpleTalker::SelectSchedule( void )
|
|
{
|
|
if ( !HasCondition(COND_RECEIVED_ORDERS) )
|
|
{
|
|
if ( GetState() == NPC_STATE_IDLE )
|
|
{
|
|
// if never seen player, try to greet him
|
|
// Filter might be preventing us from ever greeting the player
|
|
if ( HasCondition( COND_SEE_PLAYER ) && CanSayHello())
|
|
{
|
|
return SCHED_TALKER_IDLE_HELLO;
|
|
}
|
|
}
|
|
}
|
|
|
|
return BaseClass::SelectSchedule();
|
|
}
|
|
|
|
void CNPCSimpleTalker::StartTask( const Task_t *pTask )
|
|
{
|
|
switch ( pTask->iTask )
|
|
{
|
|
case TASK_TALKER_WAIT_FOR_SEMAPHORE:
|
|
if ( GetExpresser()->SemaphoreIsAvailable( this ) )
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_SPEAK:
|
|
// ask question or make statement
|
|
FIdleSpeak();
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_RESPOND:
|
|
// respond to question
|
|
IdleRespond();
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_HELLO:
|
|
// greet player
|
|
FIdleHello();
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_STARE:
|
|
// let the player know I know he's staring at me.
|
|
FIdleStare();
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_LOOK_AT_CLIENT:
|
|
case TASK_TALKER_CLIENT_STARE:
|
|
// track head to the client for a while.
|
|
SetWait( pTask->flTaskData );
|
|
break;
|
|
|
|
case TASK_TALKER_EYECONTACT:
|
|
break;
|
|
|
|
case TASK_TALKER_IDEALYAW:
|
|
if (GetSpeechTarget() != NULL)
|
|
{
|
|
GetMotor()->SetIdealYawToTarget( GetSpeechTarget()->GetAbsOrigin() );
|
|
}
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_HEADRESET:
|
|
// reset head position after looking at something
|
|
SetSpeechTarget( NULL );
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_BETRAYED:
|
|
Speak( TLK_BETRAYED );
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_STOPSHOOTING:
|
|
// tell player to stop shooting
|
|
Speak( TLK_NOSHOOT );
|
|
TaskComplete();
|
|
break;
|
|
default:
|
|
BaseClass::StartTask( pTask );
|
|
}
|
|
}
|
|
|
|
void CNPCSimpleTalker::RunTask( const Task_t *pTask )
|
|
{
|
|
switch( pTask->iTask )
|
|
{
|
|
case TASK_TALKER_WAIT_FOR_SEMAPHORE:
|
|
if ( GetExpresser()->SemaphoreIsAvailable( this ) )
|
|
TaskComplete();
|
|
break;
|
|
|
|
case TASK_TALKER_CLIENT_STARE:
|
|
case TASK_TALKER_LOOK_AT_CLIENT:
|
|
|
|
if ( pTask->iTask == TASK_TALKER_CLIENT_STARE && AI_IsSinglePlayer() )
|
|
{
|
|
// Get edict for one player
|
|
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
|
|
Assert( pPlayer );
|
|
|
|
// fail out if the player looks away or moves away.
|
|
if ( ( pPlayer->GetAbsOrigin() - GetAbsOrigin() ).Length2D() > TALKER_STARE_DIST )
|
|
{
|
|
// player moved away.
|
|
TaskFail("Player moved away");
|
|
}
|
|
|
|
Vector forward;
|
|
AngleVectors( pPlayer->GetLocalAngles(), &forward );
|
|
if ( UTIL_DotPoints( pPlayer->GetAbsOrigin(), GetAbsOrigin(), forward ) < m_flFieldOfView )
|
|
{
|
|
// player looked away
|
|
TaskFail("Player looked away");
|
|
}
|
|
}
|
|
|
|
if ( IsWaitFinished() )
|
|
{
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
|
|
case TASK_TALKER_EYECONTACT:
|
|
if (IsMoving() || !GetExpresser()->IsSpeaking() || GetSpeechTarget() == NULL)
|
|
{
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
|
|
case TASK_WAIT_FOR_MOVEMENT:
|
|
FIdleSpeakWhileMoving();
|
|
BaseClass::RunTask( pTask );
|
|
break;
|
|
|
|
default:
|
|
BaseClass::RunTask( pTask );
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Purpose :
|
|
// Input :
|
|
// Output :
|
|
//------------------------------------------------------------------------------
|
|
|
|
Activity CNPCSimpleTalker::NPC_TranslateActivity( Activity eNewActivity )
|
|
{
|
|
if ((eNewActivity == ACT_IDLE) &&
|
|
(GetExpresser()->IsSpeaking()) &&
|
|
(SelectWeightedSequence ( ACT_SIGNAL3 ) != ACTIVITY_NOT_AVAILABLE) )
|
|
{
|
|
return ACT_SIGNAL3;
|
|
}
|
|
else if ((eNewActivity == ACT_SIGNAL3) &&
|
|
(SelectWeightedSequence ( ACT_SIGNAL3 ) == ACTIVITY_NOT_AVAILABLE) )
|
|
{
|
|
return ACT_IDLE;
|
|
}
|
|
return BaseClass::NPC_TranslateActivity( eNewActivity );
|
|
}
|
|
|
|
|
|
void CNPCSimpleTalker::Event_Killed( const CTakeDamageInfo &info )
|
|
{
|
|
AlertFriends( info.GetAttacker() );
|
|
if ( info.GetAttacker()->GetFlags() & FL_CLIENT )
|
|
{
|
|
LimitFollowers( info.GetAttacker(), 0 );
|
|
}
|
|
BaseClass::Event_Killed( info );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CNPCSimpleTalker::EnumFriends( CBaseEntity *pPrevious, int listNumber, bool bTrace )
|
|
{
|
|
CBaseEntity *pFriend = pPrevious;
|
|
char *pszFriend;
|
|
trace_t tr;
|
|
Vector vecCheck;
|
|
|
|
pszFriend = m_szFriends[ FriendNumber(listNumber) ];
|
|
while ( pszFriend != NULL && ((pFriend = gEntList.FindEntityByClassname( pFriend, pszFriend )) != NULL) )
|
|
{
|
|
if (pFriend == this || !pFriend->IsAlive())
|
|
// don't talk to self or dead people
|
|
continue;
|
|
|
|
if ( bTrace )
|
|
{
|
|
Vector vecCheck;
|
|
pFriend->CollisionProp()->NormalizedToWorldSpace( Vector( 0.5f, 0.5f, 1.0f ), &vecCheck );
|
|
UTIL_TraceLine( GetAbsOrigin(), vecCheck, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
|
|
}
|
|
else
|
|
{
|
|
tr.fraction = 1.0;
|
|
}
|
|
|
|
if (tr.fraction == 1.0)
|
|
{
|
|
return pFriend;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pKiller -
|
|
//-----------------------------------------------------------------------------
|
|
void CNPCSimpleTalker::AlertFriends( CBaseEntity *pKiller )
|
|
{
|
|
CBaseEntity *pFriend = NULL;
|
|
int i;
|
|
|
|
// for each friend in this bsp...
|
|
for ( i = 0; i < TLK_CFRIENDS; i++ )
|
|
{
|
|
while ((pFriend = EnumFriends( pFriend, i, true )) != NULL )
|
|
{
|
|
CAI_BaseNPC *pNPC = pFriend->MyNPCPointer();
|
|
if ( pNPC->IsAlive() )
|
|
{
|
|
// If a client killed me, make everyone else mad/afraid of him
|
|
if ( pKiller->GetFlags() & FL_CLIENT )
|
|
{
|
|
CNPCSimpleTalker*pTalkNPC = (CNPCSimpleTalker *)pFriend;
|
|
|
|
if (pTalkNPC && pTalkNPC->IsOkToCombatSpeak())
|
|
{
|
|
// FIXME: need to check CanSpeakConcept?
|
|
pTalkNPC->Speak( TLK_BETRAYED );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( IRelationType(pKiller) == D_HT)
|
|
{
|
|
// Killed by an enemy!!!
|
|
CNPCSimpleTalker *pAlly = (CNPCSimpleTalker *)pNPC;
|
|
|
|
if( pAlly && pAlly->GetExpresser()->CanSpeakConcept( TLK_ALLY_KILLED ) )
|
|
{
|
|
pAlly->Speak( TLK_ALLY_KILLED );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CNPCSimpleTalker::ShutUpFriends( void )
|
|
{
|
|
CBaseEntity *pFriend = NULL;
|
|
int i;
|
|
|
|
// for each friend in this bsp...
|
|
for ( i = 0; i < TLK_CFRIENDS; i++ )
|
|
{
|
|
while ((pFriend = EnumFriends( pFriend, i, true )) != NULL)
|
|
{
|
|
CAI_BaseNPC *pNPC = pFriend->MyNPCPointer();
|
|
if ( pNPC )
|
|
{
|
|
pNPC->SentenceStop();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// UNDONE: Keep a follow time in each follower, make a list of followers in this function and do LRU
|
|
// UNDONE: Check this in Restore to keep restored NPCs from joining a full list of followers
|
|
void CNPCSimpleTalker::LimitFollowers( CBaseEntity *pPlayer, int maxFollowers )
|
|
{
|
|
CBaseEntity *pFriend = NULL;
|
|
int i, count;
|
|
|
|
count = 0;
|
|
// for each friend in this bsp...
|
|
for ( i = 0; i < TLK_CFRIENDS; i++ )
|
|
{
|
|
while ((pFriend = EnumFriends( pFriend, i, false )) != NULL)
|
|
{
|
|
CAI_BaseNPC *pNPC = pFriend->MyNPCPointer();
|
|
CNPCSimpleTalker *pTalker;
|
|
if ( pNPC )
|
|
{
|
|
if ( pNPC->GetTarget() == pPlayer )
|
|
{
|
|
count++;
|
|
if ( count > maxFollowers && (pTalker = dynamic_cast<CNPCSimpleTalker *>( pNPC ) ) != NULL )
|
|
pTalker->StopFollowing();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// HandleAnimEvent - catches the NPC-specific messages
|
|
// that occur when tagged animation frames are played.
|
|
//=========================================================
|
|
void CNPCSimpleTalker::HandleAnimEvent( animevent_t *pEvent )
|
|
{
|
|
switch( pEvent->event )
|
|
{
|
|
case SCRIPT_EVENT_SENTENCE_RND1: // Play a named sentence group 25% of the time
|
|
if (random->RandomInt(0,99) < 75)
|
|
break;
|
|
// fall through...
|
|
case SCRIPT_EVENT_SENTENCE: // Play a named sentence group
|
|
ShutUpFriends();
|
|
PlaySentence( pEvent->options, random->RandomFloat(2.8, 3.4) );
|
|
//Msg( "script event speak\n");
|
|
break;
|
|
|
|
default:
|
|
BaseClass::HandleAnimEvent( pEvent );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Scan for nearest, visible friend. If fPlayer is true, look for nearest player
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPCSimpleTalker::IsValidSpeechTarget( int flags, CBaseEntity *pEntity )
|
|
{
|
|
return BaseClass::IsValidSpeechTarget( flags, pEntity );
|
|
}
|
|
|
|
CBaseEntity *CNPCSimpleTalker::FindNearestFriend(bool fPlayer)
|
|
{
|
|
return FindSpeechTarget( (fPlayer) ? AIST_PLAYERS : AIST_NPCS );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Respond to a previous question
|
|
//-----------------------------------------------------------------------------
|
|
void CNPCSimpleTalker::IdleRespond( void )
|
|
{
|
|
if (!IsOkToSpeak())
|
|
return;
|
|
|
|
// play response
|
|
SpeakAnswerFriend( GetSpeechTarget() );
|
|
|
|
DeferAllIdleSpeech( random->RandomFloat( TALKER_DEFER_IDLE_SPEAK_MIN, TALKER_DEFER_IDLE_SPEAK_MAX ) );
|
|
}
|
|
|
|
bool CNPCSimpleTalker::IsOkToSpeak( void )
|
|
{
|
|
if ( m_flNextIdleSpeechTime > gpGlobals->curtime )
|
|
return false;
|
|
|
|
return BaseClass::IsOkToSpeak();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find a nearby friend to stare at
|
|
//-----------------------------------------------------------------------------
|
|
int CNPCSimpleTalker::FIdleStare( void )
|
|
{
|
|
// Don't idly speak if our speech filter is preventing us
|
|
if ( GetSpeechFilter() && GetSpeechFilter()->GetIdleModifier() == 0 )
|
|
return true;
|
|
|
|
SpeakIfAllowed( TLK_STARE );
|
|
|
|
SetSpeechTarget( FindNearestFriend( true ) );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Try to greet player first time he's seen
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int CNPCSimpleTalker::FIdleHello( void )
|
|
{
|
|
// Filter might be preventing us from ever greeting the player
|
|
if ( !CanSayHello() )
|
|
return false;
|
|
|
|
// get a player
|
|
CBaseEntity *pPlayer = FindNearestFriend(true);
|
|
|
|
if (pPlayer)
|
|
{
|
|
if (FInViewCone(pPlayer) && FVisible(pPlayer))
|
|
{
|
|
SayHelloToPlayer( pPlayer );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Say hello to the specified player
|
|
//-----------------------------------------------------------------------------
|
|
void CNPCSimpleTalker::SayHelloToPlayer( CBaseEntity *pPlayer )
|
|
{
|
|
Assert( !GetExpresser()->SpokeConcept(TLK_HELLO) );
|
|
|
|
SetSpeechTarget( pPlayer );
|
|
|
|
Speak( TLK_HELLO );
|
|
DeferAllIdleSpeech( random->RandomFloat( 5, 10 ) );
|
|
|
|
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
|
|
CAI_PlayerAlly *pTalker;
|
|
for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ )
|
|
{
|
|
pTalker = dynamic_cast<CAI_PlayerAlly *>(ppAIs[i]);
|
|
|
|
if( pTalker && FVisible( pTalker ) )
|
|
{
|
|
// Tell this guy he's already said hello to the player, too.
|
|
pTalker->GetExpresser()->SetSpokeConcept( TLK_HELLO, NULL );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------
|
|
// Stop all allies from idle speech for a fixed amount
|
|
// of time. Mostly filthy hack to hold us over until
|
|
// acting comes online.
|
|
//---------------------------------------------------------
|
|
void CNPCSimpleTalker::DeferAllIdleSpeech( float flDelay, CAI_BaseNPC *pIgnore )
|
|
{
|
|
// Brute force. Just plow through NPC list looking for talkers.
|
|
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
|
|
CNPCSimpleTalker *pTalker;
|
|
|
|
float flTime = gpGlobals->curtime + flDelay;
|
|
|
|
for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ )
|
|
{
|
|
if( ppAIs[i] != pIgnore )
|
|
{
|
|
pTalker = dynamic_cast<CNPCSimpleTalker *>(ppAIs[i]);
|
|
|
|
if( pTalker )
|
|
{
|
|
pTalker->m_flNextIdleSpeechTime = flTime;
|
|
}
|
|
}
|
|
}
|
|
|
|
BaseClass::DeferAllIdleSpeech( flDelay, pIgnore );
|
|
}
|
|
|
|
//=========================================================
|
|
// FIdleSpeak
|
|
// ask question of nearby friend, or make statement
|
|
//=========================================================
|
|
int CNPCSimpleTalker::FIdleSpeak( void )
|
|
{
|
|
// try to start a conversation, or make statement
|
|
int pitch;
|
|
|
|
if (!IsOkToSpeak())
|
|
return false;
|
|
|
|
Assert( GetExpresser()->SemaphoreIsAvailable( this ) );
|
|
|
|
pitch = GetExpresser()->GetVoicePitch();
|
|
|
|
// player using this entity is alive and wounded?
|
|
CBaseEntity *pTarget = GetTarget();
|
|
|
|
if ( pTarget != NULL )
|
|
{
|
|
if ( pTarget->IsPlayer() )
|
|
{
|
|
if ( pTarget->IsAlive() )
|
|
{
|
|
SetSpeechTarget( GetTarget() );
|
|
if (GetExpresser()->CanSpeakConcept( TLK_PLHURT3) &&
|
|
(GetTarget()->m_iHealth <= GetTarget()->m_iMaxHealth / 8))
|
|
{
|
|
Speak( TLK_PLHURT3 );
|
|
return true;
|
|
}
|
|
else if (GetExpresser()->CanSpeakConcept( TLK_PLHURT2) &&
|
|
(GetTarget()->m_iHealth <= GetTarget()->m_iMaxHealth / 4))
|
|
{
|
|
Speak( TLK_PLHURT2 );
|
|
return true;
|
|
}
|
|
else if (GetExpresser()->CanSpeakConcept( TLK_PLHURT1) &&
|
|
(GetTarget()->m_iHealth <= GetTarget()->m_iMaxHealth / 2))
|
|
{
|
|
Speak( TLK_PLHURT1 );
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//!!!KELLY - here's a cool spot to have the talkNPC talk about the dead player if we want.
|
|
// "Oh dear, Gordon Freeman is dead!" -Scientist
|
|
// "Damn, I can't do this without you." -Barney
|
|
}
|
|
}
|
|
}
|
|
|
|
// ROBIN: Disabled idle question & answer for now
|
|
/*
|
|
// if there is a friend nearby to speak to, play sentence, set friend's response time, return
|
|
CBaseEntity *pFriend = FindNearestFriend(false);
|
|
|
|
// 75% chance of talking to another citizen if one is available.
|
|
if (pFriend && !(pFriend->IsMoving()) && random->RandomInt( 0, 3 ) != 0 )
|
|
{
|
|
if ( SpeakQuestionFriend( pFriend ) )
|
|
{
|
|
// force friend to answer
|
|
CAI_PlayerAlly *pTalkNPC = dynamic_cast<CAI_PlayerAlly *>(pFriend);
|
|
if (pTalkNPC && !pTalkNPC->HasSpawnFlags(SF_NPC_GAG) && !pTalkNPC->IsInAScript() )
|
|
{
|
|
SetSpeechTarget( pFriend );
|
|
pTalkNPC->SetAnswerQuestion( this );
|
|
pTalkNPC->GetExpresser()->BlockSpeechUntil( GetExpresser()->GetTimeSpeechComplete() );
|
|
|
|
m_nSpeak++;
|
|
}
|
|
|
|
// Don't let anyone else butt in.
|
|
DeferAllIdleSpeech( random->RandomFloat( TALKER_DEFER_IDLE_SPEAK_MIN, TALKER_DEFER_IDLE_SPEAK_MAX ), pTalkNPC );
|
|
return true;
|
|
}
|
|
}
|
|
*/
|
|
|
|
// Otherwise, play an idle statement, try to face client when making a statement.
|
|
CBaseEntity *pFriend = FindNearestFriend(true);
|
|
if ( pFriend )
|
|
{
|
|
SetSpeechTarget( pFriend );
|
|
|
|
// If we're about to talk to the player, and we've never said hello, say hello first
|
|
if ( !GetSpeechFilter() || !GetSpeechFilter()->NeverSayHello() )
|
|
{
|
|
if ( GetExpresser()->CanSpeakConcept( TLK_HELLO ) && !GetExpresser()->SpokeConcept( TLK_HELLO ) )
|
|
{
|
|
SayHelloToPlayer( pFriend );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if ( Speak( TLK_IDLE ) )
|
|
{
|
|
DeferAllIdleSpeech( random->RandomFloat( TALKER_DEFER_IDLE_SPEAK_MIN, TALKER_DEFER_IDLE_SPEAK_MAX ) );
|
|
m_nSpeak++;
|
|
}
|
|
else
|
|
{
|
|
// We failed to speak. Don't try again for a bit.
|
|
m_flNextIdleSpeechTime = gpGlobals->curtime + 3;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// didn't speak
|
|
m_flNextIdleSpeechTime = gpGlobals->curtime + 3;
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Speak the right question based upon who we're asking
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPCSimpleTalker::SpeakQuestionFriend( CBaseEntity *pFriend )
|
|
{
|
|
return Speak( TLK_QUESTION );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Speak the right answer based upon who we're answering
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPCSimpleTalker::SpeakAnswerFriend( CBaseEntity *pFriend )
|
|
{
|
|
return Speak( TLK_ANSWER );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CNPCSimpleTalker::FIdleSpeakWhileMoving( void )
|
|
{
|
|
if ( GetExpresser()->CanSpeak() )
|
|
{
|
|
if (!GetExpresser()->IsSpeaking() || GetSpeechTarget() == NULL)
|
|
{
|
|
// override so that during walk, a scientist may talk and greet player
|
|
FIdleHello();
|
|
|
|
if ( ShouldSpeakRandom( m_nSpeak * 20, GetSpeechFilter() ? GetSpeechFilter()->GetIdleModifier() : 1.0 ) )
|
|
{
|
|
FIdleSpeak();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CNPCSimpleTalker::PlayScriptedSentence( const char *pszSentence, float delay, float volume, soundlevel_t soundlevel, bool bConcurrent, CBaseEntity *pListener )
|
|
{
|
|
if ( !bConcurrent )
|
|
ShutUpFriends();
|
|
|
|
int sentenceIndex = BaseClass::PlayScriptedSentence( pszSentence, delay, volume, soundlevel, bConcurrent, pListener );
|
|
delay += engine->SentenceLength( sentenceIndex );
|
|
if ( delay < 0 )
|
|
delay = 0;
|
|
m_useTime = gpGlobals->curtime + delay;
|
|
|
|
// Stop all idle speech until after the sentence has completed
|
|
DeferAllIdleSpeech( delay + random->RandomInt( 3.0f, 5.0f ) );
|
|
|
|
return sentenceIndex;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Tell this NPC to answer a question from another NPC
|
|
//-----------------------------------------------------------------------------
|
|
void CNPCSimpleTalker::SetAnswerQuestion( CNPCSimpleTalker *pSpeaker )
|
|
{
|
|
if ( !m_hCine )
|
|
{
|
|
SetCondition( COND_TALKER_RESPOND_TO_QUESTION );
|
|
}
|
|
|
|
SetSpeechTarget( (CAI_BaseNPC *)pSpeaker );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CNPCSimpleTalker::OnTakeDamage_Alive( const CTakeDamageInfo &info )
|
|
{
|
|
CTakeDamageInfo subInfo = info;
|
|
|
|
// if player damaged this entity, have other friends talk about it.
|
|
if (subInfo.GetAttacker() && (subInfo.GetAttacker()->GetFlags() & FL_CLIENT) && subInfo.GetDamage() < GetHealth() )
|
|
{
|
|
CBaseEntity *pFriend = FindNearestFriend(false);
|
|
|
|
if (pFriend && pFriend->IsAlive())
|
|
{
|
|
// only if not dead or dying!
|
|
CNPCSimpleTalker *pTalkNPC = (CNPCSimpleTalker *)pFriend;
|
|
|
|
if (pTalkNPC && pTalkNPC->IsOkToCombatSpeak())
|
|
{
|
|
pTalkNPC->Speak( TLK_NOSHOOT );
|
|
}
|
|
}
|
|
}
|
|
return BaseClass::OnTakeDamage_Alive( subInfo );
|
|
}
|
|
|
|
int CNPCSimpleTalker::SelectNonCombatSpeechSchedule()
|
|
{
|
|
if ( !IsOkToSpeak() )
|
|
return SCHED_NONE;
|
|
|
|
// talk about world
|
|
if ( ShouldSpeakRandom( m_nSpeak * 2, GetSpeechFilter() ? GetSpeechFilter()->GetIdleModifier() : 1.0 ) )
|
|
{
|
|
//Msg("standing idle speak\n" );
|
|
return SCHED_TALKER_IDLE_SPEAK;
|
|
}
|
|
|
|
// failed to speak, so look at the player if he's around
|
|
if ( AI_IsSinglePlayer() && GetExpresser()->CanSpeak() && HasCondition ( COND_SEE_PLAYER ) && random->RandomInt( 0, 6 ) == 0 )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
|
|
Assert( pPlayer );
|
|
|
|
if ( pPlayer )
|
|
{
|
|
// watch the client.
|
|
Vector forward;
|
|
AngleVectors( pPlayer->GetLocalAngles(), &forward );
|
|
if ( ( pPlayer->GetAbsOrigin() - GetAbsOrigin() ).Length2D() < TALKER_STARE_DIST &&
|
|
UTIL_DotPoints( pPlayer->GetAbsOrigin(), GetAbsOrigin(), forward ) >= m_flFieldOfView )
|
|
{
|
|
// go into the special STARE schedule if the player is close, and looking at me too.
|
|
return SCHED_TALKER_IDLE_WATCH_CLIENT_STARE;
|
|
}
|
|
|
|
return SCHED_TALKER_IDLE_WATCH_CLIENT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// look at who we're talking to
|
|
if ( GetSpeechTarget() && GetExpresser()->IsSpeaking() )
|
|
return SCHED_TALKER_IDLE_EYE_CONTACT;
|
|
}
|
|
return SCHED_NONE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPCSimpleTalker::CanSayHello( void )
|
|
{
|
|
#ifndef HL1_DLL
|
|
if ( Classify() == CLASS_PLAYER_ALLY_VITAL )
|
|
return false;
|
|
#endif
|
|
|
|
if ( GetSpeechFilter() && GetSpeechFilter()->NeverSayHello() )
|
|
return false;
|
|
|
|
if ( !GetExpresser()->CanSpeakConcept(TLK_HELLO) || GetExpresser()->SpokeConcept(TLK_HELLO) )
|
|
return false;
|
|
|
|
if ( !IsOkToSpeak() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CNPCSimpleTalker::OnStartingFollow( CBaseEntity *pTarget )
|
|
{
|
|
GetExpresser()->SetSpokeConcept( TLK_HELLO, NULL ); // Don't say hi after you've started following
|
|
if ( IsOkToSpeak() ) // don't speak if idle talk is blocked. player commanded/use follow will always speak
|
|
Speak( TLK_STARTFOLLOW );
|
|
SetSpeechTarget( GetTarget() );
|
|
ClearCondition( COND_PLAYER_PUSHING );
|
|
}
|
|
|
|
void CNPCSimpleTalker::OnStoppingFollow( CBaseEntity *pTarget )
|
|
{
|
|
if ( !(m_afMemory & bits_MEMORY_PROVOKED) )
|
|
{
|
|
if ( IsOkToCombatSpeak() )
|
|
{
|
|
if ( pTarget == NULL )
|
|
Speak( TLK_STOPFOLLOW );
|
|
else
|
|
Speak( TLK_STOP );
|
|
}
|
|
SetSpeechTarget( FindNearestFriend(true) );
|
|
}
|
|
}
|
|
|
|
void CNPCSimpleTalker::FollowerUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
|
|
{
|
|
// Don't allow use during a scripted_sentence
|
|
if ( m_useTime > gpGlobals->curtime )
|
|
return;
|
|
|
|
if ( pCaller != NULL && pCaller->IsPlayer() )
|
|
{
|
|
if ( !m_FollowBehavior.GetFollowTarget() && IsInterruptable() )
|
|
{
|
|
#if TOML_TODO
|
|
LimitFollowers( pCaller , 1 );
|
|
#endif
|
|
|
|
if ( m_afMemory & bits_MEMORY_PROVOKED )
|
|
Msg( "I'm not following you, you evil person!\n" );
|
|
else
|
|
{
|
|
StartFollowing( pCaller );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
StopFollowing();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CNPCSimpleTalker::InputIdleRespond( inputdata_t &inputdata )
|
|
{
|
|
// We've been told to respond. Check combat speak, not isoktospeak, because
|
|
// we don't want to check the idle speech time.
|
|
if (!IsOkToCombatSpeak())
|
|
return;
|
|
|
|
IdleRespond();
|
|
}
|
|
|
|
int CNPCSimpleTalkerExpresser::SpeakRawSentence( const char *pszSentence, float delay, float volume, soundlevel_t soundlevel, CBaseEntity *pListener )
|
|
{
|
|
char szSpecificSentence[1024];
|
|
int sentenceIndex = -1;
|
|
|
|
if ( !pszSentence )
|
|
return sentenceIndex;
|
|
|
|
if ( pszSentence[0] == AI_SP_START_MONOLOG )
|
|
{
|
|
// this sentence command will start this NPC speaking
|
|
// lengthy monolog from smaller sentences.
|
|
BeginMonolog( (char *)pszSentence, pListener );
|
|
return -1;
|
|
}
|
|
else if ( pszSentence[0] == AI_SP_MONOLOG_LINE )
|
|
{
|
|
Q_strncpy(szSpecificSentence, pszSentence, sizeof(szSpecificSentence) );
|
|
szSpecificSentence[0] = AI_SP_SPECIFIC_SENTENCE;
|
|
pszSentence = szSpecificSentence;
|
|
}
|
|
else
|
|
{
|
|
// this bit of speech is interrupting my monolog!
|
|
SuspendMonolog( 0 );
|
|
}
|
|
|
|
return CAI_Expresser::SpeakRawSentence( pszSentence, delay, volume, soundlevel, pListener );
|
|
}
|
|
|
|
//-------------------------------------
|
|
|
|
void CNPCSimpleTalkerExpresser::BeginMonolog( char *pszSentenceName, CBaseEntity *pListener )
|
|
{
|
|
if( pListener )
|
|
{
|
|
m_hMonologTalkTarget = pListener;
|
|
}
|
|
else
|
|
{
|
|
Warning( "NULL Listener in BeginMonolog()!\n" );
|
|
Assert(0);
|
|
EndMonolog();
|
|
return;
|
|
}
|
|
|
|
Q_strncpy( m_szMonologSentence, pszSentenceName ,sizeof(m_szMonologSentence));
|
|
|
|
// change the "AI_SP_START_MONOLOG" to an "AI_SP_MONOLOG_LINE". m_sMonologSentence is now the
|
|
// string we'll tack numbers onto to play sentences from this group in
|
|
// sequential order.
|
|
m_szMonologSentence[0] = AI_SP_MONOLOG_LINE;
|
|
|
|
m_fMonologSuspended = false;
|
|
|
|
m_iMonologIndex = 0;
|
|
}
|
|
|
|
//-------------------------------------
|
|
|
|
void CNPCSimpleTalkerExpresser::EndMonolog( void )
|
|
{
|
|
m_szMonologSentence[0] = 0;
|
|
m_iMonologIndex = -1;
|
|
m_fMonologSuspended = false;
|
|
m_hMonologTalkTarget = NULL;
|
|
}
|
|
|
|
//-------------------------------------
|
|
|
|
void CNPCSimpleTalkerExpresser::SpeakMonolog( void )
|
|
{
|
|
int i;
|
|
char szSentence[ MONOLOGNAME_LEN ];
|
|
|
|
if( !HasMonolog() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( CanSpeak() )
|
|
{
|
|
if( m_fMonologSuspended )
|
|
{
|
|
if ( GetOuter()->ShouldResumeMonolog() )
|
|
{
|
|
ResumeMonolog();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
Q_snprintf( szSentence,sizeof(szSentence), "%s%d", m_szMonologSentence, m_iMonologIndex );
|
|
m_iMonologIndex++;
|
|
|
|
i = SpeakRawSentence( szSentence, 0, VOL_NORM );
|
|
|
|
if ( i == -1 )
|
|
{
|
|
EndMonolog();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( GetOuter()->ShouldSuspendMonolog() )
|
|
{
|
|
SuspendMonolog( 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------------
|
|
|
|
void CNPCSimpleTalkerExpresser::SuspendMonolog( float flInterval )
|
|
{
|
|
if( HasMonolog() )
|
|
{
|
|
m_fMonologSuspended = true;
|
|
}
|
|
|
|
// free up other characters to speak.
|
|
if ( GetSink()->UseSemaphore() )
|
|
{
|
|
GetSpeechSemaphore( GetOuter() )->Release();
|
|
}
|
|
}
|
|
|
|
//-------------------------------------
|
|
|
|
void CNPCSimpleTalkerExpresser::ResumeMonolog( void )
|
|
{
|
|
if( m_iMonologIndex > 0 )
|
|
{
|
|
// back up and repeat what I was saying
|
|
// when interrupted.
|
|
m_iMonologIndex--;
|
|
}
|
|
|
|
GetOuter()->OnResumeMonolog();
|
|
m_fMonologSuspended = false;
|
|
}
|
|
|
|
// try to smell something
|
|
void CNPCSimpleTalker::TrySmellTalk( void )
|
|
{
|
|
if ( !IsOkToSpeak() )
|
|
return;
|
|
|
|
if ( HasCondition( COND_SMELL ) && GetExpresser()->CanSpeakConcept( TLK_SMELL ) )
|
|
Speak( TLK_SMELL );
|
|
}
|
|
|
|
void CNPCSimpleTalker::OnChangeRunningBehavior( CAI_BehaviorBase *pOldBehavior, CAI_BehaviorBase *pNewBehavior )
|
|
{
|
|
BaseClass::OnChangeRunningBehavior( pOldBehavior, pNewBehavior );
|
|
|
|
CAI_FollowBehavior *pFollowBehavior;
|
|
if ( ( pFollowBehavior = dynamic_cast<CAI_FollowBehavior *>(pNewBehavior) ) != NULL )
|
|
{
|
|
OnStartingFollow( pFollowBehavior->GetFollowTarget() );
|
|
}
|
|
else if ( ( pFollowBehavior = dynamic_cast<CAI_FollowBehavior *>(pOldBehavior) ) != NULL )
|
|
{
|
|
OnStoppingFollow( pFollowBehavior->GetFollowTarget() );
|
|
}
|
|
}
|
|
|
|
|
|
bool CNPCSimpleTalker::OnBehaviorChangeStatus( CAI_BehaviorBase *pBehavior, bool fCanFinishSchedule )
|
|
{
|
|
bool interrupt = BaseClass::OnBehaviorChangeStatus( pBehavior, fCanFinishSchedule );
|
|
if ( !interrupt )
|
|
{
|
|
interrupt = ( dynamic_cast<CAI_FollowBehavior *>(pBehavior) != NULL && ( m_NPCState == NPC_STATE_IDLE || m_NPCState == NPC_STATE_ALERT ) );
|
|
}
|
|
return interrupt;
|
|
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return true if I should speak based on the chance & the speech filter's modifier
|
|
//-----------------------------------------------------------------------------
|
|
bool CNPCSimpleTalker::ShouldSpeakRandom( int iChance, float flModifier )
|
|
{
|
|
if ( flModifier != 1.0 )
|
|
{
|
|
// Avoid divide by zero
|
|
if ( !flModifier )
|
|
return false;
|
|
|
|
iChance = floor( (float)iChance / flModifier );
|
|
}
|
|
|
|
return (random->RandomInt(0,iChance) == 0);
|
|
}
|
|
|
|
|
|
AI_BEGIN_CUSTOM_NPC(talk_monster,CNPCSimpleTalker)
|
|
DECLARE_USES_SCHEDULE_PROVIDER( CAI_FollowBehavior )
|
|
|
|
DECLARE_TASK(TASK_TALKER_RESPOND)
|
|
DECLARE_TASK(TASK_TALKER_SPEAK)
|
|
DECLARE_TASK(TASK_TALKER_HELLO)
|
|
DECLARE_TASK(TASK_TALKER_BETRAYED)
|
|
DECLARE_TASK(TASK_TALKER_HEADRESET)
|
|
DECLARE_TASK(TASK_TALKER_STOPSHOOTING)
|
|
DECLARE_TASK(TASK_TALKER_STARE)
|
|
DECLARE_TASK(TASK_TALKER_LOOK_AT_CLIENT)
|
|
DECLARE_TASK(TASK_TALKER_CLIENT_STARE)
|
|
DECLARE_TASK(TASK_TALKER_EYECONTACT)
|
|
DECLARE_TASK(TASK_TALKER_IDEALYAW)
|
|
DECLARE_TASK(TASK_TALKER_WAIT_FOR_SEMAPHORE)
|
|
|
|
//=========================================================
|
|
// > SCHED_TALKER_IDLE_RESPONSE
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_TALKER_IDLE_RESPONSE,
|
|
|
|
" Tasks"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE" // Stop and listen
|
|
" TASK_WAIT 0.5" // Wait until sure it's me they are talking to
|
|
" TASK_TALKER_IDEALYAW 0" // look at who I'm talking to
|
|
" TASK_FACE_IDEAL 0"
|
|
" TASK_TALKER_EYECONTACT 0" // Wait until speaker is done
|
|
" TASK_TALKER_WAIT_FOR_SEMAPHORE 0"
|
|
" TASK_TALKER_EYECONTACT 0" // Wait until speaker is done
|
|
" TASK_TALKER_RESPOND 0" // Wait and then say my response
|
|
" TASK_TALKER_IDEALYAW 0" // look at who I'm talking to
|
|
" TASK_FACE_IDEAL 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_SIGNAL3"
|
|
" TASK_TALKER_EYECONTACT 0" // Wait until speaker is done
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_COMBAT"
|
|
" COND_PLAYER_PUSHING"
|
|
" COND_GIVE_WAY"
|
|
)
|
|
|
|
//=========================================================
|
|
// > SCHED_TALKER_IDLE_SPEAK
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_TALKER_IDLE_SPEAK,
|
|
|
|
" Tasks"
|
|
" TASK_TALKER_SPEAK 0" // question or remark
|
|
" TASK_TALKER_IDEALYAW 0" // look at who I'm talking to
|
|
" TASK_FACE_IDEAL 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_SIGNAL3"
|
|
" TASK_TALKER_EYECONTACT 0"
|
|
" TASK_WAIT_RANDOM 0.5"
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_COMBAT"
|
|
" COND_PLAYER_PUSHING"
|
|
" COND_GIVE_WAY"
|
|
)
|
|
|
|
//=========================================================
|
|
// > SCHED_TALKER_IDLE_HELLO
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_TALKER_IDLE_HELLO,
|
|
|
|
" Tasks"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_SIGNAL3" // Stop and talk
|
|
" TASK_TALKER_HELLO 0" // Try to say hello to player
|
|
" TASK_TALKER_EYECONTACT 0"
|
|
" TASK_WAIT 0.5" // wait a bit
|
|
" TASK_TALKER_HELLO 0" // Try to say hello to player
|
|
" TASK_TALKER_EYECONTACT 0"
|
|
" TASK_WAIT 0.5" // wait a bit
|
|
" TASK_TALKER_HELLO 0" // Try to say hello to player
|
|
" TASK_TALKER_EYECONTACT 0"
|
|
" TASK_WAIT 0.5" // wait a bit
|
|
" TASK_TALKER_HELLO 0" // Try to say hello to player
|
|
" TASK_TALKER_EYECONTACT 0"
|
|
" TASK_WAIT 0.5 " // wait a bit
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_PROVOKED"
|
|
" COND_HEAR_COMBAT"
|
|
" COND_HEAR_DANGER"
|
|
" COND_PLAYER_PUSHING"
|
|
" COND_GIVE_WAY"
|
|
)
|
|
|
|
//=========================================================
|
|
// > SCHED_TALKER_IDLE_STOP_SHOOTING
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_TALKER_IDLE_STOP_SHOOTING,
|
|
|
|
" Tasks"
|
|
" TASK_TALKER_STOPSHOOTING 0" // tell player to stop shooting friend
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
)
|
|
|
|
//=========================================================
|
|
// Scold the player before attacking.
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_TALKER_BETRAYED,
|
|
|
|
" Tasks"
|
|
" TASK_TALKER_BETRAYED 0"
|
|
" TASK_WAIT 0.5"
|
|
""
|
|
" Interrupts"
|
|
" COND_HEAR_DANGER"
|
|
)
|
|
|
|
//=========================================================
|
|
// > SCHED_TALKER_IDLE_WATCH_CLIENT
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_TALKER_IDLE_WATCH_CLIENT,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
" TASK_TALKER_LOOK_AT_CLIENT 6"
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_PROVOKED"
|
|
" COND_HEAR_COMBAT" // sound flags - change these and you'll break the talking code.
|
|
" COND_HEAR_DANGER"
|
|
" COND_SMELL"
|
|
" COND_PLAYER_PUSHING"
|
|
" COND_TALKER_CLIENTUNSEEN"
|
|
" COND_GIVE_WAY"
|
|
" COND_IDLE_INTERRUPT"
|
|
)
|
|
|
|
//=========================================================
|
|
// > SCHED_TALKER_IDLE_WATCH_CLIENT_STARE
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_TALKER_IDLE_WATCH_CLIENT_STARE,
|
|
|
|
" Tasks"
|
|
" TASK_STOP_MOVING 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
" TASK_TALKER_CLIENT_STARE 6"
|
|
" TASK_TALKER_STARE 0"
|
|
" TASK_TALKER_IDEALYAW 0" // look at who I'm talking to
|
|
" TASK_FACE_IDEAL 0 "
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_SIGNAL3"
|
|
" TASK_TALKER_EYECONTACT 0"
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_PROVOKED"
|
|
" COND_HEAR_COMBAT" // sound flags - change these and you'll break the talking code.
|
|
" COND_HEAR_DANGER"
|
|
" COND_SMELL"
|
|
" COND_PLAYER_PUSHING"
|
|
" COND_TALKER_CLIENTUNSEEN"
|
|
" COND_GIVE_WAY"
|
|
" COND_IDLE_INTERRUPT"
|
|
)
|
|
|
|
//=========================================================
|
|
// > SCHED_TALKER_IDLE_EYE_CONTACT
|
|
//=========================================================
|
|
DEFINE_SCHEDULE
|
|
(
|
|
SCHED_TALKER_IDLE_EYE_CONTACT,
|
|
|
|
" Tasks"
|
|
" TASK_TALKER_IDEALYAW 0" // look at who I'm talking to
|
|
" TASK_FACE_IDEAL 0"
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_SIGNAL3"
|
|
" TASK_TALKER_EYECONTACT 0" // Wait until speaker is done
|
|
""
|
|
" Interrupts"
|
|
" COND_NEW_ENEMY"
|
|
" COND_LIGHT_DAMAGE"
|
|
" COND_HEAVY_DAMAGE"
|
|
" COND_HEAR_DANGER"
|
|
" COND_HEAR_COMBAT"
|
|
" COND_PLAYER_PUSHING"
|
|
" COND_GIVE_WAY"
|
|
" COND_IDLE_INTERRUPT"
|
|
)
|
|
|
|
AI_END_CUSTOM_NPC()
|