id-software/DoomRTX
1
0
Fork 0
mirror of https://github.com/jmarshall23/DoomRTX.git synced 2026-08-16 00:01:53 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
4ffd8b753305f29dd89a7ebcf62bc9224bc095ac
DoomRTX/neo/prey/Prey/game_monster_ai.cpp
T
Justin Marshall 8d5f678b25 Initial Prey Game integration support.
2026-05-05 15:01:01 -07:00

2159 lines
66 KiB
C++
Raw Blame History

#include "precompiled.h"
#pragma hdrstop
#include "prey_local.h"
//-----------------------------------------------------
// hhNoClipEnt
//-----------------------------------------------------
CLASS_DECLARATION(idEntity, hhNoClipEnt)
END_CLASS
void hhNoClipEnt::Spawn( void ) {
if(GetPhysics())
GetPhysics()->SetContents(0);
}
//-----------------------------------------------------
// hhAINode
//-----------------------------------------------------
CLASS_DECLARATION( idEntity, hhAINode )
END_CLASS
hhAINode::hhAINode( void ) {
user.Clear();
}
void hhAINode::Save( idSaveGame *savefile ) const {
user.Save( savefile );
}
void hhAINode::Restore( idRestoreGame *savefile ) {
user.Restore( savefile );
}
//-----------------------------------------------------
// hhMonsterAI
//-----------------------------------------------------
idList<idAI*> hhMonsterAI::allSimpleMonsters;
hhMonsterAI::hhMonsterAI() {
lookOffset = ang_zero;
shootTarget = NULL;
bBossBar = false;
spawnThinkFlags = 0;
lastContactTime = gameLocal.time;
nextSpeechTime = gameLocal.time;
frozen = false;
soundOnModel = false;
}
hhMonsterAI::~hhMonsterAI() {
allSimpleMonsters.Remove(this);
if ( bBossBar && spawnArgs.GetBool( "remove_bar_on_dissolve" ) ) {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player && player->hud ) {
bBossBar = false;
player->hud->HandleNamedEvent("HideProgressBar");
player->hud->StateChanged(gameLocal.time);
}
}
}
void hhMonsterAI::Spawn() {
AI_HAS_RANGE_ATTACK = spawnArgs.GetBool("has_range_attack", "0");
AI_HAS_MELEE_ATTACK = spawnArgs.GetBool("has_melee_attack", "0");
targetReaction.reactionIndex = -1;
targetReaction.entity = NULL;
allSimpleMonsters.AddUnique(this);
bBindAxis = spawnArgs.GetBool( "bind_axis" );
bCanFall = spawnArgs.GetBool( "can_fall", "0" );
bSeeThroughPortals = spawnArgs.GetBool( "can_see_portals", "0" );
bBindOrient = spawnArgs.GetBool( "bind_orient", "0" );
hearingRange = spawnArgs.GetInt( "hearing_range", "1024" );
bCanWallwalk = spawnArgs.GetBool( "can_wallwalk", "0" );
fallDelay = spawnArgs.GetInt( "fall_delay" );
bOverrideKilledByGravityZones = spawnArgs.GetBool( "overrideKilledByGravityZones" );
bNeverTarget = spawnArgs.GetBool( "never_target", "0" );
bNoCombat = spawnArgs.GetBool( "no_combat", "0" );
const char *temp;
if ( spawnArgs.GetString( "fx_custom_blood", "", &temp ) ) {
bCustomBlood = true;
} else {
bCustomBlood = false;
}
nextSpiritProxyCheck = 0;
nextTurnUpdate = 0;
frozen = false;
//handle initial rotation and sticking on wallwalk
if ( !IsHidden() ) {
PostEventSec( &MA_InitialWallwalk, 0.1f );
PostEventMS(&MA_EnemyOnSpawn, 10);
}
PostEventMS(&EV_PostSpawn, 0);
if ( spawnArgs.GetInt( "wander_radius" ) ) {
spawnOrigin = GetOrigin();
}
// CJR: Clear the DDA values used for tracking damage inflicted on the player
totalDDADamage = 0;
}
void hhMonsterAI::Event_PostSpawn() {
CreateHealthTriggers();
//TODO: Move to character/girlfriend code when it exists
// Spawn earrings for girlfriend
idEntity *ent;
const char *defName = spawnArgs.GetString("def_earring", NULL);
if (defName && defName[0] && head.IsValid()) {
const char *boneNameL = spawnArgs.GetString("earringboneL");
const char *boneNameR = spawnArgs.GetString("earringboneR");
idDict args;
args.Clear();
args.Set( "origin", GetPhysics()->GetOrigin().ToString() );
ent = gameLocal.SpawnObject(defName, &args);
if (ent) {
ent->MoveToJoint(head.GetEntity(), boneNameL);
ent->BindToJoint(head.GetEntity(), boneNameL, false);
}
ent = gameLocal.SpawnObject(defName, &args);
if (ent) {
ent->MoveToJoint(head.GetEntity(), boneNameR);
ent->BindToJoint(head.GetEntity(), boneNameR, false);
}
}
}
bool hhMonsterAI::HasPathTo(const idVec3 &destPt) {
if(!GetAAS()) // || !allowAAS) //TODO: support the allowAAS functionality
return FALSE;
idVec3 fromPos = GetPhysics()->GetOrigin();
int currAreaNum = PointReachableAreaNum(fromPos);
int toAreaNum = PointReachableAreaNum(destPt);
// Invalid #'s ?
if(toAreaNum == 0 || currAreaNum == 0)
return FALSE;
aasPath_t path;
return PathToGoal(path, currAreaNum, fromPos, toAreaNum, destPt);
}
/*
==============================
hhMonsterAI::LinkScriptVariables(void)
==============================
*/
#define LinkScriptVariable( name ) name.LinkTo( scriptObject, #name )
void hhMonsterAI::LinkScriptVariables(void) {
idAI::LinkScriptVariables();
LinkScriptVariable( AI_HAS_RANGE_ATTACK ); // required for reaction system
LinkScriptVariable( AI_HAS_MELEE_ATTACK ); // required for reaction system
LinkScriptVariable( AI_USING_REACTION ); // TRUE if monster is currently using reaction
LinkScriptVariable( AI_REACTION_FAILED ); // TRUE if the last reaction attempt failed (path blocked, exclusive problem, etc)
LinkScriptVariable( AI_REACTION_ANIM );
LinkScriptVariable( AI_BACKWARD );
LinkScriptVariable( AI_STRAFE_LEFT );
LinkScriptVariable( AI_STRAFE_RIGHT );
LinkScriptVariable( AI_UPWARD );
LinkScriptVariable( AI_DOWNWARD );
LinkScriptVariable( AI_SHUTTLE_DOCKED );
LinkScriptVariable( AI_VEHICLE_ATTACK );
LinkScriptVariable( AI_VEHICLE_ALT_ATTACK );
LinkScriptVariable( AI_WALLWALK );
LinkScriptVariable( AI_FALLING );
LinkScriptVariable( AI_PATHING );
LinkScriptVariable( AI_TURN_DIR );
LinkScriptVariable( AI_FLY_NO_SEEK );
LinkScriptVariable( AI_FOLLOWING_PATH );
}
void hhMonsterAI::Think( void ) {
PROFILE_SCOPE("AI", PROFMASK_NORMAL|PROFMASK_AI);
if (ai_skipThink.GetBool()) { //HUMANHEAD rww
return;
}
idVec3 oldOrigin = physicsObj.GetOrigin();
idVec3 oldVelocity = physicsObj.GetLinearVelocity();
if ( thinkFlags & TH_THINK ) {
// Update vehicle guns
if(AI_VEHICLE && InVehicle()) {
usercmd_t cmds;
const signed char speed = 64; // In range [0..127]
memset( &cmds, 0, sizeof(usercmd_t) );
cmds.buttons |= (AI_VEHICLE_ATTACK) ? BUTTON_ATTACK : 0;
cmds.buttons |= (AI_VEHICLE_ALT_ATTACK) ? BUTTON_ATTACK_ALT : 0;
if(AI_FORWARD) {
cmds.forwardmove = speed;
} else if(AI_BACKWARD) {
cmds.forwardmove = -speed;
}
if(AI_STRAFE_RIGHT) {
cmds.rightmove = speed;
} else if(AI_STRAFE_LEFT) {
cmds.rightmove = -speed;
}
if(AI_UPWARD) {
cmds.upmove = speed;
} else if(AI_DOWNWARD) {
cmds.upmove = -speed;
}
GetVehicleInterfaceLocal()->BufferPilotCmds( &cmds, NULL );
AI_SHUTTLE_DOCKED = GetVehicleInterfaceLocal()->IsVehicleDocked();
}
// clear out the enemy when he dies or is hidden
idActor *enemyEnt = enemy.GetEntity();
if ( enemyEnt ) {
if ( enemyEnt->IsType( hhSpiritProxy::Type ) ) {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player && player->AI_DEAD ) {
EnemyDead();
}
} else if ( enemyEnt->health <= 0 ) {
EnemyDead();
}
}
//HUMANHEAD: aob - vehicle updates our viewAxis
if( !InVehicle() ) {
current_yaw += deltaViewAngles.yaw;
ideal_yaw = idMath::AngleNormalize180( ideal_yaw + deltaViewAngles.yaw );
deltaViewAngles.Zero();
viewAxis = idAngles( 0, current_yaw, 0 ).ToMat3();
// Determine turn dir
if (gameLocal.time > nextTurnUpdate) {
AI_TURN_DIR = GetTurnDir();
nextTurnUpdate = gameLocal.time + 250;
}
}
//HUMANHEAD END
if ( num_cinematics ) {
if ( !IsHidden() && torsoAnim.AnimDone( 0 ) ) {
PlayCinematic();
}
RunPhysics();
} else if ( !allowHiddenMovement && IsHidden() ) {
// hidden monsters
UpdateAIScript();
// HUMANHEAD pdm: Vehicle support
} else if ( InVehicle() ) {
UpdateEnemyPosition();
UpdateAIScript();
FlyMove();
// HUMANHEAD END
} else {
// clear the ik before we do anything else so the skeleton doesn't get updated twice
walkIK.ClearJointMods();
// HUMANHEAD NLA
physicsObj.ResetNumTouchEnt(0);
// HUMANHEAD END
switch( move.moveType ) {
case MOVETYPE_DEAD :
// dead monsters
UpdateAIScript();
DeadMove();
break;
case MOVETYPE_FLY :
// flying monsters
UpdateEnemyPosition();
UpdateAIScript();
FlyMove();
PlayChatter();
CheckBlink();
break;
case MOVETYPE_STATIC :
// static monsters
UpdateEnemyPosition();
UpdateAIScript();
StaticMove();
PlayChatter();
CheckBlink();
break;
case MOVETYPE_ANIM :
// animation based movement
UpdateEnemyPosition();
UpdateAIScript();
AnimMove();
PlayChatter();
CheckBlink();
break;
case MOVETYPE_SLIDE :
// velocity based movement
UpdateEnemyPosition();
UpdateAIScript();
SlideMove();
PlayChatter();
CheckBlink();
break;
}
// HUMANHEAD NLA
ClientImpacts();
// HUMANHEAD END
}
// clear pain flag so that we recieve any damage between now and the next time we run the script
AI_PAIN = false;
AI_SPECIAL_DAMAGE = 0;
AI_PUSHED = false;
} else if ( thinkFlags & TH_PHYSICS ) {
RunPhysics();
}
// HUMANHEAD jrm - need to call ticker function per aaron
if (thinkFlags & TH_TICKER) {
Ticker();
}
if ( af_push_moveables ) {
PushWithAF();
}
if ( fl.hidden && allowHiddenMovement ) {
// UpdateAnimation won't call frame commands when hidden, so call them here when we allow hidden movement
animator.ServiceAnims( gameLocal.previousTime, gameLocal.time );
}
UpdateMuzzleFlash();
UpdateAnimation();
UpdateParticles();
UpdateWounds();
Present();
UpdateDamageEffects();
LinkCombat();
CrashLand( oldOrigin, oldVelocity );
if(health > 0) {
idStr tmp;
if(ai_showNoAAS.GetBool() && spawnArgs.GetString("use_aas", "", tmp) && spawnArgs.GetBool("noaas_warning","1")) {
if(!aas) {
gameRenderWorld->DrawText("?", this->GetEyePosition() + idVec3(0.0f, 0.0f, 12.0f), 0.75f, colorYellow, gameLocal.GetLocalPlayer()->viewAngles.ToMat3());
}
}
}
if ( !AI_DEAD && bCanFall && !IsHidden() && !fl.isTractored ) {
if ( physicsObj.HasContacts() || physicsObj.GetLinearVelocity().LengthSqr() < 4 ) {
lastContactTime = gameLocal.time;
if ( AI_FALLING ) {
AI_FALLING = false;
bCanFall = false;
SetState( GetScriptFunction( "state_Idle" ) );
SetWaitState( "" );
}
} else if ( !AI_FALLING && !af.IsActive() && physicsObj.GetLinearVelocity().LengthSqr() > 0 ) {
if ( gameLocal.time - lastContactTime > fallDelay ) {
AI_FALLING = true;
SetState( GetScriptFunction( "state_Nothing" ) );
Event_AnimState(ANIMCHANNEL_TORSO, "Torso_Fall", 4);
Event_AnimState(ANIMCHANNEL_LEGS, "Legs_Fall", 4);
}
}
}
//update wallwalk
if ( bCanWallwalk && !fl.isTractored ) {
trace_t TraceInfo;
gameLocal.clip.TracePoint(TraceInfo, GetOrigin(), GetOrigin() + this->GetPhysics()->GetGravityNormal() * 50, GetPhysics()->GetClipMask(), this);
if( TraceInfo.fraction < 1.0f && gameLocal.GetMatterType(TraceInfo, NULL) == SURFTYPE_WALLWALK ) {
SetGravity( -TraceInfo.c.normal * DEFAULT_GRAVITY );
AI_WALLWALK = true;
} else if ( AI_WALLWALK ) {
SetGravity( idVec3(0,0,-DEFAULT_GRAVITY) );
AI_WALLWALK = false;
}
} else if ( AI_WALLWALK ) {
SetGravity( idVec3(0,0,-DEFAULT_GRAVITY) );
AI_WALLWALK = false;
}
if ( bBossBar ) {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player && player->hud ) {
player->hud->SetStateFloat( "progress", idMath::ClampFloat( 0.0f, 1.0f, float(health) / (float)spawnHealth ) );
player->hud->StateChanged(gameLocal.time);
player->hud->Redraw( gameLocal.realClientTime );
}
}
if( ai_debugBrain.GetInteger() > 0 && !IsHidden() ) {
if ( enemy.IsValid() && enemy->GetHealth() > 0 ) {
gameRenderWorld->DebugArrow( colorWhite, GetOrigin(), enemy->GetOrigin(), 10 );
float dist = ( GetPhysics()->GetOrigin() - enemy->GetPhysics()->GetOrigin() ).LengthFast();
gameRenderWorld->DrawText( va("%i", int(dist)), this->GetEyePosition() + idVec3(0.0f, 0.0f, 60.0f), 0.75f, colorYellow, gameLocal.GetLocalPlayer()->viewAngles.ToMat3());
}
if ( state ) {
if ( physicsObj.GetClipMask() == 0 ) {
gameRenderWorld->DrawText(state->Name(), GetEyePosition() + idVec3(0.0f, 0.0f, 40.0f), 0.75f, colorRed, gameLocal.GetLocalPlayer()->viewAngles.ToMat3());
} else {
gameRenderWorld->DrawText(state->Name(), GetEyePosition() + idVec3(0.0f, 0.0f, 40.0f), 0.75f, colorGreen, gameLocal.GetLocalPlayer()->viewAngles.ToMat3());
}
}
gameRenderWorld->DrawText(torsoAnim.state, this->GetEyePosition() + idVec3(0.0f, 0.0f, 20.0f), 0.75f, colorYellow, gameLocal.GetLocalPlayer()->viewAngles.ToMat3());
gameRenderWorld->DrawText(legsAnim.state, this->GetEyePosition() + idVec3(0.0f, 0.0f, 0.0f), 0.75f, colorYellow, gameLocal.GetLocalPlayer()->viewAngles.ToMat3());
if ( !walkIK.IsActivated() ) {
gameRenderWorld->DrawText("ik disabled", GetEyePosition() + idVec3(0.0f, 0.0f, -20.0f), 0.75f, colorRed, gameLocal.GetLocalPlayer()->viewAngles.ToMat3());
}
}
}
void hhMonsterAI::ApplyImpulse( idEntity *ent, int id, const idVec3 &point, const idVec3 &force ) {
//we don't want monsters pushed around by the player, projectiles, or splashDamange, so early out if they are.
if( !af.IsActive() ) {
if ( ent && (ent->IsType( hhProjectile::Type ) || ent->IsType( idWorldspawn::Type ) || ent->IsType( idPlayer::Type )) ) {
return;
}
}
af.GetPhysics()->UpdateTime( gameLocal.GetTime() );
BecomeActive(TH_THINK);
idAI::ApplyImpulse( ent, id, point, force );
}
//
// hhMonsterAI::CheckValidReaction
// Helper function for using reactions.
//
bool hhMonsterAI::CheckValidReaction() {
hhReaction *reaction = targetReaction.GetReaction();
if( !reaction || !reaction->causeEntity.IsValid() ) {
return false;
}
return true;
}
//
// hhMonsterAI::FinishReaction
// Called once a reaction has been used/failed. If it failed, set the failed flag and exit.
// Otherwise, set any 'finish_key' we have.
//
void hhMonsterAI::FinishReaction( bool bFailed ) {
AI_USING_REACTION = false;
if( bFailed ) {
AI_REACTION_FAILED = true;
}
else {
hhReaction *reaction = targetReaction.GetReaction();
if( reaction && reaction->desc->finish_key.Length() ) {
spawnArgs.Set( reaction->desc->finish_key.c_str(), reaction->desc->finish_val.c_str() );
}
}
//monster is finished with this reaction. let others use it
if ( targetReaction.entity.IsValid() ) {
targetReaction.entity->spawnArgs.Set( "react_inuse", "0" );
}
}
void hhMonsterAI::Killed(idEntity *inflictor, idEntity *attacker,
int damage, const idVec3 &dir, int location )
{
if ( AI_DEAD ) {
AI_DAMAGE = true;
return;
}
if ( bBossBar && spawnArgs.GetBool( "remove_bar_on_death" ) ) {
idPlayer *player = gameLocal.GetLocalPlayer();
if ( player && player->hud ) {
bBossBar = false;
player->hud->HandleNamedEvent("HideProgressBar");
player->hud->StateChanged(gameLocal.time);
}
}
HandleNoGore();
idAI::Killed(inflictor, attacker, damage, dir, location);
fl.noPortal = 0; // CJR: Set so that killed monsters never collide with portals
SendDamageToDDA(); // CJR DDA: Send any accumulated damage to the dda system
// General non-item dropping (for monsters, souls, etc.)
const idKeyValue *kv = NULL;
kv = spawnArgs.MatchPrefix( "def_drops", NULL );
while ( kv ) {
idStr drops = kv->GetValue();
idDict args;
idStr last5 = kv->GetKey().Right(5);
if ( drops.Length() && idStr::Icmp( last5, "Joint" ) != 0) {
args.Set( "classname", drops );
// HUMANHEAD pdm: specify monster so souls can call back to remove body when picked up
args.Set("monsterSpawnedBy", name.c_str());
idVec3 origin;
idMat3 axis;
idStr jointKey = kv->GetKey() + idStr("Joint");
idStr jointName = spawnArgs.GetString( jointKey );
idStr joint2JointKey = kv->GetKey() + idStr("Joint2Joint");
idStr j2jName = spawnArgs.GetString( joint2JointKey );
idEntity *newEnt = NULL;
gameLocal.SpawnEntityDef( args, &newEnt );
HH_ASSERT(newEnt != NULL);
// Spin to correct heading
if(newEnt->IsType(hhMonsterAI::Type)) {
hhMonsterAI *newAI = static_cast<hhMonsterAI*>(newEnt);
newAI->current_yaw = current_yaw;
newAI->ideal_yaw = ideal_yaw;
}
if(jointName.Length()) {
jointHandle_t joint = GetAnimator()->GetJointHandle( jointName );
if (!GetAnimator()->GetJointTransform( joint, gameLocal.time, origin, axis ) ) {
gameLocal.Printf( "%s refers to invalid joint '%s' on entity '%s'\n", (const char*)jointKey.c_str(), (const char*)jointName, (const char*)name );
origin = renderEntity.origin;
axis = renderEntity.axis;
}
axis *= renderEntity.axis;
origin = renderEntity.origin + origin * renderEntity.axis;
newEnt->SetAxis(axis);
newEnt->SetOrigin(origin);
}
else {
newEnt->SetAxis(viewAxis);
newEnt->SetOrigin(GetOrigin());
}
}
kv = spawnArgs.MatchPrefix( "def_drops", kv );
}
}
void hhMonsterAI::Event_Remove( void ) {
if( InVehicle() ) {
GetVehicleInterface()->GetVehicle()->EjectPilot();
}
idAI::Event_Remove();
}
void hhMonsterAI::EnterVehicle( hhVehicle* vehicle ) {
if (!vehicle->WillAcceptPilot(this)) {
return;
}
spawnArgs.Set( "use_aas", spawnArgs.GetString( "aas_shuttle", "aasDroid" ) );
SetAAS();
idAI::EnterVehicle( vehicle );
PostEventSec( &MA_SetVehicleState, 0.1f );
}
bool hhMonsterAI::TestMelee( void ) const {
trace_t trace;
idActor *enemyEnt = enemy.GetEntity();
if ( !enemyEnt || !melee_range ) {
return false;
}
//FIXME: make work with gravity vector
idVec3 org = physicsObj.GetOrigin();
const idBounds &myBounds = physicsObj.GetBounds();
idBounds bounds;
idBounds meleeBounds( spawnArgs.GetVector( "melee_boundmin", "0 0 0" ), spawnArgs.GetVector( "melee_boundmax", "0 0 0" ) );
if ( meleeBounds != bounds_zero ) {
//check custom rotated meleebound
idBox meleeBox( meleeBounds, org, renderEntity.axis );
idBounds enemyBounds = enemyEnt->GetPhysics()->GetBounds();
enemyBounds.TranslateSelf( enemyEnt->GetPhysics()->GetOrigin() );
idBox enemyBox( enemyBounds );
if ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugBox( colorYellow, meleeBox );
}
if ( !enemyBox.IntersectsBox( meleeBox ) ) {
return false;
}
} else {
// expand the bounds out by our melee range
bounds[0][0] = -melee_range;
bounds[0][1] = -melee_range;
bounds[0][2] = myBounds[0][2] - 4.0f;
bounds[1][0] = melee_range;
bounds[1][1] = melee_range;
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 ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugBounds( colorYellow, bounds, vec3_zero, gameLocal.msec );
}
if ( !bounds.IntersectsBounds( enemyBounds ) ) {
return false;
}
}
idVec3 start = GetEyePosition();
idVec3 end = enemyEnt->GetEyePosition();
gameLocal.clip.TracePoint( trace, start, end, MASK_SHOT_BOUNDINGBOX, this );
if ( ( trace.fraction == 1.0f ) || ( gameLocal.GetTraceEntity( trace ) == enemyEnt ) ) {
return true;
}
return false;
}
bool hhMonsterAI::MoveToPosition( const idVec3 &pos, bool enemyBlocks ) {
if(AI_VEHICLE && InVehicle()) {
GetVehicleInterfaceLocal()->ThrustTowards( pos, 1.0f );
return true;
} else {
return idAI::MoveToPosition( pos, enemyBlocks );
}
}
bool hhMonsterAI::TurnToward( const idVec3 &pos ) {
if (AI_VEHICLE && InVehicle()) {
GetVehicleInterfaceLocal()->OrientTowards( pos, 0.5 );
return true;
} else {
return idAI::TurnToward( pos );
}
}
bool hhMonsterAI::CanSee( idEntity *ent, bool useFov ) {
trace_t tr;
idVec3 eye;
idVec3 toPos;
if ( ent->IsHidden() ) {
return false;
}
if ( ent->IsType( idActor::Type ) ) {
idActor *act = static_cast<idActor*>(ent);
// If this actor is in a vehicle, look at the vehicle, not the actor
if(act->InVehicle()) {
ent = act->GetVehicleInterface()->GetVehicle();
}
}
if ( ent->IsType( idActor::Type ) ) {
toPos = ( ( idActor * )ent )->GetEyePosition();
} else {
toPos = ent->GetPhysics()->GetOrigin();
}
if ( useFov && !CheckFOV( toPos ) ) {
return false;
}
eye = GetEyePosition();
if ( InVehicle() ) {
gameLocal.clip.TracePoint( tr, eye, toPos, MASK_SHOT_BOUNDINGBOX, GetVehicleInterface()->GetVehicle() ); // HUMANHEAD JRM
if ( tr.fraction >= 1.0f || ( gameLocal.GetTraceEntity( tr ) == ent ) ) {
return true;
}
} else {
gameLocal.clip.TracePoint( tr, eye, toPos, MASK_SHOT_BOUNDINGBOX, this ); // HUMANHEAD JRM
if ( tr.fraction >= 1.0f || ( gameLocal.GetTraceEntity( tr ) == ent ) ) {
return true;
} else if ( bSeeThroughPortals && aas ) {
#if 0 // jmarshall - AI portals
shootTarget = NULL;
int myArea = gameRenderWorld->PointInArea( GetOrigin() );
int numPortals = gameRenderWorld->NumGamePortalsInArea( myArea );
if ( numPortals > 0 ) {
int enemyArea = gameRenderWorld->PointInArea( ent->GetOrigin() );
for ( int i=0;i<numPortals;i++ ) {
//if portal's destination area is the same as monster's enemy's area
if ( gameRenderWorld->GetSoundPortal( myArea, i ).areas[0] == enemyArea ) {
//find the portal and set it as this monster's shoottarget
idEntity *spawnedEnt = NULL;
for( spawnedEnt = gameLocal.spawnedEntities.Next(); spawnedEnt != NULL; spawnedEnt = spawnedEnt->spawnNode.Next() ) {
if ( !spawnedEnt->IsType( hhPortal::Type ) ) {
continue;
}
if ( gameRenderWorld->PointInArea( spawnedEnt->GetOrigin() ) == myArea) {
shootTarget = spawnedEnt;
return true;
}
}
}
}
}
#endif
}
}
return false;
}
idPlayer* hhMonsterAI::GetClosestPlayer(void) {
idEntity *closestEnt = NULL;
float closestDist = idMath::INFINITY;
for(int i=0;i<gameLocal.numClients;i++) {
idEntity *ent = gameLocal.entities[i];
if(ent) {
HH_ASSERT(ent->IsType(idPlayer::Type));
float l = (ent->GetOrigin()-GetOrigin()).Length();
if(l < closestDist || !closestEnt) {
closestDist = l;
closestEnt = ent;
}
}
}
return static_cast<idPlayer*>(closestEnt);
}
void hhMonsterAI::Show() {
if ( spawnThinkFlags != 0 ) {
int temp = spawnThinkFlags;
spawnThinkFlags = 0;
BecomeActive( temp );
}
idAI::Show();
PostEventMS(&MA_EnemyOnSpawn, 10);
Event_InitialWallwalk();
}
bool hhMonsterAI::GetFacePosAngle( const idVec3 &pos, float &delta ) {
float diff;
float angle1;
float angle2;
idVec3 sourceOrigin;
idVec3 targetOrigin;
sourceOrigin = GetPhysics()->GetOrigin();
targetOrigin = pos;//target->GetPhysics()->GetOrigin();
angle1 = DEG2RAD( GetGravViewAxis()[0].ToYaw() ); // VIEWAXIS_TO_GETGRAVVIEWAXIS
angle2 = hhUtils::PointToAngle( targetOrigin.x - sourceOrigin.x, targetOrigin.y - sourceOrigin.y );
if(angle2 > angle1) {
diff = angle2 - angle1;
if( diff > DEG2RAD(180.0f) ) {
delta = DEG2RAD(359.9f) - diff;
return false;
}
else {
delta = diff;
return true;
}
}
else {
diff = angle1 - angle2;
if( diff > DEG2RAD(180.0f) ) {
delta = DEG2RAD(359.9f) - diff;
return true;
}
else {
delta = diff;
return false;
}
}
}
void hhMonsterAI::Distracted( idActor *newEnemy ) {
SetEnemy( newEnemy );
}
void hhMonsterAI::SetEnemy( idActor *newEnemy ) {
idAI::SetEnemy( newEnemy );
}
idVec3 hhMonsterAI::GetTouchPos(idEntity *ent, const hhReactionDesc *desc ) {
assert(ent != NULL);
assert(desc != NULL);
idVec3 pos = ent->GetOrigin();
idVec3 offset = desc->touchOffsets.GetVector("all", "0 0 0");
if ( offset == vec3_zero ) {
// Each monster def type has its own offset etc.
// touchoffset_monster_hunter
offset = desc->touchOffsets.GetVector(GetEntityDefName(), "0 0 0");
}
idStr touchDirType = desc->touchDir;
// When touching this ent, move to it as if it were 'cover'
if( touchDirType == idStr("cover") && enemy.IsValid() ) {
idVec3 goalPos = ent->GetOrigin() + offset.x * (ent->GetOrigin() - GetEnemy()->GetOrigin()).ToNormal();
goalPos.z += offset.z;
return goalPos;
}
// Move directly toward this ent from our pos
else if(touchDirType == idStr("direct")) {
idVec3 dir = GetOrigin() - pos;
dir.Normalize();
offset *= dir.ToMat3();
return pos + offset;
}
else if(touchDirType == idStr("object")) {
ent->GetFloorPos( 64.f, pos );
idVec3 dir = GetOrigin() - pos;
dir.Normalize();
return pos + (dir * offset.x);
}
else {
offset *= ent->GetAxis();
return pos + offset;
}
}
bool hhMonsterAI::GetPhysicsToVisualTransform( idVec3 &origin, idMat3 &axis ) {
if ( af.IsActive() ) {
af.GetPhysicsToVisualTransform( origin, axis );
return true;
}
origin = modelOffset;
if ( GetBindMaster() && bindJoint != INVALID_JOINT ) {
idMat3 masterAxis;
idVec3 masterOrigin;
GetMasterPosition( masterOrigin, masterAxis );
axis = physicsObj.localAxis * masterAxis;
origin = masterOrigin + physicsObj.GetLocalOrigin() * masterAxis;
} else if ( ( InVehicle() || bBindOrient ) && GetBindMaster() ) {
axis = GetBindMaster()->GetAxis();
} else {
axis = viewAxis;
}
return true;
}
void hhMonsterAI::UpdateModelTransform( void ) {
idVec3 origin;
idMat3 axis;
if ( GetPhysicsToVisualTransform( origin, axis ) ) {
if ( bBindAxis && GetBindMaster() ) {
renderEntity.axis = GetBindMaster() ->GetAxis();
} else {
renderEntity.axis = axis * GetPhysics()->GetAxis();
}
if ( GetBindMaster() && bindJoint != INVALID_JOINT ) {
if ( head.IsValid() && head->GetPhysics() ) {
head->GetPhysics()->Evaluate(gameLocal.time-gameLocal.previousTime, gameLocal.time);
}
renderEntity.origin = origin;
} else {
if ( GetBindMaster() && head.IsValid() && head->GetPhysics() ) {
head->GetPhysics()->Evaluate(gameLocal.time-gameLocal.previousTime, gameLocal.time);
}
renderEntity.origin = GetPhysics()->GetOrigin() + origin * renderEntity.axis;
}
} else {
renderEntity.axis = GetPhysics()->GetAxis();
renderEntity.origin = GetPhysics()->GetOrigin();
}
}
void hhMonsterAI::UpdateFromPhysics( bool moveBack ) {
// set master delta angles for actors
if ( GetBindMaster() ) {
if( !InVehicle() ) {
idAngles delta = GetDeltaViewAngles();
if ( moveBack ) {
delta.yaw -= physicsObj.GetMasterDeltaYaw();
} else {
delta.yaw += physicsObj.GetMasterDeltaYaw();
}
SetDeltaViewAngles( delta );
} else {
SetAxis( GetBindMaster()->GetAxis() );
}
}
if ( UpdateAnimationControllers() ) {
BecomeActive( TH_ANIMATE );
}
UpdateVisuals();
}
void hhMonsterAI::CreateHealthTriggers() {
const char keyPrefix[] = "health_percent_trigger_";
int keyPrefixLen = strlen(keyPrefix);
const idKeyValue *kv = spawnArgs.MatchPrefix(keyPrefix, NULL);
healthTriggers.Clear();
while(kv) {
hhMonsterHealthTrigger t;
idStr k = kv->GetKey();
idStr perct = k.Right(k.Length() - strlen(keyPrefix));
float p = float(atoi(perct.c_str())) * 0.01f;
t.healthThresh = int(float(health) * p);
t.triggerEnt = gameLocal.FindEntity(kv->GetValue().c_str());
if(!t.triggerEnt.GetEntity()) {
gameLocal.Warning("%s specified %s key with entity \"%s\", but that entity does not exist!", name.c_str(), kv->GetKey().c_str(), kv->GetValue().c_str());
}
healthTriggers.Append(t);
kv = spawnArgs.MatchPrefix(keyPrefix, kv);
}
}
void hhMonsterAI::UpdateHealthTriggers(int oldHealth, int currHealth) {
// Trigger them
for(int i=0;i<healthTriggers.Num();i++) {
// For now, only trigger them ONCE, if scripters want something else, we can change later
if(healthTriggers[i].triggerCount <= 0 && currHealth < healthTriggers[i].healthThresh) {
if(healthTriggers[i].triggerEnt.GetEntity()) {
healthTriggers[i].triggerEnt.GetEntity()->ProcessEvent(&EV_Activate, this);
healthTriggers[i].triggerCount++;
}
}
}
}
//
// Damage()
//
void hhMonsterAI::Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const char *damageDefName, const float damageScale, const int location ) {
// Return if we don't take damage
if ( !fl.takedamage ) {
return;
}
if ( spawnArgs.GetBool( "noPlayerDamage", "0" ) ) {
if ( attacker && attacker->IsType( idPlayer::Type ) ) {
return;
}
}
int oldHealth = health;
idAI::Damage(inflictor, attacker, dir, damageDefName, damageScale, location);
UpdateHealthTriggers(oldHealth, health);
if ( bCustomBlood && inflictor ) {
hhFxInfo fxInfo;
fxInfo.RemoveWhenDone( true );
BroadcastFxInfoPrefixed( "fx_custom_blood", inflictor->GetOrigin(), mat3_identity, &fxInfo );
}
const idDict *damageDef = gameLocal.FindEntityDefDict( damageDefName );
if ( AI_DEAD && damageDef ) {
if ( damageDef->GetBool( "ice" ) && spawnArgs.GetBool( "can_freeze", "0" ) ) {
SetSkinByName( spawnArgs.GetString( "skin_freeze" ) );
if( af.IsLoaded() ) {
af.GetPhysics()->SetSelfCollision(false);
af.GetPhysics()->SetContactFrictionScale(0);
af.GetPhysics()->SetTimeScaleRamp(0,2);
for(int i=0; i < af.GetPhysics()->GetNumConstraints(); i++) {
idAFConstraint* constraint = af.GetPhysics()->GetConstraint(i);
switch( constraint->GetType() ) {
case CONSTRAINT_BALLANDSOCKETJOINT:
static_cast<idAFConstraint_BallAndSocketJoint*>(constraint)->SetFriction(200.0f);
static_cast<idAFConstraint_BallAndSocketJoint*>(constraint)->SetNoLimit();
break;
case CONSTRAINT_UNIVERSALJOINT:
static_cast<idAFConstraint_UniversalJoint*>(constraint)->SetFriction(200.0f);
static_cast<idAFConstraint_UniversalJoint*>(constraint)->SetNoLimit();
break;
case CONSTRAINT_HINGE:
static_cast<idAFConstraint_Hinge*>(constraint)->SetFriction(200.0f);
static_cast<idAFConstraint_Hinge*>(constraint)->SetNoLimit();
break;
}
}
}
spawnArgs.Set("fx_deatheffect", spawnArgs.GetString( "fx_ice" ));
spawnArgs.Set("produces_splats", "0");
if( modelDefHandle > 0 )
gameRenderWorld->RemoveDecals( modelDefHandle );
//SetDeformation(DEFORMTYPE_DEATHEFFECT, gameLocal.time + 5000, 12000);
SetShaderParm(SHADERPARM_TIME_OF_DEATH, MS2SEC(gameLocal.time+100000));
CancelEvents( &EV_Dispose );
PostEventSec( &EV_Dispose, 5 );
}
if ( damageDef->GetBool( "burn" ) && !spawnArgs.GetBool( "no_burn" ) ) {
SetSkinByName( spawnArgs.GetString( "skin_burn" ) );
spawnArgs.Set("fx_deatheffect", spawnArgs.GetString( "fx_burn" ));
if( modelDefHandle > 0 )
gameRenderWorld->RemoveDecals( modelDefHandle );
CancelEvents( &EV_Dispose );
PostEventSec( &EV_Dispose, 0 );
}
if ( damageDef->GetBool( "acid" ) && spawnArgs.GetBool( "acidburn" ) ) {
SetSkinByName( spawnArgs.GetString( "skin_acidburn" ) );
SetDeformation(DEFORMTYPE_DEATHEFFECT, gameLocal.time + 2500, 8000); // starttime, duration
PostEventSec( &EV_StartSound, 1.5f, "snd_acid", SND_CHANNEL_ANY, 1 );
spawnArgs.Set("fx_deatheffect", spawnArgs.GetString( "fx_acid" ));
spawnArgs.Set("mtr_splat1", spawnArgs.GetString( "mtr_acidsplat" ));
spawnArgs.Delete("mtr_splat2");
spawnArgs.Delete("mtr_splat3");
spawnArgs.Delete("mtr_splat4");
spawnArgs.Set("keepDecals", "1");
CancelEvents( &EV_Dispose );
PostEventSec( &EV_Dispose, 1.5 );
}
}
}
bool hhMonsterAI::NearEnoughTouchPos( idEntity* ent, const idVec3& targetPos, idBounds& bounds ) {
bounds.TranslateSelf( targetPos );
idBounds bnds( idVec3(-16.f, -16.f, -8.f), idVec3(16.f, 16.f, 64.f) );
bnds.TranslateSelf( physicsObj.GetOrigin() );
//uncomment these to show debug lines
// gameRenderWorld->DebugBounds( colorOrange, bounds );
// gameRenderWorld->DebugArrow( colorRed, targetPos, targetPos + idVec3(0, 0, 10), 5 );
// gameRenderWorld->DebugBounds( colorRed, bnds );
if( bnds.IntersectsBounds( bounds ) ) {
return true;
}
return false;
}
bool hhMonsterAI::GetTouchPosBound( const hhReactionDesc *desc, idBounds & bnds ) {
idStr minName, maxName;
idVec3 min, max;
minName = va("min_%s", GetEntityDefName());
maxName = va("max_%s", GetEntityDefName());
if( !desc->touchOffsets.GetVector(minName.c_str(), "0 0 0", min) || !desc->touchOffsets.GetVector(maxName.c_str(), "0 0 0", max) ) {
return false;
}
min -= idVec3( 16.f, 16.f, 8.f );
max += idVec3( 16.f, 16.f, 64.f );
bnds.Clear();
bnds[ 0 ] = min;
bnds[ 1 ] = max;
return true;
}
int hhMonsterAI::EvaluateReaction( const hhReaction *react ) {
// Volume/Distance
// If a volume in specified, then use that as our spatial check
float distSq = ( react->causeEntity->GetOrigin() - GetOrigin() ).LengthSqr();
if( react->desc->listenerVolumes.Num() > 0 ) {
int count = 0;
int i;
for( i = 0; i < react->desc->listenerVolumes.Num(); i++ ) {
assert( react->desc->listenerVolumes[ i ]->GetPhysics() != NULL );
assert( GetPhysics() != NULL );
if( react->desc->listenerVolumes[ i ]->GetPhysics()->GetAbsBounds().IntersectsBounds( GetPhysics()->GetAbsBounds() ) ) {
//MDC-TODO: Draw bounds debugging info...
count++; //one is good enough to continue - no need to check the rest
break;
}
}
// If we are in ZERO of the listener volumes, then we can bail because this reaction doesn't apply to us
if( count == 0 ) {
return 0;
}
}
if ( react->desc->effectVolumes.Num() > 0 && GetEnemy() ) {
int count = 0;
for( int i = 0; i < react->desc->effectVolumes.Num(); i++ ) {
assert( react->desc->effectVolumes[ i ]->GetPhysics() != NULL );
assert( GetPhysics() != NULL );
if( react->desc->effectVolumes[ i ]->GetPhysics()->GetAbsBounds().IntersectsBounds( GetEnemy()->GetPhysics()->GetAbsBounds() ) ) {
count++; //one is good enough to return false - no need to check the rest
break;
}
}
// If enemy is in ZERO of the effect volumes, then we can bail because this reaction doesn't apply to us
if( count == 0 ) {
return 0;
}
}
if( react->desc->listenerRadius > 0.f || react->desc->listenerMinRadius > 0.f ) {
// TOO FAR
if( react->desc->listenerRadius > 0.f && distSq > react->desc->listenerRadius * react->desc->listenerRadius ) {
return 0;
}
// TOO CLOSE
if( react->desc->listenerMinRadius > 0.f && distSq < react->desc->listenerMinRadius * react->desc->listenerMinRadius ) {
return 0;
}
}
// Path-finding
if( react->desc->CauseRequiresPathfinding() ) {
if( !HasPathTo( GetTouchPos(react->causeEntity.GetEntity(), react->desc ) ) ) {
//MDC-TODO: draw path debugging
return 0;
}
else {
//MDC-TODO: draw path debugging
}
}
// Can-See
if( react->desc->flags & hhReactionDesc::flagReq_CanSee ) {
if( react->causeEntity.IsValid() ) {
if( !CanSee(react->causeEntity.GetEntity(), TRUE) ) {
return 0;
}
}
}
return 100;
}
int hhMonsterAI::ReactionTo( const idEntity *ent ) {
if ( bNoCombat ) {
return ATTACK_IGNORE;
}
const idActor *actor = static_cast<const idActor *>( ent );
if( actor && actor->IsType(hhDeathProxy::Type) ) {
return ATTACK_IGNORE;
}
//only attack spiritwalking players if they hurt me
if ( ent->IsType( hhPlayer::Type ) ) {
const hhPlayer *player = static_cast<const hhPlayer*>( ent );
if ( nextSpiritProxyCheck == 0 && player && player->IsSpiritWalking() ) {
nextSpiritProxyCheck = gameLocal.time + SEC2MS(2);
return ATTACK_ON_DAMAGE;
}
}
if ( ent->IsType( hhSpiritProxy::Type ) ) {
if ( gameLocal.time > nextSpiritProxyCheck ) {
nextSpiritProxyCheck = 0;
//attack spiritproxy on sight if we have no enemy or if its closer than our current enemy
if ( enemy.IsValid() && enemy->IsType( hhPlayer::Type ) ) {
float distToEnemy = (enemy->GetOrigin() - GetOrigin()).LengthSqr();
float distToProxy = (ent->GetOrigin() - GetOrigin()).LengthSqr();
if ( distToProxy < distToEnemy ) {
return ATTACK_ON_SIGHT;
} else {
//HUMANHEAD jsh PCF 4/29/06 fixed logic error with spiritproxy checking
return ATTACK_IGNORE;
}
} else {
return ATTACK_ON_SIGHT;
}
} else {
return ATTACK_IGNORE;
}
}
if ( ent->IsType( hhMonsterAI::Type ) ) {
const hhMonsterAI *entAI = static_cast<const hhMonsterAI *>( ent );
if ( entAI && entAI->bNeverTarget ) {
return ATTACK_IGNORE;
}
}
return idAI::ReactionTo( ent );
}
bool hhMonsterAI::UpdateAnimationControllers( void ) {
idVec3 local;
idVec3 focusPos;
idVec3 left;
idVec3 dir;
idVec3 orientationJointPos;
idVec3 localDir;
idAngles newLookAng;
idAngles diff;
idMat3 mat;
idMat3 axis;
idMat3 orientationJointAxis;
idAFAttachment *headEnt = head.GetEntity();
idVec3 eyepos;
idVec3 pos;
int i;
idAngles jointAng;
float orientationJointYaw;
if ( AI_DEAD ) {
return idActor::UpdateAnimationControllers();
}
if ( orientationJoint == INVALID_JOINT ) {
orientationJointAxis = viewAxis;
orientationJointPos = physicsObj.GetOrigin();
orientationJointYaw = current_yaw;
} else {
GetJointWorldTransform( orientationJoint, gameLocal.time, orientationJointPos, orientationJointAxis );
orientationJointYaw = orientationJointAxis[ 2 ].ToYaw();
orientationJointAxis = idAngles( 0.0f, orientationJointYaw, 0.0f ).ToMat3();
}
if ( ai_debugBrain.GetBool() ) {
gameRenderWorld->DebugArrow( colorCyan, orientationJointPos, orientationJointPos + orientationJointAxis[0] * 64.0, 10, 1 );
}
if ( focusJoint != INVALID_JOINT ) {
if ( headEnt ) {
headEnt->GetJointWorldTransform( focusJoint, gameLocal.time, eyepos, axis );
} else {
// JRMMERGE_GRAVAXIS - What about GetGravAxis() are we still using/needing that?
GetJointWorldTransform( focusJoint, gameLocal.time, eyepos, axis );
}
eyeOffset.z = eyepos.z - physicsObj.GetOrigin().z;
} else {
eyepos = GetEyePosition();
}
if ( headEnt ) {
CopyJointsFromBodyToHead();
}
// 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();
idEntity *focusEnt = focusEntity.GetEntity();
//HUMANHEAD jsh allow eyefocus independent from allowJointMod
if ( ( !allowJointMod && !allowEyeFocus ) || ( gameLocal.time >= focusTime && focusTime != -1 ) || GetPhysics()->GetGravityNormal() != idVec3( 0,0,-1) ) {
focusPos = GetEyePosition() + orientationJointAxis[ 0 ] * 512.0f;
} else if ( focusEnt == NULL ) {
// keep looking at last position until focusTime is up
focusPos = currentFocusPos;
} else if ( focusEnt == enemy.GetEntity() ) {
focusPos = lastVisibleEnemyPos + lastVisibleEnemyEyeOffset - eyeVerticalOffset * enemy.GetEntity()->GetPhysics()->GetGravityNormal();
} else if ( focusEnt->IsType( idActor::Type ) ) {
focusPos = static_cast<idActor *>( focusEnt )->GetEyePosition() - eyeVerticalOffset * focusEnt->GetPhysics()->GetGravityNormal();
} else {
focusPos = focusEnt->GetPhysics()->GetOrigin();
}
currentFocusPos = currentFocusPos + ( focusPos - currentFocusPos ) * eyeFocusRate;
// determine yaw from origin instead of from focus joint since joint may be offset, which can cause us to bounce between two angles
dir = focusPos - orientationJointPos;
newLookAng.yaw = idMath::AngleNormalize180( dir.ToYaw() - orientationJointYaw );
newLookAng.roll = 0.0f;
newLookAng.pitch = 0.0f;
newLookAng += lookOffset;
#if 0
gameRenderWorld->DebugLine( colorRed, orientationJointPos, focusPos, gameLocal.msec );
gameRenderWorld->DebugLine( colorYellow, orientationJointPos, orientationJointPos + orientationJointAxis[ 0 ] * 32.0f, gameLocal.msec );
gameRenderWorld->DebugLine( colorGreen, orientationJointPos, orientationJointPos + newLookAng.ToForward() * 48.0f, gameLocal.msec );
#endif
//JRMMERGE_GRAVAXIS: This changed to much to merge, see if you can get your monsters on planets changes back in here. I'll leave both versions
#if OLD_CODE
GetGravViewAxis().ProjectVector( dir, localDir ); // HUMANHEAD JRM: VIEWAXIS_TO_GETGRAVVIEWAXIS
lookAng.yaw = idMath::AngleNormalize180( localDir.ToYaw() );
lookAng.pitch = -idMath::AngleNormalize180( localDir.ToPitch() );
lookAng.roll = 0.0f;
#else
// determine pitch from joint position
dir = focusPos - eyepos;
if ( ai_debugBrain.GetBool() ) {
gameRenderWorld->DebugArrow( colorYellow, eyepos, eyepos + dir, 10, 1 );
}
dir.NormalizeFast();
orientationJointAxis.ProjectVector( dir, localDir );
newLookAng.pitch = -idMath::AngleNormalize180( localDir.ToPitch() ) + lookOffset.pitch;
newLookAng.roll = 0.0f;
#endif
diff = newLookAng - lookAng;
if ( eyeAng != diff ) {
eyeAng = diff;
eyeAng.Clamp( eyeMin, eyeMax );
idAngles angDelta = diff - eyeAng;
if ( !angDelta.Compare( ang_zero, 0.1f ) ) {
alignHeadTime = gameLocal.time;
} else {
alignHeadTime = gameLocal.time + ( 0.5f + 0.5f * gameLocal.random.RandomFloat() ) * focusAlignTime;
}
}
if ( idMath::Fabs( newLookAng.yaw ) < 0.1f ) {
alignHeadTime = gameLocal.time;
}
if ( ( gameLocal.time >= alignHeadTime ) || ( gameLocal.time < forceAlignHeadTime ) ) {
alignHeadTime = gameLocal.time + ( 0.5f + 0.5f * gameLocal.random.RandomFloat() ) * focusAlignTime;
destLookAng = newLookAng;
destLookAng.Clamp( lookMin, lookMax );
}
diff = destLookAng - lookAng;
if ( ( lookMin.pitch == -180.0f ) && ( lookMax.pitch == 180.0f ) ) {
if ( ( diff.pitch > 180.0f ) || ( diff.pitch <= -180.0f ) ) {
diff.pitch = 360.0f - diff.pitch;
}
}
if ( ( lookMin.yaw == -180.0f ) && ( lookMax.yaw == 180.0f ) ) {
if ( diff.yaw > 180.0f ) {
diff.yaw -= 360.0f;
} else if ( diff.yaw <= -180.0f ) {
diff.yaw += 360.0f;
}
}
lookAng = lookAng + diff * headFocusRate;
lookAng.Normalize180();
jointAng.roll = 0.0f;
if ( allowJointMod ) {
for( i = 0; i < lookJoints.Num(); i++ ) {
jointAng.pitch = 0;
jointAng.yaw = lookAng.yaw * lookJointAngles[ i ].yaw;
animator.SetJointAxis( lookJoints[ i ], JOINTMOD_WORLD, jointAng.ToMat3() );
idMat3 pitchRot;
hhMath::BuildRotationMatrix( DEG2RAD(-lookAng.pitch * lookJointAngles[ i ].pitch), 0, pitchRot );
animator.GetJointLocalTransform( lookJoints[ i ], gameLocal.time, pos, mat );
animator.SetJointAxis( lookJoints[ i ], JOINTMOD_LOCAL_OVERRIDE, pitchRot * mat );
}
}
if ( move.moveType == MOVETYPE_FLY ) {
// lean into turns
AdjustFlyingAngles();
}
if ( headEnt ) {
idAnimator *headAnimator = headEnt->GetAnimator();
// HUMANHEAD pdm: Added support for look joints in head entities
if ( allowJointMod ) {
for( i = 0; i < headLookJoints.Num(); i++ ) {
jointAng.pitch = lookAng.pitch * headLookJointAngles[ i ].pitch;
jointAng.yaw = lookAng.yaw * headLookJointAngles[ i ].yaw;
headAnimator->SetJointAxis( headLookJoints[ i ], JOINTMOD_WORLD, jointAng.ToMat3() );
}
}
// HUMANHEAD END
if ( allowEyeFocus ) {
idMat3 eyeAxis = ( lookAng + eyeAng ).ToMat3(); idMat3 headTranspose = headEnt->GetPhysics()->GetAxis().Transpose();
axis = eyeAxis * orientationJointAxis;
left = axis[ 1 ] * eyeHorizontalOffset;
eyepos -= headEnt->GetPhysics()->GetOrigin();
headAnimator->SetJointPos( leftEyeJoint, JOINTMOD_WORLD_OVERRIDE, eyepos + ( axis[ 0 ] * 64.0f + left ) * headTranspose );
headAnimator->SetJointPos( rightEyeJoint, JOINTMOD_WORLD_OVERRIDE, eyepos + ( axis[ 0 ] * 64.0f - left ) * headTranspose );
//if ( ai_debugMove.GetBool() ) {
// gameRenderWorld->DebugLine( colorRed, orientationJointPos, eyepos + ( axis[ 0 ] * 64.0f + left ) * headTranspose, gameLocal.msec );
//}
} else {
headEnt->BecomeActive( TH_ANIMATE );
headAnimator->ClearJoint( leftEyeJoint );
headAnimator->ClearJoint( rightEyeJoint );
}
} else {
if ( allowEyeFocus ) {
idMat3 eyeAxis = ( lookAng + eyeAng ).ToMat3();
axis = eyeAxis * orientationJointAxis;
left = axis[ 1 ] * eyeHorizontalOffset;
eyepos += axis[ 0 ] * 64.0f - physicsObj.GetOrigin();
animator.SetJointPos( leftEyeJoint, JOINTMOD_WORLD_OVERRIDE, eyepos + left );
animator.SetJointPos( rightEyeJoint, JOINTMOD_WORLD_OVERRIDE, eyepos - left );
} else {
animator.ClearJoint( leftEyeJoint );
animator.ClearJoint( rightEyeJoint );
}
}
//HUMANHEAD pdm jawflap
hhAnimator *theAnimator;
if (head.IsValid()) {
theAnimator = head->GetAnimator();
}
else {
theAnimator = GetAnimator();
}
JawFlap(theAnimator);
//END HUMANHEAD
return true;
}
//overridden to allow attack nodes farther away than our current enemydistance
void hhMonsterAI::Event_GetCombatNode( void ) {
int i;
float dist;
idEntity *targetEnt;
idCombatNode *node;
float bestDist;
idCombatNode *bestNode;
idActor *enemyEnt = enemy.GetEntity();
if ( !targets.Num() ) {
// no combat nodes
idThread::ReturnEntity( NULL );
return;
}
if ( !enemyEnt || !EnemyPositionValid() ) {
// don't return a combat node if we don't have an enemy or
// if we can see he's not in the last place we saw him
idThread::ReturnEntity( NULL );
return;
}
// find the closest attack node that can see our enemy and is closer than our enemy
bestNode = NULL;
const idVec3 &myPos = physicsObj.GetOrigin();
bestDist = 9999999.0f ;
for( i = 0; i < targets.Num(); i++ ) {
targetEnt = targets[ i ].GetEntity();
if ( !targetEnt || !targetEnt->IsType( idCombatNode::Type ) ) {
continue;
}
node = static_cast<idCombatNode *>( targetEnt );
if ( !node->IsDisabled() && node->EntityInView( enemyEnt, lastVisibleEnemyPos ) ) {
idVec3 org = node->GetPhysics()->GetOrigin();
dist = ( myPos - org ).LengthSqr();
if ( dist < bestDist ) {
bestNode = node;
bestDist = dist;
}
}
}
idThread::ReturnEntity( bestNode );
}
void hhMonsterAI::FlyTurn( void ) { //overridden for vehicle code changes
if ( move.moveCommand == MOVE_FACE_ENEMY ) {
TurnToward( lastVisibleEnemyPos );
} else if ( ( move.moveCommand == MOVE_FACE_ENTITY ) && move.goalEntity.GetEntity() ) {
TurnToward( move.goalEntity.GetEntity()->GetPhysics()->GetOrigin() );
} else if ( move.speed > 0.0f ) {
const idVec3 &vel = physicsObj.GetLinearVelocity();
if ( vel.ToVec2().LengthSqr() > 0.1f ) {
if ( InVehicle() ) {
if ( move.goalEntity.IsValid() ) {
TurnToward( move.goalEntity.GetEntity()->GetPhysics()->GetOrigin() );
} else {
TurnToward( GetVehicleInterface()->GetVehicle()->GetPhysics()->GetLinearVelocity().ToYaw() );
}
} else {
if ( vel.ToVec2().LengthSqr() > 0.1f ) {
TurnToward( vel.ToYaw() );
}
}
}
}
Turn();
}
//overridden to allow custom hearingRange
void hhMonsterAI::UpdateEnemyPosition( void ) {
idActor *enemyEnt = enemy.GetEntity();
int enemyAreaNum;
int areaNum;
aasPath_t path;
predictedPath_t predictedPath;
idVec3 enemyPos;
bool onGround;
if ( !enemyEnt ) {
return;
}
const idVec3 &org = physicsObj.GetOrigin();
if ( move.moveType == MOVETYPE_FLY ) {
enemyPos = enemyEnt->GetPhysics()->GetOrigin();
onGround = true;
} else {
onGround = enemyEnt->GetFloorPos( 64.0f, enemyPos );
if ( enemyEnt->OnLadder() ) {
onGround = false;
}
}
if ( onGround ) {
// when we don't have an AAS, we can't tell if an enemy is reachable or not,
// so just assume that he is.
if ( !aas ) {
enemyAreaNum = 0;
lastReachableEnemyPos = enemyPos;
} else {
enemyAreaNum = PointReachableAreaNum( enemyPos, 1.0f );
if ( enemyAreaNum ) {
areaNum = PointReachableAreaNum( org );
if ( PathToGoal( path, areaNum, org, enemyAreaNum, enemyPos ) ) {
lastReachableEnemyPos = enemyPos;
}
}
}
}
AI_ENEMY_IN_FOV = false;
AI_ENEMY_VISIBLE = false;
if ( CanSee( enemyEnt, false ) ) {
AI_ENEMY_VISIBLE = true;
if ( CheckFOV( enemyEnt->GetPhysics()->GetOrigin() ) ) {
AI_ENEMY_IN_FOV = true;
}
SetEnemyPosition();
} else {
// check if we heard any sounds in the last frame
if ( enemyEnt == gameLocal.GetAlertEntity() ) {
float dist = ( enemyEnt->GetPhysics()->GetOrigin() - org ).LengthSqr();
//allow the sound's own radius to override hearingRange, if it is set
if ( gameLocal.lastAIAlertRadius ) {
if ( dist < Square( gameLocal.lastAIAlertRadius ) ) {
SetEnemyPosition();
}
} else if ( dist < Square( hearingRange ) ) {
SetEnemyPosition();
}
}
}
if ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugBounds( colorLtGrey, enemyEnt->GetPhysics()->GetBounds(), lastReachableEnemyPos, gameLocal.msec );
gameRenderWorld->DebugBounds( colorWhite, enemyEnt->GetPhysics()->GetBounds(), lastVisibleReachableEnemyPos, gameLocal.msec );
}
}
void hhMonsterAI::BecameBound(hhBindController *b) {
SetState( GetScriptFunction( "state_Nothing" ) );
}
void hhMonsterAI::BecameUnbound(hhBindController *b) {
if ( health > 0 ) {
SetState( GetScriptFunction( "state_Idle" ) );
}
}
void hhMonsterAI::CrashLand( const idVec3 &oldOrigin, const idVec3 &oldVelocity ) {
const trace_t& trace = physicsObj.GetGroundTrace();
if ( af.IsActive() || (!physicsObj.HasGroundContacts() || trace.fraction == 1.0f) && !IsBound() ) {
return;
}
//aob - only check when we land on the ground
//If we get here we can assume we currently have ground contacts
if( physicsObj.HadGroundContacts() ) {
return;
}
// if the monster wasn't going down
if ( ( oldVelocity * -physicsObj.GetGravityNormal() ) >= 0.0f ) {
return;
}
idVec3 deltaVelocity = DetermineDeltaCollisionVelocity( oldVelocity, trace );
float delta = (IsBound()) ? deltaVelocity.Length() : deltaVelocity * physicsObj.GetGravityNormal();
if ( delta < spawnArgs.GetFloat( "fatal_fall_velocity", "900" ) ) {
return; // Early out
}
if( trace.fraction == 1.0f ) {
return;
}
Damage( NULL, NULL, oldVelocity.ToNormal(), "damage_monsterfall", 1, INVALID_JOINT );
}
hhEntityFx* hhMonsterAI::SpawnFxLocal( const char *fxName, const idVec3 &origin, const idMat3& axis, const hhFxInfo* const fxInfo, bool forceClient ) {
//overridden to use GetJointWorldTransform to set location if binding to a bone
idDict fxArgs;
hhEntityFx * fx = NULL;
if ( g_skipFX.GetBool() ) {
return NULL;
}
if( !fxName || !fxName[0] ) {
return NULL;
}
// Spawn an fx
fxArgs.Set( "fx", fxName );
fxArgs.SetBool( "start", fxInfo ? fxInfo->StartIsSet() : true );
fxArgs.SetVector( "origin", origin );
fxArgs.SetMatrix( "rotation", axis );
//HUMANHEAD: aob
if( fxInfo ) {
fxArgs.SetBool( "removeWhenDone", fxInfo->RemoveWhenDone() );
fxArgs.SetBool( "onlyVisibleInSpirit", fxInfo->OnlyVisibleInSpirit() ); // CJR
fxArgs.SetBool( "onlyInvisibleInSpirit", fxInfo->OnlyInvisibleInSpirit() ); // tmj
fxArgs.SetBool( "toggle", fxInfo->Toggle() );
}
//HUMANHEAD END
//HUMANHEAD rww - use forceClient
if (forceClient) {
//this can happen on the "server" in the case of listen servers as well
fx = (hhEntityFx *)gameLocal.SpawnClientObject( "func_fx", &fxArgs );
}
else {
assert(!gameLocal.isClient);
fx = (hhEntityFx *)gameLocal.SpawnObject( "func_fx", &fxArgs );
}
if( fxInfo ) {
fx->SetFxInfo( *fxInfo );
}
if( fxInfo && fxInfo->EntityIsSet() ) {
fx->fl.noRemoveWhenUnbound = fxInfo->NoRemoveWhenUnbound();
if( fxInfo->BindBoneIsSet() ) {
idVec3 bonePos;
idMat3 boneAxis;
GetJointWorldTransform( fxInfo->GetBindBone(), bonePos, boneAxis );
fx->SetOrigin( bonePos );
fx->BindToJoint( fxInfo->GetEntity(), fxInfo->GetBindBone(), true );
} else if( fx && fx->Joint() && *fx->Joint() ) {
fx->MoveToJoint( fxInfo->GetEntity(), fx->Joint() );
fx->BindToJoint( fxInfo->GetEntity(), fx->Joint(), true );
} else {
fx->Bind( fxInfo->GetEntity(), true );
}
}
fx->Show();
return fx;
}
bool hhMonsterAI::AttackMelee( const char *meleeDefName ) {
const idDict *meleeDef;
idActor *enemyEnt = enemy.GetEntity();
const char *p;
const idSoundShader *shader;
meleeDef = gameLocal.FindEntityDefDict( meleeDefName, false );
if ( !meleeDef ) {
gameLocal.Error( "Unknown melee '%s'", meleeDefName );
}
if ( !enemyEnt ) {
p = meleeDef->GetString( "snd_miss" );
if ( p && *p ) {
shader = declManager->FindSound( p );
StartSoundShader( shader, SND_CHANNEL_DAMAGE, 0, false, NULL );
}
return false;
}
// make sure the trace can actually hit the enemy
if ( !TestMeleeDef(meleeDefName) ) {
// missed
p = meleeDef->GetString( "snd_miss" );
if ( p && *p ) {
shader = declManager->FindSound( p );
StartSoundShader( shader, SND_CHANNEL_DAMAGE, 0, false, NULL );
}
return false;
}
//
// 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;
if ( spawnArgs.GetBool( "smart_knockback", "0" ) ) {
//do some traces to determine which dir to kick enemy
idAngles ang = viewAxis.ToAngles();
idVec3 forward, right, up;
ang.ToVectors( &forward, &right, &up );
trace_t trace;
gameLocal.clip.TraceBounds( trace, enemyEnt->GetOrigin(), enemyEnt->GetOrigin() + -forward * 400, enemyEnt->GetPhysics()->GetBounds(), MASK_SOLID, this );
if ( trace.fraction != 1.0f ) {
//there's room to kick the player back
globalKickDir = -forward;
if ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugArrow( colorRed, enemyEnt->GetOrigin(), enemyEnt->GetOrigin() + globalKickDir * 500, 10, 10000 );
}
} else {
gameLocal.clip.TraceBounds( trace, enemyEnt->GetOrigin(), enemyEnt->GetOrigin() + right * 400, enemyEnt->GetPhysics()->GetBounds(), MASK_SOLID, this );
if ( trace.fraction != 1.0f ) {
globalKickDir = right;
if ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugArrow( colorRed, enemyEnt->GetOrigin(), enemyEnt->GetOrigin() + globalKickDir * 500, 10, 10000 );
}
} else {
gameLocal.clip.TraceBounds( trace, enemyEnt->GetOrigin(), enemyEnt->GetOrigin() + right * 400, enemyEnt->GetPhysics()->GetBounds(), MASK_SOLID, this );
if ( trace.fraction != 1.0f ) {
globalKickDir = -right;
if ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugArrow( colorRed, enemyEnt->GetOrigin(), enemyEnt->GetOrigin() + globalKickDir * 500, 10, 10000 );
}
}
}
}
}
enemyEnt->Damage( this, this, globalKickDir, meleeDefName, 1.0f, INVALID_JOINT );
//swap skin if we have successfully hit
idStr hitSkin = spawnArgs.GetString( "skin_melee_hit", "" );
if ( hitSkin.Length() ) {
SetSkinByName( hitSkin.c_str() );
}
lastAttackTime = gameLocal.time;
return true;
}
bool hhMonsterAI::TestMeleeDef( const char *meleeDefName ) const {
//tests using "melee_boundmin" and "melee_boundmax" in the damage def
trace_t trace;
idActor *enemyEnt = enemy.GetEntity();
const idDict *meleeDef;
meleeDef = gameLocal.FindEntityDefDict( meleeDefName, false );
if ( !meleeDef ) {
gameLocal.Error( "Unknown melee '%s'", meleeDefName );
}
if ( !enemyEnt || !melee_range ) {
return false;
}
//FIXME: make work with gravity vector
idVec3 org = physicsObj.GetOrigin();
const idBounds &myBounds = physicsObj.GetBounds();
idBounds bounds;
idBounds meleeBounds( meleeDef->GetVector( "melee_boundmin" ), meleeDef->GetVector( "melee_boundmax" ) );
if ( meleeBounds != bounds_zero ) {
//check custom rotated meleebound
idBox meleeBox( meleeBounds, org, renderEntity.axis );
idBounds enemyBounds = enemyEnt->GetPhysics()->GetBounds();
enemyBounds.TranslateSelf( enemyEnt->GetPhysics()->GetOrigin() );
idBox enemyBox( enemyBounds );
if ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugBox( colorYellow, meleeBox, 5000 );
}
if ( !enemyBox.IntersectsBox( meleeBox ) ) {
return false;
}
} else {
// expand the bounds out by our melee range
bounds[0][0] = -melee_range;
bounds[0][1] = -melee_range;
bounds[0][2] = myBounds[0][2] - 4.0f;
bounds[1][0] = melee_range;
bounds[1][1] = melee_range;
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 ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugBounds( colorYellow, bounds, vec3_zero, gameLocal.msec );
}
if ( !bounds.IntersectsBounds( enemyBounds ) ) {
return false;
}
}
idVec3 start = GetEyePosition();
idVec3 end = enemyEnt->GetEyePosition();
gameLocal.clip.TracePoint( trace, start, end, MASK_SHOT_BOUNDINGBOX, this );
if ( ( trace.fraction == 1.0f ) || ( gameLocal.GetTraceEntity( trace ) == enemyEnt ) ) {
return true;
}
return false;
}
void hhMonsterAI::PrintDebug() {
if ( enemy.IsValid() ) {
int dist = int(( GetPhysics()->GetOrigin() - enemy->GetPhysics()->GetOrigin() ).LengthFast());
gameLocal.Printf( " Enemy: %s\n", enemy->GetName() );
gameLocal.Printf( " Distance to Enemy: %d\n", dist );
gameLocal.Printf( " Enemy Area: %i\n", PointReachableAreaNum(enemy->GetOrigin()) );
gameLocal.Printf( " Enemy Reachable: %s\n", AI_ENEMY_REACHABLE ? "yes" : "no" );
gameLocal.Printf( " Enemy Visible: %s\n", AI_ENEMY_VISIBLE ? "yes" : "no" );
} else {
gameLocal.Printf( " Enemy: None\n" );
}
gameLocal.Printf( " Current Area: %i\n", PointReachableAreaNum(GetOrigin()) );
if ( state ) {
gameLocal.Printf( " State: %s\n", state->Name() );
}
gameLocal.Printf( " Health: %i/%i\n", GetHealth(), spawnArgs.GetInt( "health" ) );
gameLocal.Printf( " Torso State: %s\n", torsoAnim.state.c_str() );
gameLocal.Printf( " Legs State: %s\n", legsAnim.state.c_str() );
gameLocal.Printf( " IK: %s\n", walkIK.IsActivated() ? "enable" : "disabled" );
gameLocal.Printf( " Turnrate: %f\n", turnRate );
}
bool hhMonsterAI::NewWanderDir( const idVec3 &dest ) {
if ( spawnArgs.GetInt( "wander_radius" ) ) {
//pick a new dest based on radius from starting origin
idVec3 offset = hhUtils::RandomVector() * float(spawnArgs.GetInt( "wander_radius" ));
offset.z = 0.0f;
const idVec3 newDest = spawnOrigin + offset;
return idAI::NewWanderDir( newDest );
} else {
return idAI::NewWanderDir( dest );
}
}
/*
=====================
hhMonsterAI::Save
=====================
*/
void hhMonsterAI::Save( idSaveGame *savefile ) const {
savefile->WriteInt( targetReaction.reactionIndex );
targetReaction.entity.Save( savefile);
shootTarget.Save( savefile );
currPassageway.Save( savefile );
savefile->WriteBool( bCanFall );
int i, num = healthTriggers.Num();
savefile->WriteInt( num );
for (i = 0; i < num; i++) {
savefile->WriteInt( healthTriggers[i].healthThresh );
healthTriggers[i].triggerEnt.Save( savefile );
savefile->WriteInt( healthTriggers[i].triggerCount );
}
savefile->WriteInt( hearingRange );
savefile->WriteInt( lastContactTime );
savefile->WriteBool( bSeeThroughPortals );
savefile->WriteBool( bBossBar );
savefile->WriteInt( nextSpeechTime );
savefile->WriteAngles( lookOffset );
savefile->WriteVec3( spawnOrigin );
savefile->WriteBool( bBindOrient );
savefile->WriteInt( numDDADamageSamples );
savefile->WriteFloat( totalDDADamage );
savefile->WriteInt( spawnThinkFlags );
savefile->WriteBool( bCanWallwalk );
savefile->WriteBool( bOverrideKilledByGravityZones );
savefile->WriteInt( fallDelay );
savefile->WriteBool( soundOnModel );
savefile->WriteBool( bBindAxis );
savefile->WriteBool( bCustomBlood );
savefile->WriteBool( bNoCombat );
savefile->WriteBool( bNeverTarget );
savefile->WriteInt( nextSpiritProxyCheck );
};
/*
=====================
hhMonsterAI::Restore
=====================
*/
void hhMonsterAI::Restore( idRestoreGame *savefile ) {
savefile->ReadInt( targetReaction.reactionIndex );
targetReaction.entity.Restore( savefile);
shootTarget.Restore( savefile );
currPassageway.Restore( savefile );
savefile->ReadBool( bCanFall );
int i, num;
savefile->ReadInt( num );
healthTriggers.SetNum( num );
for (i = 0; i < num; i++) {
savefile->ReadInt( healthTriggers[i].healthThresh );
healthTriggers[i].triggerEnt.Restore( savefile );
savefile->ReadInt( healthTriggers[i].triggerCount );
}
savefile->ReadInt( hearingRange );
savefile->ReadInt( lastContactTime );
savefile->ReadBool( bSeeThroughPortals );
savefile->ReadBool( bBossBar );
savefile->ReadInt( nextSpeechTime );
savefile->ReadAngles( lookOffset );
savefile->ReadVec3( spawnOrigin );
savefile->ReadBool( bBindOrient );
savefile->ReadInt( numDDADamageSamples );
savefile->ReadFloat( totalDDADamage );
savefile->ReadInt( spawnThinkFlags );
savefile->ReadBool( bCanWallwalk );
savefile->ReadBool( bOverrideKilledByGravityZones );
savefile->ReadInt( fallDelay );
savefile->ReadBool( soundOnModel );
savefile->ReadBool( bBindAxis );
savefile->ReadBool( bCustomBlood );
savefile->ReadBool( bNoCombat );
savefile->ReadBool( bNeverTarget );
savefile->ReadInt( nextSpiritProxyCheck );
allSimpleMonsters.AddUnique(this);
nextTurnUpdate = 0;
if ( AI_VEHICLE ) {
if ( GetVehicleInterface() ) {
ResetClipModel();
hhVehicle *vehicle = GetVehicleInterface()->GetVehicle();
spawnArgs.Set( "use_aas", spawnArgs.GetString( "aas_shuttle", "aasDroid" ) );
SetAAS();
SetState( GetScriptFunction( "state_VehicleCombat" ) );
}
}
};
/*
=====================
hhMonsterAI::GetTurnDir
Returns -1 if left, 0 if facing ideal, and 1 if turning right
=====================
*/
int hhMonsterAI::GetTurnDir( void ) {
float diff;
if ( !turnRate ) {
return 0;
}
diff = idMath::AngleNormalize180( current_yaw - ideal_yaw );
if ( idMath::Fabs( diff ) < 0.01f ) {
// force it to be exact
current_yaw = ideal_yaw;
return 0;
}
return (diff < 0 ? -1 : 1);
}
//=============================================================================
//
// hhMonsterAI::SendDamageToDDA()
//
// Informs the player of the amount of damage inflicted upon it until this
// creature was killed.
//=============================================================================
void hhMonsterAI::SendDamageToDDA() {
if ( gameLocal.isMultiplayer ) {
return;
}
int ddaIndex = spawnArgs.GetInt( "ddaIndex", "0" );
if ( gameLocal.GetDDA() && ddaIndex >= 0 ) { // Only include certain creatures in the DDA calculation (exclude such things as crawlers and NPCs)
gameLocal.GetDDA()->DDA_AddDamage( ddaIndex, totalDDADamage );
gameLocal.GetDDA()->DDA_AddSurvivalHealth( ddaIndex, gameLocal.GetLocalPlayer()->GetHealth() );
}
totalDDADamage = 0;
}
void hhMonsterAI::FlyMove( void ) {
idVec3 goalPos;
idVec3 oldorigin;
idVec3 newDest;
AI_BLOCKED = false;
if ( ( move.moveCommand != MOVE_NONE ) && ReachedPos( move.moveDest, move.moveCommand ) ) {
StopMove( MOVE_STATUS_DONE );
}
if ( move.moveCommand != MOVE_TO_POSITION_DIRECT ) {
idVec3 vel = physicsObj.GetLinearVelocity();
if ( GetMovePos( goalPos ) ) {
CheckObstacleAvoidance( goalPos, newDest );
goalPos = newDest;
}
if ( !AI_FLY_NO_SEEK && move.speed ) {
FlySeekGoal( vel, goalPos );
}
// add in bobbing
AddFlyBob( vel );
if ( enemy.GetEntity() && ( move.moveCommand != MOVE_TO_POSITION ) ) {
AdjustFlyHeight( vel, goalPos );
}
AdjustFlySpeed( vel );
physicsObj.SetLinearVelocity( vel );
}
// turn
FlyTurn();
// run the physics for this frame
oldorigin = physicsObj.GetOrigin();
physicsObj.UseFlyMove( true );
physicsObj.UseVelocityMove( false );
physicsObj.SetDelta( vec3_zero );
physicsObj.ForceDeltaMove( disableGravity );
RunPhysics();
monsterMoveResult_t moveResult = physicsObj.GetMoveResult();
if ( !af_push_moveables && attack.Length() && TestMelee() ) {
DirectDamage( attack, enemy.GetEntity() );
} else {
idEntity *blockEnt = physicsObj.GetSlideMoveEntity();
if ( blockEnt && blockEnt->IsType( idMoveable::Type ) && blockEnt->GetPhysics()->IsPushable() ) {
KickObstacles( viewAxis[ 0 ], kickForce, blockEnt );
} else if ( moveResult == MM_BLOCKED ) {
move.blockTime = gameLocal.time + 500;
AI_BLOCKED = true;
}
}
idVec3 org = physicsObj.GetOrigin();
if ( oldorigin != org ) {
TouchTriggers();
}
if ( ai_debugMove.GetBool() ) {
gameRenderWorld->DebugLine( colorCyan, oldorigin, physicsObj.GetOrigin(), 4000 );
gameRenderWorld->DebugBounds( colorOrange, physicsObj.GetBounds(), org, gameLocal.msec );
gameRenderWorld->DebugBounds( colorMagenta, physicsObj.GetBounds(), move.moveDest, gameLocal.msec );
gameRenderWorld->DebugLine( colorRed, org, org + physicsObj.GetLinearVelocity(), gameLocal.msec, true );
gameRenderWorld->DebugLine( colorBlue, org, goalPos, gameLocal.msec, true );
gameRenderWorld->DebugLine( colorYellow, org + EyeOffset(), org + EyeOffset() + viewAxis[ 0 ] * physicsObj.GetGravityAxis() * 16.0f, gameLocal.msec, true );
DrawRoute();
}
}
void hhMonsterAI::Activate( idEntity *activator ) {
if ( spawnThinkFlags != 0 ) {
int temp = spawnThinkFlags;
spawnThinkFlags = 0;
BecomeActive( temp );
}
idAI::Activate( activator );
}
void hhMonsterAI::Hide() {
if ( spawnThinkFlags == 0 && ai_hideSkipThink.GetBool() ) {
if ( ( spawnArgs.GetBool( "hide" ) || spawnArgs.GetBool( "portal" ) ) ) {
spawnThinkFlags = thinkFlags;
thinkFlags = 0;
}
}
idAI::Hide();
}
void hhMonsterAI::HideNoDormant() {
idAI::Hide();
}
void hhMonsterAI::BecomeActive( int flags ) {
if ( spawnThinkFlags != 0 ) {
spawnThinkFlags |= flags;
return;
}
idAI::BecomeActive( flags );
}
void hhMonsterAI::HandleNoGore(void) {
if (GERMAN_VERSION || g_nogore.GetBool()) {
fl.takedamage = false;
fl.canBeTractored = false;
GetPhysics()->SetContents(0);
float time = spawnArgs.GetFloat("nogore_dispose_time", "1");
if (time > 0.0f) {
//PostEventSec(&EV_Dispose, time);
}
}
}
bool hhMonsterAI::GetPhysicsToSoundTransform( idVec3 &origin, idMat3 &axis ) {
if ( soundOnModel ) {
idVec3 boneOrigin;
idMat3 boneAxis;
jointHandle_t bone = animator.GetJointHandle( spawnArgs.GetString( "sound_joint", "b1" ) );
if ( bone != INVALID_JOINT && animator.GetJointTransform( bone, gameLocal.time, boneOrigin, boneAxis ) ) {
origin = boneOrigin;
axis = boneAxis * viewAxis;
return true;
}
}
return idAI::GetPhysicsToSoundTransform( origin, axis );
}
void hhMonsterAI::AddLocalMatterWound( jointHandle_t jointNum, const idVec3 &localOrigin, const idVec3 &localNormal, const idVec3 &localDir, int damageDefIndex, const idMaterial *collisionMaterial ) {
if ( bCustomBlood ) {
return;
}
const idDeclEntityDef *def = static_cast<const idDeclEntityDef *>( declManager->DeclByIndex( DECL_ENTITYDEF, damageDefIndex ) );
if ( def == NULL ) {
return;
}
surfTypes_t matterType = gameLocal.GetMatterType( this, collisionMaterial, "idEntity::AddLocalMatterWound" );
GetWoundManager()->AddWounds( def, matterType, jointNum, localOrigin, localNormal, localDir );
if ( head.IsValid() ) {
head->AddLocalMatterWound( jointNum, localOrigin, localNormal, localDir, damageDefIndex, collisionMaterial );
}
//TODO: Grab head projection code from below and put into ApplyImpactMark()
}
Reference in New Issue View Git Blame Copy Permalink