/***
*
* Copyright ( c ) 1996 - 2002 , Valve LLC . All rights reserved .
*
* This product contains software technology licensed from Id
* Software , Inc . ( " Id Technology " ) . Id Technology ( c ) 1996 Id Software , Inc .
* All Rights Reserved .
*
* This source code contains proprietary and confidential information of
* Valve LLC and its suppliers . Access to this code is restricted to
* persons who have executed a written SDK license with Valve . Any access ,
* use or distribution of this code by or to any unlicensed person is illegal .
*
* * * */
/*
= = = = = scripted . cpp = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
*/
# include "extdll.h"
# include "util.h"
# include "cbase.h"
# include "monsters.h"
# include "player.h"
# if !defined(ANIMATION_H)
# include "animation.h"
# endif
# if !defined(SAVERESTORE_H)
# include "saverestore.h"
# endif
# include "schedule.h"
# include "scripted.h"
# include "defaultai.h"
# include "movewith.h"
/*
classname " scripted_sequence "
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 "
donetrigger " whatever " - can be any other triggerable entity such as another sequence , train , door , or a special case like " die " or " remove "
moveto - if set the monster first moves to this nodes position
range # - only search this far to find the target
spawnflags - ( stop if blocked , stop if player seen )
*/
//
// Cache user-entity-field values until spawn is called.
//
void CCineMonster : : KeyValue ( KeyValueData * pkvd )
{
if ( FStrEq ( pkvd - > szKeyName , " m_iszIdle " ) )
{
m_iszIdle = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_iszPlay " ) )
{
m_iszPlay = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_iszEntity " ) )
{
m_iszEntity = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_iszAttack " ) )
{
m_iszAttack = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_iszMoveTarget " ) )
{
m_iszMoveTarget = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_iszFireOnBegin " ) )
{
m_iszFireOnBegin = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_fMoveTo " ) )
{
m_fMoveTo = atoi ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_fTurnType " ) )
{
m_fTurnType = atoi ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_fAction " ) )
{
m_fAction = atoi ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
// LRC else if (FStrEq(pkvd->szKeyName, "m_flRepeat"))
// {
// m_flRepeat = atof( pkvd->szValue );
// pkvd->fHandled = TRUE;
// }
else if ( FStrEq ( pkvd - > szKeyName , " m_flRadius " ) )
{
m_flRadius = atof ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_iRepeats " ) )
{
m_iRepeats = atoi ( pkvd - > szValue ) ;
m_iRepeatsLeft = m_iRepeats ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_fRepeatFrame " ) )
{
m_fRepeatFrame = atof ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_iFinishSchedule " ) )
{
m_iFinishSchedule = atoi ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " m_iPriority " ) )
{
m_iPriority = atoi ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else
{
CBaseMonster : : KeyValue ( pkvd ) ;
}
}
TYPEDESCRIPTION CCineMonster : : m_SaveData [ ] =
{
DEFINE_FIELD ( CCineMonster , m_iState , FIELD_INTEGER ) , //LRC
DEFINE_FIELD ( CCineMonster , m_iszIdle , FIELD_STRING ) ,
DEFINE_FIELD ( CCineMonster , m_iszPlay , FIELD_STRING ) ,
DEFINE_FIELD ( CCineMonster , m_iszEntity , FIELD_STRING ) ,
DEFINE_FIELD ( CCineMonster , m_iszAttack , FIELD_STRING ) , //LRC
DEFINE_FIELD ( CCineMonster , m_iszMoveTarget , FIELD_STRING ) , //LRC
DEFINE_FIELD ( CCineMonster , m_iszFireOnBegin , FIELD_STRING ) ,
DEFINE_FIELD ( CCineMonster , m_fMoveTo , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_fTurnType , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_fAction , FIELD_INTEGER ) ,
//LRC- this is unused DEFINE_FIELD( CCineMonster, m_flRepeat, FIELD_FLOAT ),
DEFINE_FIELD ( CCineMonster , m_flRadius , FIELD_FLOAT ) ,
DEFINE_FIELD ( CCineMonster , m_iDelay , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_startTime , FIELD_TIME ) ,
DEFINE_FIELD ( CCineMonster , m_saved_movetype , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_saved_solid , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_saved_effects , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_iFinishSchedule , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_interruptable , FIELD_BOOLEAN ) ,
//LRC
DEFINE_FIELD ( CCineMonster , m_iRepeats , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_iRepeatsLeft , FIELD_INTEGER ) ,
DEFINE_FIELD ( CCineMonster , m_fRepeatFrame , FIELD_FLOAT ) ,
DEFINE_FIELD ( CCineMonster , m_iPriority , FIELD_INTEGER ) ,
} ;
IMPLEMENT_SAVERESTORE ( CCineMonster , CBaseMonster )
LINK_ENTITY_TO_CLASS ( scripted_sequence , CCineMonster )
LINK_ENTITY_TO_CLASS ( scripted_action , CCineMonster ) //LRC
LINK_ENTITY_TO_CLASS ( aiscripted_sequence , CCineMonster ) //LRC - aiscripted sequences don't need to be seperate
void CCineMonster : : Spawn ( void )
{
// pev->solid = SOLID_TRIGGER;
// UTIL_SetSize( pev, Vector( -8, -8, -8 ), Vector( 8, 8, 8 ) );
pev - > solid = SOLID_NOT ;
m_iState = STATE_OFF ; //LRC
if ( FStringNull ( m_iszIdle ) & & FStringNull ( pev - > targetname ) ) // if no targetname, start now
{
SetThink ( & CCineMonster : : CineThink ) ;
SetNextThink ( 1.0f ) ;
}
else if ( m_iszIdle )
{
SetThink ( & CCineMonster : : InitIdleThink ) ;
SetNextThink ( 1.0f ) ;
}
if ( pev - > spawnflags & SF_SCRIPT_NOINTERRUPT )
m_interruptable = FALSE ;
else
m_interruptable = TRUE ;
//LRC - the only difference between AI and normal sequences
if ( FClassnameIs ( pev , " aiscripted_sequence " ) | | pev - > spawnflags & SF_SCRIPT_OVERRIDESTATE )
{
m_iPriority | = SS_INTERRUPT_ANYSTATE ;
}
}
//
// CineStart
//
void CCineMonster : : Use ( CBaseEntity * pActivator , CBaseEntity * pCaller , USE_TYPE useType , float value )
{
// do I already know who I should use
CBaseEntity * pEntity = m_hTargetEnt ;
CBaseMonster * pTarget = NULL ;
if ( pEntity )
pTarget = pEntity - > MyMonsterPointer ( ) ;
if ( pTarget )
{
// am I already playing the script?
if ( pTarget - > m_scriptState = = SCRIPT_PLAYING )
return ;
m_startTime = gpGlobals - > time + 0.05f ; //why the delay? -- LRC
}
else
{
// ALERT(at_console, "Sequence \"%s\" triggered, can't find target; searching\n", STRING(pev->targetname));
m_hActivator = pActivator ;
// if not, try finding them
SetThink ( & CCineMonster : : CineThink ) ;
// SetNextThink( 0 );
CineThink ( ) ; //LRC
}
}
// This doesn't really make sense since only MOVETYPE_PUSH get 'Blocked' events
void CCineMonster : : Blocked ( CBaseEntity * pOther )
{
}
void CCineMonster : : Touch ( CBaseEntity * pOther )
{
/*
ALERT ( at_aiconsole , " Cine Touch \n " ) ;
if ( m_pentTarget & & OFFSET ( pOther - > pev ) = = OFFSET ( m_pentTarget ) )
{
CBaseMonster * pTarget = GetClassPtr ( ( CBaseMonster * ) VARS ( m_pentTarget ) ) ;
pTarget - > m_monsterState = = MONSTERSTATE_SCRIPT ;
}
*/
}
/*
entvars_t * pevOther = VARS ( gpGlobals - > other ) ;
if ( ! FBitSet ( pevOther - > flags , FL_MONSTER ) )
{
// touched by a non-monster.
return ;
}
pevOther - > origin . z + = 1 ;
if ( FBitSet ( pevOther - > flags , FL_ONGROUND ) )
{
// clear the onground so physics don't bitch
pevOther - > flags - = FL_ONGROUND ;
}
// toss the monster!
pevOther - > velocity = pev - > movedir * pev - > speed ;
pevOther - > velocity . z + = m_flHeight ;
pev - > solid = SOLID_NOT ; // kill the trigger for now !!!UNDONE
}
*/
//
// ********** Cinematic DIE **********
//
void CCineMonster : : Die ( void )
{
SetThink ( & CCineMonster : : SUB_Remove ) ;
}
//
// ********** Cinematic PAIN **********
//
void CCineMonster : : Pain ( void )
{
}
//
// ********** Cinematic Think **********
//
//LRC: now redefined... find a viable entity with the given name, and return it (or NULL if not found).
CBaseMonster * CCineMonster : : FindEntity ( const char * sName , CBaseEntity * pActivator )
{
CBaseEntity * pEntity ;
pEntity = UTIL_FindEntityByTargetname ( NULL , sName , pActivator ) ;
//m_hTargetEnt = NULL;
CBaseMonster * pMonster = NULL ;
while ( pEntity )
{
if ( FBitSet ( pEntity - > pev - > flags , FL_MONSTER ) )
{
pMonster = pEntity - > MyMonsterPointer ( ) ;
if ( pMonster & & pMonster - > CanPlaySequence ( m_iPriority | SS_INTERRUPT_ALERT ) )
{
return pMonster ;
}
ALERT ( at_console , " Found %s, but can't play! \n " , sName ) ;
}
pEntity = UTIL_FindEntityByTargetname ( pEntity , sName , pActivator ) ;
pMonster = NULL ;
}
// couldn't find something with the given targetname; assume it's a classname instead.
if ( ! pMonster )
{
pEntity = NULL ;
while ( ( pEntity = UTIL_FindEntityInSphere ( pEntity , pev - > origin , m_flRadius ) ) ! = NULL )
{
if ( FClassnameIs ( pEntity - > pev , sName ) )
{
if ( FBitSet ( pEntity - > pev - > flags , FL_MONSTER ) )
{
pMonster = pEntity - > MyMonsterPointer ( ) ;
if ( pMonster & & pMonster - > CanPlaySequence ( m_iPriority ) )
{
return pMonster ;
}
}
}
}
}
return NULL ;
}
// make the entity enter a scripted sequence
void CCineMonster : : PossessEntity ( void )
{
CBaseEntity * pEntity = m_hTargetEnt ;
CBaseMonster * pTarget = NULL ;
if ( pEntity )
pTarget = pEntity - > MyMonsterPointer ( ) ;
if ( pTarget )
{
if ( pTarget - > m_pCine )
{
pTarget - > m_pCine - > CancelScript ( ) ;
}
pTarget - > m_pCine = this ;
if ( m_iszAttack )
{
// anything with that name?
pTarget - > m_hTargetEnt = UTIL_FindEntityByTargetname ( NULL , STRING ( m_iszAttack ) , m_hActivator ) ;
if ( pTarget - > m_hTargetEnt = = 0 )
{ // nothing. Anything with that classname?
while ( ( pTarget - > m_hTargetEnt = UTIL_FindEntityInSphere ( pTarget - > m_hTargetEnt , pev - > origin , m_flRadius ) ) ! = NULL )
{
if ( FClassnameIs ( pTarget - > m_hTargetEnt - > pev , STRING ( m_iszAttack ) ) ) break ;
}
}
if ( pTarget - > m_hTargetEnt = = 0 )
{ // nothing. Oh well.
ALERT ( at_console , " %s %s has a missing \" turn target \" : %s \n " , STRING ( pev - > classname ) , STRING ( pev - > targetname ) , STRING ( m_iszAttack ) ) ;
pTarget - > m_hTargetEnt = this ;
}
}
else
{
pTarget - > m_hTargetEnt = this ;
}
if ( m_iszMoveTarget )
{
// anything with that name?
pTarget - > m_pGoalEnt = UTIL_FindEntityByTargetname ( NULL , STRING ( m_iszMoveTarget ) , m_hActivator ) ;
if ( pTarget - > m_pGoalEnt = = 0 )
{ // nothing. Oh well.
ALERT ( at_console , " %s %s has a missing \" move target \" : %s \n " , STRING ( pev - > classname ) , STRING ( pev - > targetname ) , STRING ( m_iszMoveTarget ) ) ;
pTarget - > m_pGoalEnt = this ;
}
}
else
{
pTarget - > m_pGoalEnt = this ;
}
// if (IsAction())
// pTarget->PushEnemy(this,pev->origin);
m_saved_movetype = pTarget - > pev - > movetype ;
m_saved_solid = pTarget - > pev - > solid ;
m_saved_effects = pTarget - > pev - > effects ;
pTarget - > pev - > effects | = pev - > effects ;
// ALERT(at_console, "script. IsAction = %d",IsAction());
m_iState = STATE_ON ; // LRC: assume we'll set it to 'on', unless proven otherwise...
switch ( m_fMoveTo )
{
case 1 :
case 2 :
DelayStart ( 1 ) ;
m_iState = STATE_TURN_ON ;
// fall through...
case 0 :
case 4 :
case 5 :
case 6 :
pTarget - > m_scriptState = SCRIPT_WAIT ;
break ;
}
// ALERT( at_aiconsole, "\"%s\" found and used (INT: %s)\n", STRING( pTarget->pev->targetname ), FBitSet(pev->spawnflags, SF_SCRIPT_NOINTERRUPT)?"No":"Yes" );
pTarget - > m_IdealMonsterState = MONSTERSTATE_SCRIPT ;
// if (m_iszIdle)
// {
// ALERT(at_console, "Possess: Play idle sequence\n");
// StartSequence( pTarget, m_iszIdle, FALSE );
// if (FStrEq( STRING(m_iszIdle), STRING(m_iszPlay)))
// {
// pTarget->pev->framerate = 0;
// }
// }
// ALERT(at_console, "Finished PossessEntity, ms %d, ims %d\n", pTarget->m_MonsterState, pTarget->m_IdealMonsterState);
}
}
// at the beginning of the level, set up the idle animation. --LRC
void CCineMonster : : InitIdleThink ( void )
{
if ( ( m_hTargetEnt = FindEntity ( STRING ( m_iszEntity ) , NULL ) ) ! = NULL )
{
PossessEntity ( ) ;
m_startTime = gpGlobals - > time + ( float ) 1E6 ;
ALERT ( at_aiconsole , " script \" %s \" using monster \" %s \" \n " , STRING ( pev - > targetname ) , STRING ( m_iszEntity ) ) ;
}
else
{
CancelScript ( ) ;
ALERT ( at_aiconsole , " script \" %s \" can't find monster \" %s \" \n " , STRING ( pev - > targetname ) , STRING ( m_iszEntity ) ) ;
SetNextThink ( 1.0f ) ;
}
}
void CCineMonster : : CineThink ( void )
{
// ALERT(at_console, "Sequence think, activator %s\n", STRING(m_hActivator->pev->targetname));
if ( ( m_hTargetEnt = FindEntity ( STRING ( m_iszEntity ) , m_hActivator ) ) ! = NULL )
{
// ALERT(at_console, "Sequence found %s \"%s\"\n", STRING(m_hTargetEnt->pev->classname), STRING(m_hTargetEnt->pev->targetname));
PossessEntity ( ) ;
ALERT ( at_aiconsole , " script \" %s \" using monster \" %s \" \n " , STRING ( pev - > targetname ) , STRING ( m_iszEntity ) ) ;
}
else
{
CancelScript ( ) ;
ALERT ( at_aiconsole , " script \" %s \" can't find monster \" %s \" \n " , STRING ( pev - > targetname ) , STRING ( m_iszEntity ) ) ;
SetNextThink ( 1.0f ) ;
}
}
// lookup a sequence name and setup the target monster to play it
BOOL CCineMonster : : StartSequence ( CBaseMonster * pTarget , int iszSeq , BOOL completeOnEmpty )
{
if ( ! iszSeq & & completeOnEmpty )
{
SequenceDone ( pTarget ) ;
return FALSE ;
}
pTarget - > pev - > sequence = pTarget - > LookupSequence ( STRING ( iszSeq ) ) ;
if ( pTarget - > pev - > sequence = = - 1 )
{
ALERT ( at_error , " %s: unknown scripted sequence \" %s \" \n " , STRING ( pTarget - > pev - > targetname ) , STRING ( iszSeq ) ) ;
pTarget - > pev - > sequence = 0 ;
// return FALSE;
}
#if 0
char * s ;
if ( pev - > spawnflags & SF_SCRIPT_NOINTERRUPT )
s = " No " ;
else
s = " Yes " ;
ALERT ( at_console , " %s (%s): started \" %s \" :INT:%s \n " , STRING ( pTarget - > pev - > targetname ) , STRING ( pTarget - > pev - > classname ) , STRING ( iszSeq ) , s ) ;
# endif
pTarget - > pev - > frame = 0 ;
pTarget - > ResetSequenceInfo ( ) ;
return TRUE ;
}
//=========================================================
// SequenceDone - called when a scripted sequence animation
// sequence is done playing ( or when an AI Scripted Sequence
// doesn't supply an animation sequence to play ). Expects
// the CBaseMonster pointer to the monster that the sequence
// possesses.
//=========================================================
void CCineMonster : : SequenceDone ( CBaseMonster * pMonster )
{
m_iRepeatsLeft = m_iRepeats ; //LRC - reset the repeater count
m_iState = STATE_OFF ; // we've finished.
// ALERT( at_console, "Sequence %s finished\n", STRING(pev->targetname));//STRING( m_pCine->m_iszPlay ) );
if ( ! ( pev - > spawnflags & SF_SCRIPT_REPEATABLE ) )
{
SetThink ( & CCineMonster : : SUB_Remove ) ;
SetNextThink ( 0.1f ) ;
}
// This is done so that another sequence can take over the monster when triggered by the first
pMonster - > CineCleanup ( ) ;
FixScriptMonsterSchedule ( pMonster ) ;
// This may cause a sequence to attempt to grab this guy NOW, so we have to clear him out
// of the existing sequence
SUB_UseTargets ( NULL , USE_TOGGLE , 0 ) ;
}
//=========================================================
// When a monster finishes a scripted sequence, we have to
// fix up its state and schedule for it to return to a
// normal AI monster.
//
// Scripted sequences just dirty the Schedule and drop the
// monster in Idle State.
//
// or select a specific AMBUSH schedule, regardless of state. //LRC
//=========================================================
void CCineMonster : : FixScriptMonsterSchedule ( CBaseMonster * pMonster )
{
if ( pMonster - > m_IdealMonsterState ! = MONSTERSTATE_DEAD )
pMonster - > m_IdealMonsterState = MONSTERSTATE_IDLE ;
// pMonster->ClearSchedule();
switch ( m_iFinishSchedule )
{
case SCRIPT_FINISHSCHED_DEFAULT :
pMonster - > ClearSchedule ( ) ;
break ;
case SCRIPT_FINISHSCHED_AMBUSH :
pMonster - > ChangeSchedule ( pMonster - > GetScheduleOfType ( SCHED_AMBUSH ) ) ;
break ;
default :
ALERT ( at_aiconsole , " FixScriptMonsterSchedule - no case! \n " ) ;
pMonster - > ClearSchedule ( ) ;
break ;
}
}
BOOL CBaseMonster : : ExitScriptedSequence ( )
{
if ( pev - > deadflag = = DEAD_DYING )
{
// is this legal?
// BUGBUG -- This doesn't call Killed()
m_IdealMonsterState = MONSTERSTATE_DEAD ;
return FALSE ;
}
if ( m_pCine )
{
m_pCine - > CancelScript ( ) ;
}
return TRUE ;
}
void CCineMonster : : AllowInterrupt ( BOOL fAllow )
{
if ( pev - > spawnflags & SF_SCRIPT_NOINTERRUPT )
return ;
m_interruptable = fAllow ;
}
BOOL CCineMonster : : CanInterrupt ( void )
{
if ( ! m_interruptable )
return FALSE ;
CBaseEntity * pTarget = m_hTargetEnt ;
if ( pTarget ! = NULL & & pTarget - > pev - > deadflag = = DEAD_NO )
return TRUE ;
return FALSE ;
}
int CCineMonster : : IgnoreConditions ( void )
{
if ( CanInterrupt ( ) )
return 0 ;
// Big fat BUG: This is an IgnoreConditions function - we need to return the conditions
// that _shouldn't_ be able to break the script, instead of the conditions that _should_!!
return SCRIPT_BREAK_CONDITIONS ;
}
void ScriptEntityCancel ( edict_t * pentCine )
{
// make sure they are a scripted_sequence
if ( FClassnameIs ( pentCine , " scripted_sequence " ) | | FClassnameIs ( pentCine , " scripted_action " ) )
{
( ( CCineMonster * ) VARS ( pentCine ) ) - > m_iState = STATE_OFF ;
CCineMonster * pCineTarget = GetClassPtr ( ( CCineMonster * ) VARS ( pentCine ) ) ;
// make sure they have a monster in mind for the script
CBaseEntity * pEntity = pCineTarget - > m_hTargetEnt ;
CBaseMonster * pTarget = NULL ;
if ( pEntity )
pTarget = pEntity - > MyMonsterPointer ( ) ;
if ( pTarget )
{
// make sure their monster is actually playing a script
if ( pTarget - > m_MonsterState = = MONSTERSTATE_SCRIPT | | pTarget - > m_IdealMonsterState = = MONSTERSTATE_SCRIPT )
{
// tell them do die
pTarget - > m_scriptState = CCineMonster : : SCRIPT_CLEANUP ;
// do it now
pTarget - > CineCleanup ( ) ;
//LRC - clean up so that if another script is starting immediately, the monster will notice it.
pTarget - > ClearSchedule ( ) ;
}
}
}
}
// find all the cinematic entities with my targetname and stop them from playing
void CCineMonster : : CancelScript ( void )
{
ALERT ( at_aiconsole , " Cancelling script: %s \n " , STRING ( m_iszPlay ) ) ;
if ( ! pev - > targetname )
{
ScriptEntityCancel ( edict ( ) ) ;
return ;
}
CBaseEntity * pCineTarget = UTIL_FindEntityByTargetname ( NULL , STRING ( pev - > targetname ) ) ;
while ( pCineTarget )
{
ScriptEntityCancel ( ENT ( pCineTarget - > pev ) ) ;
pCineTarget = UTIL_FindEntityByTargetname ( pCineTarget , STRING ( pev - > targetname ) ) ;
}
}
// find all the cinematic entities with my targetname and tell them whether to wait before starting
void CCineMonster : : DelayStart ( int state )
{
CBaseEntity * pCine = UTIL_FindEntityByTargetname ( NULL , STRING ( pev - > targetname ) ) ;
while ( pCine )
{
if ( FClassnameIs ( pCine - > pev , " scripted_sequence " ) | | FClassnameIs ( pCine - > pev , " scripted_action " ) )
{
CCineMonster * pTarget = GetClassPtr ( ( CCineMonster * ) ( pCine - > pev ) ) ;
if ( state )
{
// ALERT(at_console, "Delaying start\n");
pTarget - > m_iDelay + + ;
}
else
{
pTarget - > m_iDelay - - ;
if ( pTarget - > m_iDelay < = 0 )
{
pTarget - > m_iState = STATE_ON ; //LRC
FireTargets ( STRING ( m_iszFireOnBegin ) , this , this , USE_TOGGLE , 0 ) ; //LRC
pTarget - > m_startTime = gpGlobals - > time + 0.05f ; // why the delay? -- LRC
}
}
}
pCine = UTIL_FindEntityByTargetname ( pCine , STRING ( pev - > targetname ) ) ;
}
}
// Find an entity that I'm interested in and precache the sounds he'll need in the sequence.
void CCineMonster : : Activate ( void )
{
CBaseEntity * pEntity ;
CBaseMonster * pTarget ;
// The entity name could be a target name or a classname
// Check the targetname
pEntity = UTIL_FindEntityByTargetname ( NULL , STRING ( m_iszEntity ) ) ;
pTarget = NULL ;
while ( ! pTarget & & pEntity )
{
if ( FBitSet ( pEntity - > pev - > flags , FL_MONSTER ) )
{
pTarget = pEntity - > MyMonsterPointer ( ) ;
}
pEntity = UTIL_FindEntityByTargetname ( pEntity , STRING ( m_iszEntity ) ) ;
}
// If no entity with that targetname, check the classname
if ( ! pTarget )
{
pEntity = UTIL_FindEntityByClassname ( NULL , STRING ( m_iszEntity ) ) ;
while ( ! pTarget & & pEntity )
{
pTarget = pEntity - > MyMonsterPointer ( ) ;
pEntity = UTIL_FindEntityByClassname ( pEntity , STRING ( m_iszEntity ) ) ;
}
}
// Found a compatible entity
if ( pTarget )
{
void * pmodel ;
pmodel = GET_MODEL_PTR ( pTarget - > edict ( ) ) ;
if ( pmodel )
{
// Look through the event list for stuff to precache
SequencePrecache ( pmodel , STRING ( m_iszIdle ) ) ;
SequencePrecache ( pmodel , STRING ( m_iszPlay ) ) ;
}
}
CBaseMonster : : Activate ( ) ;
}
BOOL CBaseMonster : : CineCleanup ( )
{
CCineMonster * pOldCine = m_pCine ;
// am I linked to a cinematic?
if ( m_pCine )
{
// okay, reset me to what it thought I was before
m_pCine - > m_hTargetEnt = NULL ;
pev - > movetype = m_pCine - > m_saved_movetype ;
// LRC - why mess around with this? Solidity isn't changed by sequences!
// pev->solid = m_pCine->m_saved_solid;
if ( m_pCine - > pev - > spawnflags & SF_SCRIPT_STAYDEAD )
pev - > deadflag = DEAD_DYING ;
}
else
{
// arg, punt
pev - > movetype = MOVETYPE_STEP ; // this is evil
pev - > solid = SOLID_SLIDEBOX ;
}
m_pCine = NULL ;
m_hTargetEnt = NULL ;
m_pGoalEnt = NULL ;
if ( pev - > deadflag = = DEAD_DYING )
{
// last frame of death animation?
pev - > health = 0 ;
pev - > framerate = 0.0 ;
pev - > solid = SOLID_NOT ;
SetState ( MONSTERSTATE_DEAD ) ;
pev - > deadflag = DEAD_DEAD ;
UTIL_SetSize ( pev , pev - > mins , Vector ( pev - > maxs . x , pev - > maxs . y , pev - > mins . z + 2 ) ) ;
if ( pOldCine & & FBitSet ( pOldCine - > pev - > spawnflags , SF_SCRIPT_LEAVECORPSE ) )
{
SetUse ( NULL ) ; // BUGBUG -- This doesn't call Killed()
SetThink ( NULL ) ; // This will probably break some stuff
SetTouch ( NULL ) ;
}
else
SUB_StartFadeOut ( ) ; // SetThink( SUB_DoNothing );
// This turns off animation & physics in case their origin ends up stuck in the world or something
StopAnimation ( ) ;
pev - > movetype = MOVETYPE_NONE ;
pev - > effects | = EF_NOINTERP ; // Don't interpolate either, assume the corpse is positioned in its final resting place
return FALSE ;
}
// If we actually played a sequence
if ( pOldCine & & pOldCine - > m_iszPlay )
{
if ( ! ( pOldCine - > pev - > spawnflags & SF_SCRIPT_NOSCRIPTMOVEMENT ) )
{
// reset position
Vector new_origin , new_angle ;
GetBonePosition ( 0 , new_origin , new_angle ) ;
// Figure out how far they have moved
// We can't really solve this problem because we can't query the movement of the origin relative
// to the sequence. We can get the root bone's position as we do here, but there are
// cases where the root bone is in a different relative position to the entity's origin
// before/after the sequence plays. So we are stuck doing this:
// !!!HACKHACK: Float the origin up and drop to floor because some sequences have
// irregular motion that can't be properly accounted for.
// UNDONE: THIS SHOULD ONLY HAPPEN IF WE ACTUALLY PLAYED THE SEQUENCE.
Vector oldOrigin = pev - > origin ;
// UNDONE: ugly hack. Don't move monster if they don't "seem" to move
// this really needs to be done with the AX,AY,etc. flags, but that aren't consistantly
// being set, so animations that really do move won't be caught.
if ( ( oldOrigin - new_origin ) . Length2D ( ) < 8.0f )
new_origin = oldOrigin ;
pev - > origin . x = new_origin . x ;
pev - > origin . y = new_origin . y ;
pev - > origin . z + = 1 ;
pev - > flags | = FL_ONGROUND ;
int drop = DROP_TO_FLOOR ( ENT ( pev ) ) ;
// Origin in solid? Set to org at the end of the sequence
if ( drop < 0 )
pev - > origin = oldOrigin ;
else if ( drop = = 0 ) // Hanging in air?
{
pev - > origin . z = new_origin . z ;
pev - > flags & = ~ FL_ONGROUND ;
}
// else entity hit floor, leave there
// pEntity->pev->origin.z = new_origin.z + 5.0; // damn, got to fix this
UTIL_SetOrigin ( this , pev - > origin ) ;
pev - > effects | = EF_NOINTERP ;
}
// We should have some animation to put these guys in, but for now it's idle.
// Due to NOINTERP above, there won't be any blending between this anim & the sequence
m_Activity = ACT_RESET ;
}
// set them back into a normal state
pev - > enemy = NULL ;
if ( pev - > health > 0 )
m_IdealMonsterState = MONSTERSTATE_IDLE ; // m_previousState;
else
{
// Dropping out because he got killed
// Can't call killed() no attacker and weirdness (late gibbing) may result
m_IdealMonsterState = MONSTERSTATE_DEAD ;
SetConditions ( bits_COND_LIGHT_DAMAGE ) ;
pev - > deadflag = DEAD_DYING ;
FCheckAITrigger ( ) ;
pev - > deadflag = DEAD_NO ;
}
// SetAnimation( m_MonsterState );
//LRC- removed, was never implemented. ClearBits(pev->spawnflags, SF_MONSTER_WAIT_FOR_SCRIPT );
return TRUE ;
}
class CScriptedSentence : public CBaseToggle
{
public :
void Spawn ( void ) ;
void KeyValue ( KeyValueData * pkvd ) ;
void Use ( CBaseEntity * pActivator , CBaseEntity * pCaller , USE_TYPE useType , float value ) ;
void EXPORT FindThink ( void ) ;
void EXPORT DelayThink ( void ) ;
void EXPORT DurationThink ( void ) ;
int ObjectCaps ( void ) { return ( CBaseToggle : : ObjectCaps ( ) & ~ FCAP_ACROSS_TRANSITION ) ; }
STATE GetState ( ) { return m_playing ? STATE_ON : STATE_OFF ; }
virtual int Save ( CSave & save ) ;
virtual int Restore ( CRestore & restore ) ;
static TYPEDESCRIPTION m_SaveData [ ] ;
CBaseMonster * FindEntity ( CBaseEntity * pActivator ) ;
BOOL AcceptableSpeaker ( CBaseMonster * pMonster ) ;
BOOL StartSentence ( CBaseMonster * pTarget ) ;
private :
int m_iszSentence ; // string index for idle animation
int m_iszEntity ; // entity that is wanted for this sentence
float m_flRadius ; // range to search
float m_flDuration ; // How long the sentence lasts
float m_flRepeat ; // maximum repeat rate
float m_flAttenuation ;
float m_flVolume ;
BOOL m_active ; // is the sentence enabled? (for m_flRepeat)
BOOL m_playing ; //LRC- is the sentence playing? (for GetState)
int m_iszListener ; // name of entity to look at while talking
} ;
# 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
TYPEDESCRIPTION CScriptedSentence : : m_SaveData [ ] =
{
DEFINE_FIELD ( CScriptedSentence , m_iszSentence , FIELD_STRING ) ,
DEFINE_FIELD ( CScriptedSentence , m_iszEntity , FIELD_STRING ) ,
DEFINE_FIELD ( CScriptedSentence , m_flRadius , FIELD_FLOAT ) ,
DEFINE_FIELD ( CScriptedSentence , m_flDuration , FIELD_FLOAT ) ,
DEFINE_FIELD ( CScriptedSentence , m_flRepeat , FIELD_FLOAT ) ,
DEFINE_FIELD ( CScriptedSentence , m_flAttenuation , FIELD_FLOAT ) ,
DEFINE_FIELD ( CScriptedSentence , m_flVolume , FIELD_FLOAT ) ,
DEFINE_FIELD ( CScriptedSentence , m_active , FIELD_BOOLEAN ) ,
DEFINE_FIELD ( CScriptedSentence , m_playing , FIELD_BOOLEAN ) ,
DEFINE_FIELD ( CScriptedSentence , m_iszListener , FIELD_STRING ) ,
} ;
IMPLEMENT_SAVERESTORE ( CScriptedSentence , CBaseToggle )
LINK_ENTITY_TO_CLASS ( scripted_sentence , CScriptedSentence )
void CScriptedSentence : : KeyValue ( KeyValueData * pkvd )
{
if ( FStrEq ( pkvd - > szKeyName , " sentence " ) )
{
m_iszSentence = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " entity " ) )
{
m_iszEntity = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " duration " ) )
{
m_flDuration = atof ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " radius " ) )
{
m_flRadius = atof ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " refire " ) )
{
m_flRepeat = atof ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " attenuation " ) )
{
pev - > impulse = atoi ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " volume " ) )
{
m_flVolume = atof ( pkvd - > szValue ) * 0.1f ;
pkvd - > fHandled = TRUE ;
}
else if ( FStrEq ( pkvd - > szKeyName , " listener " ) )
{
m_iszListener = ALLOC_STRING ( pkvd - > szValue ) ;
pkvd - > fHandled = TRUE ;
}
else
CBaseToggle : : KeyValue ( pkvd ) ;
}
void CScriptedSentence : : Use ( CBaseEntity * pActivator , CBaseEntity * pCaller , USE_TYPE useType , float value )
{
if ( ! m_active )
return ;
//ALERT( at_console, "Firing sentence: %s\n", STRING( m_iszSentence ) );
m_hActivator = pActivator ;
SetThink ( & CScriptedSentence : : FindThink ) ;
SetNextThink ( 0 ) ;
}
void CScriptedSentence : : Spawn ( void )
{
pev - > solid = SOLID_NOT ;
m_active = TRUE ;
m_playing = FALSE ; //LRC
// if no targetname, start now
if ( ! pev - > targetname )
{
SetThink ( & CScriptedSentence : : FindThink ) ;
SetNextThink ( 1.0f ) ;
}
switch ( pev - > impulse )
{
case 1 :
// Medium radius
m_flAttenuation = ATTN_STATIC ;
break ;
case 2 :
// Large radius
m_flAttenuation = ATTN_NORM ;
break ;
case 3 :
//EVERYWHERE
m_flAttenuation = ATTN_NONE ;
break ;
default :
case 0 :
// Small radius
m_flAttenuation = ATTN_IDLE ;
break ;
}
pev - > impulse = 0 ;
// No volume, use normal
if ( m_flVolume < = 0.0f )
m_flVolume = 1.0f ;
}
void CScriptedSentence : : FindThink ( void )
{
if ( ! m_iszEntity ) //LRC- no target monster given: speak through HEV
{
CBasePlayer * pPlayer = ( CBasePlayer * ) UTIL_FindEntityByClassname ( NULL , " player " ) ;
if ( pPlayer )
{
m_playing = TRUE ;
if ( ( STRING ( m_iszSentence ) ) [ 0 ] = = ' ! ' )
pPlayer - > SetSuitUpdate ( STRING ( m_iszSentence ) , FALSE , 0 ) ;
else
pPlayer - > SetSuitUpdate ( STRING ( m_iszSentence ) , TRUE , 0 ) ;
if ( pev - > spawnflags & SF_SENTENCE_ONCE )
UTIL_Remove ( this ) ;
SetThink ( & CScriptedSentence : : DurationThink ) ;
SetNextThink ( m_flDuration ) ;
m_active = FALSE ;
}
else
ALERT ( at_console , " ScriptedSentence: can't find \" player \" to play HEV sentence!? \n " ) ;
return ;
}
CBaseMonster * pMonster = FindEntity ( m_hActivator ) ;
if ( pMonster )
{
m_playing = TRUE ;
StartSentence ( pMonster ) ;
if ( pev - > spawnflags & SF_SENTENCE_ONCE )
UTIL_Remove ( this ) ;
SetThink ( & CScriptedSentence : : DurationThink ) ;
SetNextThink ( m_flDuration ) ;
m_active = FALSE ;
//ALERT( at_console, "%s: found monster %s\n", STRING( m_iszSentence ), STRING( m_iszEntity ) );
}
else
{
//ALERT( at_console, "%s: can't find monster %s\n", STRING( m_iszSentence ), STRING( m_iszEntity ) );
SetNextThink ( m_flRepeat + 0.5f ) ;
}
}
//LRC
void CScriptedSentence : : DurationThink ( void )
{
m_playing = FALSE ;
SetNextThink ( m_flRepeat ) ;
SetThink ( & CScriptedSentence : : DelayThink ) ;
}
void CScriptedSentence : : DelayThink ( void )
{
m_active = TRUE ;
if ( ! pev - > targetname )
SetNextThink ( 0.1f ) ;
SetThink ( & CScriptedSentence : : FindThink ) ;
}
BOOL CScriptedSentence : : AcceptableSpeaker ( CBaseMonster * pMonster )
{
if ( pMonster )
{
if ( pev - > spawnflags & SF_SENTENCE_FOLLOWERS )
{
if ( pMonster - > m_hTargetEnt = = 0 | | ! pMonster - > m_hTargetEnt - > IsPlayer ( ) )
return FALSE ;
}
BOOL override ;
if ( pev - > spawnflags & SF_SENTENCE_INTERRUPT )
override = TRUE ;
else
override = FALSE ;
if ( pMonster - > CanPlaySentence ( override ) )
return TRUE ;
}
return FALSE ;
}
CBaseMonster * CScriptedSentence : : FindEntity ( CBaseEntity * pActivator )
{
CBaseEntity * pTarget ;
CBaseMonster * pMonster ;
pTarget = UTIL_FindEntityByTargetname ( NULL , STRING ( m_iszEntity ) , pActivator ) ;
pMonster = NULL ;
while ( pTarget )
{
pMonster = pTarget - > MyMonsterPointer ( ) ;
if ( pMonster ! = NULL )
{
if ( AcceptableSpeaker ( pMonster ) )
return pMonster ;
//ALERT( at_console, "%s (%s), not acceptable\n", STRING( pMonster->pev->classname ), STRING( pMonster->pev->targetname ) );
}
pTarget = UTIL_FindEntityByTargetname ( pTarget , STRING ( m_iszEntity ) , pActivator ) ;
}
pTarget = NULL ;
while ( ( pTarget = UTIL_FindEntityInSphere ( pTarget , pev - > origin , m_flRadius ) ) ! = NULL )
{
if ( FClassnameIs ( pTarget - > pev , STRING ( m_iszEntity ) ) )
{
if ( FBitSet ( pTarget - > pev - > flags , FL_MONSTER ) )
{
pMonster = pTarget - > MyMonsterPointer ( ) ;
if ( AcceptableSpeaker ( pMonster ) )
return pMonster ;
}
}
}
return NULL ;
}
BOOL CScriptedSentence : : StartSentence ( CBaseMonster * pTarget )
{
if ( ! pTarget )
{
ALERT ( at_aiconsole , " Not Playing sentence %s \n " , STRING ( m_iszSentence ) ) ;
return FALSE ;
}
BOOL bConcurrent = FALSE ;
//LRC: Er... if the "concurrent" flag is NOT set, we make bConcurrent true!?
if ( ! ( pev - > spawnflags & SF_SENTENCE_CONCURRENT ) )
bConcurrent = TRUE ;
CBaseEntity * pListener = NULL ;
if ( ! FStringNull ( m_iszListener ) )
{
float radius = m_flRadius ;
if ( FStrEq ( STRING ( m_iszListener ) , " player " ) )
radius = 4096 ; // Always find the player
pListener = UTIL_FindEntityGeneric ( STRING ( m_iszListener ) , pTarget - > pev - > origin , radius ) ;
}
pTarget - > PlayScriptedSentence ( STRING ( m_iszSentence ) , m_flDuration , m_flVolume , m_flAttenuation , bConcurrent , pListener ) ;
ALERT ( at_aiconsole , " Playing sentence %s (%.1f) \n " , STRING ( m_iszSentence ) , ( double ) m_flDuration ) ;
SUB_UseTargets ( NULL , USE_TOGGLE , 0 ) ;
return TRUE ;
}
//=========================================================
// Furniture - this is the cool comment I cut-and-pasted
//=========================================================
class CFurniture : public CBaseMonster
{
public :
void Spawn ( void ) ;
void Die ( void ) ;
int Classify ( void ) ;
virtual int ObjectCaps ( void ) { return ( CBaseMonster : : ObjectCaps ( ) & ~ FCAP_ACROSS_TRANSITION ) ; }
} ;
LINK_ENTITY_TO_CLASS ( monster_furniture , CFurniture )
//=========================================================
// Furniture is killed
//=========================================================
void CFurniture : : Die ( void )
{
SetThink ( & CBaseEntity : : SUB_Remove ) ;
pev - > nextthink = gpGlobals - > time ;
}
//=========================================================
// This used to have something to do with bees flying, but
// now it only initializes moving furniture in scripted sequences
//=========================================================
void CFurniture : : Spawn ( )
{
PRECACHE_MODEL ( STRING ( pev - > model ) ) ;
SET_MODEL ( ENT ( pev ) , STRING ( pev - > model ) ) ;
pev - > movetype = MOVETYPE_NONE ;
pev - > solid = SOLID_BBOX ;
pev - > health = 80000 ;
pev - > takedamage = DAMAGE_AIM ;
pev - > effects = 0 ;
pev - > yaw_speed = 0 ;
pev - > sequence = 0 ;
pev - > frame = 0 ;
//pev->nextthink += 1.0f;
//SetThink( &WalkMonsterDelay );
ResetSequenceInfo ( ) ;
pev - > frame = 0 ;
MonsterInit ( ) ;
}
//=========================================================
// ID's Furniture as neutral (noone will attack it)
//=========================================================
int CFurniture : : Classify ( void )
{
return m_iClass ? m_iClass : CLASS_NONE ;
}