eukara/halflife-sdk-steam
1
0
Fork 0
forked from valve/halflife-sdk
Code Pull requests Activity
halflife-sdk-steam/dlls/scripted.cpp

1260 lines
34 KiB
C++
Raw Permalink Blame History

/***
*
* Copyright (c) 1996-2001, 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"
#ifndef ANIMATION_H
#include "animation.h"
#endif
#ifndef SAVERESTORE_H
#include "saverestore.h"
#endif
#include "schedule.h"
#include "scripted.h"
#include "defaultai.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_fMoveTo"))
{
m_fMoveTo = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
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_iFinishSchedule"))
{
m_iFinishSchedule = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
{
CBaseMonster::KeyValue( pkvd );
}
}
TYPEDESCRIPTION CCineMonster::m_SaveData[] =
{
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_fMoveTo, FIELD_INTEGER ),
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 ),
};
IMPLEMENT_SAVERESTORE( CCineMonster, CBaseMonster );
LINK_ENTITY_TO_CLASS( scripted_sequence, CCineMonster );
#define CLASSNAME "scripted_sequence"
LINK_ENTITY_TO_CLASS( aiscripted_sequence, CCineAI );
void CCineMonster :: Spawn( void )
{
// pev->solid = SOLID_TRIGGER;
// UTIL_SetSize(pev, Vector(-8, -8, -8), Vector(8, 8, 8));
pev->solid = SOLID_NOT;
// REMOVE: The old side-effect
#if 0
if ( m_iszIdle )
m_fMoveTo = 4;
#endif
// if no targetname, start now
if ( FStringNull(pev->targetname) || !FStringNull( m_iszIdle ) )
{
SetThink( &CCineMonster::CineThink );
pev->nextthink = gpGlobals->time + 1.0;
// Wait to be used?
if ( pev->targetname )
m_startTime = gpGlobals->time + 1E6;
}
if ( pev->spawnflags & SF_SCRIPT_NOINTERRUPT )
m_interruptable = FALSE;
else
m_interruptable = TRUE;
}
//=========================================================
// FCanOverrideState - returns FALSE, scripted sequences
// cannot possess entities regardless of state.
//=========================================================
BOOL CCineMonster :: FCanOverrideState( void )
{
if ( pev->spawnflags & SF_SCRIPT_OVERRIDESTATE )
return TRUE;
return FALSE;
}
//=========================================================
// FCanOverrideState - returns true because scripted AI can
// possess entities regardless of their state.
//=========================================================
BOOL CCineAI :: FCanOverrideState( void )
{
return TRUE;
}
//
// 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.05;
}
else
{
// if not, try finding them
SetThink( &CCineMonster::CineThink );
pev->nextthink = gpGlobals->time;
}
}
// 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 **********
//
// find a viable entity
int CCineMonster :: FindEntity( void )
{
edict_t *pentTarget;
pentTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(m_iszEntity));
m_hTargetEnt = NULL;
CBaseMonster *pTarget = NULL;
while (!FNullEnt(pentTarget))
{
if ( FBitSet( VARS(pentTarget)->flags, FL_MONSTER ))
{
pTarget = GetMonsterPointer( pentTarget );
if ( pTarget && pTarget->CanPlaySequence( FCanOverrideState(), SS_INTERRUPT_BY_NAME ) )
{
m_hTargetEnt = pTarget;
return TRUE;
}
ALERT( at_console, "Found %s, but can't play!\n", STRING(m_iszEntity) );
}
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(m_iszEntity));
pTarget = NULL;
}
if ( !pTarget )
{
CBaseEntity *pEntity = NULL;
while ((pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, m_flRadius )) != NULL)
{
if (FClassnameIs( pEntity->pev, STRING(m_iszEntity)))
{
if ( FBitSet( pEntity->pev->flags, FL_MONSTER ))
{
pTarget = pEntity->MyMonsterPointer( );
if ( pTarget && pTarget->CanPlaySequence( FCanOverrideState(), SS_INTERRUPT_IDLE ) )
{
m_hTargetEnt = pTarget;
return TRUE;
}
}
}
}
}
pTarget = NULL;
m_hTargetEnt = NULL;
return FALSE;
}
// 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 )
{
// FindEntity() just checked this!
#if 0
if ( !pTarget->CanPlaySequence( FCanOverrideState() ) )
{
ALERT( at_aiconsole, "Can't possess entity %s\n", STRING(pTarget->pev->classname) );
return;
}
#endif
pTarget->m_pGoalEnt = this;
pTarget->m_pCine = this;
pTarget->m_hTargetEnt = this;
m_saved_movetype = pTarget->pev->movetype;
m_saved_solid = pTarget->pev->solid;
m_saved_effects = pTarget->pev->effects;
pTarget->pev->effects |= pev->effects;
switch (m_fMoveTo)
{
case 0:
pTarget->m_scriptState = SCRIPT_WAIT;
break;
case 1:
pTarget->m_scriptState = SCRIPT_WALK_TO_MARK;
DelayStart( 1 );
break;
case 2:
pTarget->m_scriptState = SCRIPT_RUN_TO_MARK;
DelayStart( 1 );
break;
case 4:
UTIL_SetOrigin( pTarget->pev, pev->origin );
pTarget->pev->ideal_yaw = pev->angles.y;
pTarget->pev->avelocity = Vector( 0, 0, 0 );
pTarget->pev->velocity = Vector( 0, 0, 0 );
pTarget->pev->effects |= EF_NOINTERP;
pTarget->pev->angles.y = pev->angles.y;
pTarget->m_scriptState = SCRIPT_WAIT;
m_startTime = gpGlobals->time + 1E6;
// UNDONE: Add a flag to do this so people can fixup physics after teleporting monsters
// pTarget->pev->flags &= ~FL_ONGROUND;
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)
{
StartSequence( pTarget, m_iszIdle, FALSE );
if (FStrEq( STRING(m_iszIdle), STRING(m_iszPlay)))
{
pTarget->pev->framerate = 0;
}
}
}
}
// make the entity carry out the scripted sequence instructions, but without
// destroying the monster's state.
void CCineAI :: PossessEntity( void )
{
Schedule_t *pNewSchedule;
CBaseEntity *pEntity = m_hTargetEnt;
CBaseMonster *pTarget = NULL;
if ( pEntity )
pTarget = pEntity->MyMonsterPointer();
if ( pTarget )
{
if ( !pTarget->CanPlaySequence( FCanOverrideState(), SS_INTERRUPT_AI ) )
{
ALERT( at_aiconsole, "(AI)Can't possess entity %s\n", STRING(pTarget->pev->classname) );
return;
}
pTarget->m_pGoalEnt = this;
pTarget->m_pCine = this;
pTarget->m_hTargetEnt = this;
m_saved_movetype = pTarget->pev->movetype;
m_saved_solid = pTarget->pev->solid;
m_saved_effects = pTarget->pev->effects;
pTarget->pev->effects |= pev->effects;
switch (m_fMoveTo)
{
case 0:
case 5:
pTarget->m_scriptState = SCRIPT_WAIT;
break;
case 1:
pTarget->m_scriptState = SCRIPT_WALK_TO_MARK;
break;
case 2:
pTarget->m_scriptState = SCRIPT_RUN_TO_MARK;
break;
case 4:
// zap the monster instantly to the site of the script entity.
UTIL_SetOrigin( pTarget->pev, pev->origin );
pTarget->pev->ideal_yaw = pev->angles.y;
pTarget->pev->avelocity = Vector( 0, 0, 0 );
pTarget->pev->velocity = Vector( 0, 0, 0 );
pTarget->pev->effects |= EF_NOINTERP;
pTarget->pev->angles.y = pev->angles.y;
pTarget->m_scriptState = SCRIPT_WAIT;
m_startTime = gpGlobals->time + 1E6;
// UNDONE: Add a flag to do this so people can fixup physics after teleporting monsters
pTarget->pev->flags &= ~FL_ONGROUND;
break;
default:
ALERT ( at_aiconsole, "aiscript: invalid Move To Position value!" );
break;
}
ALERT( at_aiconsole, "\"%s\" found and used\n", STRING( pTarget->pev->targetname ) );
pTarget->m_IdealMonsterState = MONSTERSTATE_SCRIPT;
/*
if (m_iszIdle)
{
StartSequence( pTarget, m_iszIdle, FALSE );
if (FStrEq( STRING(m_iszIdle), STRING(m_iszPlay)))
{
pTarget->pev->framerate = 0;
}
}
*/
// Already in a scripted state?
if ( pTarget->m_MonsterState == MONSTERSTATE_SCRIPT )
{
pNewSchedule = pTarget->GetScheduleOfType( SCHED_AISCRIPT );
pTarget->ChangeSchedule( pNewSchedule );
}
}
}
void CCineMonster :: CineThink( void )
{
if (FindEntity())
{
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 ) );
pev->nextthink = gpGlobals->time + 1.0;
}
}
// 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;
}
// lookup a sequence name and setup the target monster to play it
// overridden for CCineAI because it's ok for them to not have an animation sequence
// for the monster to play. For a regular Scripted Sequence, that situation is an error.
BOOL CCineAI :: StartSequence( CBaseMonster *pTarget, int iszSeq, BOOL completeOnEmpty )
{
if ( iszSeq == 0 && completeOnEmpty )
{
// no sequence was provided. Just let the monster proceed, however, we still have to fire any Sequence target
// and remove any non-repeatable CineAI entities here ( because there is code elsewhere that handles those tasks, but
// not until the animation sequence is finished. We have to manually take care of these things where there is no sequence.
SequenceDone ( pTarget );
return TRUE;
}
pTarget->pev->sequence = pTarget->LookupSequence( STRING( iszSeq ) );
if (pTarget->pev->sequence == -1)
{
ALERT( at_error, "%s: unknown aiscripted sequence \"%s\"\n", STRING( pTarget->pev->targetname ), STRING( iszSeq) );
pTarget->pev->sequence = 0;
// return FALSE;
}
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 )
{
//ALERT( at_aiconsole, "Sequence %s finished\n", STRING( m_pCine->m_iszPlay ) );
if ( !( pev->spawnflags & SF_SCRIPT_REPEATABLE ) )
{
SetThink( &CCineMonster::SUB_Remove );
pev->nextthink = gpGlobals->time + 0.1;
}
// 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.
//=========================================================
void CCineMonster :: FixScriptMonsterSchedule( CBaseMonster *pMonster )
{
if ( pMonster->m_IdealMonsterState != MONSTERSTATE_DEAD )
pMonster->m_IdealMonsterState = MONSTERSTATE_IDLE;
pMonster->ClearSchedule();
}
//=========================================================
// 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.
//
// AI Scripted sequences will, depending on what the level
// designer selects:
//
// -Dirty the monster's schedule and drop out of the
// sequence in their current state.
//
// -Select a specific AMBUSH schedule, regardless of state.
//=========================================================
void CCineAI :: FixScriptMonsterSchedule( CBaseMonster *pMonster )
{
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;
return SCRIPT_BREAK_CONDITIONS;
}
void ScriptEntityCancel( edict_t *pentCine )
{
// make sure they are a scripted_sequence
if (FClassnameIs( pentCine, CLASSNAME ))
{
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 )
{
// tell them do die
pTarget->m_scriptState = CCineMonster::SCRIPT_CLEANUP;
// do it now
pTarget->CineCleanup( );
}
}
}
}
// 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;
}
edict_t *pentCineTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->targetname));
while (!FNullEnt(pentCineTarget))
{
ScriptEntityCancel( pentCineTarget );
pentCineTarget = FIND_ENTITY_BY_TARGETNAME(pentCineTarget, STRING(pev->targetname));
}
}
// find all the cinematic entities with my targetname and tell them to wait before starting
void CCineMonster :: DelayStart( int state )
{
edict_t *pentCine = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->targetname));
while (!FNullEnt(pentCine))
{
if (FClassnameIs( pentCine, "scripted_sequence" ))
{
CCineMonster *pTarget = GetClassPtr((CCineMonster *)VARS(pentCine));
if (state)
{
pTarget->m_iDelay++;
}
else
{
pTarget->m_iDelay--;
if (pTarget->m_iDelay <= 0)
pTarget->m_startTime = gpGlobals->time + 0.05;
}
}
pentCine = FIND_ENTITY_BY_TARGETNAME(pentCine, 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 )
{
edict_t *pentTarget;
CBaseMonster *pTarget;
// The entity name could be a target name or a classname
// Check the targetname
pentTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(m_iszEntity));
pTarget = NULL;
while (!pTarget && !FNullEnt(pentTarget))
{
if ( FBitSet( VARS(pentTarget)->flags, FL_MONSTER ))
{
pTarget = GetMonsterPointer( pentTarget );
}
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(m_iszEntity));
}
// If no entity with that targetname, check the classname
if ( !pTarget )
{
pentTarget = FIND_ENTITY_BY_CLASSNAME(NULL, STRING(m_iszEntity));
while (!pTarget && !FNullEnt(pentTarget))
{
pTarget = GetMonsterPointer( pentTarget );
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, 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 ) );
}
}
}
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;
pev->solid = m_pCine->m_saved_solid;
pev->effects = m_pCine->m_saved_effects;
}
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.0)
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( pev, 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 );
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 );
int ObjectCaps( void ) { return (CBaseToggle :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
CBaseMonster *FindEntity( void );
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; // repeat rate
float m_flAttenuation;
float m_flVolume;
BOOL m_active;
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_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.1;
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) );
SetThink( &CScriptedSentence::FindThink );
pev->nextthink = gpGlobals->time;
}
void CScriptedSentence :: Spawn( void )
{
pev->solid = SOLID_NOT;
m_active = TRUE;
// if no targetname, start now
if ( !pev->targetname )
{
SetThink( &CScriptedSentence::FindThink );
pev->nextthink = gpGlobals->time + 1.0;
}
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 )
m_flVolume = 1.0;
}
void CScriptedSentence :: FindThink( void )
{
CBaseMonster *pMonster = FindEntity();
if ( pMonster )
{
StartSentence( pMonster );
if ( pev->spawnflags & SF_SENTENCE_ONCE )
UTIL_Remove( this );
SetThink( &CScriptedSentence::DelayThink );
pev->nextthink = gpGlobals->time + m_flDuration + m_flRepeat;
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) );
pev->nextthink = gpGlobals->time + m_flRepeat + 0.5;
}
}
void CScriptedSentence :: DelayThink( void )
{
m_active = TRUE;
if ( !pev->targetname )
pev->nextthink = gpGlobals->time + 0.1;
SetThink( &CScriptedSentence::FindThink );
}
BOOL CScriptedSentence :: AcceptableSpeaker( CBaseMonster *pMonster )
{
if ( pMonster )
{
if ( pev->spawnflags & SF_SENTENCE_FOLLOWERS )
{
if ( pMonster->m_hTargetEnt == NULL || !FClassnameIs(pMonster->m_hTargetEnt->pev, "player") )
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( void )
{
edict_t *pentTarget;
CBaseMonster *pMonster;
pentTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(m_iszEntity));
pMonster = NULL;
while (!FNullEnt(pentTarget))
{
pMonster = GetMonsterPointer( pentTarget );
if ( pMonster != NULL )
{
if ( AcceptableSpeaker( pMonster ) )
return pMonster;
// ALERT( at_console, "%s (%s), not acceptable\n", STRING(pMonster->pev->classname), STRING(pMonster->pev->targetname) );
}
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(m_iszEntity));
}
CBaseEntity *pEntity = NULL;
while ((pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, m_flRadius )) != NULL)
{
if (FClassnameIs( pEntity->pev, STRING(m_iszEntity)))
{
if ( FBitSet( pEntity->pev->flags, FL_MONSTER ))
{
pMonster = pEntity->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 NULL;
}
BOOL bConcurrent = FALSE;
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), 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 ( &CFurniture::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((char *)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.0;
// SetThink (WalkMonsterDelay);
ResetSequenceInfo( );
pev->frame = 0;
MonsterInit();
}
//=========================================================
// ID's Furniture as neutral (noone will attack it)
//=========================================================
int CFurniture::Classify ( void )
{
return CLASS_NONE;
}
View git blame Copy permalink