5151 lines
141 KiB
C++
5151 lines
141 KiB
C++
/*
|
|
================
|
|
|
|
AI.cpp
|
|
|
|
================
|
|
*/
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../Game_local.h"
|
|
|
|
#include "AI.h"
|
|
#include "AI_Manager.h"
|
|
#include "AI_Util.h"
|
|
#include "../Projectile.h"
|
|
#include "../spawner.h"
|
|
#include "AI_Tactical.h"
|
|
|
|
const char* aiTalkMessageString [ ] = {
|
|
"None",
|
|
"primary",
|
|
"secondary",
|
|
"loop"
|
|
};
|
|
|
|
static const float AI_SIGHTDELAYSCALE = 5000.0f; // Full sight delay at 5 seconds or more of not seeing enemy
|
|
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAI
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
=====================
|
|
idAI::idAI
|
|
=====================
|
|
*/
|
|
idAI::idAI ( void ) {
|
|
projectile_height_to_distance_ratio = 1.0f;
|
|
|
|
aas = NULL;
|
|
aasSensor = NULL;
|
|
aasFind = NULL;
|
|
|
|
lastHitCheckResult = false;
|
|
lastHitCheckTime = 0;
|
|
lastAttackTime = 0;
|
|
projectile = NULL;
|
|
projectileClipModel = NULL;
|
|
chatterTime = 0;
|
|
talkState = TALK_NEVER;
|
|
talkTarget = NULL;
|
|
talkMessage = TALKMSG_NONE;
|
|
talkBusyCount = 0;
|
|
|
|
enemy.ent = NULL;
|
|
enemy.lastVisibleChangeTime = 0;
|
|
enemy.lastVisibleTime = 0;
|
|
|
|
fl.neverDormant = false; // AI's can go dormant
|
|
|
|
allowEyeFocus = true;
|
|
disablePain = false;
|
|
allowJointMod = true;
|
|
focusEntity = NULL;
|
|
focusTime = 0;
|
|
alignHeadTime = 0;
|
|
forceAlignHeadTime = 0;
|
|
|
|
orientationJoint = INVALID_JOINT;
|
|
|
|
eyeVerticalOffset = 0.0f;
|
|
eyeHorizontalOffset = 0.0f;
|
|
headFocusRate = 0.0f;
|
|
eyeFocusRate = 0.0f;
|
|
focusAlignTime = 0;
|
|
focusRange = 0.0f;
|
|
focusType = AIFOCUS_NONE;
|
|
|
|
memset ( &combat.fl, 0, sizeof(combat.fl) );
|
|
combat.max_chasing_turn = 0;
|
|
combat.shotAtTime = 0;
|
|
combat.shotAtAngle = 0.0f;
|
|
combat.meleeRange = 0.0f;
|
|
combat.tacticalPainTaken = 0;
|
|
combat.tacticalFlinches = 0;
|
|
combat.investigateTime = 0;
|
|
combat.aggressiveScale = 1.0f;
|
|
|
|
passive.animFidgetPrefix.Clear ( );
|
|
passive.animIdlePrefix.Clear ( );
|
|
passive.animTalkPrefix.Clear ( );
|
|
passive.idleAnim.Clear();
|
|
passive.prefix.Clear();
|
|
passive.idleAnimChangeTime = 0;
|
|
passive.fidgetTime = 0;
|
|
passive.talkTime = 0;
|
|
memset ( &passive.fl, 0, sizeof(passive.fl) );
|
|
|
|
pain.lastTakenTime = 0;
|
|
pain.takenThisFrame = 0;
|
|
pain.loopEndTime = 0;
|
|
|
|
enemy.range = 0;
|
|
enemy.range2d = 0;
|
|
enemy.smoothedLinearVelocity.Zero ( );
|
|
enemy.smoothedPushedVelocity.Zero ( );
|
|
enemy.lastKnownPosition.Zero ( );
|
|
enemy.lastVisibleEyePosition.Zero ( );
|
|
enemy.lastVisibleChestPosition.Zero ( );
|
|
enemy.lastVisibleFromEyePosition.Zero ( );
|
|
enemy.checkTime = 0;
|
|
enemy.changeTime = 0;
|
|
enemy.lastVisibleChangeTime = 0;
|
|
enemy.lastVisibleTime = 0;
|
|
memset ( &enemy.fl, 0, sizeof(enemy.fl) );
|
|
|
|
currentFocusPos.Zero();
|
|
eyeAng.Zero();
|
|
lookAng.Zero();
|
|
destLookAng.Zero();
|
|
lookMin.Zero();
|
|
lookMax.Zero();
|
|
|
|
eyeMin.Zero();
|
|
eyeMax.Zero();
|
|
|
|
helperCurrent = NULL;
|
|
helperIdeal = NULL;
|
|
|
|
speakTime = 0;
|
|
|
|
actionAnimNum = 0;
|
|
actionSkipTime = 0;
|
|
actionTime = 0;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::~idAI
|
|
=====================
|
|
*/
|
|
idAI::~idAI() {
|
|
// Make sure we arent stuck in the simple think list
|
|
simpleThinkNode.Remove ( );
|
|
|
|
delete aasFind;
|
|
delete aasSensor;
|
|
delete projectileClipModel;
|
|
DeconstructScriptObject();
|
|
scriptObject.Free();
|
|
aiManager.RemoveTeammate ( this );
|
|
SetPhysics( NULL );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::Save
|
|
=====================
|
|
*/
|
|
void idAI::Save( idSaveGame *savefile ) const {
|
|
int i;
|
|
|
|
// cnicholson: These 3 vars are intentionally not saved, as noted in the restore
|
|
// NOSAVE: idLinkList<idAI> simpleThinkNode;
|
|
// NOSAVE: idAAS* aas;
|
|
// NOSAVE: idAASCallback* aasFind;
|
|
// NOTE That some AAS stuff is done at end of ::Restore
|
|
|
|
// Movement
|
|
move.Save( savefile );
|
|
savedMove.Save( savefile );
|
|
|
|
savefile->WriteStaticObject( physicsObj );
|
|
savefile->WriteBool( GetPhysics() == static_cast<const idPhysics *>(&physicsObj) );
|
|
|
|
savefile->WriteBool( lastHitCheckResult );
|
|
savefile->WriteInt( lastHitCheckTime );
|
|
savefile->WriteInt( lastAttackTime );
|
|
savefile->WriteFloat( projectile_height_to_distance_ratio );
|
|
|
|
savefile->WriteInt( attackAnimInfo.Num() );
|
|
for( i = 0; i < attackAnimInfo.Num(); i++ ) {
|
|
savefile->WriteVec3( attackAnimInfo[ i ].attackOffset );
|
|
savefile->WriteVec3( attackAnimInfo[ i ].eyeOffset );
|
|
}
|
|
|
|
// TOSAVE: mutable idClipModel* projectileClipModel;
|
|
projectile.Save ( savefile );
|
|
|
|
// Talking
|
|
savefile->WriteInt( chatterTime );
|
|
// savefile->WriteInt( chatterRateCombat ); // NOSAVE:
|
|
// savefile->WriteInt( chatterRateIdle ); // NOSAVE:
|
|
savefile->WriteInt( talkState );
|
|
talkTarget.Save( savefile );
|
|
savefile->WriteInt( talkMessage );
|
|
savefile->WriteInt( talkBusyCount );
|
|
savefile->WriteInt ( speakTime );
|
|
|
|
// Focus
|
|
lookTarget.Save ( savefile );
|
|
savefile->WriteInt( focusType );
|
|
focusEntity.Save ( savefile );
|
|
savefile->WriteFloat ( focusRange );
|
|
savefile->WriteInt ( focusAlignTime );
|
|
savefile->WriteInt ( focusTime );
|
|
savefile->WriteVec3( currentFocusPos );
|
|
|
|
// Looking
|
|
savefile->WriteBool( allowJointMod );
|
|
savefile->WriteInt( alignHeadTime );
|
|
savefile->WriteInt( forceAlignHeadTime );
|
|
savefile->WriteAngles( eyeAng );
|
|
savefile->WriteAngles( lookAng );
|
|
savefile->WriteAngles( destLookAng );
|
|
savefile->WriteAngles( lookMin );
|
|
savefile->WriteAngles( lookMax );
|
|
|
|
savefile->WriteInt( lookJoints.Num() );
|
|
for( i = 0; i < lookJoints.Num(); i++ ) {
|
|
savefile->WriteJoint( lookJoints[ i ] );
|
|
savefile->WriteAngles( lookJointAngles[ i ] );
|
|
}
|
|
|
|
savefile->WriteFloat( eyeVerticalOffset );
|
|
savefile->WriteFloat( eyeHorizontalOffset );
|
|
savefile->WriteFloat( headFocusRate );
|
|
savefile->WriteFloat( eyeFocusRate );
|
|
|
|
// Joint Controllers
|
|
savefile->WriteAngles( eyeMin );
|
|
savefile->WriteAngles( eyeMax );
|
|
savefile->WriteJoint( orientationJoint );
|
|
|
|
pusher.Save( savefile ); // cnicholson: Added unsaved var
|
|
scriptedActionEnt.Save( savefile ); // cnicholson: Added unsaved var
|
|
|
|
savefile->Write( &aifl, sizeof( aifl ) );
|
|
|
|
// Misc
|
|
savefile->WriteInt ( actionAnimNum );
|
|
savefile->WriteInt ( actionTime );
|
|
savefile->WriteInt ( actionSkipTime );
|
|
savefile->WriteInt ( flagOverrides );
|
|
|
|
// Combat variables
|
|
savefile->Write( &combat.fl, sizeof( combat.fl ) );
|
|
savefile->WriteFloat ( combat.max_chasing_turn );
|
|
savefile->WriteFloat ( combat.shotAtTime );
|
|
savefile->WriteFloat ( combat.shotAtAngle );
|
|
savefile->WriteVec2 ( combat.hideRange );
|
|
savefile->WriteVec2 ( combat.attackRange );
|
|
savefile->WriteInt ( combat.attackSightDelay );
|
|
savefile->WriteFloat ( combat.meleeRange );
|
|
savefile->WriteFloat ( combat.aggressiveRange );
|
|
savefile->WriteFloat ( combat.aggressiveScale );
|
|
savefile->WriteInt ( combat.investigateTime );
|
|
savefile->WriteFloat ( combat.visStandHeight );
|
|
savefile->WriteFloat ( combat.visCrouchHeight );
|
|
savefile->WriteFloat ( combat.visRange );
|
|
savefile->WriteFloat ( combat.earRange );
|
|
savefile->WriteFloat ( combat.awareRange );
|
|
savefile->WriteInt ( combat.tacticalMaskAvailable );
|
|
savefile->WriteInt ( (int&)combat.tacticalCurrent );
|
|
savefile->WriteInt ( combat.tacticalUpdateTime );
|
|
savefile->WriteInt ( combat.tacticalPainTaken );
|
|
savefile->WriteInt ( combat.tacticalPainThreshold );
|
|
savefile->WriteInt ( combat.tacticalFlinches );
|
|
savefile->WriteInt ( combat.maxLostVisTime );
|
|
savefile->WriteFloat ( combat.threatBase );
|
|
savefile->WriteFloat ( combat.threatCurrent );
|
|
savefile->WriteInt ( combat.coverValidTime );
|
|
savefile->WriteInt ( combat.maxInvalidCoverTime );
|
|
|
|
// Passive state variables
|
|
savefile->WriteString ( passive.prefix );
|
|
savefile->WriteString ( passive.animFidgetPrefix );
|
|
savefile->WriteString ( passive.animIdlePrefix);
|
|
savefile->WriteString ( passive.animTalkPrefix );
|
|
savefile->WriteString ( passive.idleAnim );
|
|
savefile->WriteInt ( passive.idleAnimChangeTime );
|
|
savefile->WriteInt ( passive.fidgetTime );
|
|
savefile->WriteInt ( passive.talkTime );
|
|
savefile->Write ( &passive.fl, sizeof(passive.fl) );
|
|
|
|
// Enemy
|
|
enemy.ent.Save ( savefile );
|
|
savefile->Write ( &enemy.fl, sizeof(enemy.fl) );
|
|
savefile->WriteInt ( enemy.lastVisibleChangeTime );
|
|
savefile->WriteVec3 ( enemy.lastKnownPosition );
|
|
savefile->WriteVec3 ( enemy.smoothedLinearVelocity );
|
|
savefile->WriteVec3 ( enemy.smoothedPushedVelocity );
|
|
savefile->WriteVec3 ( enemy.lastVisibleEyePosition );
|
|
savefile->WriteVec3 ( enemy.lastVisibleChestPosition );
|
|
savefile->WriteVec3 ( enemy.lastVisibleFromEyePosition );
|
|
savefile->WriteInt ( enemy.lastVisibleTime );
|
|
savefile->WriteFloat ( enemy.range );
|
|
savefile->WriteFloat ( enemy.range2d );
|
|
savefile->WriteInt ( enemy.changeTime );
|
|
savefile->WriteInt ( enemy.checkTime );
|
|
|
|
// Pain variables
|
|
savefile->WriteFloat ( pain.threshold );
|
|
savefile->WriteFloat ( pain.takenThisFrame );
|
|
savefile->WriteInt ( pain.lastTakenTime );
|
|
savefile->WriteInt ( pain.loopEndTime );
|
|
savefile->WriteString ( pain.loopType );
|
|
|
|
// Functions
|
|
funcs.first_sight.Save ( savefile );
|
|
funcs.sight.Save ( savefile );
|
|
funcs.pain.Save ( savefile );
|
|
funcs.damage.Save ( savefile );
|
|
funcs.death.Save ( savefile );
|
|
funcs.attack.Save ( savefile );
|
|
funcs.init.Save ( savefile );
|
|
funcs.onclick.Save ( savefile );
|
|
funcs.launch_projectile.Save ( savefile );
|
|
funcs.footstep.Save ( savefile );
|
|
|
|
mPlayback.Save( savefile ); // cnicholson: Added save functionality
|
|
mLookPlayback.Save( savefile ); // cnicholson: Added save functionality
|
|
|
|
// Tactical Sensor
|
|
aasSensor->Save( savefile );
|
|
|
|
// Helpers
|
|
tether.Save ( savefile );
|
|
helperCurrent.Save ( savefile );
|
|
helperIdeal.Save ( savefile );
|
|
leader.Save ( savefile );
|
|
spawner.Save ( savefile );
|
|
|
|
// Action timers
|
|
actionTimerRangedAttack.Save ( savefile );
|
|
actionTimerEvade.Save ( savefile );
|
|
actionTimerSpecialAttack.Save ( savefile );
|
|
actionTimerPain.Save ( savefile );
|
|
|
|
// Actions
|
|
actionEvadeLeft.Save ( savefile );
|
|
actionEvadeRight.Save ( savefile );
|
|
actionRangedAttack.Save ( savefile );
|
|
actionMeleeAttack.Save ( savefile );
|
|
actionLeapAttack.Save ( savefile );
|
|
actionJumpBack.Save ( savefile );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::Restore
|
|
=====================
|
|
*/
|
|
void idAI::Restore( idRestoreGame *savefile ) {
|
|
bool restorePhysics;
|
|
int i;
|
|
int num;
|
|
idBounds bounds;
|
|
|
|
InitNonPersistentSpawnArgs ( );
|
|
|
|
// INTENTIONALLY NOT SAVED: idLinkList<idAI> simpleThinkNode;
|
|
// INTENTIONALLY NOT SAVED: idAAS* aas;
|
|
// INTENTIONALLY NOT SAVED: idAASCallback* aasFind;
|
|
// NOTE That some AAS stuff is done at end of ::Restore
|
|
|
|
move.Restore( savefile );
|
|
savedMove.Restore( savefile );
|
|
|
|
savefile->ReadStaticObject( physicsObj );
|
|
savefile->ReadBool( restorePhysics );
|
|
if ( restorePhysics ) {
|
|
RestorePhysics( &physicsObj );
|
|
}
|
|
|
|
savefile->ReadBool( lastHitCheckResult );
|
|
savefile->ReadInt( lastHitCheckTime );
|
|
savefile->ReadInt( lastAttackTime );
|
|
savefile->ReadFloat( projectile_height_to_distance_ratio );
|
|
|
|
savefile->ReadInt( num );
|
|
attackAnimInfo.SetGranularity( 1 );
|
|
attackAnimInfo.SetNum( num );
|
|
for( i = 0; i < num; i++ ) {
|
|
savefile->ReadVec3( attackAnimInfo[ i ].attackOffset );
|
|
savefile->ReadVec3( attackAnimInfo[ i ].eyeOffset );
|
|
}
|
|
|
|
// TORESTORE: mutable idClipModel* projectileClipModel;
|
|
projectile.Restore( savefile );
|
|
|
|
// Talking
|
|
savefile->ReadInt( chatterTime );
|
|
// savefile->ReadInt( chatterRateCombat ); // Don't save
|
|
// savefile->ReadInt( chatterRateIdle ); // Don't save
|
|
savefile->ReadInt( i );
|
|
talkState = static_cast<talkState_t>( i );
|
|
talkTarget.Restore( savefile );
|
|
savefile->ReadInt( i );
|
|
talkMessage = static_cast<talkMessage_t>( i );
|
|
savefile->ReadInt( talkBusyCount );
|
|
savefile->ReadInt ( speakTime );
|
|
|
|
// Focus
|
|
lookTarget.Restore ( savefile );
|
|
savefile->ReadInt( i );
|
|
focusType = static_cast<aiFocus_t>( i );
|
|
focusEntity.Restore ( savefile );
|
|
savefile->ReadFloat ( focusRange );
|
|
savefile->ReadInt ( focusAlignTime );
|
|
savefile->ReadInt ( focusTime );
|
|
savefile->ReadVec3( currentFocusPos );
|
|
|
|
// Looking
|
|
savefile->ReadBool( allowJointMod );
|
|
savefile->ReadInt( alignHeadTime );
|
|
savefile->ReadInt( forceAlignHeadTime );
|
|
savefile->ReadAngles( eyeAng );
|
|
savefile->ReadAngles( lookAng );
|
|
savefile->ReadAngles( destLookAng );
|
|
savefile->ReadAngles( lookMin );
|
|
savefile->ReadAngles( lookMax );
|
|
|
|
savefile->ReadInt( num );
|
|
lookJoints.SetGranularity( 1 );
|
|
lookJoints.SetNum( num );
|
|
lookJointAngles.SetGranularity( 1 );
|
|
lookJointAngles.SetNum( num );
|
|
for( i = 0; i < num; i++ ) {
|
|
savefile->ReadJoint( lookJoints[ i ] );
|
|
savefile->ReadAngles( lookJointAngles[ i ] );
|
|
}
|
|
|
|
savefile->ReadFloat( eyeVerticalOffset );
|
|
savefile->ReadFloat( eyeHorizontalOffset );
|
|
savefile->ReadFloat( headFocusRate );
|
|
savefile->ReadFloat( eyeFocusRate );
|
|
|
|
// Joint Controllers
|
|
savefile->ReadAngles( eyeMin );
|
|
savefile->ReadAngles( eyeMax );
|
|
savefile->ReadJoint( orientationJoint );
|
|
|
|
pusher.Restore( savefile ); // cnicholson: Added unrestored var
|
|
scriptedActionEnt.Restore ( savefile ); // cnicholson: Added unrestored var
|
|
|
|
savefile->Read( &aifl, sizeof( aifl ) );
|
|
|
|
// Misc
|
|
savefile->ReadInt ( actionAnimNum );
|
|
savefile->ReadInt ( actionTime );
|
|
savefile->ReadInt ( actionSkipTime );
|
|
savefile->ReadInt ( flagOverrides );
|
|
|
|
// Combat variables
|
|
savefile->Read ( &combat.fl, sizeof( combat.fl ) );
|
|
savefile->ReadFloat ( combat.max_chasing_turn );
|
|
savefile->ReadFloat ( combat.shotAtTime );
|
|
savefile->ReadFloat ( combat.shotAtAngle );
|
|
savefile->ReadVec2 ( combat.hideRange );
|
|
savefile->ReadVec2 ( combat.attackRange );
|
|
savefile->ReadInt ( combat.attackSightDelay );
|
|
savefile->ReadFloat ( combat.meleeRange );
|
|
savefile->ReadFloat ( combat.aggressiveRange );
|
|
savefile->ReadFloat ( combat.aggressiveScale );
|
|
savefile->ReadInt ( combat.investigateTime );
|
|
savefile->ReadFloat ( combat.visStandHeight );
|
|
savefile->ReadFloat ( combat.visCrouchHeight );
|
|
savefile->ReadFloat ( combat.visRange );
|
|
savefile->ReadFloat ( combat.earRange );
|
|
savefile->ReadFloat ( combat.awareRange );
|
|
savefile->ReadInt ( combat.tacticalMaskAvailable );
|
|
savefile->ReadInt ( (int&)combat.tacticalCurrent );
|
|
savefile->ReadInt ( combat.tacticalUpdateTime );
|
|
savefile->ReadInt ( combat.tacticalPainTaken );
|
|
savefile->ReadInt ( combat.tacticalPainThreshold );
|
|
savefile->ReadInt ( combat.tacticalFlinches );
|
|
savefile->ReadInt ( combat.maxLostVisTime );
|
|
savefile->ReadFloat ( combat.threatBase );
|
|
savefile->ReadFloat ( combat.threatCurrent );
|
|
savefile->ReadInt ( combat.coverValidTime );
|
|
savefile->ReadInt ( combat.maxInvalidCoverTime );
|
|
|
|
// Passive state variables
|
|
savefile->ReadString ( passive.prefix );
|
|
savefile->ReadString ( passive.animFidgetPrefix );
|
|
savefile->ReadString ( passive.animIdlePrefix);
|
|
savefile->ReadString ( passive.animTalkPrefix );
|
|
savefile->ReadString ( passive.idleAnim );
|
|
savefile->ReadInt ( passive.idleAnimChangeTime );
|
|
savefile->ReadInt ( passive.fidgetTime );
|
|
savefile->ReadInt ( passive.talkTime );
|
|
savefile->Read ( &passive.fl, sizeof(passive.fl) );
|
|
|
|
// Enemy
|
|
enemy.ent.Restore ( savefile );
|
|
savefile->Read ( &enemy.fl, sizeof(enemy.fl) );
|
|
savefile->ReadInt ( enemy.lastVisibleChangeTime );
|
|
savefile->ReadVec3 ( enemy.lastKnownPosition );
|
|
savefile->ReadVec3 ( enemy.smoothedLinearVelocity );
|
|
savefile->ReadVec3 ( enemy.smoothedPushedVelocity );
|
|
savefile->ReadVec3 ( enemy.lastVisibleEyePosition );
|
|
savefile->ReadVec3 ( enemy.lastVisibleChestPosition );
|
|
savefile->ReadVec3 ( enemy.lastVisibleFromEyePosition );
|
|
savefile->ReadInt ( enemy.lastVisibleTime );
|
|
savefile->ReadFloat ( enemy.range );
|
|
savefile->ReadFloat ( enemy.range2d );
|
|
savefile->ReadInt ( enemy.changeTime );
|
|
savefile->ReadInt ( enemy.checkTime );
|
|
|
|
// Pain variables
|
|
savefile->ReadFloat ( pain.threshold );
|
|
savefile->ReadFloat ( pain.takenThisFrame );
|
|
savefile->ReadInt ( pain.lastTakenTime );
|
|
savefile->ReadInt ( pain.loopEndTime );
|
|
savefile->ReadString ( pain.loopType );
|
|
|
|
// Functions
|
|
funcs.first_sight.Restore ( savefile );
|
|
funcs.sight.Restore ( savefile );
|
|
funcs.pain.Restore ( savefile );
|
|
funcs.damage.Restore ( savefile );
|
|
funcs.death.Restore ( savefile );
|
|
funcs.attack.Restore ( savefile );
|
|
funcs.init.Restore ( savefile );
|
|
funcs.onclick.Restore ( savefile );
|
|
funcs.launch_projectile.Restore ( savefile );
|
|
funcs.footstep.Restore ( savefile );
|
|
|
|
mPlayback.Restore( savefile ); // cnicholson: Added restore functionality
|
|
mLookPlayback.Restore( savefile ); // cnicholson: Added restore functionality
|
|
|
|
// Tactical Sensor
|
|
aasSensor->Restore( savefile );
|
|
|
|
// Helpers
|
|
tether.Restore ( savefile );
|
|
helperCurrent.Restore( savefile );
|
|
helperIdeal.Restore ( savefile );
|
|
leader.Restore ( savefile );
|
|
spawner.Restore ( savefile );
|
|
|
|
// Action timers
|
|
actionTimerRangedAttack.Restore ( savefile );
|
|
actionTimerEvade.Restore ( savefile );
|
|
actionTimerSpecialAttack.Restore ( savefile );
|
|
actionTimerPain.Restore ( savefile );
|
|
|
|
// Actions
|
|
actionEvadeLeft.Restore ( savefile );
|
|
actionEvadeRight.Restore ( savefile );
|
|
actionRangedAttack.Restore ( savefile );
|
|
actionMeleeAttack.Restore ( savefile );
|
|
actionLeapAttack.Restore ( savefile );
|
|
actionJumpBack.Restore ( savefile );
|
|
|
|
// Set the AAS if the character has the correct gravity vector
|
|
idVec3 gravity = spawnArgs.GetVector( "gravityDir", "0 0 -1" );
|
|
gravity *= g_gravity.GetFloat();
|
|
if ( gravity == gameLocal.GetGravity() ) {
|
|
SetAAS();
|
|
}
|
|
|
|
// create combat collision hull for exact collision detection, do initial set un-hidden
|
|
SetCombatModel();
|
|
LinkCombat();
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::InitNonPersistentSpawnArgs
|
|
=====================
|
|
*/
|
|
void idAI::InitNonPersistentSpawnArgs ( void ) {
|
|
aasSensor = rvAASTacticalSensor::CREATE_SENSOR(this);
|
|
aasFind = NULL;
|
|
|
|
simpleThinkNode.Remove ( );
|
|
simpleThinkNode.SetOwner ( this );
|
|
|
|
chatterRateIdle = SEC2MS ( spawnArgs.GetFloat ( "chatter_rate_idle", "0" ) );
|
|
chatterRateCombat = SEC2MS ( spawnArgs.GetFloat ( "chatter_rate_combat", "0" ) );
|
|
chatterTime = 0;
|
|
|
|
combat.tacticalMaskUpdate = 0;
|
|
|
|
enemy.smoothVelocityRate = spawnArgs.GetFloat ( "smoothVelocityRate", "0.1" );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::Spawn
|
|
=====================
|
|
*/
|
|
void idAI::Spawn( void ) {
|
|
const char* jointname;
|
|
const idKeyValue* kv;
|
|
idStr jointName;
|
|
idAngles jointScale;
|
|
jointHandle_t joint;
|
|
idVec3 local_dir;
|
|
|
|
// Are all monsters disabled?
|
|
if ( !g_monsters.GetBool() ) {
|
|
PostEventMS( &EV_Remove, 0 );
|
|
return;
|
|
}
|
|
|
|
// Initialize the non saved spawn args
|
|
InitNonPersistentSpawnArgs ( );
|
|
|
|
spawnArgs.GetInt( "team", "1", team );
|
|
spawnArgs.GetInt( "rank", "0", rank );
|
|
|
|
animPrefix = spawnArgs.GetString ( "animPrefix", "" );
|
|
|
|
// Standard flags
|
|
fl.notarget = spawnArgs.GetBool ( "notarget", "0" );
|
|
fl.quickBurn = false;
|
|
|
|
// AI flags
|
|
flagOverrides = 0;
|
|
memset ( &aifl, 0, sizeof(aifl) );
|
|
aifl.ignoreFlashlight = spawnArgs.GetBool ( "ignore_flashlight", "1" );
|
|
aifl.lookAtPlayer = spawnArgs.GetBool ( "lookAtPlayer", "0" );
|
|
aifl.disableLook = spawnArgs.GetBool ( "noLook", "0" );
|
|
aifl.undying = spawnArgs.GetBool ( "undying", "0" );
|
|
aifl.killerGuard = spawnArgs.GetBool ( "killer_guard", "0" );
|
|
aifl.scriptedEndWithIdle = true;
|
|
|
|
// Setup Move Data
|
|
move.Spawn( spawnArgs );
|
|
|
|
pain.threshold = spawnArgs.GetInt ( "painThreshold", "0" );
|
|
pain.takenThisFrame = 0;
|
|
|
|
// Initialize combat variables
|
|
combat.fl.aware = spawnArgs.GetBool ( "ambush", "0" );
|
|
combat.fl.tetherNoBreak = spawnArgs.GetBool ( "tetherNoBreak", "0" );
|
|
combat.fl.noChatter = spawnArgs.GetBool ( "noCombatChatter" );
|
|
combat.hideRange = spawnArgs.GetVec2 ( "hideRange", "150 750" );
|
|
combat.attackRange = spawnArgs.GetVec2 ( "attackRange", "0 1000" );
|
|
combat.attackSightDelay = SEC2MS ( spawnArgs.GetFloat ( "attackSightDelay", "1" ) );
|
|
combat.visRange = spawnArgs.GetFloat( "visRange", "2048" );
|
|
combat.visStandHeight = spawnArgs.GetFloat( "visStandHeight", "68" );
|
|
combat.visCrouchHeight = spawnArgs.GetFloat( "visCrouchHeight", "48" );
|
|
combat.earRange = spawnArgs.GetFloat( "earRange", "2048" );
|
|
combat.awareRange = spawnArgs.GetFloat( "awareRange", "150" );
|
|
combat.aggressiveRange = spawnArgs.GetFloat( "aggressiveRange", "0" );
|
|
combat.maxLostVisTime = SEC2MS ( spawnArgs.GetFloat ( "maxLostVisTime", "10" ) );
|
|
combat.tacticalPainThreshold = spawnArgs.GetInt ( "tactical_painThreshold", va("%d", health / 4) );
|
|
combat.coverValidTime = 0;
|
|
combat.maxInvalidCoverTime = SEC2MS ( spawnArgs.GetFloat ( "maxInvalidCoverTime", "1" ) );
|
|
combat.threatBase = spawnArgs.GetFloat ( "threatBase", "1" );
|
|
combat.threatCurrent = combat.threatBase;
|
|
|
|
SetPassivePrefix ( spawnArgs.GetString ( "passivePrefix" ) );
|
|
|
|
disablePain = spawnArgs.GetBool ( "nopain", "0" );
|
|
|
|
spawnArgs.GetFloat( "melee_range", "64", combat.meleeRange );
|
|
spawnArgs.GetFloat( "projectile_height_to_distance_ratio", "1", projectile_height_to_distance_ratio );
|
|
|
|
//melee superhero -- take far reduced damage from melee.
|
|
if ( spawnArgs.GetString( "objectivetitle_failed", NULL ) && spawnArgs.GetBool( "meleeSuperhero", "1") ) {
|
|
aifl.meleeSuperhero = true;
|
|
} else {
|
|
aifl.meleeSuperhero = false;
|
|
}
|
|
|
|
//announce rate
|
|
announceRate = spawnArgs.GetFloat( "announceRate" );
|
|
if( 0.0f == announceRate ) {
|
|
announceRate = AISPEAK_CHANCE;
|
|
}
|
|
|
|
fl.takedamage = !spawnArgs.GetBool( "noDamage" );
|
|
|
|
animator.RemoveOriginOffset( true );
|
|
|
|
// create combat collision hull for exact collision detection
|
|
SetCombatModel();
|
|
|
|
lookMin = spawnArgs.GetAngles( "look_min", "-80 -75 0" );
|
|
lookMax = spawnArgs.GetAngles( "look_max", "80 75 0" );
|
|
|
|
lookJoints.SetGranularity( 1 );
|
|
lookJointAngles.SetGranularity( 1 );
|
|
kv = spawnArgs.MatchPrefix( "look_joint", NULL );
|
|
while( kv ) {
|
|
jointName = kv->GetKey();
|
|
jointName.StripLeadingOnce( "look_joint " );
|
|
joint = animator.GetJointHandle( jointName );
|
|
if ( joint == INVALID_JOINT ) {
|
|
gameLocal.Warning( "Unknown look_joint '%s' on entity %s", jointName.c_str(), name.c_str() );
|
|
} else {
|
|
jointScale = spawnArgs.GetAngles( kv->GetKey(), "0 0 0" );
|
|
jointScale.roll = 0.0f;
|
|
|
|
// if no scale on any component, then don't bother adding it. this may be done to
|
|
// zero out rotation from an inherited entitydef.
|
|
if ( jointScale != ang_zero ) {
|
|
lookJoints.Append( joint );
|
|
lookJointAngles.Append( jointScale );
|
|
}
|
|
}
|
|
kv = spawnArgs.MatchPrefix( "look_joint", kv );
|
|
}
|
|
|
|
// calculate joint positions on attack frames so we can do proper "can hit" tests
|
|
CalculateAttackOffsets();
|
|
|
|
eyeMin = spawnArgs.GetAngles( "eye_turn_min", "-10 -30 0" );
|
|
eyeMax = spawnArgs.GetAngles( "eye_turn_max", "10 30 0" );
|
|
eyeVerticalOffset = spawnArgs.GetFloat( "eye_verticle_offset", "5" );
|
|
eyeHorizontalOffset = spawnArgs.GetFloat( "eye_horizontal_offset", "-8" );
|
|
headFocusRate = spawnArgs.GetFloat( "head_focus_rate", "0.06" );
|
|
eyeFocusRate = spawnArgs.GetFloat( "eye_focus_rate", "0.5" );
|
|
focusRange = spawnArgs.GetFloat( "focus_range", "0" );
|
|
focusAlignTime = SEC2MS( spawnArgs.GetFloat( "focus_align_time", "1" ) );
|
|
|
|
jointname = spawnArgs.GetString( "joint_orientation" );
|
|
if ( *jointname ) {
|
|
orientationJoint = animator.GetJointHandle( jointname );
|
|
if ( orientationJoint == INVALID_JOINT ) {
|
|
gameLocal.Warning( "Joint '%s' not found on '%s'", jointname, name.c_str() );
|
|
}
|
|
}
|
|
|
|
jointname = spawnArgs.GetString( "joint_flytilt" );
|
|
if ( *jointname ) {
|
|
move.flyTiltJoint = animator.GetJointHandle( jointname );
|
|
if ( move.flyTiltJoint == INVALID_JOINT ) {
|
|
gameLocal.Warning( "Joint '%s' not found on '%s'", jointname, name.c_str() );
|
|
}
|
|
}
|
|
|
|
physicsObj.SetSelf( this );
|
|
physicsObj.SetClipModel( new idClipModel( GetPhysics()->GetClipModel() ), 1.0f );
|
|
physicsObj.SetMass( spawnArgs.GetFloat( "mass", "100" ) );
|
|
|
|
if ( spawnArgs.GetBool( "big_monster" ) ) {
|
|
physicsObj.SetContents( 0 );
|
|
physicsObj.SetClipMask( MASK_MONSTERSOLID & ~CONTENTS_BODY );
|
|
} else {
|
|
if ( use_combat_bbox ) {
|
|
physicsObj.SetContents( CONTENTS_BODY|CONTENTS_SOLID );
|
|
} else {
|
|
physicsObj.SetContents( CONTENTS_BODY );
|
|
}
|
|
physicsObj.SetClipMask( MASK_MONSTERSOLID );
|
|
}
|
|
|
|
// move up to make sure the monster is at least an epsilon above the floor
|
|
physicsObj.SetOrigin( GetPhysics()->GetOrigin() + idVec3( 0, 0, CM_CLIP_EPSILON ) );
|
|
|
|
idVec3 gravity = spawnArgs.GetVector( "gravityDir", "0 0 -1" );
|
|
gravity *= g_gravity.GetFloat();
|
|
physicsObj.SetGravity( gravity );
|
|
|
|
SetPhysics( &physicsObj );
|
|
|
|
physicsObj.GetGravityAxis().ProjectVector( viewAxis[ 0 ], local_dir );
|
|
move.current_yaw = local_dir.ToYaw();
|
|
move.ideal_yaw = idMath::AngleNormalize180( move.current_yaw );
|
|
|
|
lookAng.Zero ( );
|
|
lookAng.yaw = move.current_yaw;
|
|
|
|
|
|
SetAAS();
|
|
|
|
projectile = NULL;
|
|
projectileClipModel = NULL;
|
|
|
|
if ( spawnArgs.GetBool( "hide" ) || spawnArgs.GetBool( "trigger_anim" ) ) {
|
|
fl.takedamage = false;
|
|
physicsObj.SetContents( 0 );
|
|
physicsObj.GetClipModel()->Unlink();
|
|
Hide();
|
|
} else {
|
|
// play a looping ambient sound if we have one
|
|
StartSound( "snd_ambient", SND_CHANNEL_AMBIENT, 0, false, NULL );
|
|
}
|
|
|
|
if ( health <= 0 ) {
|
|
gameLocal.Warning( "entity '%s' doesn't have health set", name.c_str() );
|
|
health = 1;
|
|
}
|
|
|
|
BecomeActive( TH_THINK );
|
|
|
|
if ( move.fl.allowPushMovables ) {
|
|
af.SetupPose( this, gameLocal.time );
|
|
af.GetPhysics()->EnableClip();
|
|
}
|
|
|
|
// init the move variables
|
|
StopMove( MOVE_STATUS_DONE );
|
|
|
|
// Initialize any scripts
|
|
idStr prefix = "script_";
|
|
for ( kv = spawnArgs.MatchPrefix ( prefix.c_str(), NULL );
|
|
kv;
|
|
kv = spawnArgs.MatchPrefix ( prefix.c_str(), kv ) ) {
|
|
SetScript ( kv->GetKey().c_str() + prefix.Length(), kv->GetValue() );
|
|
}
|
|
|
|
// Initialize actions
|
|
actionEvadeLeft.Init ( spawnArgs, "action_evadeLeft", NULL, 0 );
|
|
actionEvadeRight.Init ( spawnArgs, "action_evadeRight", NULL, 0 );
|
|
actionRangedAttack.Init ( spawnArgs, "action_rangedAttack", NULL, AIACTIONF_ATTACK );
|
|
actionMeleeAttack.Init ( spawnArgs, "action_meleeAttack", NULL, AIACTIONF_ATTACK|AIACTIONF_MELEE );
|
|
actionLeapAttack.Init ( spawnArgs, "action_leapAttack", NULL, AIACTIONF_ATTACK );
|
|
actionJumpBack.Init ( spawnArgs, "action_jumpBack", NULL, 0 );
|
|
|
|
// Global action timers
|
|
actionTimerRangedAttack.Init ( spawnArgs, "actionTimer_RangedAttack" );
|
|
actionTimerEvade.Init ( spawnArgs, "actionTimer_Evade" );
|
|
actionTimerSpecialAttack.Init ( spawnArgs, "actionTimer_SpecialAttack" );
|
|
actionTimerPain.Init ( spawnArgs, "actionTimer_pain" );
|
|
|
|
// Available tactical options
|
|
combat.tacticalUpdateTime = 0;
|
|
combat.tacticalCurrent = AITACTICAL_NONE;
|
|
combat.tacticalMaskUpdate = 0;
|
|
combat.tacticalMaskAvailable = AITACTICAL_TURRET_BIT|AITACTICAL_MOVE_FOLLOW_BIT|AITACTICAL_MOVE_TETHER_BIT;
|
|
combat.tacticalMaskAvailable |= (spawnArgs.GetBool ( "tactical_cover", "0" ) ? AITACTICAL_COVER_BITS : 0);
|
|
combat.tacticalMaskAvailable |= (spawnArgs.GetBool ( "tactical_ranged", "0" ) ? AITACTICAL_RANGED_BITS : 0);
|
|
combat.tacticalMaskAvailable |= (spawnArgs.GetBool ( "tactical_hide", "0" ) ? AITACTICAL_HIDE_BIT : 0);
|
|
combat.tacticalMaskAvailable |= (spawnArgs.GetBool ( "tactical_rush", "0" ) ? AITACTICAL_MELEE_BIT : 0);
|
|
combat.tacticalMaskAvailable |= (spawnArgs.GetBool ( "tactical_passive", "0" ) ? AITACTICAL_PASSIVE_BIT : 0);
|
|
combat.tacticalMaskAvailable |= (spawnArgs.GetBool ( "allowPlayerPush", "0" ) ? AITACTICAL_MOVE_PLAYERPUSH_BIT : 0);
|
|
|
|
// Talking?
|
|
const char* npc;
|
|
if ( spawnArgs.GetString( "npc_name", NULL, &npc ) != NULL && *npc ) {
|
|
if ( spawnArgs.GetBool ( "follows", "0" ) ) {
|
|
SetTalkState ( TALK_FOLLOW );
|
|
} else {
|
|
switch ( spawnArgs.GetInt( "talks" ) )
|
|
{
|
|
case 2:
|
|
SetTalkState ( TALK_WAIT );
|
|
break;
|
|
case 1:
|
|
SetTalkState ( TALK_OK );
|
|
break;
|
|
case 0:
|
|
default:
|
|
SetTalkState ( TALK_BUSY );
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
SetTalkState ( TALK_NEVER );
|
|
}
|
|
|
|
// Passive or aggressive ai?
|
|
if ( spawnArgs.GetBool ( "passive" ) ) {
|
|
Event_BecomePassive ( true );
|
|
|
|
if ( spawnArgs.GetInt ( "passive" ) > 1 ) {
|
|
aifl.disableLook = true;
|
|
}
|
|
}
|
|
|
|
// Print out a warning about any AI that is spawned unhidden since they will be all thinking
|
|
if( gameLocal.GameState ( ) == GAMESTATE_STARTUP && !spawnArgs.GetInt( "hide" ) && !spawnArgs.GetInt( "trigger_anim" ) && !spawnArgs.GetInt( "trigger_cover" ) && !spawnArgs.GetInt( "trigger_move" ) ){
|
|
gameLocal.Warning( "Unhidden AI placed in map (will be constantly active): %s (%s)", name.c_str(), GetPhysics()->GetOrigin().ToString() );
|
|
}
|
|
|
|
Begin ( );
|
|
|
|
// RAVEN BEGIN
|
|
// twhitaker: needed this for difficulty settings
|
|
PostEventMS( &EV_PostSpawn, 0 );
|
|
// RAVEN END
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idAI::Begin
|
|
===================
|
|
*/
|
|
void idAI::Begin ( void ) {
|
|
const char* temp;
|
|
bool animWalk;
|
|
bool animRun;
|
|
|
|
// Look for the lack of a run or walk animation and force the opposite
|
|
animWalk = HasAnim ( ANIMCHANNEL_LEGS, "walk" );
|
|
animRun = HasAnim ( ANIMCHANNEL_LEGS, "run" );
|
|
if ( !animWalk && animRun ) {
|
|
move.fl.noWalk = true;
|
|
} else if ( !animRun && animWalk ) {
|
|
move.fl.noRun = true;
|
|
}
|
|
|
|
// If a trigger anim or hide is specified then wait until activated before waking up
|
|
if ( spawnArgs.GetString ( "trigger_anim", "", &temp ) || spawnArgs.GetBool ( "hide" ) ) {
|
|
Hide();
|
|
PostState ( "Wait_Activated" );
|
|
PostState ( "State_WakeUp", SEC2MS(spawnArgs.GetFloat ( "wait" ) ) );
|
|
// Wake up
|
|
} else {
|
|
PostState ( "State_WakeUp", SEC2MS(spawnArgs.GetFloat ( "wait" ) ) );
|
|
}
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idAI::WakeUp
|
|
===================
|
|
*/
|
|
void idAI::WakeUp ( void ) {
|
|
const char* temp;
|
|
|
|
// Already awake?
|
|
if ( aifl.awake ) {
|
|
return;
|
|
}
|
|
|
|
// Find the closest helper
|
|
UpdateHelper ( );
|
|
|
|
aifl.awake = true;
|
|
|
|
// If the monster is flying then start them with the flying movement type
|
|
if ( spawnArgs.GetBool ( "static" ) ) {
|
|
SetMoveType ( MOVETYPE_STATIC );
|
|
} else if ( spawnArgs.GetBool ( "flying" ) ) {
|
|
SetMoveType ( MOVETYPE_FLY );
|
|
move.moveDest = physicsObj.GetOrigin();
|
|
move.moveDest.z += move.fly_offset;
|
|
} else {
|
|
SetMoveType ( MOVETYPE_ANIM );
|
|
}
|
|
|
|
// Wake up any linked entities
|
|
WakeUpTargets ( );
|
|
|
|
// Default enemy?
|
|
if ( !combat.fl.ignoreEnemies ) {
|
|
if ( spawnArgs.GetString ( "enemy", "", &temp ) && *temp ) {
|
|
SetEnemy ( gameLocal.FindEntity ( temp ) );
|
|
} else if ( spawnArgs.GetBool ( "forceEnemy", "0" ) ) {
|
|
SetEnemy ( FindEnemy ( false, true ) );
|
|
}
|
|
}
|
|
|
|
// Default leader?
|
|
if ( spawnArgs.GetString ( "leader", "", &temp ) && *temp ) {
|
|
SetLeader ( gameLocal.FindEntity ( temp ) );
|
|
}
|
|
|
|
// If hidden and face enemy is specified we should orient ourselves toward our enemy immediately
|
|
if ( enemy.ent && IsHidden ( ) && spawnArgs.GetBool ( "faceEnemy" ) ) {
|
|
TurnToward ( enemy.ent->GetPhysics()->GetOrigin() );
|
|
move.current_yaw = move.ideal_yaw;
|
|
viewAxis = idAngles( 0, move.current_yaw, 0 ).ToMat3();
|
|
}
|
|
|
|
Show ( );
|
|
|
|
aiManager.AddTeammate ( this );
|
|
|
|
// External script functions
|
|
ExecScriptFunction( funcs.init, this );
|
|
|
|
OnWakeUp ( );
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idAI::List_f
|
|
===================
|
|
*/
|
|
void idAI::List_f( const idCmdArgs &args ) {
|
|
int e;
|
|
int i;
|
|
idEntity* check;
|
|
int count;
|
|
idDict countsFixed;
|
|
idDict countsSpawned;
|
|
|
|
count = 0;
|
|
|
|
gameLocal.Printf( "%-4s %-20s %s\n", " Num", "EntityDef", "Name" );
|
|
gameLocal.Printf( "------------------------------------------------\n" );
|
|
for( e = 0; e < MAX_GENTITIES; e++ ) {
|
|
check = gameLocal.entities[ e ];
|
|
if ( !check ) {
|
|
continue;
|
|
}
|
|
|
|
if ( check->IsType ( idAI::Type ) ) {
|
|
idAI* checkAI = static_cast<idAI*>(check);
|
|
|
|
// Skip spawned AI
|
|
if ( checkAI->spawner ) {
|
|
continue;
|
|
}
|
|
countsFixed.SetInt ( check->GetEntityDefName(), countsFixed.GetInt ( check->GetEntityDefName(), "0" ) + 1 );
|
|
|
|
gameLocal.Printf( "%4i: %-20s %-20s move: %d\n", e, check->GetEntityDefName(), check->name.c_str(), checkAI->move.fl.allowAnimMove );
|
|
count++;
|
|
} else if ( check->IsType ( rvSpawner::GetClassType() ) ) {
|
|
const idKeyValue* kv;
|
|
rvSpawner* checkSpawner = static_cast<rvSpawner*>(check);
|
|
for ( kv = check->spawnArgs.MatchPrefix( "def_spawn", NULL ); kv; kv = check->spawnArgs.MatchPrefix( "def_spawn", kv ) ) {
|
|
countsSpawned.SetInt ( kv->GetValue(), countsSpawned.GetInt ( kv->GetValue(), "0" ) + 1 );
|
|
}
|
|
for ( i = 0; i < checkSpawner->GetNumSpawnPoints(); i ++ ) {
|
|
check = checkSpawner->GetSpawnPoint ( i );
|
|
if ( !check ) {
|
|
continue;
|
|
}
|
|
for ( kv = check->spawnArgs.MatchPrefix( "def_spawn", NULL ); kv; kv = check->spawnArgs.MatchPrefix( "def_spawn", kv ) ) {
|
|
countsSpawned.SetInt ( kv->GetValue(), countsSpawned.GetInt ( kv->GetValue(), "0" ) + 1 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Combine the two lists
|
|
for ( e = 0; e < countsSpawned.GetNumKeyVals(); e ++ ) {
|
|
const char* keyName = countsSpawned.GetKeyVal ( e )->GetKey();
|
|
countsFixed.Set ( keyName, va("(%s) %3d",
|
|
countsSpawned.GetKeyVal ( e )->GetValue().c_str(),
|
|
countsFixed.GetInt ( keyName, "0" ) + atoi(countsSpawned.GetKeyVal ( e )->GetValue()) ) );
|
|
}
|
|
|
|
// Print out total counts
|
|
if ( countsFixed.GetNumKeyVals() ) {
|
|
gameLocal.Printf( "------------------------------------------------\n" );
|
|
for ( e = 0; e < countsFixed.GetNumKeyVals(); e ++ ) {
|
|
const idKeyValue* kv = countsFixed.GetKeyVal ( e );
|
|
gameLocal.Printf( "%10s: %-20s\n", kv->GetValue().c_str(), kv->GetKey().c_str() );
|
|
}
|
|
}
|
|
|
|
gameLocal.Printf( "------------------------------------------------\n" );
|
|
gameLocal.Printf( "...%d monsters (%d unique types)\n", count, countsFixed.GetNumKeyVals() );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::DormantBegin
|
|
|
|
called when entity becomes dormant
|
|
================
|
|
*/
|
|
void idAI::DormantBegin( void ) {
|
|
// since dormant happens on a timer, we wont get to update particles to
|
|
// hidden through the think loop, but we need to hide them though.
|
|
if ( enemyNode.InList() ) {
|
|
// remove ourselves from the enemy's enemylist
|
|
enemyNode.Remove();
|
|
}
|
|
idActor::DormantBegin();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::DormantEnd
|
|
|
|
called when entity wakes from being dormant
|
|
================
|
|
*/
|
|
void idAI::DormantEnd( void ) {
|
|
if ( enemy.ent && !enemyNode.InList() ) {
|
|
// let our enemy know we're back on the trail
|
|
idActor *enemyEnt = dynamic_cast< idActor *>( enemy.ent.GetEntity() );
|
|
if( enemyEnt ){
|
|
enemyNode.AddToEnd( enemyEnt->enemyList );
|
|
}
|
|
}
|
|
idActor::DormantEnd();
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::ValidateCover
|
|
|
|
Validate the reserved cover feature with current conditions. Also quickly tests if
|
|
cover does not face enemy at all, which triggers an instant update (ignoring maxCoverInvalidTime)
|
|
=====================
|
|
*/
|
|
bool idAI::ValidateCover( ) {
|
|
if ( !InCoverMode( ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( aasSensor->TestValidWithCurrentState() && (!enemy.ent || enemy.range > combat.awareRange ) ) {
|
|
combat.coverValidTime = gameLocal.time;
|
|
} else if ( combat.coverValidTime && !IsCoverValid ( ) ) {
|
|
combat.coverValidTime = 0;
|
|
OnCoverInvalidated();
|
|
}
|
|
|
|
return IsCoverValid();
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::DoDormantTests
|
|
=====================
|
|
*/
|
|
bool idAI::DoDormantTests ( void ) {
|
|
// If in a scripted move that we should never go dormant in
|
|
if ( aifl.scripted && aifl.scriptedNeverDormant ) {
|
|
return false;
|
|
}
|
|
// If following a player never go dormant
|
|
if ( leader && leader->IsType ( idPlayer::GetClassType ( ) ) ) {
|
|
return false;
|
|
}
|
|
// AI should no longer go dormant when outside of tether
|
|
if ( IsTethered () && !IsWithinTether ( ) ) {
|
|
return false;
|
|
}
|
|
return idActor::DoDormantTests ( );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::Think
|
|
=====================
|
|
*/
|
|
void idAI::Think( void ) {
|
|
|
|
// if we are completely closed off from the player, don't do anything at all
|
|
if ( CheckDormant() ) {
|
|
return;
|
|
}
|
|
|
|
// Simple think this frame?
|
|
aifl.simpleThink = aiManager.IsSimpleThink ( this );
|
|
|
|
aiManager.thinkCount++;
|
|
|
|
// AI Speeds
|
|
if ( ai_speeds.GetBool ( ) ) {
|
|
aiManager.timerThink.Start ( );
|
|
}
|
|
|
|
if ( thinkFlags & TH_THINK ) {
|
|
// clear out the enemy when he dies or is hidden
|
|
idEntity* enemyEnt = enemy.ent;
|
|
idActor* enemyAct = dynamic_cast<idActor*>( enemyEnt );
|
|
|
|
// Clear our enemy if necessary
|
|
if ( enemyEnt ) {
|
|
if (enemyAct && enemyAct->IsInVehicle()) {
|
|
SetEnemy(enemyAct->GetVehicleController().GetVehicle()); // always get angry at the enemy's vehicle first, not the enemy himself
|
|
} else {
|
|
bool enemyDead = (enemyEnt->fl.takedamage && enemyEnt->health <= 0);
|
|
if ( enemyDead || enemyEnt->fl.notarget || enemyEnt->IsHidden() || (enemyAct && enemyAct->team == team)) {
|
|
ClearEnemy ( enemyDead );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Action time is stopped when the torso is not idle
|
|
if ( !aifl.action ) {
|
|
actionTime += gameLocal.msec;
|
|
}
|
|
|
|
ValidateCover();
|
|
|
|
move.current_yaw += deltaViewAngles.yaw;
|
|
move.ideal_yaw = idMath::AngleNormalize180( move.ideal_yaw + deltaViewAngles.yaw );
|
|
deltaViewAngles.Zero();
|
|
|
|
if( move.moveType != MOVETYPE_PLAYBACK ){
|
|
viewAxis = idAngles( 0, move.current_yaw, 0 ).ToMat3();
|
|
}
|
|
|
|
if ( !move.fl.allowHiddenMove && IsHidden() ) {
|
|
// hidden monsters
|
|
UpdateStates ();
|
|
} else if( !ai_freeze.GetBool() ) {
|
|
Prethink();
|
|
|
|
// clear the ik before we do anything else so the skeleton doesn't get updated twice
|
|
walkIK.ClearJointMods();
|
|
|
|
// update enemy position if not dead
|
|
if ( !aifl.dead ) {
|
|
UpdateEnemy ( );
|
|
}
|
|
|
|
// update state machine
|
|
UpdateStates();
|
|
|
|
// run all movement commands
|
|
Move();
|
|
|
|
// if not dead, chatter and blink
|
|
if( move.moveType != MOVETYPE_DEAD ){
|
|
UpdateChatter();
|
|
CheckBlink();
|
|
}
|
|
|
|
Postthink();
|
|
} else {
|
|
DrawTactical ( );
|
|
}
|
|
|
|
// clear pain flag so that we recieve any damage between now and the next time we run the script
|
|
aifl.pain = false;
|
|
aifl.damage = false;
|
|
aifl.pushed = false;
|
|
pusher = NULL;
|
|
} else if ( thinkFlags & TH_PHYSICS ) {
|
|
RunPhysics();
|
|
}
|
|
|
|
if ( move.fl.allowPushMovables ) {
|
|
PushWithAF();
|
|
}
|
|
|
|
if ( fl.hidden && move.fl.allowHiddenMove ) {
|
|
// UpdateAnimation won't call frame commands when hidden, so call them here when we allow hidden movement
|
|
animator.ServiceAnims( gameLocal.previousTime, gameLocal.time );
|
|
}
|
|
|
|
aasSensor->Update();
|
|
|
|
UpdateAnimation();
|
|
Present();
|
|
LinkCombat();
|
|
|
|
// AI Speeds
|
|
if ( ai_speeds.GetBool ( ) ) {
|
|
aiManager.timerThink.Stop ( );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::UpdateFocus
|
|
============
|
|
*/
|
|
void idAI::UpdateFocus ( const idMat3& orientationAxis ) {
|
|
// Alwasy look at enemy
|
|
if ( !allowJointMod || !allowEyeFocus ) {
|
|
SetFocus ( AIFOCUS_NONE, 0 );
|
|
} else if ( IsBehindCover() && !aifl.action && !IsSpeaking() ) {
|
|
SetFocus ( AIFOCUS_NONE, 0 );
|
|
} else if ( !aifl.scripted && (IsEnemyRecentlyVisible(2.0f) || gameLocal.GetTime()-lastAttackTime<1000) ) {
|
|
//not scripted and: have an enemy OR we shot at an enemy recently (for when we kill an enemy in the middle of a volley)
|
|
SetFocus ( AIFOCUS_ENEMY, 1000 );
|
|
} else if ( move.fl.moving && InCoverMode ( ) && DistanceTo ( aasSensor->ReservedOrigin() ) < move.walkRange * 2.0f ) {
|
|
SetFocus ( AIFOCUS_COVER, 1000 );
|
|
} else if ( InLookAtCoverMode() ) {
|
|
SetFocus ( AIFOCUS_COVERLOOK, 1000 );
|
|
} else if ( talkTarget && gameLocal.time < passive.talkTime ) {
|
|
SetFocus ( AIFOCUS_TALK, 100 );
|
|
} else if ( lookTarget ) {
|
|
SetFocus ( AIFOCUS_TARGET, 100 );
|
|
} else if ( !IsBehindCover() && tether && DistanceTo ( move.moveDest ) < move.walkRange * 2.0f ) {
|
|
SetFocus ( AIFOCUS_TETHER, 100 );
|
|
} else if ( IsTethered() && (move.fl.moving || IsBehindCover()) ) {
|
|
//tethered and at cover or moving - don't look at leader or player
|
|
SetFocus ( AIFOCUS_NONE, 0 );
|
|
} else if ( helperCurrent && helperCurrent->IsCombat ( ) ) {
|
|
SetFocus ( AIFOCUS_HELPER, 100 );
|
|
} else if ( !aifl.scripted && !move.fl.moving ) {
|
|
idEntity* lookat = NULL;
|
|
aiFocus_t newfocus = AIFOCUS_NONE;
|
|
|
|
if ( leader ) {
|
|
idVec3 dir2Leader = leader->GetPhysics()->GetOrigin()-GetPhysics()->GetOrigin();
|
|
if ( (viewAxis[0] * dir2Leader) > 0.0f ) {
|
|
//leader is in front of me
|
|
newfocus = AIFOCUS_LEADER;
|
|
lookat = leader;
|
|
} else if ( focusType == AIFOCUS_LEADER ) {
|
|
//stop looking at him!
|
|
SetFocus ( AIFOCUS_NONE, 0 );
|
|
}
|
|
} else if ( aifl.lookAtPlayer && !move.fl.moving ) {
|
|
newfocus = AIFOCUS_PLAYER;
|
|
lookat = gameLocal.GetLocalPlayer();
|
|
}
|
|
|
|
if ( newfocus != AIFOCUS_NONE && lookat ) {
|
|
if ( DistanceTo ( lookat ) < focusRange * (move.fl.moving?2.0f:1.0f) && CheckFOV ( lookat->GetPhysics()->GetOrigin() ) ) {
|
|
SetFocus ( newfocus, 1000 );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure cover look wasnt invalidated
|
|
if ( focusType == AIFOCUS_COVERLOOK && !aasSensor->Look() ) {
|
|
focusType = AIFOCUS_NONE;
|
|
} else if ( focusType == AIFOCUS_COVER && !aasSensor->Reserved ( ) ) {
|
|
focusType = AIFOCUS_NONE;
|
|
} else if ( focusType == AIFOCUS_HELPER && !helperCurrent ) {
|
|
focusType = AIFOCUS_NONE;
|
|
} else if ( focusType == AIFOCUS_TETHER && !tether ) {
|
|
focusType = AIFOCUS_NONE;
|
|
}
|
|
|
|
// Update focus type to none when the focus time runs out
|
|
if ( focusType != AIFOCUS_NONE ) {
|
|
if ( gameLocal.time > focusTime ) {
|
|
focusType = AIFOCUS_NONE;
|
|
}
|
|
}
|
|
|
|
// Calculate the focus position
|
|
if ( focusType == AIFOCUS_NONE ) {
|
|
currentFocusPos = GetEyePosition() + orientationAxis[ 0 ] * 64.0f;
|
|
} else if ( focusType == AIFOCUS_COVER ) {
|
|
currentFocusPos = GetEyePosition() + aasSensor->Reserved()->Normal() * 64.0f;
|
|
} else if ( focusType == AIFOCUS_COVERLOOK ) {
|
|
currentFocusPos = GetEyePosition() + aasSensor->Look()->Normal() * 64.0f;
|
|
} else if ( focusType == AIFOCUS_ENEMY ) {
|
|
currentFocusPos = enemy.lastVisibleEyePosition;
|
|
} else if ( focusType == AIFOCUS_HELPER ) {
|
|
currentFocusPos = helperCurrent->GetPhysics()->GetOrigin() + helperCurrent->GetDirection ( this );
|
|
} else if ( focusType == AIFOCUS_TETHER ) {
|
|
currentFocusPos = GetEyePosition() + tether->GetPhysics()->GetAxis()[0] * 64.0f;
|
|
} else {
|
|
idEntity* focusEnt = NULL;
|
|
switch ( focusType ) {
|
|
case AIFOCUS_LEADER: focusEnt = leader; break;
|
|
case AIFOCUS_PLAYER: focusEnt = gameLocal.GetLocalPlayer(); break;
|
|
case AIFOCUS_TALK: focusEnt = talkTarget; break;
|
|
case AIFOCUS_TARGET: focusEnt = lookTarget; break;
|
|
}
|
|
if ( focusEnt ) {
|
|
if ( focusEnt->IsType ( idActor::GetClassType ( ) ) ) {
|
|
currentFocusPos = static_cast<idActor*>(focusEnt)->GetEyePosition() - eyeVerticalOffset * focusEnt->GetPhysics()->GetGravityNormal();
|
|
} else {
|
|
currentFocusPos = focusEnt->GetPhysics()->GetOrigin();
|
|
}
|
|
} else {
|
|
currentFocusPos = GetEyePosition() + orientationAxis[ 0 ] * 64.0f;
|
|
}
|
|
}
|
|
|
|
//draw it so we can see what they think they're looking at!
|
|
if ( DebugFilter(ai_debugMove) ) { // Cyan & Blue = currentFocusPos
|
|
if ( focusType != AIFOCUS_NONE ) {
|
|
gameRenderWorld->DebugArrow( colorCyan, GetEyePosition(), currentFocusPos, 0 );
|
|
} else {
|
|
gameRenderWorld->DebugArrow( colorBlue, GetEyePosition(), currentFocusPos, 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::UpdateStates
|
|
=====================
|
|
*/
|
|
void idAI::UpdateStates ( void ) {
|
|
MEM_SCOPED_TAG(tag,MA_DEFAULT);
|
|
|
|
// Continue updating tactical state if for some reason we dont have one
|
|
if ( !aifl.dead && !aifl.scripted && !aifl.action && stateThread.IsIdle ( ) && aifl.scriptedEndWithIdle ) {
|
|
UpdateTactical ( 0 );
|
|
} else {
|
|
UpdateState();
|
|
}
|
|
|
|
// clear the hit enemy flag so we catch the next time we hit someone
|
|
aifl.hitEnemy = false;
|
|
|
|
if ( move.fl.allowHiddenMove || !IsHidden() ) {
|
|
// update the animstate if we're not hidden
|
|
UpdateAnimState();
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::OnStateChange
|
|
=====================
|
|
*/
|
|
void idAI::OnStateChange ( int channel ) {
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::OverrideFlag
|
|
=====================
|
|
*/
|
|
void idAI::OverrideFlag ( aiFlagOverride_t flag, bool value ) {
|
|
bool oldValue;
|
|
|
|
switch ( flag ) {
|
|
case AIFLAGOVERRIDE_DISABLEPAIN: oldValue = disablePain; break;
|
|
case AIFLAGOVERRIDE_DAMAGE: oldValue = fl.takedamage; break;
|
|
case AIFLAGOVERRIDE_NOTURN: oldValue = move.fl.noTurn; break;
|
|
case AIFLAGOVERRIDE_NOGRAVITY: oldValue = move.fl.noGravity; break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
if ( oldValue == value ) {
|
|
return;
|
|
}
|
|
|
|
int flagOverride = 1 << (flag * 2);
|
|
int flagOverrideValue = 1 << ((flag * 2) + 1);
|
|
|
|
if ( (flagOverrides & flagOverride) && !!(flagOverrides & flagOverrideValue) == value ) {
|
|
flagOverrides &= ~flagOverride;
|
|
} else {
|
|
if ( oldValue ) {
|
|
flagOverrides |= flagOverrideValue;
|
|
} else {
|
|
flagOverrides &= ~flagOverrideValue;
|
|
}
|
|
flagOverrides |= flagOverride;
|
|
}
|
|
|
|
switch ( flag ) {
|
|
case AIFLAGOVERRIDE_DISABLEPAIN: disablePain = value; break;
|
|
case AIFLAGOVERRIDE_DAMAGE: fl.takedamage = value; break;
|
|
case AIFLAGOVERRIDE_NOTURN: move.fl.noTurn = value; break;
|
|
case AIFLAGOVERRIDE_NOGRAVITY: move.fl.noGravity = value; break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::RestoreFlag
|
|
=====================
|
|
*/
|
|
void idAI::RestoreFlag ( aiFlagOverride_t flag ) {
|
|
int flagOverride = 1 << (flag * 2);
|
|
int flagOverrideValue = 1 << ((flag * 2) + 1);
|
|
bool value;
|
|
|
|
if ( !(flagOverrides&flagOverride) ) {
|
|
return;
|
|
}
|
|
|
|
value = !!(flagOverrides & flagOverrideValue);
|
|
|
|
switch ( flag ) {
|
|
case AIFLAGOVERRIDE_DISABLEPAIN: disablePain = value; break;
|
|
case AIFLAGOVERRIDE_DAMAGE: fl.takedamage = value; break;
|
|
case AIFLAGOVERRIDE_NOTURN: move.fl.noTurn = value; break;
|
|
case AIFLAGOVERRIDE_NOGRAVITY: move.fl.noGravity = value; break;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
|
|
Damage
|
|
|
|
***********************************************************************/
|
|
|
|
/*
|
|
=====================
|
|
idAI::ReactionTo
|
|
=====================
|
|
*/
|
|
int idAI::ReactionTo( const idEntity *ent ) {
|
|
|
|
if ( ent->fl.hidden ) {
|
|
// ignore hidden entities
|
|
return ATTACK_IGNORE;
|
|
}
|
|
|
|
if ( !ent->IsType( idActor::GetClassType() ) ) {
|
|
return ATTACK_IGNORE;
|
|
}
|
|
|
|
if( combat.fl.ignoreEnemies ){
|
|
return ATTACK_IGNORE;
|
|
}
|
|
|
|
const idActor *actor = static_cast<const idActor *>( ent );
|
|
if ( actor->IsType( idPlayer::GetClassType() ) && static_cast<const idPlayer *>(actor)->noclip ) {
|
|
// ignore players in noclip mode
|
|
return ATTACK_IGNORE;
|
|
}
|
|
|
|
// actors on different teams will always fight each other
|
|
if ( actor->team != team ) {
|
|
if ( actor->fl.notarget ) {
|
|
// don't attack on sight when attacker is notargeted
|
|
return ATTACK_ON_DAMAGE; /* | ATTACK_ON_ACTIVATE ; */
|
|
}
|
|
return ATTACK_ON_SIGHT | ATTACK_ON_DAMAGE; /* | ATTACK_ON_ACTIVATE; */
|
|
}
|
|
|
|
//FIXME: temporarily disabled monsters of same rank fighting because it's happening too much.
|
|
// monsters will fight when attacked by lower or equal ranked monsters. rank 0 never fights back.
|
|
//if ( rank && ( actor->rank <= rank ) ) {
|
|
if ( rank && ( actor->rank < rank ) ) {
|
|
return ATTACK_ON_DAMAGE;
|
|
}
|
|
|
|
// don't fight back
|
|
return ATTACK_IGNORE;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::AdjustHealthByDamage
|
|
=====================
|
|
*/
|
|
void idAI::AdjustHealthByDamage ( int damage ) {
|
|
if ( aifl.undying ) {
|
|
return;
|
|
}
|
|
idActor::AdjustHealthByDamage ( damage );
|
|
|
|
if ( g_perfTest_aiUndying.GetBool() && health <= 0 ) {
|
|
//so we still take pain!
|
|
health = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::Pain
|
|
=====================
|
|
*/
|
|
bool idAI::Pain( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
|
|
aifl.pain = idActor::Pain( inflictor, attacker, damage, dir, location );
|
|
aifl.damage = true;
|
|
|
|
// force a blink
|
|
blink_time = 0;
|
|
|
|
// No special handling if friendly fire
|
|
// jshepard: friendly fire will cause pain. Players will only be able to pain buddy marines
|
|
// via splash damage.
|
|
|
|
/*
|
|
if ( attacker && attacker->IsType ( idActor::GetClassType ( ) ) ) {
|
|
if ( static_cast<idActor*>( attacker )->team == team ) {
|
|
return aifl.pain;
|
|
}
|
|
}
|
|
*/
|
|
|
|
// ignore damage from self
|
|
if ( attacker != this ) {
|
|
// React to taking pain
|
|
ReactToPain ( attacker, damage );
|
|
|
|
pain.takenThisFrame += damage;
|
|
pain.lastTakenTime = gameLocal.time;
|
|
combat.tacticalPainTaken += damage;
|
|
|
|
// If taken too much pain where we then skip the current destination
|
|
if ( combat.tacticalPainThreshold && combat.tacticalPainTaken > combat.tacticalPainThreshold ) {
|
|
if (team==AITEAM_STROGG &&
|
|
(combat.tacticalMaskAvailable&AITACTICAL_COVER_BITS) &&
|
|
IsType(rvAITactical::GetClassType()) &&
|
|
ai_allowTacticalRush.GetBool() &&
|
|
spawnArgs.GetBool("rushOnPain", "1")) {
|
|
|
|
// clear any tether
|
|
tether = NULL;
|
|
|
|
// change ranged distances
|
|
combat.attackRange[0] = 0.0f;
|
|
combat.attackRange[1] = 100.0f; // make them get really close
|
|
|
|
// remove cover behavior
|
|
combat.tacticalMaskAvailable &= ~AITACTICAL_COVER_BITS;
|
|
|
|
// add ranged behavior
|
|
combat.tacticalMaskAvailable |= AITACTICAL_RANGED_BITS;
|
|
}
|
|
ForceTacticalUpdate ( );
|
|
return true;
|
|
}
|
|
|
|
// If looping pain and a new paintype comes in we can stop the loop
|
|
if ( pain.loopEndTime && pain.loopType.Icmp ( painType ) ) {
|
|
pain.loopEndTime = 0;
|
|
pain.loopType = painType;
|
|
}
|
|
|
|
ExecScriptFunction( funcs.damage );
|
|
}
|
|
|
|
// If we were hit by our enemy and our enemy isnt visible then
|
|
// force the enemy visiblity to be updated as if we saw him momentarily
|
|
if ( enemy.ent == attacker && !enemy.fl.visible ) {
|
|
UpdateEnemyPosition ( true );
|
|
}
|
|
|
|
return aifl.pain;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::Killed
|
|
=====================
|
|
*/
|
|
void idAI::Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
|
|
idAngles ang;
|
|
const char* modelDeath;
|
|
const idKeyValue* kv;
|
|
|
|
if ( g_debugDamage.GetBool() ) {
|
|
gameLocal.Printf( "Damage: joint: '%s', zone '%s'\n", animator.GetJointName( ( jointHandle_t )location ),
|
|
GetDamageGroup( location ) );
|
|
}
|
|
|
|
if ( aifl.dead ) {
|
|
aifl.pain = true;
|
|
aifl.damage = true;
|
|
return;
|
|
}
|
|
|
|
aifl.dead = true;
|
|
|
|
// turn off my flashlight, if I had one
|
|
ProcessEvent( &AI_Flashlight, false );
|
|
|
|
// Detach from any spawners
|
|
if( GetSpawner() ) {
|
|
GetSpawner()->Detach( this );
|
|
SetSpawner( NULL );
|
|
}
|
|
|
|
// Hide surfaces on death
|
|
for ( kv = spawnArgs.MatchPrefix ( "deathhidesurface", NULL );
|
|
kv;
|
|
kv = spawnArgs.MatchPrefix ( "deathhidesurface", kv ) ) {
|
|
HideSurface ( kv->GetValue() );
|
|
}
|
|
|
|
// stop all voice sounds
|
|
StopSpeaking( true );
|
|
|
|
SetMoveType ( MOVETYPE_DEAD );
|
|
|
|
move.fl.noGravity = false;
|
|
move.fl.allowPushMovables = false;
|
|
aifl.scripted = false;
|
|
|
|
physicsObj.UseFlyMove( false );
|
|
physicsObj.ForceDeltaMove( false );
|
|
|
|
// end our looping ambient sound
|
|
StopSound( SND_CHANNEL_AMBIENT, false );
|
|
|
|
if ( attacker && attacker->IsType( idActor::GetClassType() ) ) {
|
|
gameLocal.AlertAI( ( idActor * )attacker );
|
|
|
|
aiManager.AnnounceKill ( this, attacker, inflictor );
|
|
aiManager.AnnounceDeath ( this, attacker );
|
|
}
|
|
|
|
if ( attacker && attacker->IsType( idActor::GetClassType() ) ) {
|
|
gameLocal.AlertAI( ( idActor * )attacker );
|
|
}
|
|
|
|
// activate targets
|
|
ActivateTargets( this );
|
|
|
|
RemoveAttachments();
|
|
RemoveProjectile();
|
|
StopMove( MOVE_STATUS_DONE );
|
|
|
|
OnDeath();
|
|
CheckDeathObjectives();
|
|
|
|
ClearEnemy();
|
|
|
|
// make monster nonsolid
|
|
physicsObj.SetContents( 0 );
|
|
physicsObj.GetClipModel()->Unlink();
|
|
|
|
Unbind();
|
|
if ( g_perfTest_aiNoRagdoll.GetBool() ) {
|
|
if ( spawnArgs.MatchPrefix( "lipsync_death" ) ) {
|
|
Speak( "lipsync_death", true );
|
|
} else {
|
|
StartSound( "snd_death", SND_CHANNEL_VOICE, 0, false, NULL );
|
|
}
|
|
physicsObj.SetLinearVelocity( vec3_zero );
|
|
physicsObj.PutToRest();
|
|
physicsObj.DisableImpact();
|
|
|
|
} else if( fl.quickBurn ){
|
|
if ( spawnArgs.MatchPrefix( "lipsync_death" ) ) {
|
|
Speak( "lipsync_death", true );
|
|
} else {
|
|
StartSound( "snd_death", SND_CHANNEL_VOICE, 0, false, NULL );
|
|
}
|
|
|
|
physicsObj.SetLinearVelocity( vec3_zero );
|
|
physicsObj.PutToRest();
|
|
physicsObj.DisableImpact();
|
|
|
|
} else {
|
|
if ( StartRagdoll() ) {
|
|
if ( spawnArgs.MatchPrefix( "lipsync_death" ) ) {
|
|
Speak( "lipsync_death", true );
|
|
} else {
|
|
StartSound( "snd_death", SND_CHANNEL_VOICE, 0, false, NULL );
|
|
}
|
|
}
|
|
|
|
if ( spawnArgs.GetString( "model_death", "", &modelDeath ) ) {
|
|
// lost soul is only case that does not use a ragdoll and has a model_death so get the death sound in here
|
|
if ( spawnArgs.MatchPrefix( "lipsync_death" ) ) {
|
|
Speak( "lipsync_death", true );
|
|
} else {
|
|
StartSound( "snd_death", SND_CHANNEL_VOICE, 0, false, NULL );
|
|
}
|
|
renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
|
|
SetModel( modelDeath );
|
|
physicsObj.SetLinearVelocity( vec3_zero );
|
|
physicsObj.PutToRest();
|
|
physicsObj.DisableImpact();
|
|
}
|
|
}
|
|
|
|
SetState ( "State_Killed" );
|
|
|
|
kv = spawnArgs.MatchPrefix( "def_drops", NULL );
|
|
while( kv ) {
|
|
idDict args;
|
|
idEntity *tEnt;
|
|
if( kv->GetValue() != "" ){
|
|
args.Set( "classname", kv->GetValue() );
|
|
args.Set( "origin", physicsObj.GetAbsBounds().GetCenter().ToString() );
|
|
// Let items know that they are of the dropped variety
|
|
args.Set( "dropped", "1" );
|
|
if (gameLocal.SpawnEntityDef( args, &tEnt )) {
|
|
if ( tEnt && tEnt->GetPhysics()) { //tEnt *should* be valid, but hey...
|
|
// magic/arbitrary number to give it some spin. Some constants used to ensure guns rarely fall standing up
|
|
tEnt->GetPhysics()->SetAngularVelocity( idVec3( (gameLocal.random.RandomFloat() * 10.0f) + 20.0f,
|
|
(gameLocal.random.RandomFloat() * 10.0f) + 20.0f,
|
|
(gameLocal.random.RandomFloat() * 10.0f) + 20.0f));
|
|
}
|
|
}
|
|
}
|
|
kv = spawnArgs.MatchPrefix( "def_drops", kv );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
|
|
Targeting/Combat
|
|
|
|
***********************************************************************/
|
|
|
|
/*
|
|
=====================
|
|
idAI::Activate
|
|
|
|
Notifies the script that a monster has been activated by a trigger or flashlight
|
|
=====================
|
|
*/
|
|
void idAI::Activate( idEntity *activator ) {
|
|
idPlayer *player;
|
|
|
|
// Set our tether?
|
|
if ( activator && activator->IsType ( rvAITether::GetClassType ( ) ) ) {
|
|
SetTether ( static_cast<rvAITether*>(activator) );
|
|
}
|
|
|
|
if ( aifl.dead ) {
|
|
// ignore it when they're dead
|
|
return;
|
|
}
|
|
|
|
// make sure he's not dormant
|
|
dormantStart = 0;
|
|
|
|
aifl.activated = true;
|
|
if ( !activator || !activator->IsType( idPlayer::GetClassType() ) ) {
|
|
player = gameLocal.GetLocalPlayer();
|
|
} else {
|
|
player = static_cast<idPlayer *>( activator );
|
|
}
|
|
|
|
if ( ReactionTo( player ) & ATTACK_ON_ACTIVATE ) {
|
|
SetEnemy( player );
|
|
}
|
|
|
|
// If being activated by a spawner we need to attach to it
|
|
if ( activator && activator->IsType ( rvSpawner::GetClassType() ) ) {
|
|
rvSpawner* spawn = static_cast<rvSpawner*>( activator );
|
|
spawn->Attach ( this );
|
|
SetSpawner ( spawn );
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::TalkTo
|
|
=====================
|
|
*/
|
|
void idAI::TalkTo( idActor *actor ) {
|
|
|
|
// jshepard: the dead do not speak.
|
|
if ( aifl.dead )
|
|
return;
|
|
|
|
ExecScriptFunction( funcs.onclick );
|
|
|
|
// Cant talk when already talking
|
|
if ( aifl.action || IsSpeaking ( ) || !aiManager.CheckTeamTimer ( team, AITEAMTIMER_ACTION_TALK ) ) {
|
|
return;
|
|
}
|
|
|
|
|
|
switch ( GetTalkState ( ) ) {
|
|
case TALK_OK:
|
|
if ( talkMessage >= TALKMSG_LOOP ) {
|
|
//MCG: requested change: stop responding after one loop
|
|
return;
|
|
}
|
|
// at least one second between talking to people
|
|
aiManager.SetTeamTimer ( team, AITEAMTIMER_ACTION_TALK, 2000 );
|
|
|
|
talkTarget = actor;
|
|
|
|
// Move to the next talk message
|
|
talkMessage = (talkMessage_t)((int)talkMessage + 1);
|
|
|
|
// Loop until we find a valid talk message
|
|
while ( 1 ) {
|
|
idStr postfix;
|
|
if ( talkMessage >= TALKMSG_LOOP ) {
|
|
postfix = aiTalkMessageString[TALKMSG_LOOP];
|
|
postfix += va("%d", (int)(talkMessage - TALKMSG_LOOP+1) );
|
|
} else {
|
|
postfix = aiTalkMessageString[talkMessage];
|
|
}
|
|
// Try the lipsync for the specific passive prefix first
|
|
if ( Speak ( va("lipsync_%stalk_%s", passive.prefix.c_str(), postfix.c_str() ) ) ) {
|
|
break;
|
|
}
|
|
// Try the generic lipsync for the current talk message
|
|
if ( Speak ( va("lipsync_talk_%s", postfix.c_str() ) ) ) {
|
|
break;
|
|
}
|
|
// If the first loop failed then there is no other options
|
|
if ( talkMessage == TALKMSG_LOOP ) {
|
|
return;
|
|
} else if ( talkMessage >= TALKMSG_LOOP ) {
|
|
talkMessage = TALKMSG_LOOP;
|
|
} else {
|
|
talkMessage = (talkMessage_t)((int)talkMessage + 1);
|
|
}
|
|
}
|
|
|
|
// Start talking anim if we have one
|
|
if ( IsSpeaking ( ) ) {
|
|
passive.talkTime = speakTime;
|
|
}
|
|
|
|
break;
|
|
|
|
case TALK_FOLLOW:
|
|
if ( actor == leader ) {
|
|
leader = NULL;
|
|
Speak ( "lipsync_stopfollow", true );
|
|
} else {
|
|
leader = actor;
|
|
Speak ( "lipsync_follow", true );
|
|
}
|
|
break;
|
|
|
|
case TALK_BUSY:
|
|
if ( talkBusyCount > 3 )
|
|
{//only say a max of 4 lines
|
|
return;
|
|
}
|
|
talkBusyCount++;
|
|
//try to say this variant - if we can't, stop forever
|
|
if ( !Speak ( va("lipsync_busy_%d",talkBusyCount) ) )
|
|
{//nevermore
|
|
talkBusyCount = 999;
|
|
}
|
|
break;
|
|
|
|
case TALK_WAIT:
|
|
//do nothing
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::GetTalkState
|
|
=====================
|
|
*/
|
|
talkState_t idAI::GetTalkState( void ) const {
|
|
if ( ( talkState != TALK_NEVER ) && aifl.dead ) {
|
|
return TALK_DEAD;
|
|
}
|
|
if ( IsHidden() ) {
|
|
return TALK_NEVER;
|
|
}
|
|
if ( (talkState == TALK_OK || talkState == TALK_FOLLOW) && aifl.scripted ) {
|
|
return TALK_BUSY;
|
|
}
|
|
return talkState;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::TouchedByFlashlight
|
|
=====================
|
|
*/
|
|
void idAI::TouchedByFlashlight( idActor *flashlight_owner ) {
|
|
if ( RespondToFlashlight() ) {
|
|
Activate( flashlight_owner );
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::ClearEnemy
|
|
=====================
|
|
*/
|
|
void idAI::ClearEnemy( bool dead ) {
|
|
// Dont bother if we dont have an enemy
|
|
if ( !enemy.ent ) {
|
|
return;
|
|
}
|
|
|
|
if ( move.moveCommand == MOVE_TO_ENEMY ) {
|
|
StopMove( MOVE_STATUS_DEST_NOT_FOUND );
|
|
} else if ( !aifl.scripted
|
|
&& move.moveCommand == MOVE_TO_COVER
|
|
&& !move.fl.done
|
|
&& aasSensor->Reserved()
|
|
&& !IsBehindCover() ) {
|
|
//clear cover and stop move
|
|
aasSensor->Reserve( NULL );
|
|
combat.coverValidTime = 0;
|
|
OnCoverInvalidated();
|
|
ForceTacticalUpdate();
|
|
StopMove( MOVE_STATUS_DONE );
|
|
}
|
|
|
|
enemyNode.Remove();
|
|
enemy.ent = NULL;
|
|
enemy.fl.dead = dead;
|
|
combat.fl.seenEnemyDirectly = false;
|
|
|
|
UpdateHelper ( );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::UpdateEnemyPosition
|
|
=====================
|
|
*/
|
|
void idAI::UpdateEnemyPosition ( bool forceUpdate ) {
|
|
if( !enemy.ent || (!enemy.fl.visible && !forceUpdate) ) {
|
|
return;
|
|
}
|
|
|
|
idActor* enemyActor = dynamic_cast<idActor*>(enemy.ent.GetEntity());
|
|
idEntity* enemyEnt = static_cast<idEntity*>(enemy.ent.GetEntity());
|
|
|
|
enemy.lastVisibleFromEyePosition = GetEyePosition ( );
|
|
|
|
// Update the enemy origin if it isnt locked
|
|
if ( !enemy.fl.lockOrigin ) {
|
|
enemy.lastKnownPosition = enemyEnt->GetPhysics()->GetOrigin();
|
|
|
|
if ( enemyActor ) {
|
|
enemy.lastVisibleEyePosition = enemyActor->GetEyePosition();
|
|
enemy.lastVisibleChestPosition = enemyActor->GetChestPosition();
|
|
} else {
|
|
enemy.lastVisibleEyePosition = enemy.ent->GetPhysics()->GetOrigin ( );
|
|
enemy.lastVisibleChestPosition = enemy.ent->GetPhysics()->GetOrigin ( );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::UpdateEnemy
|
|
=====================
|
|
*/
|
|
void idAI::UpdateEnemy ( void ) {
|
|
predictedPath_t predictedPath;
|
|
|
|
// If we lost our enemy then clear it out to be sure
|
|
if( !enemy.ent ) {
|
|
return;
|
|
}
|
|
|
|
// Rest to not being in fov
|
|
enemy.fl.inFov = false;
|
|
|
|
// Bail out if we arent queued to do a complex think
|
|
if ( aifl.simpleThink ) {
|
|
// Keep the fov flag up to date
|
|
if ( IsEnemyVisible ( ) ) {
|
|
enemy.fl.inFov = CheckFOV( enemy.lastKnownPosition );
|
|
}
|
|
} else {
|
|
bool oldVisible;
|
|
|
|
// Cache current enemy visiblity so we can see if it changes
|
|
oldVisible = IsEnemyVisible ( );
|
|
|
|
// See if enemy still visible
|
|
UpdateEnemyVisibility ( );
|
|
|
|
// If our enemy isnt visible but is within aware range then we know where he is
|
|
if ( !IsEnemyVisible ( ) && DistanceTo ( enemy.ent ) < combat.awareRange ) {
|
|
UpdateEnemyPosition( true );
|
|
} else {
|
|
/*
|
|
// check if we heard any sounds in the last frame
|
|
if ( enemyEnt == gameLocal.GetAlertActor() ) {
|
|
float dist = ( enemyEnt->GetPhysics()->GetOrigin() - physicsObj.GetOrigin() ).LengthSqr();
|
|
if ( dist < Square( combat.earRange ) ) {
|
|
SetEnemyPosition();
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
// Update fov
|
|
enemy.fl.inFov = CheckFOV( enemy.lastKnownPosition );
|
|
|
|
// Set enemy.visibleTime to the time when the visibility flag changed
|
|
if ( oldVisible != IsEnemyVisible ( ) ) {
|
|
// Just caught sight of the enemy after loosing him, delay the attack actions a bit
|
|
if ( !oldVisible && combat.attackSightDelay ) {
|
|
float delay;
|
|
if ( enemy.lastVisibleChangeTime ) {
|
|
// The longer the enemy has not been visible, the more we should delay
|
|
delay = idMath::ClampFloat ( 0.0f, 1.0f, (gameLocal.time - enemy.lastVisibleChangeTime) / AI_SIGHTDELAYSCALE );
|
|
} else {
|
|
// The enemy has never been visible so delay the full amount
|
|
delay = 1.0f;
|
|
}
|
|
// Add to the ranged attack timer providing its not already running a timer
|
|
if ( actionTimerRangedAttack.IsDone ( actionTime) ) {
|
|
actionTimerRangedAttack.Clear ( actionTime );
|
|
actionTimerRangedAttack.Add ( combat.attackSightDelay * delay, 0.5f );
|
|
}
|
|
// Add to the special attack timer providing its not already running a timer
|
|
if ( actionTimerSpecialAttack.IsDone ( actionTime ) ) {
|
|
actionTimerSpecialAttack.Clear ( actionTime );
|
|
actionTimerSpecialAttack.Add ( combat.attackSightDelay * delay, 0.5f );
|
|
}
|
|
}
|
|
|
|
enemy.lastVisibleChangeTime = gameLocal.time;
|
|
}
|
|
|
|
// Handler for visibility change
|
|
if ( oldVisible != IsEnemyVisible ( ) ) {
|
|
OnEnemyVisiblityChange ( oldVisible );
|
|
}
|
|
}
|
|
|
|
// Adjust smoothed linear and pushed velocities for enemies
|
|
if ( enemy.fl.visible ) {
|
|
enemy.smoothedLinearVelocity += ((enemy.ent->GetPhysics()->GetLinearVelocity ( ) - enemy.ent->GetPhysics()->GetPushedLinearVelocity ( ) - enemy.smoothedLinearVelocity) * enemy.smoothVelocityRate );
|
|
enemy.smoothedPushedVelocity += ((enemy.ent->GetPhysics()->GetPushedLinearVelocity ( ) - enemy.smoothedPushedVelocity) * enemy.smoothVelocityRate );
|
|
} else {
|
|
enemy.smoothedLinearVelocity -= (enemy.smoothedLinearVelocity * enemy.smoothVelocityRate );
|
|
enemy.smoothedPushedVelocity -= (enemy.smoothedPushedVelocity * enemy.smoothVelocityRate );
|
|
}
|
|
|
|
// Update enemy range
|
|
enemy.range = DistanceTo ( enemy.lastKnownPosition );
|
|
enemy.range2d = DistanceTo2d ( enemy.lastKnownPosition );
|
|
|
|
// Calulcate the aggression scale
|
|
// Skill level 0: (1.0)
|
|
// Skill level 1: (1.0 - 1.25)
|
|
// Skill level 2: (1.0 - 1.5)
|
|
// Skill level 3: (1.0 - 1.75)
|
|
if ( combat.aggressiveRange > 0.0f ) {
|
|
combat.aggressiveScale = (g_skill.GetFloat() / MAX_SKILL_LEVELS);
|
|
combat.aggressiveScale *= 1.0f - idMath::ClampFloat ( 0.0f, 1.0f, enemy.range / combat.aggressiveRange );
|
|
combat.aggressiveScale += 1.0f;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::LastKnownPosition
|
|
=====================
|
|
*/
|
|
const idVec3& idAI::LastKnownPosition ( const idEntity *ent ) {
|
|
return (ent==enemy.ent)?(enemy.lastKnownPosition):(ent->GetPhysics()->GetOrigin());
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::UpdateEnemyVisibility
|
|
|
|
Update whether or not the AI can see its enemy or not and determine how.
|
|
=====================
|
|
*/
|
|
void idAI::UpdateEnemyVisibility ( void ) {
|
|
enemy.fl.visible = false;
|
|
|
|
// No enemy so nothing to see
|
|
if ( !enemy.ent ) {
|
|
return;
|
|
}
|
|
|
|
// Update enemy visibility flag
|
|
enemy.fl.visible = CanSeeFrom ( GetEyePosition ( ), enemy.ent, false );
|
|
|
|
// IF the enemy isnt visible and not forcing an update we can just early out
|
|
if ( !enemy.fl.visible ) {
|
|
return;
|
|
}
|
|
|
|
// If we are seeing our enemy for the first time after changing enemies, call him out
|
|
if ( enemy.lastVisibleTime < enemy.changeTime ) {
|
|
AnnounceNewEnemy( );
|
|
}
|
|
|
|
combat.fl.seenEnemyDirectly = true;
|
|
enemy.lastVisibleTime = gameLocal.time;
|
|
|
|
// Update our known locations of the enemy since we just saw him
|
|
UpdateEnemyPosition ( );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::SetSpawner
|
|
=====================
|
|
*/
|
|
void idAI::SetSpawner ( rvSpawner* _spawner ) {
|
|
spawner = _spawner;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::SetSpawner
|
|
=====================
|
|
*/
|
|
rvSpawner* idAI::GetSpawner ( void ) {
|
|
return spawner;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::SetEnemy
|
|
=====================
|
|
*/
|
|
bool idAI::SetEnemy( idEntity *newEnemy ) {
|
|
idEntity* oldEnemy;
|
|
|
|
// Look for obvious early out
|
|
if ( enemy.ent == newEnemy ) {
|
|
return true;
|
|
}
|
|
|
|
// Cant set enemy if dead
|
|
if ( aifl.dead ) {
|
|
ClearEnemy ( false );
|
|
return false;
|
|
}
|
|
|
|
// Cant set enemy if the enemy is dead or has no target set
|
|
if ( newEnemy ) {
|
|
if ( newEnemy->health <= 0 || newEnemy->fl.notarget ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
oldEnemy = enemy.ent;
|
|
enemy.fl.dead = false;
|
|
enemy.fl.lockOrigin = false;
|
|
|
|
if ( !newEnemy ) {
|
|
ClearEnemy ( false );
|
|
} else {
|
|
// Set our current enemy
|
|
enemy.ent = newEnemy;
|
|
|
|
// If the enemy is an actor then add to the actors enemy list
|
|
if( newEnemy->IsType( idActor::GetClassType() ) ){
|
|
idActor* enemyActor = static_cast<idActor*>( newEnemy );
|
|
enemyNode.AddToEnd( enemyActor->enemyList );
|
|
}
|
|
}
|
|
|
|
// Allow custom handling of enemy change
|
|
if ( enemy.ent != oldEnemy ) {
|
|
OnEnemyChange ( oldEnemy );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
===================
|
|
idAI::CalculateAttackOffsets
|
|
|
|
calculate joint positions on attack frames so we can do proper "can hit" tests
|
|
===================
|
|
*/
|
|
void idAI::CalculateAttackOffsets ( void ) {
|
|
const idDeclModelDef* modelDef;
|
|
int num;
|
|
int i;
|
|
int frame;
|
|
const frameCommand_t* command;
|
|
idMat3 axis;
|
|
const idAnim* anim;
|
|
jointHandle_t joint;
|
|
|
|
modelDef = animator.ModelDef();
|
|
if ( !modelDef ) {
|
|
return;
|
|
}
|
|
num = modelDef->NumAnims();
|
|
|
|
// needs to be off while getting the offsets so that we account for the distance the monster moves in the attack anim
|
|
animator.RemoveOriginOffset( false );
|
|
|
|
// anim number 0 is reserved for non-existant anims. to avoid off by one issues, just allocate an extra spot for
|
|
// launch offsets so that anim number can be used without subtracting 1.
|
|
attackAnimInfo.SetGranularity( 1 );
|
|
attackAnimInfo.SetNum( num + 1 );
|
|
attackAnimInfo[ 0 ].attackOffset.Zero();
|
|
attackAnimInfo[ 0 ].eyeOffset.Zero();
|
|
|
|
for( i = 1; i <= num; i++ ) {
|
|
attackAnimInfo[ i ].attackOffset.Zero();
|
|
attackAnimInfo[ i ].eyeOffset.Zero();
|
|
anim = modelDef->GetAnim( i );
|
|
if ( !anim ) {
|
|
continue;
|
|
}
|
|
|
|
frame = anim->FindFrameForFrameCommand( FC_AI_ATTACK, &command );
|
|
if ( frame >= 0 ) {
|
|
joint = animator.GetJointHandle( command->joint->c_str() );
|
|
if ( joint == INVALID_JOINT ) {
|
|
gameLocal.Error( "Invalid joint '%s' on 'ai_attack' frame command on frame %d of model '%s'", command->joint->c_str(), frame, modelDef->GetName() );
|
|
}
|
|
GetJointTransformForAnim( joint, i, FRAME2MS( frame ), attackAnimInfo[ i ].attackOffset, axis );
|
|
|
|
if ( chestOffsetJoint!= INVALID_JOINT ) {
|
|
GetJointTransformForAnim( chestOffsetJoint, i, FRAME2MS( frame ), attackAnimInfo[ i ].eyeOffset, axis );
|
|
}
|
|
}
|
|
}
|
|
|
|
animator.RemoveOriginOffset( true );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::CreateProjectileClipModel
|
|
=====================
|
|
*/
|
|
void idAI::CreateProjectileClipModel( void ) const {
|
|
if ( projectileClipModel == NULL ) {
|
|
idBounds projectileBounds( vec3_origin );
|
|
projectileBounds.ExpandSelf( 2.0f ); // projectileRadius );
|
|
projectileClipModel = new idClipModel( idTraceModel( projectileBounds ) );
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::GetPredictedAimDirOffset
|
|
=====================
|
|
*/
|
|
void idAI::GetPredictedAimDirOffset ( const idVec3& source, const idVec3& target, float projectileSpeed, const idVec3& targetVelocity, idVec3& offset ) const {
|
|
float a;
|
|
float b;
|
|
float c;
|
|
float d;
|
|
float t;
|
|
idVec3 r;
|
|
|
|
// Make sure there is something to predict
|
|
if ( targetVelocity.LengthSqr ( ) == 0.0f ) {
|
|
offset.Zero ( );
|
|
return;
|
|
}
|
|
|
|
// Solve for (t): magnitude(targetVelocity * t + target - source) = projectileSpeed * t
|
|
|
|
r = (target-source);
|
|
a = (targetVelocity * targetVelocity) - Square(projectileSpeed);
|
|
b = (targetVelocity * 2.0f) * r;
|
|
c = r*r;
|
|
d = b*b - 4*a*c;
|
|
t = 0.0f;
|
|
|
|
if ( d >= 0.0f ) {
|
|
float t1;
|
|
float t2;
|
|
float denom;
|
|
d = idMath::Sqrt(d);
|
|
denom = 1.0f / (2.0f * a);
|
|
t1 = (-b + d) * denom;
|
|
t2 = (-b - d) * denom;
|
|
if ( t1 < 0.0f && t2 < 0.0f ) {
|
|
t = 0.0f;
|
|
} else if ( t1 < 0.0f ) {
|
|
t = t2;
|
|
} else if ( t2 < 0.0f ) {
|
|
t = t1;
|
|
} else {
|
|
t = Min(t1,t2);
|
|
}
|
|
}
|
|
|
|
offset = targetVelocity * t;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::GetAimDir
|
|
=====================
|
|
*/
|
|
bool idAI::GetAimDir(
|
|
const idVec3& firePos,
|
|
const idEntity* target,
|
|
const idDict* projectileDef,
|
|
idEntity* ignore,
|
|
idVec3& aimDir,
|
|
float aimOffset,
|
|
float predict
|
|
) const
|
|
{
|
|
idVec3 targetPos1;
|
|
idVec3 targetPos2;
|
|
idVec3 targetLinearVel;
|
|
idVec3 targetPushedVel;
|
|
idVec3 delta;
|
|
float max_height;
|
|
bool result;
|
|
idEntity* targetEnt = const_cast<idEntity*>(target);
|
|
|
|
// if no aimAtEnt or projectile set
|
|
if ( !targetEnt ) {
|
|
aimDir = viewAxis[ 0 ] * physicsObj.GetGravityAxis();
|
|
return false;
|
|
}
|
|
|
|
float projectileSpeed = idProjectile::GetVelocity ( projectileDef ).LengthFast ( );
|
|
idVec3 projectileGravity = idProjectile::GetGravity ( projectileDef );
|
|
|
|
if ( projectileClipModel == NULL ) {
|
|
CreateProjectileClipModel();
|
|
}
|
|
|
|
if ( targetEnt == enemy.ent ) {
|
|
targetPos2 = enemy.lastVisibleEyePosition;
|
|
targetPos1 = enemy.lastVisibleChestPosition;
|
|
targetPushedVel = enemy.smoothedPushedVelocity;
|
|
targetLinearVel = enemy.smoothedLinearVelocity;
|
|
} else if ( targetEnt->IsType( idActor::GetClassType() ) ) {
|
|
targetPos2 = static_cast<idActor*>(targetEnt)->GetEyePosition ( );
|
|
targetPos1 = static_cast<idActor*>(targetEnt)->GetChestPosition ( );
|
|
targetPushedVel = target->GetPhysics()->GetPushedLinearVelocity ( );
|
|
targetLinearVel = (target->GetPhysics()->GetLinearVelocity ( ) - targetPushedVel);
|
|
} else {
|
|
targetPos1 = targetEnt->GetPhysics()->GetAbsBounds().GetCenter();
|
|
targetPos2 = targetPos1;
|
|
targetPushedVel.Zero ( );
|
|
targetLinearVel.Zero ( );
|
|
}
|
|
|
|
// Target prediction
|
|
if ( projectileSpeed == 0.0f ) {
|
|
// Hitscan prediction actually causes the hitscan to miss unless it is predicted.
|
|
delta = (targetLinearVel * (-1.0f + predict));
|
|
} else {
|
|
// Projectile prediction must figure out how far to lead the shot to hit the target
|
|
GetPredictedAimDirOffset ( firePos, targetPos1, projectileSpeed, (targetLinearVel*predict)+targetPushedVel, delta );
|
|
}
|
|
targetPos1 += delta;
|
|
targetPos2 += delta;
|
|
|
|
result = false;
|
|
|
|
// try aiming for chest
|
|
delta = targetPos1 - firePos;
|
|
max_height = (delta.NormalizeFast ( ) + aimOffset) * projectile_height_to_distance_ratio;
|
|
if ( max_height > 0.0f ) {
|
|
result = PredictTrajectory( firePos, targetPos1 + delta * aimOffset, projectileSpeed, projectileGravity, projectileClipModel, MASK_SHOT_RENDERMODEL, max_height, ignore, targetEnt, ai_debugTrajectory.GetBool() ? 1000 : 0, aimDir );
|
|
if ( result || !targetEnt->IsType( idActor::GetClassType() ) ) {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// try aiming for head
|
|
delta = targetPos2 - firePos;
|
|
max_height = (delta.NormalizeFast ( ) + aimOffset) * projectile_height_to_distance_ratio;
|
|
if ( max_height > 0.0f ) {
|
|
result = PredictTrajectory( firePos, targetPos2 + delta * aimOffset, projectileSpeed, projectileGravity, projectileClipModel, MASK_SHOT_RENDERMODEL, max_height, ignore, targetEnt, ai_debugTrajectory.GetBool() ? 1000 : 0, aimDir );
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::CreateProjectile
|
|
=====================
|
|
*/
|
|
idProjectile *idAI::CreateProjectile ( const idDict* projectileDict, const idVec3 &pos, const idVec3 &dir ) {
|
|
idEntity* ent;
|
|
const char* clsname;
|
|
|
|
if ( !projectile.GetEntity() ) {
|
|
gameLocal.SpawnEntityDef( *projectileDict, &ent, false );
|
|
if ( !ent ) {
|
|
clsname = projectileDict->GetString( "classname" );
|
|
gameLocal.Error( "Could not spawn entityDef '%s'", clsname );
|
|
}
|
|
|
|
if ( !ent->IsType( idProjectile::GetClassType() ) ) {
|
|
clsname = ent->GetClassname();
|
|
gameLocal.Error( "'%s' is not an idProjectile", clsname );
|
|
}
|
|
projectile = (idProjectile*)ent;
|
|
}
|
|
|
|
projectile.GetEntity()->Create( this, pos, dir );
|
|
|
|
return projectile.GetEntity();
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::RemoveProjectile
|
|
=====================
|
|
*/
|
|
void idAI::RemoveProjectile( void ) {
|
|
if ( projectile.GetEntity() ) {
|
|
projectile.GetEntity()->PostEventMS( &EV_Remove, 0 );
|
|
projectile = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::Attack
|
|
=====================
|
|
*/
|
|
bool idAI::Attack ( const char* attackName, jointHandle_t joint, idEntity* target, const idVec3& pushVelocity ) {
|
|
// Get the attack dictionary
|
|
const idDict* attackDict;
|
|
attackDict = gameLocal.FindEntityDefDict ( spawnArgs.GetString ( va("def_attack_%s", attackName ) ), false );
|
|
if ( !attackDict ) {
|
|
gameLocal.Error ( "could not find attack entityDef 'def_attack_%s (%s)' on AI entity %s", attackName, spawnArgs.GetString ( va("def_attack_%s", attackName ) ), GetName ( ) );
|
|
}
|
|
|
|
// Melee Attack?
|
|
if ( spawnArgs.GetBool ( va("attack_%s_melee", attackName ), "0" ) ) {
|
|
return AttackMelee ( attackName, attackDict );
|
|
}
|
|
|
|
// Ranged attack (hitscan or projectile)?
|
|
return ( AttackRanged ( attackName, attackDict, joint, target, pushVelocity ) != NULL );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::AttackRanged
|
|
=====================
|
|
*/
|
|
idProjectile* idAI::AttackRanged (
|
|
const char* attackName,
|
|
const idDict* attackDict,
|
|
jointHandle_t joint,
|
|
idEntity* target,
|
|
const idVec3& pushVelocity
|
|
)
|
|
{
|
|
float attack_accuracy;
|
|
float attack_cone;
|
|
float attack_spread;
|
|
int attack_count;
|
|
bool attack_hitscan;
|
|
float attack_predict;
|
|
float attack_pullback;
|
|
int i;
|
|
idVec3 muzzleOrigin;
|
|
idMat3 muzzleAxis;
|
|
idVec3 dir;
|
|
idAngles ang;
|
|
idMat3 axis;
|
|
idProjectile* lastProjectile;
|
|
|
|
lastProjectile = NULL;
|
|
|
|
// Generic attack properties
|
|
attack_accuracy = spawnArgs.GetFloat ( va("attack_%s_accuracy", attackName ), "7" );
|
|
attack_cone = spawnArgs.GetFloat ( va("attack_%s_cone", attackName ), "75" );
|
|
attack_spread = DEG2RAD ( spawnArgs.GetFloat ( va("attack_%s_spread", attackName ), "0" ) );
|
|
attack_count = spawnArgs.GetInt ( va("attack_%s_count", attackName ), "1" );
|
|
attack_hitscan = spawnArgs.GetBool ( va("attack_%s_hitscan", attackName ), "0" );
|
|
attack_predict = spawnArgs.GetFloat ( va("attack_%s_predict", attackName ), "0" );
|
|
attack_pullback = spawnArgs.GetFloat ( va("attack_%s_pullback", attackName ), "0" );
|
|
|
|
// Get the muzzle origin and axis from the given launch joint
|
|
GetMuzzle( joint, muzzleOrigin, muzzleAxis );
|
|
if ( attack_pullback )
|
|
{
|
|
muzzleOrigin -= muzzleAxis[0]*attack_pullback;
|
|
}
|
|
|
|
// set aiming direction
|
|
bool calcAim = true;
|
|
if ( GetEnemy() && GetEnemy() == target && GetEnemy() == gameLocal.GetLocalPlayer() && spawnArgs.GetBool( va("attack_%s_missFirstShot",attackName) ) ) {
|
|
//purposely miss
|
|
if ( gameLocal.random.RandomFloat() < 0.5f ) {
|
|
//actually, hit anyway...
|
|
} else {
|
|
idVec3 targetPos = enemy.lastVisibleEyePosition;
|
|
idVec3 eFacing;
|
|
idVec3 left, up;
|
|
|
|
up.Set( 0, 0, 1 );
|
|
left = viewAxis[0].Cross(up);
|
|
|
|
if ( GetEnemy()->IsType( idActor::GetClassType() ) )
|
|
{
|
|
eFacing = ((idActor*)GetEnemy())->viewAxis[0];
|
|
}
|
|
else
|
|
{
|
|
eFacing = GetEnemy()->GetPhysics()->GetAxis()[0];
|
|
}
|
|
if ( left*eFacing > 0 )
|
|
{
|
|
targetPos += left * ((gameLocal.random.RandomFloat()*8.0f) + 8.0f);
|
|
}
|
|
else
|
|
{
|
|
targetPos -= left * ((gameLocal.random.RandomFloat()*8.0f) + 8.0f);
|
|
}
|
|
dir = targetPos-muzzleOrigin;
|
|
dir.Normalize();
|
|
attack_accuracy = 0;
|
|
|
|
calcAim = false;
|
|
//don't miss next time
|
|
spawnArgs.SetBool( va("attack_%s_missFirstShot",attackName), false );
|
|
}
|
|
}
|
|
if ( calcAim ) {
|
|
if ( target && !spawnArgs.GetBool ( va("attack_%s_lockToJoint",attackName), "0" ) ) {
|
|
GetAimDir( muzzleOrigin, target, attackDict, this, dir,
|
|
spawnArgs.GetFloat ( va("attack_%s_aimoffset", attackName )),
|
|
attack_predict );
|
|
} else {
|
|
dir = muzzleAxis[0];
|
|
if ( spawnArgs.GetBool ( va("attack_%s_lockToJoint",attackName), "0" ) )
|
|
{
|
|
if ( spawnArgs.GetBool( va("attack_%s_traceToNextJoint", attackName ), "0" ) )
|
|
{
|
|
jointHandle_t endJoint = animator.GetFirstChild( joint );
|
|
if ( endJoint != INVALID_JOINT && endJoint != joint )
|
|
{
|
|
idVec3 endJointPos;
|
|
idMat3 blah;
|
|
GetJointWorldTransform( endJoint, gameLocal.GetTime(), endJointPos, blah );
|
|
dir = endJointPos-muzzleOrigin;
|
|
//ARGHH: need to be able to set range!!!
|
|
//const_cast<idDict*>(attackDict)->SetFloat( "range", dir.Normalize() );//NOTE: yes, I intentionally normalize here as well as use the result for length...
|
|
dir.Normalize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// random accuracy
|
|
ang = dir.ToAngles();
|
|
ang.pitch += gameLocal.random.CRandomFloat ( ) * attack_accuracy;
|
|
ang.yaw += gameLocal.random.CRandomFloat ( ) * attack_accuracy;
|
|
|
|
// Lock attacks to a cone?
|
|
if ( attack_cone ) {
|
|
float diff;
|
|
// clamp the attack direction to be within monster's attack cone so he doesn't do
|
|
// things like throw the missile backwards if you're behind him
|
|
diff = idMath::AngleDelta( ang.yaw, move.current_yaw );
|
|
if ( diff > attack_cone ) {
|
|
ang.yaw = move.current_yaw + attack_cone;
|
|
} else if ( diff < -attack_cone ) {
|
|
ang.yaw = move.current_yaw - attack_cone;
|
|
}
|
|
}
|
|
|
|
ang.Normalize360 ( );
|
|
axis = ang.ToMat3();
|
|
|
|
for( i = 0; i < attack_count; i++ ) {
|
|
float angle;
|
|
float spin;
|
|
|
|
// spread the projectiles out
|
|
angle = idMath::Sin( attack_spread * gameLocal.random.RandomFloat() );
|
|
spin = (float)DEG2RAD( 360.0f ) * gameLocal.random.RandomFloat();
|
|
dir = axis[ 0 ] + axis[ 2 ] * ( angle * idMath::Sin( spin ) ) - axis[ 1 ] * ( angle * idMath::Cos( spin ) );
|
|
dir.Normalize();
|
|
|
|
if ( attack_hitscan ) {
|
|
gameLocal.HitScan( *attackDict, muzzleOrigin, dir, muzzleOrigin, this, false, combat.aggressiveScale );
|
|
} else {
|
|
// launch the projectile
|
|
if ( !projectile.GetEntity() ) {
|
|
CreateProjectile( attackDict, muzzleOrigin, dir );
|
|
}
|
|
lastProjectile = projectile.GetEntity();
|
|
lastProjectile->Launch( muzzleOrigin, dir, pushVelocity, 0.0f, combat.aggressiveScale );
|
|
|
|
// Let the script manage projectiles if need be
|
|
ExecScriptFunction ( funcs.launch_projectile, lastProjectile );
|
|
|
|
projectile = NULL;
|
|
}
|
|
}
|
|
|
|
lastAttackTime = gameLocal.time;
|
|
|
|
// If shooting at another ai entity then kick off an attack reaction
|
|
if ( enemy.ent && enemy.ent->IsType ( idAI::GetClassType() ) ) {
|
|
static_cast<idAI*>(enemy.ent.GetEntity())->ReactToShotAt ( this, muzzleOrigin, axis[0] );
|
|
}
|
|
|
|
return lastProjectile;
|
|
}
|
|
|
|
/*s
|
|
================
|
|
idAI::DamageFeedback
|
|
|
|
callback function for when another entity recieved damage from this entity
|
|
================
|
|
*/
|
|
void idAI::DamageFeedback( idEntity *victim, idEntity *inflictor, int &damage ) {
|
|
if ( ( victim == this ) && inflictor->IsType( idProjectile::GetClassType() ) ) {
|
|
// monsters only get half damage from their own projectiles
|
|
damage = ( damage + 1 ) / 2; // round up so we don't do 0 damage
|
|
} else if ( victim == enemy.ent ) {
|
|
aifl.hitEnemy = true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::DirectDamage
|
|
|
|
Causes direct damage to an entity
|
|
|
|
kickDir is specified in the monster's coordinate system, and gives the direction
|
|
that the view kick and knockback should go
|
|
=====================
|
|
*/
|
|
void idAI::DirectDamage( const char *meleeDefName, idEntity *ent ) {
|
|
const idDict *meleeDef;
|
|
const char *p;
|
|
const idSoundShader *shader;
|
|
|
|
meleeDef = gameLocal.FindEntityDefDict( meleeDefName, false );
|
|
if ( !meleeDef ) {
|
|
gameLocal.Error( "Unknown damage def '%s' on '%s'", meleeDefName, name.c_str() );
|
|
}
|
|
|
|
if ( !ent->fl.takedamage ) {
|
|
const idSoundShader *shader = declManager->FindSound(meleeDef->GetString( "snd_miss" ));
|
|
StartSoundShader( shader, SND_CHANNEL_DAMAGE, 0, false, NULL );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// do the damage
|
|
//
|
|
p = meleeDef->GetString( "snd_hit" );
|
|
if ( p && *p ) {
|
|
shader = declManager->FindSound( p );
|
|
StartSoundShader( shader, SND_CHANNEL_DAMAGE, 0, false, NULL );
|
|
}
|
|
|
|
idVec3 kickDir;
|
|
meleeDef->GetVector( "kickDir", "0 0 0", kickDir );
|
|
|
|
idVec3 globalKickDir;
|
|
globalKickDir = ( viewAxis * physicsObj.GetGravityAxis() ) * kickDir;
|
|
|
|
// ent->Damage( this, this, globalKickDir, meleeDefName, 1.0f, INVALID_JOINT );
|
|
float damageScale = spawnArgs.GetFloat( "damageScale", "1" );
|
|
ent->Damage( this, this, globalKickDir, meleeDefName, damageScale, NULL );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::TestMelee
|
|
=====================
|
|
*/
|
|
bool idAI::TestMelee( void ) const {
|
|
trace_t trace;
|
|
idEntity* enemyEnt = enemy.ent;
|
|
|
|
if ( !enemyEnt || !combat.meleeRange ) {
|
|
return false;
|
|
}
|
|
|
|
//FIXME: make work with gravity vector
|
|
idVec3 org = physicsObj.GetOrigin();
|
|
const idBounds &myBounds = physicsObj.GetBounds();
|
|
idBounds bounds;
|
|
|
|
// expand the bounds out by our melee range
|
|
bounds[0][0] = -combat.meleeRange;
|
|
bounds[0][1] = -combat.meleeRange;
|
|
bounds[0][2] = myBounds[0][2] - 4.0f;
|
|
bounds[1][0] = combat.meleeRange;
|
|
bounds[1][1] = combat.meleeRange;
|
|
bounds[1][2] = myBounds[1][2] + 4.0f;
|
|
bounds.TranslateSelf( org );
|
|
|
|
idVec3 enemyOrg = enemyEnt->GetPhysics()->GetOrigin();
|
|
idBounds enemyBounds = enemyEnt->GetPhysics()->GetBounds();
|
|
enemyBounds.TranslateSelf( enemyOrg );
|
|
|
|
if ( DebugFilter(ai_debugMove) ) { //YELLOW = Test Melee Bounds
|
|
gameRenderWorld->DebugBounds( colorYellow, bounds, vec3_zero, gameLocal.msec );
|
|
}
|
|
|
|
if ( !bounds.IntersectsBounds( enemyBounds ) ) {
|
|
return false;
|
|
}
|
|
|
|
idVec3 start = GetEyePosition();
|
|
idVec3 end = enemyEnt->GetEyePosition();
|
|
|
|
gameLocal.TracePoint( this, trace, start, end, MASK_SHOT_BOUNDINGBOX, this );
|
|
if ( ( trace.fraction == 1.0f ) || ( gameLocal.GetTraceEntity( trace ) == enemyEnt ) ) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::AttackMelee
|
|
|
|
jointname allows the endpoint to be exactly specified in the model,
|
|
as for the commando tentacle. If not specified, it will be set to
|
|
the facing direction + combat.meleeRange.
|
|
|
|
kickDir is specified in the monster's coordinate system, and gives the direction
|
|
that the view kick and knockback should go
|
|
=====================
|
|
*/
|
|
bool idAI::AttackMelee ( const char *attackName, const idDict* meleeDict ) {
|
|
idEntity* enemyEnt = enemy.ent;
|
|
const char* p;
|
|
const idSoundShader* shader;
|
|
|
|
if ( !enemyEnt ) {
|
|
p = meleeDict->GetString( "snd_miss" );
|
|
if ( p && *p ) {
|
|
shader = declManager->FindSound( p );
|
|
StartSoundShader( shader, SND_CHANNEL_DAMAGE, 0, false, NULL );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// check for the "saving throw" automatic melee miss on lethal blow
|
|
// stupid place for this.
|
|
bool forceMiss = false;
|
|
if ( enemyEnt->IsType( idPlayer::GetClassType() ) && g_skill.GetInteger() < 2 ) {
|
|
int damage, armor;
|
|
idPlayer *player = static_cast<idPlayer*>( enemyEnt );
|
|
player->CalcDamagePoints( this, this, meleeDict, 1.0f, INVALID_JOINT, &damage, &armor );
|
|
|
|
if ( enemyEnt->health <= damage ) {
|
|
int t = gameLocal.time - player->lastSavingThrowTime;
|
|
if ( t > SAVING_THROW_TIME ) {
|
|
player->lastSavingThrowTime = gameLocal.time;
|
|
t = 0;
|
|
}
|
|
if ( t < 1000 ) {
|
|
forceMiss = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// make sure the trace can actually hit the enemy
|
|
if ( forceMiss || !TestMelee( ) ) {
|
|
// missed
|
|
p = meleeDict->GetString( "snd_miss" );
|
|
if ( p && *p ) {
|
|
shader = declManager->FindSound( p );
|
|
StartSoundShader( shader, SND_CHANNEL_DAMAGE, 0, false, NULL );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// do the damage
|
|
//
|
|
p = meleeDict->GetString( "snd_hit" );
|
|
if ( p && *p ) {
|
|
shader = declManager->FindSound( p );
|
|
StartSoundShader( shader, SND_CHANNEL_DAMAGE, 0, false, NULL );
|
|
}
|
|
|
|
idVec3 kickDir;
|
|
meleeDict->GetVector( "kickDir", "0 0 0", kickDir );
|
|
|
|
idVec3 globalKickDir;
|
|
globalKickDir = ( viewAxis * physicsObj.GetGravityAxis() ) * kickDir;
|
|
|
|
// This allows some AI to be soft against melee-- most marines are selfMeleeDamageScale of 3, which means they take 3X from melee attacks!
|
|
float damageScale = spawnArgs.GetFloat( "damageScale", "1" ) * enemyEnt->spawnArgs.GetFloat ( "selfMeleeDamageScale", "1" );
|
|
|
|
//if attacker is a melee superhero, damageScale is way increased
|
|
idAI* enemyAI = static_cast<idAI*>(enemyEnt);
|
|
if( aifl.meleeSuperhero) {
|
|
if( damageScale >=1 ) {
|
|
damageScale *= 6;
|
|
} else {
|
|
damageScale = 6;
|
|
}
|
|
}
|
|
|
|
//if the defender is a melee superhero, damageScale is way decreased
|
|
if( enemyAI->aifl.meleeSuperhero) {
|
|
damageScale = 0.5f;
|
|
}
|
|
|
|
int location = INVALID_JOINT;
|
|
if ( enemyEnt->IsType ( idAI::Type ) ) {
|
|
location = static_cast<idAI*>(enemyEnt)->chestOffsetJoint;
|
|
}
|
|
enemyEnt->Damage( this, this, globalKickDir, meleeDict->GetString ( "classname" ), damageScale, location );
|
|
|
|
if ( meleeDict->GetString( "fx_impact", NULL ) ) {
|
|
if ( enemyEnt == gameLocal.GetLocalPlayer() ) {
|
|
idPlayer *ePlayer = static_cast<idPlayer*>(enemyEnt);
|
|
if ( ePlayer ) {
|
|
idVec3 dir = ePlayer->firstPersonViewOrigin-GetEyePosition();
|
|
dir.Normalize();
|
|
idVec3 org = ePlayer->firstPersonViewOrigin + (dir * -((gameLocal.random.RandomFloat()*8.0f)+8.0f) );
|
|
idAngles ang = ePlayer->firstPersonViewAxis.ToAngles() * -1;
|
|
idMat3 axis = ang.ToMat3();
|
|
gameLocal.PlayEffect( *meleeDict, "fx_impact", org, viewAxis );
|
|
}
|
|
}
|
|
}
|
|
|
|
lastAttackTime = gameLocal.time;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::PushWithAF
|
|
================
|
|
*/
|
|
void idAI::PushWithAF( void ) {
|
|
int i, j;
|
|
afTouch_t touchList[ MAX_GENTITIES ];
|
|
idEntity *pushed_ents[ MAX_GENTITIES ];
|
|
idEntity *ent;
|
|
idVec3 vel;
|
|
int num_pushed;
|
|
|
|
num_pushed = 0;
|
|
af.ChangePose( this, gameLocal.time );
|
|
int num = af.EntitiesTouchingAF( touchList );
|
|
for( i = 0; i < num; i++ ) {
|
|
if ( touchList[ i ].touchedEnt->IsType( idProjectile::GetClassType() ) ) {
|
|
// skip projectiles
|
|
continue;
|
|
}
|
|
|
|
// make sure we havent pushed this entity already. this avoids causing double damage
|
|
for( j = 0; j < num_pushed; j++ ) {
|
|
if ( pushed_ents[ j ] == touchList[ i ].touchedEnt ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( j >= num_pushed ) {
|
|
ent = touchList[ i ].touchedEnt;
|
|
pushed_ents[num_pushed++] = ent;
|
|
vel = ent->GetPhysics()->GetAbsBounds().GetCenter() - touchList[ i ].touchedByBody->GetWorldOrigin();
|
|
vel.Normalize();
|
|
ent->GetPhysics()->SetLinearVelocity( 100.0f * vel, touchList[ i ].touchedClipModel->GetId() );
|
|
}
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
|
|
Misc
|
|
|
|
***********************************************************************/
|
|
|
|
/*
|
|
================
|
|
idAI::GetMuzzle
|
|
================
|
|
*/
|
|
void idAI::GetMuzzle( jointHandle_t joint, idVec3 &muzzle, idMat3 &axis ) {
|
|
if ( joint == INVALID_JOINT ) {
|
|
muzzle = physicsObj.GetOrigin() + viewAxis[ 0 ] * physicsObj.GetGravityAxis() * 14;
|
|
muzzle -= physicsObj.GetGravityNormal() * physicsObj.GetBounds()[ 1 ].z * 0.5f;
|
|
} else {
|
|
GetJointWorldTransform( joint, gameLocal.time, muzzle, axis );
|
|
//MCG
|
|
//pull the muzzle back inside the bounds if possible
|
|
//FIXME: this is nasty, we should just be able to check for starting in solid and register that as a hit! But...
|
|
/*
|
|
float scale = 0.0f;
|
|
if ( physicsObj.GetBounds().RayIntersection( muzzle, -axis[0], scale ) )
|
|
{
|
|
if ( scale != 0.0f )
|
|
{//not already inside
|
|
muzzle += scale * -axis[0];
|
|
}
|
|
}
|
|
else
|
|
{//just pull it back a little anyway?
|
|
idVec3 xyOfs = muzzle-physicsObj.GetOrigin();
|
|
xyOfs.z = 0;
|
|
muzzle += xyOfs.Length() * -axis[0];
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::Hide
|
|
================
|
|
*/
|
|
void idAI::Hide( void ) {
|
|
idActor::Hide();
|
|
fl.takedamage = false;
|
|
physicsObj.SetContents( 0 );
|
|
physicsObj.GetClipModel()->Unlink();
|
|
StopSound( SND_CHANNEL_AMBIENT, false );
|
|
|
|
enemy.fl.inFov = false;
|
|
enemy.fl.visible = false;
|
|
|
|
StopMove( MOVE_STATUS_DONE );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::Show
|
|
================
|
|
*/
|
|
void idAI::Show( void ) {
|
|
idActor::Show();
|
|
if ( spawnArgs.GetBool( "big_monster" ) ) {
|
|
physicsObj.SetContents( 0 );
|
|
} else if ( use_combat_bbox ) {
|
|
physicsObj.SetContents( CONTENTS_BODY|CONTENTS_SOLID );
|
|
} else {
|
|
physicsObj.SetContents( CONTENTS_BODY );
|
|
}
|
|
|
|
physicsObj.GetClipModel()->Link();
|
|
|
|
fl.takedamage = !spawnArgs.GetBool( "noDamage" );
|
|
StartSound( "snd_ambient", SND_CHANNEL_AMBIENT, 0, false, NULL );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::CanPlayChatterSounds
|
|
|
|
Used for playing chatter sounds on monsters.
|
|
================
|
|
*/
|
|
bool idAI::CanPlayChatterSounds( void ) const {
|
|
if ( aifl.dead ) {
|
|
return false;
|
|
}
|
|
|
|
if ( IsHidden() ) {
|
|
return false;
|
|
}
|
|
|
|
if ( enemy.ent ) {
|
|
return true;
|
|
}
|
|
|
|
if ( spawnArgs.GetBool( "no_idle_chatter" ) ) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::UpdateChatter
|
|
=====================
|
|
*/
|
|
void idAI::UpdateChatter ( void ) {
|
|
int chatterRate;
|
|
const char* chatter;
|
|
|
|
// No chatter?
|
|
if ( !chatterRateIdle && !chatterRateCombat ) {
|
|
return;
|
|
}
|
|
|
|
// check if it's time to play a chat sound
|
|
if ( IsHidden() || !aifl.awake || aifl.dead || ( chatterTime > gameLocal.time ) ) {
|
|
return;
|
|
}
|
|
|
|
// Skip first chatter
|
|
if ( enemy.ent ) {
|
|
chatter = "lipsync_chatter_combat";
|
|
chatterRate = chatterRateCombat;
|
|
} else {
|
|
chatter = "lipsync_chatter_idle";
|
|
chatterRate = chatterRateIdle;
|
|
}
|
|
|
|
// Can chatter ?
|
|
if ( !chatterRate ) {
|
|
return;
|
|
}
|
|
|
|
// Start chattering, but not if he's already speaking. And he might already be speaking because he was scripted to do so.
|
|
if ( chatterTime > 0 && !IsSpeaking() ) {
|
|
Speak ( chatter, true );
|
|
}
|
|
|
|
// set the next chat time
|
|
chatterTime = gameLocal.time + chatterRate + (gameLocal.random.RandomFloat() * chatterRate * 0.5f) - (chatterRate * 0.25f);
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::HeardSound
|
|
=====================
|
|
*/
|
|
idEntity *idAI::HeardSound( int ignore_team ){
|
|
// check if we heard any sounds in the last frame
|
|
idActor *actor = gameLocal.GetAlertActor();
|
|
if ( actor && ( !ignore_team || ( ReactionTo( actor ) & ATTACK_ON_SIGHT ) ) && gameLocal.InPlayerPVS( this ) ) {
|
|
idVec3 pos = actor->GetPhysics()->GetOrigin();
|
|
idVec3 org = physicsObj.GetOrigin();
|
|
float dist = ( pos - org ).LengthSqr();
|
|
|
|
if ( dist < Square( combat.earRange ) ) {
|
|
//really close?
|
|
if ( dist < Square( combat.earRange/4.0f ) ) {
|
|
return actor;
|
|
//possible LOS
|
|
} else if ( dist < Square( combat.visRange * 2.0f ) && CanSee( actor, false ) ) {
|
|
return actor;
|
|
} else if ( combat.fl.aware ) {
|
|
//FIXME: or, maybe find cover/hide/ambush spot and wait to ambush them?
|
|
//don't have an enemy and not tethered to a position
|
|
} else if ( !GetEnemy() && !tether ) {
|
|
//go into search mode
|
|
WanderAround();
|
|
move.fl.noRun = false;
|
|
move.fl.idealRunning = true;
|
|
//undid this: was causing them to not be able to do fine nav.
|
|
//move.fl.noWalk = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::SetLeader
|
|
============
|
|
*/
|
|
void idAI::SetLeader ( idEntity *newLeader ) {
|
|
idEntity* oldLeader = leader;
|
|
|
|
if( !newLeader ){
|
|
leader = NULL;
|
|
} else if ( !newLeader->IsType( idActor::GetClassType() ) ) {
|
|
gameLocal.Error( "'%s' is not an idActor (player or ai controlled character)", newLeader->name.c_str() );
|
|
} else {
|
|
leader = static_cast<idActor *>( newLeader );
|
|
}
|
|
|
|
if ( oldLeader != leader ) {
|
|
OnLeaderChange ( oldLeader );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
Head & torso aiming
|
|
|
|
***********************************************************************/
|
|
|
|
/*
|
|
================
|
|
idAI::UpdateAnimationControllers
|
|
================
|
|
*/
|
|
bool idAI::UpdateAnimationControllers( void ) {
|
|
idVec3 left;
|
|
idVec3 dir;
|
|
idVec3 orientationJointPos;
|
|
idVec3 localDir;
|
|
idAngles newLookAng;
|
|
idMat3 mat;
|
|
idMat3 axis;
|
|
idMat3 orientationJointAxis;
|
|
idVec3 pos;
|
|
int i;
|
|
idAngles jointAng;
|
|
float orientationJointYaw;
|
|
float currentHeadFocusRate = ( combat.fl.aware ? headFocusRate : headFocusRate * 0.5f );
|
|
|
|
MEM_SCOPED_TAG(tag,MA_ANIM);
|
|
|
|
if ( aifl.dead ) {
|
|
return idActor::UpdateAnimationControllers();
|
|
}
|
|
|
|
if ( orientationJoint == INVALID_JOINT ) {
|
|
orientationJointAxis = viewAxis;
|
|
orientationJointPos = physicsObj.GetOrigin();
|
|
orientationJointYaw = move.current_yaw;
|
|
} else {
|
|
GetJointWorldTransform( orientationJoint, gameLocal.time, orientationJointPos, orientationJointAxis );
|
|
orientationJointYaw = orientationJointAxis[ 2 ].ToYaw();
|
|
orientationJointAxis = idAngles( 0.0f, orientationJointYaw, 0.0f ).ToMat3();
|
|
}
|
|
|
|
// Update the IK after we've gotten all the joint positions we need, but before we set any joint positions.
|
|
// Getting the joint positions causes the joints to be updated. The IK gets joint positions itself (which
|
|
// are already up to date because of getting the joints in this function) and then sets their positions, which
|
|
// forces the heirarchy to be updated again next time we get a joint or present the model. If IK is enabled,
|
|
// or if we have a seperate head, we end up transforming the joints twice per frame. Characters with no
|
|
// head entity and no ik will only transform their joints once. Set g_debuganim to the current entity number
|
|
// in order to see how many times an entity transforms the joints per frame.
|
|
idActor::UpdateAnimationControllers();
|
|
|
|
// Update the focus position
|
|
UpdateFocus( orientationJointAxis );
|
|
|
|
//MCG NOTE: don't know why Dube added this extra check for the torsoAnim (5/09/05), but it was causing popping, so I took it out... :/
|
|
//bool canLook = ( !torsoAnim.AnimDone(0) || !torsoAnim.GetAnimator()->CurrentAnim(ANIMCHANNEL_TORSO)->IsDone(gameLocal.GetTime()) || torsoAnim.Disabled() ) && !torsoAnim.GetAnimFlags().ai_no_look && !aifl.disableLook;
|
|
//bool canLook = (!torsoAnim.GetAnimFlags().ai_no_look && !aifl.disableLook);
|
|
|
|
bool canLook = (!animator.GetAnimFlags(animator.CurrentAnim(ANIMCHANNEL_TORSO)->AnimNum()).ai_no_look && !aifl.disableLook);
|
|
if ( !canLook ) {
|
|
//actually, do the looking, but bring it back forward...
|
|
currentFocusPos = GetEyePosition() + orientationJointAxis[ 0 ] * 64.0f;
|
|
}
|
|
|
|
// Determine the new look yaw
|
|
dir = currentFocusPos - orientationJointPos;
|
|
newLookAng.yaw = dir.ToYaw( );
|
|
|
|
// Determine the new look pitch
|
|
dir = currentFocusPos - GetEyePosition();
|
|
dir.NormalizeFast();
|
|
orientationJointAxis.ProjectVector( dir, localDir );
|
|
newLookAng.pitch = -idMath::AngleNormalize180( localDir.ToPitch() );
|
|
newLookAng.roll = 0.0f;
|
|
|
|
if ( !canLook ) {
|
|
//actually, do the looking, but bring it back forward...
|
|
newLookAng.yaw = orientationJointAxis[0].ToYaw();
|
|
newLookAng.pitch = 0;
|
|
}
|
|
// Add the angle change using the head focus rate and convert the look angles to
|
|
// local angles so they can be properly clamped.
|
|
float f = lookAng.yaw;
|
|
if ( lookMin.yaw <= -360.0f && lookMax.yaw >= 360.0f )
|
|
{
|
|
lookAng.yaw = f - orientationJointYaw;
|
|
float diff;
|
|
diff = ( idMath::AngleNormalize360(newLookAng.yaw) - idMath::AngleNormalize360(f) );
|
|
diff = idMath::AngleNormalize180( diff );
|
|
lookAng.yaw += diff * currentHeadFocusRate;
|
|
//lookAng.yaw += ( newLookAng.yaw - f ) * currentHeadFocusRate;
|
|
}
|
|
else
|
|
{
|
|
lookAng.yaw = idMath::AngleNormalize180 ( f - orientationJointYaw );
|
|
lookAng.yaw += (idMath::AngleNormalize180 ( newLookAng.yaw - f ) * currentHeadFocusRate);
|
|
}
|
|
lookAng.pitch += ( idMath::AngleNormalize180( newLookAng.pitch - lookAng.pitch ) * currentHeadFocusRate );
|
|
|
|
// Clamp the look angles
|
|
lookAng.Clamp( lookMin, lookMax );
|
|
|
|
// Calcuate the eye angles
|
|
f = eyeAng.yaw;
|
|
eyeAng.yaw = idMath::AngleNormalize180( f - orientationJointYaw );
|
|
eyeAng.yaw += (idMath::AngleNormalize180( newLookAng.yaw - f ) * eyeFocusRate);
|
|
eyeAng.pitch += (idMath::AngleNormalize180( newLookAng.pitch - eyeAng.pitch ) * eyeFocusRate);
|
|
|
|
// Clamp eye angles relative to the look angles
|
|
jointAng = eyeAng - lookAng;
|
|
jointAng.Normalize180( );
|
|
jointAng.Clamp( eyeMin, eyeMax );
|
|
eyeAng = lookAng + jointAng;
|
|
eyeAng.Normalize180( );
|
|
|
|
if ( canLook ) {
|
|
// Apply the look angles to the look joints
|
|
if ( animator.GetAnimFlags( animator.CurrentAnim( ANIMCHANNEL_TORSO )->AnimNum()).ai_look_head_only ) {
|
|
if ( neckJoint != INVALID_JOINT || headJoint != INVALID_JOINT ) {
|
|
float jScale = 1.0f;
|
|
if ( neckJoint != INVALID_JOINT && headJoint != INVALID_JOINT ) {
|
|
jScale = 0.5f;
|
|
}
|
|
jointAng.pitch = lookAng.pitch * jScale;
|
|
jointAng.yaw = lookAng.yaw * jScale;
|
|
if ( neckJoint != INVALID_JOINT ) {
|
|
animator.SetJointAxis( neckJoint, JOINTMOD_WORLD, jointAng.ToMat3() );
|
|
}
|
|
if ( headJoint != INVALID_JOINT ) {
|
|
animator.SetJointAxis( headJoint, JOINTMOD_WORLD, jointAng.ToMat3() );
|
|
}
|
|
}
|
|
//what if we have a previous joint mod on the rest of the lookJoints
|
|
//from an anim that *wasn't* ai_look_head_only...?
|
|
//just clear them? Or move them towards 0?
|
|
//FIXME: move them towards zero...
|
|
if ( newLookAng.Compare( lookAng ) ) {
|
|
//snap back now!
|
|
for( i = 0; i < lookJoints.Num(); i++ ) {
|
|
if ( lookJoints[i] != neckJoint
|
|
&& lookJoints[i] != headJoint ) {
|
|
//snap back now!
|
|
animator.ClearJoint ( lookJoints[i] );
|
|
}
|
|
}
|
|
} else {
|
|
//blend back
|
|
//yes, this is framerate dependant and inefficient and wrong, but... eliminates pops
|
|
jointAng.roll = 0.0f;
|
|
jointMod_t *curJointMod;
|
|
idAngles curJointAngleMod;
|
|
for( i = 0; i < lookJoints.Num(); i++ ) {
|
|
if ( lookJoints[i] != neckJoint
|
|
&& lookJoints[i] != headJoint ) {
|
|
//blend back
|
|
curJointMod = animator.FindExistingJointMod( lookJoints[ i ], NULL );
|
|
if ( curJointMod )
|
|
{
|
|
curJointAngleMod = curJointMod->mat.ToAngles();
|
|
curJointAngleMod *= 0.75f;
|
|
if ( fabs(curJointAngleMod.pitch) < 1.0f
|
|
&& fabs(curJointAngleMod.yaw) < 1.0f
|
|
&& fabs(curJointAngleMod.roll) < 1.0f )
|
|
{
|
|
//snap back now!
|
|
animator.ClearJoint ( lookJoints[i] );
|
|
}
|
|
else
|
|
{
|
|
animator.SetJointAxis( lookJoints[ i ], JOINTMOD_WORLD, curJointAngleMod.ToMat3() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
jointAng.roll = 0.0f;
|
|
for( i = 0; i < lookJoints.Num(); i++ ) {
|
|
jointAng.pitch = lookAng.pitch * lookJointAngles[ i ].pitch;
|
|
jointAng.yaw = lookAng.yaw * lookJointAngles[ i ].yaw;
|
|
animator.SetJointAxis( lookJoints[ i ], JOINTMOD_WORLD, jointAng.ToMat3() );
|
|
}
|
|
}
|
|
} else {
|
|
//if ( animator.GetAnimFlags(animator.CurrentAnim(ANIMCHANNEL_TORSO)->AnimNum()).ai_no_look || aifl.disableLook ) {
|
|
if ( newLookAng.Compare( lookAng ) ) {
|
|
//snap back now!
|
|
for( i = 0; i < lookJoints.Num(); i++ ) {
|
|
animator.ClearJoint ( lookJoints[i] );
|
|
}
|
|
} else {
|
|
//PCJ back to neutral
|
|
jointAng.roll = 0.0f;
|
|
for( i = 0; i < lookJoints.Num(); i++ ) {
|
|
jointAng.pitch = lookAng.pitch * lookJointAngles[ i ].pitch;
|
|
jointAng.yaw = lookAng.yaw * lookJointAngles[ i ].yaw;
|
|
animator.SetJointAxis( lookJoints[ i ], JOINTMOD_WORLD, jointAng.ToMat3() );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convert the look angles back to world angles. This is done to prevent dramatic orietation changes
|
|
// from changing the look direction abruptly (unless of course the minimums are not met)
|
|
lookAng.yaw = idMath::AngleNormalize180( lookAng.yaw + orientationJointYaw );
|
|
eyeAng.yaw = idMath::AngleNormalize180( eyeAng.yaw + orientationJointYaw );
|
|
|
|
if ( move.moveType == MOVETYPE_FLY || move.fl.flyTurning ) {
|
|
// lean into turns
|
|
AdjustFlyingAngles();
|
|
}
|
|
|
|
// Orient the eyes towards their target
|
|
if ( leftEyeJoint != INVALID_JOINT && rightEyeJoint != INVALID_JOINT ) {
|
|
if ( head ) {
|
|
idAnimator *headAnimator = head->GetAnimator();
|
|
|
|
if ( focusType != AIFOCUS_NONE && allowEyeFocus && canLook ) {
|
|
//tweak these since it's looking at the wrong spot and not calculating from each eye and I don't have time to bother rewriting all of this properly
|
|
eyeAng.yaw -= 0.5f;
|
|
eyeAng.pitch += 3.25f;
|
|
idMat3 eyeAxis = ( eyeAng ).ToMat3() * head->GetPhysics()->GetAxis().Transpose ( );
|
|
|
|
headAnimator->SetJointAxis ( leftEyeJoint, JOINTMOD_WORLD_OVERRIDE, eyeAxis );
|
|
|
|
eyeAng.yaw += 3.0f;
|
|
eyeAxis = ( eyeAng ).ToMat3() * head->GetPhysics()->GetAxis().Transpose ( );
|
|
|
|
headAnimator->SetJointAxis ( rightEyeJoint, JOINTMOD_WORLD_OVERRIDE, eyeAxis );
|
|
|
|
if ( ai_debugEyeFocus.GetBool() ) {
|
|
idVec3 eyeOrigin;
|
|
idMat3 axis;
|
|
|
|
head->GetJointWorldTransform ( rightEyeJoint, gameLocal.time, eyeOrigin, axis );
|
|
gameRenderWorld->DebugArrow ( colorGreen, eyeOrigin, ( eyeOrigin + (32.0f*axis[0])), 1, 0 );
|
|
|
|
head->GetJointWorldTransform ( leftEyeJoint, gameLocal.time, eyeOrigin, axis );
|
|
gameRenderWorld->DebugArrow ( colorGreen, eyeOrigin, ( eyeOrigin + (32.0f*axis[0])), 1, 0 );
|
|
}
|
|
} else {
|
|
headAnimator->ClearJoint( leftEyeJoint );
|
|
headAnimator->ClearJoint( rightEyeJoint );
|
|
}
|
|
} else {
|
|
if ( allowEyeFocus && focusType != AIFOCUS_NONE && !torsoAnim.GetAnimFlags().ai_no_look && !aifl.disableLook ) {
|
|
idMat3 eyeAxis = ( eyeAng ).ToMat3() * GetPhysics()->GetAxis().Transpose ( );
|
|
animator.SetJointAxis ( rightEyeJoint, JOINTMOD_WORLD_OVERRIDE, eyeAxis );
|
|
animator.SetJointAxis ( leftEyeJoint, JOINTMOD_WORLD_OVERRIDE, eyeAxis );
|
|
} else {
|
|
animator.ClearJoint( leftEyeJoint );
|
|
animator.ClearJoint( rightEyeJoint );
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void idAI::OnTouch( idEntity *other, trace_t *trace ) {
|
|
// if we dont have an enemy or had one for at least a second that is a potential enemy the set the enemy
|
|
if ( other->IsType( idActor::GetClassType() )
|
|
&& !other->fl.notarget
|
|
&& ( ReactionTo( other )&ATTACK_ON_SIGHT)
|
|
&& (!enemy.ent || gameLocal.time - enemy.changeTime > 1000 ) ) {
|
|
SetEnemy( other );
|
|
}
|
|
|
|
if ( !enemy.ent && !other->fl.notarget && ( ReactionTo( other ) & ATTACK_ON_ACTIVATE ) ) {
|
|
Activate( other );
|
|
}
|
|
pusher = other;
|
|
aifl.pushed = true;
|
|
|
|
// If pushed by the player update tactical
|
|
if ( pusher && pusher->IsType ( idPlayer::GetClassType() ) && (combat.tacticalMaskAvailable & AITACTICAL_MOVE_PLAYERPUSH_BIT) ) {
|
|
ForceTacticalUpdate ( );
|
|
}
|
|
}
|
|
|
|
idProjectile* idAI::AttackProjectile ( const idDict* projectileDict, const idVec3 &org, const idAngles &ang ) {
|
|
idVec3 start;
|
|
trace_t tr;
|
|
idBounds projBounds;
|
|
const idClipModel* projClip;
|
|
idMat3 axis;
|
|
float distance;
|
|
idProjectile* result;
|
|
|
|
if ( !projectileDict ) {
|
|
gameLocal.Warning( "%s (%s) doesn't have a projectile specified", name.c_str(), GetEntityDefName() );
|
|
return NULL;
|
|
}
|
|
|
|
axis = ang.ToMat3();
|
|
if ( !projectile.GetEntity() ) {
|
|
CreateProjectile( projectileDict, org, axis[ 0 ] );
|
|
}
|
|
|
|
// make sure the projectile starts inside the monster bounding box
|
|
const idBounds &ownerBounds = physicsObj.GetAbsBounds();
|
|
projClip = projectile.GetEntity()->GetPhysics()->GetClipModel();
|
|
projBounds = projClip->GetBounds().Rotate( projClip->GetAxis() );
|
|
|
|
// check if the owner bounds is bigger than the projectile bounds
|
|
if ( ( ( ownerBounds[1][0] - ownerBounds[0][0] ) > ( projBounds[1][0] - projBounds[0][0] ) ) &&
|
|
( ( ownerBounds[1][1] - ownerBounds[0][1] ) > ( projBounds[1][1] - projBounds[0][1] ) ) &&
|
|
( ( ownerBounds[1][2] - ownerBounds[0][2] ) > ( projBounds[1][2] - projBounds[0][2] ) ) ) {
|
|
if ( (ownerBounds - projBounds).RayIntersection( org, viewAxis[ 0 ], distance ) ) {
|
|
start = org + distance * viewAxis[ 0 ];
|
|
} else {
|
|
start = ownerBounds.GetCenter();
|
|
}
|
|
} else {
|
|
// projectile bounds bigger than the owner bounds, so just start it from the center
|
|
start = ownerBounds.GetCenter();
|
|
}
|
|
|
|
// RAVEN BEGIN
|
|
// ddynerman: multiple clip worlds
|
|
gameLocal.Translation( this, tr, start, org, projClip, projClip->GetAxis(), MASK_SHOT_RENDERMODEL, this );
|
|
// RAVEN END
|
|
|
|
// launch the projectile
|
|
projectile.GetEntity()->Launch( tr.endpos, axis[ 0 ], vec3_origin );
|
|
result = projectile;
|
|
projectile = NULL;
|
|
|
|
lastAttackTime = gameLocal.time;
|
|
|
|
return result;
|
|
}
|
|
|
|
void idAI::RadiusDamageFromJoint( const char *jointname, const char *damageDefName ) {
|
|
jointHandle_t joint;
|
|
idVec3 org;
|
|
idMat3 axis;
|
|
|
|
if ( !jointname || !jointname[ 0 ] ) {
|
|
org = physicsObj.GetOrigin();
|
|
} else {
|
|
joint = animator.GetJointHandle( jointname );
|
|
if ( joint == INVALID_JOINT ) {
|
|
gameLocal.Error( "Unknown joint '%s' on %s", jointname, GetEntityDefName() );
|
|
}
|
|
GetJointWorldTransform( joint, gameLocal.time, org, axis );
|
|
}
|
|
|
|
gameLocal.RadiusDamage( org, this, this, this, this, damageDefName );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::CanBecomeSolid
|
|
|
|
returns true if the AI entity could become solid at its current position
|
|
=====================
|
|
*/
|
|
bool idAI::CanBecomeSolid ( void ) {
|
|
int i;
|
|
int num;
|
|
idEntity * hit;
|
|
idClipModel* cm;
|
|
idClipModel* clipModels[ MAX_GENTITIES ];
|
|
|
|
// Determine what we are currently touching
|
|
// RAVEN BEGIN
|
|
// ddynerman: multiple clip worlds
|
|
num = gameLocal.ClipModelsTouchingBounds( this, physicsObj.GetAbsBounds(), MASK_MONSTERSOLID, clipModels, MAX_GENTITIES );
|
|
// RAVEN END
|
|
for ( i = 0; i < num; i++ ) {
|
|
cm = clipModels[ i ];
|
|
|
|
// don't check render entities
|
|
if ( cm->IsRenderModel() ) {
|
|
continue;
|
|
}
|
|
|
|
hit = cm->GetEntity();
|
|
if ( ( hit == this ) || !hit->fl.takedamage ) {
|
|
continue;
|
|
}
|
|
|
|
if ( physicsObj.ClipContents( cm ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::BecomeSolid
|
|
=====================
|
|
*/
|
|
void idAI::BecomeSolid( void ) {
|
|
physicsObj.EnableClip();
|
|
if ( spawnArgs.GetBool( "big_monster" ) ) {
|
|
physicsObj.SetContents( 0 );
|
|
} else if ( use_combat_bbox ) {
|
|
physicsObj.SetContents( CONTENTS_BODY|CONTENTS_SOLID );
|
|
} else {
|
|
physicsObj.SetContents( CONTENTS_BODY );
|
|
}
|
|
// RAVEN BEGIN
|
|
// ddynerman: multiple clip worlds
|
|
physicsObj.GetClipModel()->Link();
|
|
// RAVEN END
|
|
fl.takedamage = !spawnArgs.GetBool( "noDamage" );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idAI::BecomeNonSolid
|
|
=====================
|
|
*/
|
|
void idAI::BecomeNonSolid( void ) {
|
|
fl.takedamage = false;
|
|
physicsObj.SetContents( 0 );
|
|
physicsObj.GetClipModel()->Unlink();
|
|
}
|
|
|
|
const char *idAI::ChooseAnim( int channel, const char *animname ) {
|
|
int anim;
|
|
|
|
anim = GetAnim( channel, animname );
|
|
if ( anim ) {
|
|
if ( channel == ANIMCHANNEL_HEAD ) {
|
|
if ( head.GetEntity() ) {
|
|
return head.GetEntity()->GetAnimator()->AnimFullName( anim );
|
|
}
|
|
} else {
|
|
return animator.AnimFullName( anim );
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::ExecScriptFunction
|
|
============
|
|
*/
|
|
void idAI::ExecScriptFunction ( rvScriptFuncUtility& func, idEntity* parm ) {
|
|
if( parm ) {
|
|
func.InsertEntity( parm, 0 );
|
|
} else {
|
|
func.InsertEntity( this, 0 );
|
|
}
|
|
|
|
func.CallFunc( &spawnArgs );
|
|
|
|
if( parm ) {
|
|
func.RemoveIndex( 0 );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::Prethink
|
|
============
|
|
*/
|
|
void idAI::Prethink ( void ) {
|
|
// Update our helper if we are moving
|
|
if ( move.fl.moving ) {
|
|
UpdateHelper ( );
|
|
}
|
|
|
|
if ( leader ) {
|
|
idEntity* groundEnt = leader->GetGroundEntity ( );
|
|
if ( !(tether && !aifl.tetherMover) && groundEnt ) {
|
|
if ( groundEnt->IsType ( idMover::GetClassType ( ) ) ) {
|
|
idEntity* ent;
|
|
idEntity* next;
|
|
for( ent = groundEnt->GetNextTeamEntity(); ent != NULL; ent = next ) {
|
|
next = ent->GetNextTeamEntity();
|
|
if ( ent->GetBindMaster() == groundEnt && ent->IsType ( rvAITether::GetClassType ( ) ) ) {
|
|
SetTether ( static_cast<rvAITether*>(ent) );
|
|
aifl.tetherMover = true;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
SetTether ( NULL );
|
|
}
|
|
}
|
|
} else if ( tether && aifl.tetherMover ) {
|
|
SetTether ( NULL );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::Postthink
|
|
============
|
|
*/
|
|
void idAI::Postthink( void ){
|
|
if ( !aifl.simpleThink ) {
|
|
pain.takenThisFrame = 0;
|
|
}
|
|
|
|
// Draw debug tactical information
|
|
DrawTactical ( );
|
|
|
|
if( vehicleController.IsDriving() ){ // Generate some sort of command?
|
|
usercmd_t usercmd;
|
|
|
|
// Note! usercmd angles stuff is in deltas, not in absolute values.
|
|
|
|
memset( &usercmd, 0, sizeof( usercmd ) );
|
|
|
|
idVec3 toEnemy;
|
|
|
|
if( enemy.ent ){
|
|
toEnemy = enemy.ent->GetPhysics()->GetOrigin();
|
|
toEnemy -= GetPhysics()->GetOrigin();
|
|
toEnemy.Normalize();
|
|
|
|
idAngles enemyAng;
|
|
|
|
enemyAng = toEnemy.ToAngles();
|
|
|
|
usercmd.angles[PITCH] = ANGLE2SHORT( enemyAng.pitch );
|
|
usercmd.angles[YAW] = ANGLE2SHORT( enemyAng.yaw );
|
|
|
|
usercmd.buttons = BUTTON_ATTACK;
|
|
|
|
vehicleController.SetInput ( usercmd, enemyAng );
|
|
}
|
|
}
|
|
|
|
// Keep our threat value up to date
|
|
UpdateThreat ( );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::
|
|
============
|
|
*/
|
|
|
|
void idAI::OnDeath( void ){
|
|
if( vehicleController.IsDriving() ){
|
|
usercmd_t usercmd;
|
|
|
|
memset( &usercmd, 0, sizeof( usercmd ) );
|
|
usercmd.buttons = BUTTON_ATTACK;
|
|
usercmd.upmove = 300.0f; // This will cause the character to eject.
|
|
|
|
vehicleController.SetInput( usercmd, idAngles( 0, 0, 0 ) );
|
|
|
|
// Fixme! Is this safe to do immediately?
|
|
vehicleController.Eject();
|
|
}
|
|
|
|
aiManager.RemoveTeammate ( this );
|
|
|
|
ExecScriptFunction( funcs.death );
|
|
|
|
/* DONT DROP ANYTHING FOR NOW
|
|
float rVal = gameLocal.random.RandomInt( 100 );
|
|
|
|
if( spawnArgs.GetFloat( "no_drops" ) >= 1.0 ){
|
|
spawnArgs.Set( "def_dropsItem1", "" );
|
|
}else{
|
|
// Fixme! Better guys should drop better stuffs! Make drops related to guy type? Do something cooler here?
|
|
if( rVal < 25 ){ // Half of guys drop nothing?
|
|
spawnArgs.Set( "def_dropsItem1", "" );
|
|
}else if( rVal < 50 ){
|
|
spawnArgs.Set( "def_dropsItem1", "item_health_small" );
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnWakeUp
|
|
============
|
|
*/
|
|
void idAI::OnWakeUp ( void ) {
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnUpdatePlayback
|
|
============
|
|
*/
|
|
void idAI::OnUpdatePlayback ( const rvDeclPlaybackData& pbd ) {
|
|
return;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnLeaderChange
|
|
============
|
|
*/
|
|
void idAI::OnLeaderChange ( idEntity* oldLeader ) {
|
|
ForceTacticalUpdate ( );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnEnemyChange
|
|
============
|
|
*/
|
|
void idAI::OnEnemyChange ( idEntity* oldEnemy ) {
|
|
// Make sure we update our tactical state immediately
|
|
ForceTacticalUpdate ( );
|
|
|
|
// see if we should announce the enemy
|
|
if ( enemy.ent ) {
|
|
combat.fl.aware = true;
|
|
combat.investigateTime = 0;
|
|
|
|
enemy.changeTime = gameLocal.time;
|
|
|
|
enemy.lastKnownPosition = enemy.ent->GetPhysics()->GetOrigin ( );
|
|
|
|
UpdateEnemyVisibility ( );
|
|
UpdateEnemyPosition ( true );
|
|
UpdateEnemy ( );
|
|
} else {
|
|
enemy.range = 0;
|
|
enemy.range2d = 0;
|
|
enemy.changeTime = 0;
|
|
enemy.smoothedLinearVelocity.Zero ( );
|
|
enemy.smoothedPushedVelocity.Zero ( );
|
|
}
|
|
|
|
enemy.fl.visible = false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnTacticalChange
|
|
============
|
|
*/
|
|
void idAI::OnTacticalChange ( aiTactical_t oldTactical ) {
|
|
// if acutally moving to a new tactial location announce it
|
|
if ( move.fl.moving ) {
|
|
AnnounceTactical( combat.tacticalCurrent );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnFriendlyFire
|
|
============
|
|
*/
|
|
void idAI::OnFriendlyFire ( idActor* attacker ) {
|
|
AnnounceFriendlyFire( static_cast<idActor*>(attacker) );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnStartMoving
|
|
============
|
|
*/
|
|
void idAI::OnStartMoving ( void ) {
|
|
aifl.simpleThink = false;
|
|
combat.fl.crouchViewClear = false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnStopMoving
|
|
============
|
|
*/
|
|
void idAI::OnStopMoving ( aiMoveCommand_t oldMoveCommand ) {
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnStartAction
|
|
============
|
|
*/
|
|
void idAI::OnStartAction ( void ) {
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnStopAction
|
|
============
|
|
*/
|
|
void idAI::OnStopAction ( void ) {
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnEnemyVisiblityChange
|
|
============
|
|
*/
|
|
void idAI::OnEnemyVisiblityChange ( bool oldVisible ) {
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnSetKey
|
|
============
|
|
*/
|
|
void idAI::OnSetKey ( const char* key, const char* value ) {
|
|
if ( !idStr::Icmp ( key, "noCombatChatter" ) ) {
|
|
combat.fl.noChatter = spawnArgs.GetBool ( key );
|
|
} else if ( !idStr::Icmp ( key, "allowPlayerPush" ) ) {
|
|
combat.tacticalMaskAvailable &= ~(AITACTICAL_MOVE_PLAYERPUSH_BIT);
|
|
if ( spawnArgs.GetBool ( key ) ) {
|
|
combat.tacticalMaskAvailable |= AITACTICAL_MOVE_PLAYERPUSH_BIT;
|
|
}
|
|
} else if ( !idStr::Icmp ( key, "noLook" ) ) {
|
|
aifl.disableLook = spawnArgs.GetBool ( key );
|
|
} else if ( !idStr::Icmp ( key, "killer_guard" ) ) {
|
|
aifl.killerGuard = spawnArgs.GetBool ( key );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnCoverInvalidated
|
|
============
|
|
*/
|
|
void idAI::OnCoverInvalidated ( void ) {
|
|
// Force a tactical update now
|
|
ForceTacticalUpdate ( );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::OnCoverNotFacingEnemy
|
|
============
|
|
*/
|
|
void idAI::OnCoverNotFacingEnemy ( void ) {
|
|
// Clear attack timers so we can shoot right now
|
|
actionTimerRangedAttack.Clear ( actionTime );
|
|
actionRangedAttack.timer.Clear( actionTime );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::SkipCurrentDestination
|
|
|
|
Is the AI's current destination ok enough to stay at?
|
|
============
|
|
*/
|
|
bool idAI::SkipCurrentDestination ( void ) const {
|
|
// can only skip current destination when we are stopped
|
|
if ( move.fl.moving ) {
|
|
return false;
|
|
}
|
|
/*
|
|
// If we are currently behind cover and that cover is no longer valid we should skip it
|
|
if ( IsBehindCover ( ) && !IsCoverValid ( ) ) {
|
|
return true;
|
|
}
|
|
*/
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::SkipImpulse
|
|
============
|
|
*/
|
|
bool idAI::SkipImpulse( idEntity *ent, int id ){
|
|
bool skip = idActor::SkipImpulse( ent, id );
|
|
|
|
if( af.IsActive ( ) ) {
|
|
return false;
|
|
}
|
|
if( !fl.takedamage ){
|
|
return true;
|
|
}
|
|
if( move.moveCommand == MOVE_RV_PLAYBACK ){
|
|
return true;
|
|
}
|
|
|
|
return skip;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CanHitEnemy
|
|
============
|
|
*/
|
|
bool idAI::CanHitEnemy ( void ) {
|
|
trace_t tr;
|
|
idEntity *hit;
|
|
|
|
idEntity *enemyEnt = enemy.ent;
|
|
if ( !IsEnemyVisible ( ) || !enemyEnt ) {
|
|
return false;
|
|
}
|
|
|
|
// don't check twice per frame
|
|
if ( gameLocal.time == lastHitCheckTime ) {
|
|
return lastHitCheckResult;
|
|
}
|
|
|
|
lastHitCheckTime = gameLocal.time;
|
|
|
|
idVec3 toPos = enemyEnt->GetEyePosition();
|
|
idVec3 eye = GetEyePosition();
|
|
idVec3 dir;
|
|
|
|
// expand the ray out as far as possible so we can detect anything behind the enemy
|
|
dir = toPos - eye;
|
|
dir.Normalize();
|
|
toPos = eye + dir * MAX_WORLD_SIZE;
|
|
// RAVEN BEGIN
|
|
// ddynerman: multiple clip worlds
|
|
if ( g_perfTest_aiNoVisTrace.GetBool() ) {
|
|
lastHitCheckResult = true;
|
|
return lastHitCheckResult;
|
|
}
|
|
|
|
gameLocal.TracePoint( this, tr, eye, toPos, MASK_SHOT_BOUNDINGBOX, this );
|
|
hit = gameLocal.GetTraceEntity( tr );
|
|
// RAVEN END
|
|
if ( tr.fraction >= 1.0f || ( hit == enemyEnt ) ) {
|
|
lastHitCheckResult = true;
|
|
} else if ( ( tr.fraction < 1.0f ) && ( hit->IsType( idAI::Type ) ) &&
|
|
( static_cast<idAI *>( hit )->team != team ) ) {
|
|
lastHitCheckResult = true;
|
|
} else {
|
|
lastHitCheckResult = false;
|
|
}
|
|
|
|
return lastHitCheckResult;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CanHitEnemyFromJoint
|
|
============
|
|
*/
|
|
|
|
bool idAI::CanHitEnemyFromJoint( const char *jointname ){
|
|
trace_t tr;
|
|
idVec3 muzzle;
|
|
idMat3 axis;
|
|
|
|
idEntity *enemyEnt = enemy.ent;
|
|
if ( !IsEnemyVisible ( ) || !enemyEnt ) {
|
|
return false;
|
|
}
|
|
|
|
// don't check twice per frame
|
|
if ( gameLocal.time == lastHitCheckTime ) {
|
|
return lastHitCheckResult;
|
|
}
|
|
|
|
if ( g_perfTest_aiNoVisTrace.GetBool() ) {
|
|
lastHitCheckResult = true;
|
|
return true;
|
|
}
|
|
|
|
lastHitCheckTime = gameLocal.time;
|
|
|
|
idVec3 toPos = enemyEnt->GetEyePosition();
|
|
jointHandle_t joint = animator.GetJointHandle( jointname );
|
|
if ( joint == INVALID_JOINT ) {
|
|
gameLocal.Error( "Unknown joint '%s' on %s", jointname, GetEntityDefName() );
|
|
}
|
|
animator.GetJointTransform( joint, gameLocal.time, muzzle, axis );
|
|
muzzle = physicsObj.GetOrigin() + ( muzzle + modelOffset ) * viewAxis * physicsObj.GetGravityAxis();
|
|
// RAVEN BEGIN
|
|
// ddynerman: multiple clip worlds
|
|
gameLocal.TracePoint( this, tr, muzzle, toPos, MASK_SHOT_BOUNDINGBOX, this );
|
|
// RAVEN END
|
|
if ( tr.fraction >= 1.0f || ( gameLocal.GetTraceEntity( tr ) == enemyEnt ) ) {
|
|
lastHitCheckResult = true;
|
|
} else {
|
|
lastHitCheckResult = false;
|
|
}
|
|
|
|
return lastHitCheckResult;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::
|
|
============
|
|
|
|
float HeightForTrajectory( const idVec3 &start, float zVel, float gravity );
|
|
|
|
int idAI::TestTrajectory( const idVec3 &firePos, const idVec3 &target, const char *projectileName ){
|
|
idVec3 projVelocity;
|
|
idVec3 projGravity;
|
|
float testTime;
|
|
float zVel, height, pitch, s, c;
|
|
idVec3 dir;
|
|
float newVel;
|
|
float delta_x;
|
|
float delta_z;
|
|
|
|
projectileDef = gameLocal.FindEntityDefDict ( projectileName );
|
|
projVelocity = idProjectile::GetVelocity( projectileDef );
|
|
projGravity = idProjectile::GetGravity( projectileDef ).z * GetPhysics()->GetGravity();
|
|
pitch = DEG2RAD( gameLocal.random.RandomFloat() * 50 + 20 ); // Random pitch range between 20 and 70. Should this be customizeable?
|
|
|
|
idMath::SinCos( pitch, s, c );
|
|
|
|
delta_x = idMath::Sqrt( ( target.x - firePos.x ) * ( target.x - firePos.x ) + ( target.y - firePos.y ) * ( target.y - firePos.y ) );
|
|
delta_z = target.z - firePos.z;
|
|
newVel = ( delta_x / idMath::Cos( pitch ) ) * idMath::Sqrt( projGravity.z / ( 2.0f * ( delta_x * idMath::Tan( pitch ) - delta_z ) ) );
|
|
testTime = delta_x / ( newVel * c );
|
|
zVel = newVel * s;
|
|
|
|
float a = idMath::ASin ( delta_x * GetPhysics()->GetGravity().Length() / (projVelocity.x * projVelocity.x) );
|
|
a = a / 2;
|
|
|
|
float r = (projVelocity.x * projVelocity.x) * idMath::Sin ( 2 * a ) / GetPhysics()->GetGravity().Length();
|
|
if ( r < delta_x - (delta_x * 0.1) ) {
|
|
mVar.valid_lobbed_shot = 0;
|
|
return 0;
|
|
} else {
|
|
mVar.lobDir = target - firePos;
|
|
mVar.lobDir.z = 0;
|
|
mVar.lobDir.z = idMath::Tan ( a ) * mVar.lobDir.LengthFast();
|
|
mVar.lobDir.Normalize ( );
|
|
mVar.valid_lobbed_shot = gameLocal.time;
|
|
mVar.lob_vel_scale = 1.0f; // newVel / projVelocity.Length();
|
|
return 1;
|
|
}
|
|
|
|
projGravity[2] *= -1.0f;
|
|
|
|
dir = target - firePos;
|
|
dir.z = 0;
|
|
dir.Normalize();
|
|
delta_x = idMath::Sqrt( 1 - ( c * c ) );
|
|
dir.x *= delta_x;
|
|
dir.y *= delta_x;
|
|
dir.z = c;
|
|
|
|
height = HeightForTrajectory( firePos, zVel, projGravity[2] ) - firePos.z;
|
|
if ( height > MAX_WORLD_SIZE ) {
|
|
// goes higher than we want to allow
|
|
mVar.valid_lobbed_shot = 0;
|
|
return 0;
|
|
}
|
|
|
|
if ( idAI::TestTrajectory ( firePos, target, zVel, projGravity[2], testTime, height * 2, NULL,
|
|
MASK_SHOT_RENDERMODEL, this, enemy.GetEntity(), ai_debugTrajectory.GetBool() ? 4000 : 0 ) ) {
|
|
|
|
if ( ai_debugTrajectory.GetBool() ) {
|
|
float t = testTime / 100.0f;
|
|
idVec3 velocity = dir * newVel;
|
|
idVec3 lastPos, pos;
|
|
lastPos = firePos;
|
|
pos = firePos;
|
|
for ( int j = 1; j < 100; j++ ) {
|
|
pos += velocity * t;
|
|
velocity += projGravity * t;
|
|
gameRenderWorld->DebugLine( colorCyan, lastPos, pos, ai_debugTrajectory.GetBool() ? 4000 : 0 );
|
|
lastPos = pos;
|
|
}
|
|
}
|
|
|
|
mVar.lobDir = dir;
|
|
mVar.valid_lobbed_shot = gameLocal.time;
|
|
mVar.lob_vel_scale = newVel / projVelocity.Length();
|
|
}else{
|
|
mVar.valid_lobbed_shot = 0;
|
|
}
|
|
|
|
return ( (int)mVar.valid_lobbed_shot != 0 );
|
|
|
|
}
|
|
*/
|
|
|
|
/*
|
|
============
|
|
idAI::
|
|
============
|
|
*/
|
|
|
|
float idAI::GetTurnDelta( void ){
|
|
float amount;
|
|
|
|
if ( move.turnRate ) {
|
|
amount = idMath::AngleNormalize180( move.ideal_yaw - move.current_yaw );
|
|
return amount;
|
|
} else {
|
|
return 0.0f;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::GetIdleAnimName
|
|
============
|
|
*/
|
|
const char* idAI::GetIdleAnimName ( void ) {
|
|
const char* animName = NULL;
|
|
|
|
// Start idle animation
|
|
if ( enemy.ent ) {
|
|
animName = "idle_alert";
|
|
}
|
|
|
|
if ( animName && HasAnim ( ANIMCHANNEL_ALL, animName ) ) {
|
|
return animName;
|
|
}
|
|
|
|
return "idle";
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAI - Enemy Finding
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
============
|
|
idAI::FindEnemy
|
|
============
|
|
*/
|
|
idEntity *idAI::FindEnemy ( bool inFov, bool forceNearest, float maxDistSqr ){
|
|
idActor* actor;
|
|
idActor* bestEnemy;
|
|
idActor* bestEnemyBackup;
|
|
float bestThreat;
|
|
float bestThreatBackup;
|
|
float distSqr;
|
|
float enemyRangeSqr;
|
|
float awareRangeSqr;
|
|
idVec3 origin;
|
|
idVec3 delta;
|
|
pvsHandle_t pvs;
|
|
|
|
// Setup our local variables used in the search
|
|
pvs = gameLocal.pvs.SetupCurrentPVS( GetPVSAreas(), GetNumPVSAreas() );
|
|
bestThreat = 0.0f;
|
|
bestThreatBackup = 0.0f;
|
|
bestEnemy = NULL;
|
|
bestEnemyBackup = NULL;
|
|
awareRangeSqr = Square ( combat.awareRange );
|
|
enemyRangeSqr = enemy.ent ? Square ( enemy.range ) : Square ( combat.attackRange[1] );
|
|
origin = GetEyePosition ( );
|
|
|
|
// Iterate through the enemy team
|
|
for( actor = aiManager.GetEnemyTeam ( (aiTeam_t)team ); actor; actor = actor->teamNode.Next() ) {
|
|
// Skip hidden enemies and enemies that cant be targeted
|
|
if( actor->fl.notarget || actor->fl.isDormant || ( actor->IsHidden ( ) && !actor->IsInVehicle() ) ) {
|
|
continue;
|
|
}
|
|
|
|
// Calculate the distance between ourselves and our potential enemy
|
|
delta = physicsObj.GetOrigin() - actor->GetPhysics()->GetOrigin();
|
|
distSqr = delta.LengthSqr();
|
|
|
|
// Calculate the adjusted threat for this actor
|
|
float threat = CalculateEnemyThreat ( actor );
|
|
|
|
// Save the highest threat enemy as a backup in case we cannot find one we can see
|
|
if ( threat > bestThreatBackup ) {
|
|
bestThreatBackup = threat;
|
|
bestEnemyBackup = actor;
|
|
}
|
|
|
|
// If we have already found a more threatening enemy then attack that
|
|
if ( threat < bestThreat ) {
|
|
continue;
|
|
}
|
|
|
|
// If this enemy isnt in the same pvps then use them as a backup
|
|
if ( !gameLocal.pvs.InCurrentPVS( pvs, actor->GetPVSAreas(), actor->GetNumPVSAreas() ) ) {
|
|
continue;
|
|
}
|
|
|
|
// this is pretty specific to Quake 4, but we don't want the player to be around an enemy too long who can't see him. We need to randomly spike the
|
|
// awareRange on creatures to simulate them looking behind them, or noticing someone standing around for too long.
|
|
// Modders take note, this will prevent most "sneaking up on bad guys" action because they will likely spike their aware ranges out
|
|
// during the sneaking.
|
|
if( gameLocal.random.RandomFloat() < 0.005f ) {
|
|
awareRangeSqr *= 15;
|
|
}
|
|
|
|
// fov doesn't matter if they're within awareRange, we "sense" them if we're alert... (or should LOS not even matter at this point?)
|
|
if ( distSqr < awareRangeSqr || CanSeeFrom ( origin, actor, (inFov && !(combat.fl.aware&&distSqr<awareRangeSqr)) ) ) {
|
|
bestThreat = threat;
|
|
bestEnemy = actor;
|
|
}
|
|
}
|
|
|
|
// If force nearest is set we will give them an enemy reguardless of distance or sight
|
|
if( forceNearest ){
|
|
if( bestEnemy == NULL ){
|
|
bestEnemy = bestEnemyBackup;
|
|
}
|
|
}
|
|
|
|
gameLocal.pvs.FreeCurrentPVS( pvs );
|
|
|
|
return bestEnemy;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CheckForEnemy
|
|
|
|
Look for a suitable enemy
|
|
============
|
|
*/
|
|
bool idAI::CheckForEnemy ( bool useFov, bool force ) {
|
|
idEntity *newEnemy;
|
|
|
|
if ( combat.fl.ignoreEnemies ) {
|
|
return false;
|
|
}
|
|
|
|
// If we already have an enemy and arent being forced to find a new on then just return now
|
|
if ( enemy.ent && !force ) {
|
|
return true;
|
|
}
|
|
|
|
// Save last time we checked for a new enemy
|
|
enemy.checkTime = gameLocal.time;
|
|
|
|
// Dont use fov check when behind cover because you are up against a wall
|
|
newEnemy = FindEnemy ( !IsBehindCover ( ), 0, 0.0f );
|
|
|
|
// Havent found an enemy yet, see if we heard something that can be our enemy
|
|
if ( !newEnemy ) {
|
|
newEnemy = HeardSound( true );
|
|
}
|
|
|
|
// If we still havent found an enemy, see if a teammate can give us one
|
|
if ( !newEnemy ) {
|
|
return CheckForTeammateEnemy ( );
|
|
}
|
|
|
|
SetEnemy( newEnemy );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CheckForTeammateEnemy
|
|
============
|
|
*/
|
|
bool idAI::CheckForTeammateEnemy( void ) {
|
|
idActor* teammate;
|
|
idEntity* teammateEnemy;
|
|
|
|
// Not looking for a new enemy.
|
|
if ( combat.fl.ignoreEnemies ) {
|
|
return false;
|
|
}
|
|
|
|
// Find an enemy from a nearby ally
|
|
teammateEnemy = aiManager.NearestTeammateEnemy ( this, 1000.0f, false, false, &teammate );
|
|
if ( !teammateEnemy || teammateEnemy == enemy.ent ) {
|
|
return false;
|
|
}
|
|
|
|
assert ( teammate );
|
|
|
|
// Attempt to set the new enemy
|
|
if ( !SetEnemy ( teammateEnemy ) ) {
|
|
return false;
|
|
}
|
|
|
|
// If the ally is another AI entity we can use their enemy visibility information
|
|
if ( teammate->IsType ( idAI::Type ) ) {
|
|
idAI* teammateAI = static_cast<idAI*>(teammate);
|
|
enemy.smoothedLinearVelocity = teammateAI->enemy.smoothedLinearVelocity;
|
|
enemy.smoothedPushedVelocity = teammateAI->enemy.smoothedPushedVelocity;
|
|
enemy.lastKnownPosition = teammateAI->enemy.lastKnownPosition;
|
|
enemy.lastVisibleEyePosition = teammateAI->enemy.lastVisibleEyePosition;
|
|
enemy.lastVisibleFromEyePosition = teammateAI->enemy.lastVisibleEyePosition;
|
|
enemy.lastVisibleChestPosition = teammateAI->enemy.lastVisibleChestPosition;
|
|
enemy.lastVisibleTime = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CheckForCloserEnemy
|
|
============
|
|
*/
|
|
bool idAI::CheckForCloserEnemy ( void ) {
|
|
idEntity* newEnemy = NULL;
|
|
float maxDistSqr;
|
|
|
|
// Not looking for a new enemy.
|
|
if ( combat.fl.ignoreEnemies ) {
|
|
return false;
|
|
}
|
|
|
|
// See if we happen to have heard someone this frame that we can use
|
|
newEnemy = HeardSound( true );
|
|
if ( newEnemy && newEnemy != enemy.ent && newEnemy->IsType( idActor::GetClassType() ) ) {
|
|
//heard someone else!
|
|
float newDist = DistanceTo ( newEnemy->GetPhysics()->GetOrigin() );
|
|
|
|
// Are they closer than the enemy we are fighting?
|
|
if ( newDist < enemy.range ) {
|
|
//new enemy is closer than current one, take them!
|
|
SetEnemy( newEnemy );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if ( GetEnemy() && enemy.range ) {
|
|
maxDistSqr = Min( Square ( enemy.range ), Square ( combat.awareRange ) );
|
|
} else {
|
|
maxDistSqr = Square ( combat.awareRange );
|
|
}
|
|
|
|
newEnemy = FindEnemy( false, 0, maxDistSqr );
|
|
|
|
if ( !newEnemy ) {
|
|
return false;
|
|
}
|
|
|
|
SetEnemy( newEnemy );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CheckForReplaceEnemy
|
|
|
|
TODO: Call CalculateThreat ( ent ) and compare to current entity
|
|
============
|
|
*/
|
|
bool idAI::CheckForReplaceEnemy ( idEntity* replacement ) {
|
|
bool replace;
|
|
|
|
// If our replacement is a driver a vehicle and they are hidden we will
|
|
// want to shoot back at their vehicle not them.
|
|
idActor* actor;
|
|
actor = dynamic_cast<idActor*>(replacement);
|
|
if ( actor && actor->IsInVehicle ( ) && actor->IsHidden ( ) ) {
|
|
replacement = actor->GetVehicleController ( ).GetVehicle ( );
|
|
}
|
|
|
|
// Invalid replacement?
|
|
if ( !replacement) {
|
|
return false;
|
|
}
|
|
|
|
// Not looking for a new enemy.
|
|
if ( combat.fl.ignoreEnemies ) {
|
|
return false;
|
|
}
|
|
|
|
if ( replacement == enemy.ent ) {
|
|
return false;
|
|
}
|
|
|
|
// Dont want to set our enemy to a friendly target
|
|
if ( replacement->IsType( idActor::GetClassType() ) && (static_cast<idActor*>(replacement))->team == team ) {
|
|
return false;
|
|
}
|
|
|
|
// Not having an enemy will set it immediately
|
|
if ( !enemy.ent ) {
|
|
SetEnemy ( replacement );
|
|
return true;
|
|
}
|
|
|
|
// Dont change enemies too often when being hit
|
|
if ( gameLocal.time - enemy.changeTime < 1000 ) {
|
|
return false;
|
|
}
|
|
|
|
replace = false;
|
|
|
|
// If new enemy is more threatening then replace it reguardless if we can see it
|
|
if ( CalculateEnemyThreat ( replacement ) > CalculateEnemyThreat ( enemy.ent ) ) {
|
|
replace = true;
|
|
// Replace our enemy if we havent seen ours in a bit
|
|
} else if ( !IsEnemyRecentlyVisible ( 0.25f ) ) {
|
|
replace = true;
|
|
}
|
|
|
|
// Replace enemy?
|
|
if ( replace ) {
|
|
SetEnemy ( replacement );
|
|
}
|
|
|
|
return replace;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::UpdateThreat
|
|
============
|
|
*/
|
|
void idAI::UpdateThreat ( void ) {
|
|
// Start threat at base threat level
|
|
combat.threatCurrent = combat.threatBase;
|
|
|
|
// Adjust threat using current tactical state
|
|
switch ( combat.tacticalCurrent ) {
|
|
case AITACTICAL_HIDE: combat.threatCurrent *= 0.5f; break;
|
|
case AITACTICAL_MELEE: combat.threatCurrent *= 2.0f; break;
|
|
}
|
|
|
|
// Signifigantly reduced threat when in undying mode
|
|
if ( aifl.undying ) {
|
|
combat.threatCurrent *= 0.25f;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CalculateEnemyThreat
|
|
============
|
|
*/
|
|
float idAI::CalculateEnemyThreat ( idEntity* enemyEnt ) {
|
|
// Calculate the adjusted threat for this actor
|
|
float threat = 1.0f;
|
|
if ( enemyEnt->IsType ( idAI::GetClassType ( ) ) ) {
|
|
idAI* enemyAI = static_cast<idAI*>(enemyEnt);
|
|
threat = enemyAI->combat.threatCurrent;
|
|
|
|
// Increase threat for enemies that are targetting us
|
|
if ( enemyAI->enemy.ent == this && enemyAI->combat.tacticalCurrent == AITACTICAL_MELEE ) {
|
|
threat *= 2.0f;
|
|
}
|
|
} else if ( enemyEnt->IsType ( idPlayer::GetClassType ( ) ) ) {
|
|
threat = 2.0f;
|
|
} else {
|
|
threat = 1.0f;
|
|
}
|
|
|
|
float enemyRangeSqr;
|
|
float distSqr;
|
|
|
|
enemyRangeSqr = (enemy.ent) ? Square ( enemy.range ) : Square ( combat.attackRange[1] );
|
|
distSqr = (physicsObj.GetOrigin ( ) - enemyEnt->GetPhysics()->GetOrigin ( )).LengthSqr ( );
|
|
|
|
if ( distSqr > 0 ) {
|
|
return threat * (enemyRangeSqr / distSqr);
|
|
}
|
|
|
|
return threat;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CheckBlink
|
|
============
|
|
*/
|
|
void idAI::CheckBlink ( void ) {
|
|
// if ( IsSpeaking ( ) ) {
|
|
// return;
|
|
// }
|
|
idActor::CheckBlink ( );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::Speak
|
|
============
|
|
*/
|
|
bool idAI::Speak( const char *lipsync, bool random ){
|
|
assert( idStr::Icmpn( lipsync, "lipsync_", 7 ) == 0 );
|
|
|
|
if ( random ) {
|
|
// If there is no lipsync then skip it
|
|
if ( spawnArgs.MatchPrefix ( lipsync ) ) {
|
|
lipsync = spawnArgs.RandomPrefix ( lipsync, gameLocal.random );
|
|
} else {
|
|
lipsync = NULL;
|
|
}
|
|
} else {
|
|
lipsync = spawnArgs.GetString ( lipsync );
|
|
}
|
|
|
|
if ( !lipsync || !*lipsync ) {
|
|
return false;
|
|
}
|
|
|
|
if ( head ) {
|
|
speakTime = head->StartLipSyncing( lipsync );
|
|
} else {
|
|
speakTime = 0;
|
|
StartSoundShader (declManager->FindSound ( lipsync ), SND_CHANNEL_VOICE, SSF_IS_VO, false, &speakTime );
|
|
}
|
|
|
|
speakTime += gameLocal.time;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::StopSpeaking
|
|
============
|
|
*/
|
|
void idAI::StopSpeaking( bool stopAnims ){
|
|
speakTime = 0;
|
|
StopSound( SND_CHANNEL_VOICE, false );
|
|
if ( head.GetEntity() ) {
|
|
head.GetEntity()->StopSound( SND_CHANNEL_VOICE, false );
|
|
if ( stopAnims ) {
|
|
head.GetEntity()->GetAnimator()->ClearAllAnims( gameLocal.time, 100 );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::CanHitEnemyFromAnim
|
|
============
|
|
*/
|
|
bool idAI::CanHitEnemyFromAnim( int animNum, idVec3 offset ) {
|
|
idVec3 dir;
|
|
idVec3 local_dir;
|
|
idVec3 fromPos;
|
|
idMat3 axis;
|
|
idVec3 start;
|
|
trace_t tr;
|
|
idEntity* enemyEnt;
|
|
|
|
// Need an enemy.
|
|
if ( !enemy.ent ) {
|
|
return false;
|
|
}
|
|
|
|
// Enemy actor pointer
|
|
enemyEnt = static_cast<idEntity*>(enemy.ent.GetEntity());
|
|
|
|
// just do a ray test if close enough
|
|
if ( enemyEnt->GetPhysics()->GetAbsBounds().IntersectsBounds( physicsObj.GetAbsBounds().Expand( 16.0f ) ) ) {
|
|
return CanHitEnemy();
|
|
}
|
|
|
|
// calculate the world transform of the launch position
|
|
idVec3 org = physicsObj.GetOrigin()+offset;
|
|
idVec3 from;
|
|
dir = enemy.lastVisibleChestPosition - org;
|
|
physicsObj.GetGravityAxis().ProjectVector( dir, local_dir );
|
|
local_dir.z = 0.0f;
|
|
local_dir.ToVec2().Normalize();
|
|
axis = local_dir.ToMat3();
|
|
from = org + attackAnimInfo[ animNum ].attackOffset * axis;
|
|
|
|
/*
|
|
if( DebugFilter(ai_debugTactical) ) {
|
|
gameRenderWorld->DebugLine ( colorYellow, org + attackAnimInfo[ animNum ].eyeOffset * viewAxis, from, 5000 );
|
|
gameRenderWorld->DebugLine ( colorOrange, from, enemy.lastVisibleEyePosition, 5000 );
|
|
}
|
|
*/
|
|
|
|
// If the point we are shooting from is within our bounds then we are good to go, otherwise make sure its not in a wall
|
|
const idBounds &ownerBounds = physicsObj.GetAbsBounds();
|
|
if ( !ownerBounds.ContainsPoint ( from ) ) {
|
|
trace_t tr;
|
|
if ( !g_perfTest_aiNoVisTrace.GetBool() ) {
|
|
gameLocal.TracePoint( this, tr, org + attackAnimInfo[ animNum ].eyeOffset * axis, from, MASK_SHOT_BOUNDINGBOX, this );
|
|
if ( tr.fraction < 1.0f ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return CanSeeFrom ( from, enemy.lastVisibleEyePosition, true );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::ScriptedBegin
|
|
================
|
|
*/
|
|
bool idAI::ScriptedBegin ( bool endWithIdle, bool allowDormant ) {
|
|
if ( aifl.dead ) {
|
|
return false;
|
|
}
|
|
|
|
// Wakeup if not awake already
|
|
WakeUp ( );
|
|
|
|
aifl.scriptedEndWithIdle = endWithIdle;
|
|
aifl.scripted = true;
|
|
// combat.fl.aware = false;
|
|
combat.tacticalCurrent = AITACTICAL_NONE;
|
|
|
|
// Make sure the entity never goes dormant during a scripted event or
|
|
// the event may never end.
|
|
aifl.scriptedNeverDormant = !allowDormant;
|
|
dormantStart = 0;
|
|
|
|
/*
|
|
// actors will ignore enemies during scripted events
|
|
ClearEnemy ( );
|
|
*/
|
|
|
|
// Cancel any current movement
|
|
StopMove ( MOVE_STATUS_DONE );
|
|
|
|
move.fl.allowAnimMove = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::ScriptedEnd
|
|
================
|
|
*/
|
|
void idAI::ScriptedEnd ( void ) {
|
|
dormantStart = 0;
|
|
aifl.scripted = false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::ScriptedStop
|
|
================
|
|
*/
|
|
void idAI::ScriptedStop ( void ) {
|
|
if ( !aifl.scripted ) {
|
|
return;
|
|
}
|
|
aifl.scriptedEndWithIdle = true;
|
|
aifl.scripted = false;
|
|
StopMove( MOVE_STATUS_DONE );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::ScriptedMove
|
|
================
|
|
*/
|
|
void idAI::ScriptedMove ( idEntity* destEnt, float minDist, bool endWithIdle ) {
|
|
if ( !ScriptedBegin ( endWithIdle ) ) {
|
|
return;
|
|
}
|
|
|
|
//disable all temporary blocked reachabilities due to teammate obstacle avoidance
|
|
aiManager.UnMarkAllReachBlocked();
|
|
//attempt the move - NOTE: this *can* fail if there's no route or AAS obstacles are in the way!
|
|
MoveToEntity ( destEnt, minDist );
|
|
//re-enable all temporary blocked reachabilities due to teammate obstacle avoidance
|
|
aiManager.ReMarkAllReachBlocked();
|
|
|
|
// Move the torso to the idle state if its not already there
|
|
SetAnimState( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
|
|
|
|
// Move the legs into the idle state so he will start moving
|
|
SetAnimState( ANIMCHANNEL_LEGS, "Legs_Idle", 4 );
|
|
|
|
// Set up state loop for moving
|
|
SetState ( "State_ScriptedMove" );
|
|
PostState ( "State_ScriptedStop" );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::ScriptedFace
|
|
================
|
|
*/
|
|
void idAI::ScriptedFace ( idEntity* faceEnt, bool endWithIdle ) {
|
|
if ( !ScriptedBegin ( endWithIdle ) ) {
|
|
return;
|
|
}
|
|
|
|
// Force idle while facing
|
|
SetAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", 4 );
|
|
SetAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
|
|
|
|
// Start facing the entity
|
|
FaceEntity ( faceEnt );
|
|
|
|
SetState ( "State_ScriptedFace" );
|
|
PostState ( "State_ScriptedStop" );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idAI::ScriptedAnim
|
|
|
|
Plays an the given animation in an un-interruptable state. If looping will continue indefinately until
|
|
another operation which will stop a scripted sequence is called. When done can optionally return the character
|
|
back to their normal processing if endWithIdle is set to true.
|
|
================
|
|
*/
|
|
void idAI::ScriptedAnim ( const char* animname, int blendFrames, bool loop, bool endWithIdle ) {
|
|
// Start the scripted sequence
|
|
if ( !ScriptedBegin ( endWithIdle, true ) ) {
|
|
return;
|
|
}
|
|
|
|
TurnToward ( move.current_yaw );
|
|
|
|
if ( loop ) {
|
|
// Loop the given animation
|
|
PlayCycle ( ANIMCHANNEL_TORSO, animname, blendFrames );
|
|
} else {
|
|
// Play the given animation
|
|
PlayAnim ( ANIMCHANNEL_TORSO, animname, blendFrames );
|
|
}
|
|
|
|
SetAnimState ( ANIMCHANNEL_LEGS, "Wait_Frame" );
|
|
SetAnimState ( ANIMCHANNEL_TORSO, "Torso_ScriptedAnim" );
|
|
|
|
DisableAnimState ( ANIMCHANNEL_LEGS );
|
|
|
|
SetState ( "Wait_ScriptedDone" );
|
|
PostState ( "State_ScriptedStop" );
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
idAI::ScriptedPlaybackAim
|
|
============
|
|
*/
|
|
void idAI::ScriptedPlaybackAim ( const char* playback, int flags, int numFrames ) {
|
|
// Start the scripted sequence
|
|
if ( !ScriptedBegin ( false ) ) {
|
|
return;
|
|
}
|
|
|
|
mLookPlayback.Start( spawnArgs.GetString ( playback ), this, flags, numFrames );
|
|
|
|
// Wait till its done and mark it finished
|
|
SetState ( "State_ScriptedPlaybackAim" );
|
|
PostState ( "State_ScriptedStop" );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::ScriptedAction
|
|
============
|
|
*/
|
|
void idAI::ScriptedAction ( idEntity* actionEnt, bool endWithIdle ) {
|
|
const char* actionName;
|
|
|
|
if ( !actionEnt ) {
|
|
return;
|
|
}
|
|
|
|
// Get the action name
|
|
actionName = actionEnt->spawnArgs.GetString ( "action" );
|
|
if ( !*actionName ) {
|
|
gameLocal.Error ( "missing action keyword on scripted action entity '%s' for ai '%s'",
|
|
actionEnt->GetName(),
|
|
GetName() );
|
|
return;
|
|
}
|
|
|
|
// Start the scripted sequence
|
|
if ( !ScriptedBegin ( endWithIdle ) ) {
|
|
return;
|
|
}
|
|
|
|
scriptedActionEnt = actionEnt;
|
|
|
|
SetState ( "State_ScriptedStop" );
|
|
PerformAction ( va("TorsoAction_%s", actionName ), 4, true );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::FootStep
|
|
============
|
|
*/
|
|
void idAI::FootStep ( void ) {
|
|
idActor::FootStep ( );
|
|
|
|
ExecScriptFunction( funcs.footstep );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::SetScript
|
|
============
|
|
*/
|
|
void idAI::SetScript( const char* scriptName, const char* funcName ) {
|
|
if ( !funcName || !funcName[0] ) {
|
|
return;
|
|
}
|
|
|
|
// Set the associated script
|
|
if ( !idStr::Icmp ( scriptName, "first_sight" ) ) {
|
|
funcs.first_sight.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "sight" ) ) {
|
|
funcs.sight.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "pain" ) ) {
|
|
funcs.pain.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "damage" ) ) {
|
|
funcs.damage.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "death" ) ) {
|
|
funcs.death.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "attack" ) ) {
|
|
funcs.attack.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "init" ) ) {
|
|
funcs.init.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "onclick" ) ) {
|
|
funcs.onclick.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "launch_projectile" ) ) {
|
|
funcs.launch_projectile.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "footstep" ) ) {
|
|
funcs.footstep.Init( funcName );
|
|
} else if ( !idStr::Icmp ( scriptName, "postHeal" ) ) {
|
|
// hax: this is a medic only script and I don't want to store it on every AI type..
|
|
// I also don't want it generating the warning below in this case.
|
|
} else if ( !idStr::Icmp ( scriptName, "postWeaponDestroyed" ) ) {
|
|
// hax: this is a Gladiator/Light Tank only script and I don't want to store it on every AI type..
|
|
// I also don't want it generating the warning below in this case.
|
|
} else {
|
|
gameLocal.Warning ( "unknown script '%s' specified on entity '%s'", scriptName, name.c_str() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAI - Reactions
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
============
|
|
idAI::ReactToShotAt
|
|
============
|
|
*/
|
|
void idAI::ReactToShotAt ( idEntity* attacker, const idVec3 &origOrigin, const idVec3 &origDir ) {
|
|
if ( g_perfTest_aiNoDodge.GetBool() ) {
|
|
return;
|
|
}
|
|
|
|
idVec3 foo;
|
|
idVec3 diff;
|
|
diff = GetPhysics()->GetOrigin() - origOrigin;
|
|
diff = origOrigin + diff.ProjectOntoVector ( origDir ) * origDir;
|
|
diff = diff - GetPhysics()->GetOrigin();
|
|
diff.NormalizeFast ( );
|
|
diff.z = 0;
|
|
|
|
idAngles angles = diff.ToAngles ( );
|
|
float angleDelta = idMath::AngleDelta ( angles[YAW], move.current_yaw );
|
|
|
|
combat.shotAtTime = gameLocal.time;
|
|
combat.shotAtAngle = angleDelta;
|
|
|
|
// Someone is attacking us so give them a chance to be our new enemy
|
|
CheckForReplaceEnemy ( attacker );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::ReactToPain
|
|
============
|
|
*/
|
|
void idAI::ReactToPain ( idEntity* attacker, int damage ) {
|
|
CheckForReplaceEnemy ( attacker );
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAI - Helpers
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
============
|
|
idAI::UpdateHelper
|
|
============
|
|
*/
|
|
void idAI::UpdateHelper ( void ) {
|
|
rvAIHelper* oldhelper;
|
|
|
|
// Link ourselves to the closest helper
|
|
oldhelper = helperCurrent;
|
|
helperCurrent = aiManager.FindClosestHelper ( physicsObj.GetOrigin() );
|
|
|
|
// Ideal stays the same as current as long as it was the same when we started
|
|
if ( oldhelper == helperIdeal ) {
|
|
helperIdeal = helperCurrent;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::GetActiveHelper
|
|
|
|
When we have an enemy our current helper becomes the active helper, when we dont have an
|
|
enemy we instead use our ideal.
|
|
============
|
|
*/
|
|
rvAIHelper* idAI::GetActiveHelper ( void ) {
|
|
return GetEnemy ( ) ? helperCurrent : helperIdeal;
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAI - Tethers
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
============
|
|
idAI::SetTether
|
|
============
|
|
*/
|
|
void idAI::SetTether ( rvAITether* newTether ) {
|
|
aifl.tetherMover = false;
|
|
|
|
// Clear our current tether?
|
|
if ( !newTether ) {
|
|
if ( tether ) {
|
|
tether = NULL;
|
|
ForceTacticalUpdate ( );
|
|
}
|
|
} else if ( newTether->IsType ( rvAITetherClear::GetClassType ( ) ) ) {
|
|
SetTether ( NULL );
|
|
} else {
|
|
if ( newTether && !newTether->ValidateAAS ( this ) ) {
|
|
// If you have aas error out to make them fix it
|
|
if ( aas ) {
|
|
gameLocal.Error ( "tether entity '%s' does no link into the aas for ai '%s'. (try moving it closer to the floor where the aas is)",
|
|
newTether->GetName(), GetName () );
|
|
// If we dont have aas, just warn
|
|
} else {
|
|
gameLocal.Warning ( "tether entity '%s' does no link into the aas for ai '%s'. (there is no aas available)",
|
|
newTether->GetName(), GetName () );
|
|
}
|
|
SetTether ( NULL );
|
|
} else if ( newTether != tether ) {
|
|
tether = newTether;
|
|
ForceTacticalUpdate ( );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::GetTether
|
|
============
|
|
*/
|
|
rvAITether* idAI::GetTether ( void ) {
|
|
return tether;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::IsTethered
|
|
============
|
|
*/
|
|
bool idAI::IsTethered ( void ) const {
|
|
// Need a tether entity to be tethered
|
|
if ( !tether ) {
|
|
return false;
|
|
}
|
|
// If we have an enemy and that enemy is within our tether then break it if we can
|
|
if ( enemy.ent && enemy.ent->IsType ( idAI::GetClassType() ) && tether->CanBreak ( ) ) {
|
|
if ( tether->ValidateDestination ( static_cast<idAI*>(enemy.ent.GetEntity()), enemy.lastKnownPosition ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::IsWithinTether
|
|
============
|
|
*/
|
|
bool idAI::IsWithinTether ( void ) const {
|
|
if ( !IsTethered ( ) ) {
|
|
return false;
|
|
}
|
|
if ( !tether->ValidateDestination ( (idAI*)this, physicsObj.GetOrigin ( ) ) ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idAI - NonCombat
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
/*
|
|
=====================
|
|
idAI::SetTalkState
|
|
=====================
|
|
*/
|
|
void idAI::SetTalkState ( talkState_t state ) {
|
|
// Make sure state is valid
|
|
if ( ( state < 0 ) || ( state >= NUM_TALK_STATES ) ) {
|
|
gameLocal.Error( "Invalid talk state (%d)", (int)state );
|
|
}
|
|
|
|
// Same state we are already in?
|
|
if ( talkState == state ) {
|
|
return;
|
|
}
|
|
|
|
// Set new talk state
|
|
talkState = state;
|
|
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::SetPassivePrefix
|
|
============
|
|
*/
|
|
void idAI::SetPassivePrefix ( const char* prefix ) {
|
|
passive.prefix = prefix;
|
|
if ( passive.prefix.Length() ) {
|
|
passive.prefix += "_";
|
|
}
|
|
|
|
// Force an idle change
|
|
passive.idleAnimChangeTime = 0;
|
|
passive.fidgetTime = 0;
|
|
passive.talkTime = 0;
|
|
|
|
// Get animation prefixs
|
|
passive.fl.multipleIdles = GetPassiveAnimPrefix ( "idle", passive.animIdlePrefix );
|
|
GetPassiveAnimPrefix ( "fidget", passive.animFidgetPrefix );
|
|
GetPassiveAnimPrefix ( "talk", passive.animTalkPrefix );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAI::GetPassiveAnimPrefix
|
|
============
|
|
*/
|
|
bool idAI::GetPassiveAnimPrefix ( const char* animName, idStr& animPrefix ) {
|
|
const idKeyValue* key;
|
|
|
|
// First see if we have custom idle animations for the passive prefix
|
|
key = NULL;
|
|
if ( passive.prefix.Length ( ) ) {
|
|
animPrefix = va("anim_%s%s", passive.prefix.c_str(), animName );
|
|
key = spawnArgs.MatchPrefix ( animPrefix );
|
|
}
|
|
|
|
// If there are no custom idle animations for the prefix then see if there are any custom anims at all
|
|
if ( !key ) {
|
|
animPrefix = va("anim_%s", animName );
|
|
key = spawnArgs.MatchPrefix ( animPrefix );
|
|
}
|
|
|
|
if ( !key ) {
|
|
animPrefix = "";
|
|
return false;
|
|
}
|
|
|
|
return spawnArgs.MatchPrefix ( animPrefix, key ) ? true : false;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idAI::IsMeleeNeeded
|
|
===================
|
|
*/
|
|
bool idAI::IsMeleeNeeded( void ) {
|
|
|
|
if( enemy.ent && enemy.ent->IsType ( idAI::Type )) {
|
|
|
|
idAI* enemyAI = static_cast<idAI*>(enemy.ent.GetEntity());
|
|
|
|
//if our enemy is closing in on us and demands melee, we'll meet him.
|
|
if ( enemyAI->combat.tacticalCurrent == AITACTICAL_MELEE && enemy.range < combat.meleeRange ) {
|
|
return true;
|
|
}
|
|
|
|
//other checks...
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
===================
|
|
idAI::IsCrouching
|
|
===================
|
|
*/
|
|
bool idAI::IsCrouching( void ) const {
|
|
return move.fl.crouching;
|
|
}
|
|
|
|
bool idAI::CheckDeathCausesMissionFailure( void )
|
|
{
|
|
if ( spawnArgs.GetString( "objectivetitle_failed", NULL ) )
|
|
{
|
|
return true;
|
|
}
|
|
if ( targets.Num() )
|
|
{
|
|
//go through my targets and see if any are of class rvObjectiveFailed
|
|
idEntity* targEnt;
|
|
for( int i = 0; i < targets.Num(); i++ ) {
|
|
targEnt = targets[ i ].GetEntity();
|
|
if ( !targEnt )
|
|
{
|
|
continue;
|
|
}
|
|
if ( !targEnt->IsType( rvObjectiveFailed::GetClassType() ) ) {
|
|
continue;
|
|
}
|
|
if ( !spawnArgs.GetString( "inv_objective", NULL ) ) {
|
|
continue;
|
|
}
|
|
//yep!
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|