virtual bool Update( PathFinderMove& /*move*/ )
{
//Make sure we can keep heading to our current subgoal
const Vector2List& currentPath = GetCurrentPath();
int currentPathIndex = GetCurrentPathIndex();
//has the destination changed
Vector2 vDest = currentPath[currentPath.size()-1];
if( vDest == GetCurrentDestination() )
{
if( theSpatialGraph.CanGo( GetCurrentPosition(), currentPath[currentPathIndex] ) )
{
SetNewState( PathFinder::PFMS_FOLLOW );
return true;
}
else if( !theSpatialGraph.CanGo( GetCurrentPosition(), GetCurrentPosition() ) )
{
//are we blocked
SetNewState( PathFinder::PFMS_RECOVER );
return true;
}
}
//otherwise, try again
SetNewState( PathFinder::PFMS_START );
return true;
}
void CivilianAI::ComputeState(int nStimType)
{
int nStim = nStimType;
if(nStimType == -1)
nStim = ComputeStimuli();
if(!nStim)
{
SetNewState(StateStrToInt(m_szAIState));
}
else
{
if(m_nState == STATE_Escape_Hide)
{
SetNewState(STATE_Escape_Hide);
}
else if(m_bScared || (m_fStimuli[HEALTH] < 1.0f))
{
m_bScared = DTRUE;
SetNewState(STATE_Escape_RunAway);
}
else
SetNewState(StateStrToInt(m_szAIState));
}
return;
}
virtual bool Update( PathFinderMove& move )
{
if( !theSpatialGraph.IsInPathableSpace( GetCurrentPosition() ) )
{
SetNewState(PathFinder::PFMS_STARTRECOVER);
return true;
}
//find path
GetCurrentPath().clear();
bool retVal = theSpatialGraph.GetPath( GetCurrentPosition(), GetCurrentDestination(), GetCurrentPath() );
if( retVal )
{
move.LastResult = PathFinder::PFMR_PATH_FOUND;
//Initialize path index
GetCurrentPathIndex() = 0;
SetNewState( PathFinder::PFMS_FOLLOW );
//Keep ticking
return true;
}
else
{
move.LastResult = PathFinder::PFMR_PATH_NOT_FOUND;
}
//We're done if path failed
return false;
}
void OpheliaREV::MC_BestWeapon()
{
CWeapon* pW = m_InventoryMgr.GetCurrentWeapon();
if(pW == DNULL)
{
SetNewState(STATE_Idle);
return;
}
if (m_bAnimating == DFALSE)
{
if(pW)
{
if(m_InventoryMgr.GetAmmoCount(pW->GetAmmoType(DFALSE)) <= 0.0)
{
SetAnimation( m_pAnim_Sound->m_nAnim_SWITCH_WEAPON[pW->GetFireType()]);
m_pServerDE->SetModelLooping(m_hObject, DFALSE);
m_bAnimating = DTRUE;
}
else
{
m_bAnimating = DFALSE;
Metacmd++;
}
}
}
else
{
//Are we done?
if(m_pServerDE->GetModelPlaybackState(m_hObject) & MS_PLAYDONE)
{
if(pW->GetType() == WEAP_TESLACANNON)
{
m_InventoryMgr.ChangeWeapon(WEAP_SNIPERRIFLE);
pW = m_InventoryMgr.GetCurrentWeapon();
pW->ShowHandModel(DFALSE);
SetAnimation( m_pAnim_Sound->m_nAnim_SWITCH_WEAPON[pW->GetFireType()]);
}
else
{
if(m_InventoryMgr.GetAmmoCount(pW->GetAmmoType(DFALSE)) <= 0.0)
{
SetNewState(STATE_FindAmmo);
}
else
{
m_bAnimating = DFALSE;
Metacmd++;
}
}
}
}
return;
}
DDWORD CivilianAI::ObjectMessageFn(HOBJECT hSender, DDWORD messageID, HMESSAGEREAD hRead)
{
switch(messageID)
{
case MID_TRIGGER:
{
HSTRING hMsg = m_pServerDE->ReadFromMessageHString(hRead);
char *pCommand = m_pServerDE->GetStringData(hMsg);
/* 01/15/1999 Be VERY sure we should run this. -- Loki */
if ((m_nState != STATE_Escape_Hide) &&
(m_nState != STATE_Script) &&
(m_nState != STATE_Special1) &&
(m_nState != STATE_Special2) &&
(m_nState != STATE_Special3) &&
(m_nState != STATE_Special4) &&
(m_nState != STATE_Special5) &&
(m_nState != STATE_Special6) &&
(m_nState != STATE_Special7) &&
(m_nState != STATE_Special8) &&
(m_nState != STATE_Special9) &&
(_mbscmp((const unsigned char*)pCommand, (const unsigned char*)"TRIGGER") == 0))
{
m_hTarget = hSender;
if(m_bLabTech)
SetNewState(STATE_Escape_Hide);
else
SetNewState(STATE_Special1);
}
g_pServerDE->FreeString( hMsg );
break;
}
case MID_DAMAGE:
{
AI_Mgr::ObjectMessageFn(hSender, messageID, hRead);
SetNewState(STATE_Escape_RunAway);
return 0;
}
default : break;
}
return AI_Mgr::ObjectMessageFn(hSender, messageID, hRead);
}
void BugAI::AI_STATE_Escape_RunAway()
{
//SCHLEGZ 4/22/98 4:51:21 PM: sanity check
if(m_hTarget == DNULL)
{
SetNewState(STATE_Idle);
return;
}
switch(Metacmd)
{
case 1: char szSound[256];
_mbscpy((unsigned char*)szSound, (const unsigned char*)SOUND_FEAR);
m_pAnim_Sound->GetSoundPath(szSound,m_pServerDE->IntRandom(1,NUM_BUG_FEAR));
PlayAISound(szSound, 1000.0f);
Metacmd++; break;
case 2: MC_FaceTarget(); break;
case 3: m_fRadsLeft = 3.14f; Metacmd++; break;
case 4: MC_Turn(); break;
case 5: MC_Run(); break;
case 6: ComputeState(); break;
}
return;
}
void BugAI::AI_STATE_Idle()
{
if(ComputeStimuli())
{
ComputeState();
m_pServerDE->SetNextUpdate(m_hObject,0.1f);
return;
}
else
m_pServerDE->SetNextUpdate(m_hObject,0.2f);
switch(Metacmd)
{
case 1: char szSound[256];
_mbscpy((unsigned char*)szSound, (const unsigned char*)SOUND_IDLE);
m_pAnim_Sound->GetSoundPath(szSound,m_pServerDE->IntRandom(1,NUM_BUG_IDLE));
PlayAISound(szSound, 1000.0f);
Metacmd++; break;
case 2: MC_Idle(); break;
case 3: m_fRadsLeft = m_pServerDE->Random(-1.56f,1.56f);
Metacmd++; break;
case 4: MC_Turn(); break;
case 5: MC_Run(); break;
case 6: SetNewState(STATE_Idle); break;
}
return;
}
void DeathShroud::MC_Fire_Stand()
{
if (m_bAnimating == DFALSE || m_nCurMetacmd != MC_FIRE_STAND)
{
DBOOL bRet = SetAnimation(m_pAnim_Sound->m_nAnim_FIRE_STAND[8]);
//SCHLEGZ 4/22/98 3:27:12 PM: if we can't stand up, crawl out from underneath
if(!bRet)
{
SetNewState(STATE_CrawlUnderObj);
return;
}
m_pServerDE->SetModelLooping(m_hObject, DFALSE);
m_bAnimating = DTRUE;
m_nCurMetacmd = MC_FIRE_STAND;
}
else
{
if(m_pServerDE->GetModelPlaybackState(m_hObject) & MS_PLAYDONE)
{
m_bAnimating = DFALSE;
Metacmd++;
return;
}
}
return;
}
DBOOL Prophet::Fire(DBOOL bAltFire)
{
DBOOL bFire = DFALSE;
CWeapon* pW = m_InventoryMgr.GetCurrentWeapon();
if(pW == DNULL)
{
SetNewState(STATE_Idle);
return DFALSE;
}
DVector vTargetVel, vVel;
m_pServerDE->GetVelocity(m_hTarget, &vTargetVel);
m_pServerDE->GetVelocity(m_hObject, &vVel);
DFLOAT fTargetVel = VEC_MAG(vTargetVel);
DFLOAT fVel = VEC_MAG(vVel);
if(fTargetVel <= 5.0f && fVel <= 5.0f && pW->GetType() != WEAP_ASSAULTRIFLE
&& pW->GetType() != WEAP_NAPALMCANNON && pW->GetType() != WEAP_SNIPERRIFLE)
{
if(m_InventoryMgr.GetAmmoCount(pW->GetAmmoType(DFALSE)) >= pW->GetAltAmmoUse())
bFire = DTRUE;
}
// DDWORD m_nFiredWeapon = m_InventoryMgr.FireCurrentWeapon(&m_MoveObj.GetPos(), &m_MoveObj.GetRotation(), bFire);
return AI_Mgr::Fire(bFire);
}
void Prophet::MC_Fire_Stand()
{
CWeapon* pW = m_InventoryMgr.GetCurrentWeapon();
if(pW == DNULL)
{
SetNewState(STATE_Idle);
return;
}
if(pW->GetType() == WEAP_MELEE)
{
if (m_bAnimating == DFALSE || m_nCurMetacmd != MC_FIRE_STAND)
{
DBOOL bRet = SetAnimation(m_pAnim_Sound->m_nAnim_FIRE_STAND[m_pServerDE->IntRandom(4,6)]);
//SCHLEGZ 4/22/98 3:27:12 PM: if we can't stand up, crawl out from underneath
if(!bRet)
{
SetNewState(STATE_CrawlUnderObj);
return;
}
m_pServerDE->SetModelLooping(m_hObject, DFALSE);
m_bAnimating = DTRUE;
m_nCurMetacmd = MC_FIRE_STAND;
m_pServerDE->SetNextUpdate(m_hObject, 0.1f);
}
else
{
if(m_pServerDE->GetModelPlaybackState(m_hObject) & MS_PLAYDONE)
{
m_bAnimating = DFALSE;
Metacmd++;
return;
}
}
}
else
{
AI_Mgr::MC_Fire_Stand();
}
return;
}
void CultistAI::AI_STATE_AttackFar()
{
DFLOAT fHeight = (DFLOAT)fabs(m_vTargetPos.y - m_MoveObj.GetPos().y);
//SCHLEGZ 4/22/98 4:51:21 PM: sanity check
if(m_hTarget == DNULL)
{
if(fHeight <= m_vDims.y)
SetNewState(STATE_SearchVisualTarget);
else
ComputeState();
return;
}
m_fStimuli[SIGHT] = VEC_DIST(m_MoveObj.GetPos(),m_vTargetPos);
DBOOL bAbove = (m_vTargetPos.y - m_MoveObj.GetPos().y) > 0;
switch(Metacmd)
{
case 1: MC_FaceTarget(); break;
case 2: MC_BestWeapon(); break;
case 3: if(m_fStimuli[SIGHT] <= (m_fSeeingDist * 0.75) || m_nCurMetacmd == MC_FIRE_STAND || fHeight > m_vDims.y)
{
MC_Fire_Stand();
}
else
Metacmd++;
break;
case 4: if(m_fStimuli[SIGHT] > (m_fSeeingDist * 0.75))
{
MC_FaceTarget();
Metacmd--;
if(!IsLedge(m_MoveObj.GetForwardVector()) && fHeight <= m_vDims.y
&& m_nCurMetacmd != MC_FIRE_STAND
)
{
if(m_nInjuredLeg)
MC_Walk();
else
MC_Fire_Run();
}
else
{
MC_Fire_Stand();
}
}
else
Metacmd++;
break;
case 5: ComputeState(); break;
}
return;
}
void UndeadGideon::ComputeState(int nStimType)
{
int nStim = nStimType;
if(nStimType == -1)
nStim = ComputeStimuli();
DFLOAT fHeight = (DFLOAT)fabs(m_vTargetPos.y - m_MoveObj.GetPos().y);
if(nStim == 0)
{
switch(m_nState)
{
case STATE_Idle: SetNewState(STATE_Idle); break;
case STATE_SearchVisualTarget: SetNewState(STATE_Idle); break;
case STATE_SearchSmellTarget: SetNewState(STATE_Idle); break;
default: SetNewState(STATE_SearchSmellTarget); break;
}
}
else
{
if(nStimType == STIM_SMELL)
SetNewState(STATE_SearchSmellTarget);
else if(m_fStimuli[SIGHT] <= 0.85f || fHeight > m_vDims.y)
SetNewState(STATE_AttackFar);
else
SetNewState(STATE_AttackClose);
}
return;
}
void GremlinAI::ComputeState(int nStimType)
{
int nStim = nStimType;
if(nStimType == -1)
nStim = ComputeStimuli();
if(nStim == 0)
{
switch(m_nState)
{
case STATE_Idle: SetNewState(STATE_Idle); break;
case STATE_SearchVisualTarget: SetNewState(STATE_Idle); break;
case STATE_SearchSmellTarget: SetNewState(STATE_Idle); break;
default: SetNewState(STATE_SearchSmellTarget); break;
}
}
else
{
if(nStimType == STIM_SMELL)
SetNewState(STATE_SearchSmellTarget);
else if(m_fStimuli[SIGHT] <= 0.75f)
SetNewState(STATE_AttackFar);
else
SetNewState(STATE_AttackClose);
}
return;
}
virtual bool Update( PathFinderMove& move )
{
//check our current path index
const int iLookAheadCount = 3;
const Vector2List& currentPath = GetCurrentPath();
int nextPathIndex = GetCurrentPathIndex();
//Are we at our goal index
if( nextPathIndex == (int)currentPath.size() - 1 )
{
move.NextSubgoalPos = currentPath[nextPathIndex];
//check distance to goal
float sqDist = Vector2::DistanceSquared( GetCurrentPosition(), move.NextSubgoalPos );
float arrivalDistSq = GetCurrentArrivalDist();
arrivalDistSq *= arrivalDistSq;
if( sqDist <= arrivalDistSq )
{
//don't set move dir (we've arrived)
move.LastResult = PathFinder::PFMR_ARRIVED;
SetNewState( PathFinder::PFMS_VALIDATE );
return false;
}
}
else
{
//otherwise, see if we can advance our next subgoal
for( int i = 0 ; i < iLookAheadCount && (nextPathIndex+1) < (int)currentPath.size(); i++ )
{
if( theSpatialGraph.CanGo( GetCurrentPosition(), currentPath[nextPathIndex+1] ) )
{
++nextPathIndex;
}
}
GetCurrentPathIndex() = nextPathIndex;
move.NextSubgoalPos = currentPath[nextPathIndex];
}
//Move dir is normalized towards next subgoal
move.MoveDir = Vector2::Normalize( move.NextSubgoalPos - GetCurrentPosition() );
//we're done this round
SetNewState( PathFinder::PFMS_VALIDATE );
return false;
}
void MadScientistAI::ComputeState(int nStimType)
{
int nStim = nStimType;
if(nStimType == -1)
nStim = ComputeStimuli();
if(nStim == 0)
{
SetNewState(StateStrToInt(m_szAIState));
}
else
{
SetNewState(STATE_Escape_Hide);
}
return;
}
void UndeadGideon::AI_STATE_AttackFar()
{
DFLOAT fHeight = (DFLOAT)fabs(m_vTargetPos.y - m_MoveObj.GetPos().y);
//SCHLEGZ 4/22/98 4:51:21 PM: sanity check
if(m_hTarget == DNULL && m_nCurMetacmd != MC_FIRE_STAND && m_nCurMetacmd != MC_JUMP)
{
if(fHeight <= m_vDims.y)
SetNewState(STATE_SearchVisualTarget);
else
ComputeState();
return;
}
m_fStimuli[SIGHT] = VEC_DIST(m_MoveObj.GetPos(),m_vTargetPos);
DBOOL bAbove = (m_vTargetPos.y - m_MoveObj.GetPos().y) > 0;
MC_FaceTarget();
Metacmd--;
switch(Metacmd)
{
case 1: if(m_fStimuli[SIGHT] <= (m_fSeeingDist * 0.75) || m_nCurMetacmd == MC_FIRE_STAND
|| (bAbove && fHeight > m_vDims.y))
{
MC_Fire_Stand();
}
else
{
if(m_fStimuli[SIGHT] < (m_fSeeingDist * 0.20))
ComputeState();
else
MC_Walk();
}
break;
case 2: if((m_fStimuli[SIGHT] < (m_fSeeingDist * 0.20)) && m_nCurMetacmd != MC_JUMP
|| (bAbove && fHeight > m_vDims.y))
{
ComputeState();
}
else if(m_fStimuli[SIGHT] < (m_fSeeingDist * 0.30) || m_nCurMetacmd == MC_JUMP
|| IsLedge(m_MoveObj.GetForwardVector()))
{
MC_Jump();
}
else
MC_Walk();
break;
case 3: ComputeState(); break;
}
return;
}
void OpheliaREV::AI_STATE_Escape_Hide()
{
switch(Metacmd)
{
case 1: m_hTrackObject = FindObjectInRadius(m_pServerDE->GetClass("ExitHint"), m_fSeeingDist);
if(m_hTrackObject)
{
m_pServerDE->GetObjectPos(m_hTrackObject,&m_vDestPos);
SetNewState(STATE_RunToPos);
}
else
SetNewState(STATE_AttackClose);
break;
}
return;
}
void DeathShroud::ComputeState(int nStimType)
{
int nStim = nStimType;
if(nStimType == -1)
nStim = ComputeStimuli();
if(!nStim)
{
switch(m_nState)
{
case STATE_Idle: SetNewState(STATE_Idle); break;
case STATE_SearchVisualTarget: SetNewState(STATE_Idle); break;
case STATE_SearchSmellTarget: SetNewState(STATE_Idle); break;
default: SetNewState(STATE_SearchVisualTarget); break;
}
}
else
{
SetNewState(STATE_AttackFar);
}
return;
}
void Prophet::AI_STATE_Escape_RunAway()
{
DFLOAT fHeight = (DFLOAT)fabs(m_vTargetPos.y - m_MoveObj.GetPos().y);
//SCHLEGZ 4/22/98 4:51:21 PM: sanity check
if(m_hTarget == DNULL && m_nCurMetacmd != MC_FIRE_STAND)
{
if(fHeight <= m_vDims.y)
SetNewState(STATE_SearchVisualTarget);
else
ComputeState();
return;
}
switch(Metacmd)
{
case 1:
MC_FaceTarget();
m_InventoryMgr.ChangeWeapon(WEAP_MELEE);
break;
case 2:
m_fStimuli[SIGHT] = VEC_DIST(m_MoveObj.GetPos(),m_vTargetPos);
if(m_fStimuli[SIGHT] <= 75.0f)
MC_Fire_Stand();
else
{
MC_FaceTarget();
Metacmd--;
if(!IsLedge(m_MoveObj.GetForwardVector()) && fHeight <= m_vDims.y)
{
MC_Run();
}
else
{
MC_Idle();
}
}
break;
case 3:
ComputeState();
break;
}
return;
}
void Naga::AI_STATE_Special1()
{
switch(Metacmd)
{
case 1:
MC_FadeIn();
break;
case 2:
DDWORD dwFlags = m_pServerDE->GetObjectFlags(m_hObject);
dwFlags = dwFlags | FLAG_SOLID;
m_pServerDE->SetObjectFlags(m_hObject, dwFlags);
SetNewState(STATE_Idle);
break;
}
}
void DeathShroud::AI_STATE_AttackFar()
{
DFLOAT fHeight = (DFLOAT)fabs(m_vTargetPos.y - m_MoveObj.GetPos().y);
//SCHLEGZ 4/22/98 4:51:21 PM: sanity check
if(m_hTarget == DNULL && m_nCurMetacmd != MC_FIRE_STAND)
{
if(fHeight <= m_vDims.y)
SetNewState(STATE_SearchVisualTarget);
else
ComputeState();
return;
}
m_fStimuli[SIGHT] = VEC_DIST(m_MoveObj.GetPos(),m_vTargetPos);
MC_FaceTarget();
Metacmd--;
switch(Metacmd)
{
case 1: MC_Fade(DFALSE); break;
case 2: if(m_fStimuli[SIGHT] <= (m_fSeeingDist * 0.66) || m_nCurMetacmd == MC_FIRE_STAND
|| fHeight > m_vDims.y)
{
MC_Fire_Stand();
}
else
{
Metacmd++;
}
break;
case 3: MC_Fade(DTRUE); break;
case 4: if(m_fStimuli[SIGHT] <= (m_fSeeingDist * 0.33) || fHeight > m_vDims.y)
Metacmd++;
else
MC_Walk();
break;
case 5: ComputeState(); break;
}
return;
}
virtual bool Update( PathFinderMove& move )
{
//are we back in pathable space?
if( theSpatialGraph.IsInPathableSpace( GetCurrentPosition() ) )
{
SetNewState( PathFinder::PFMS_FOLLOW );
return true;
}
const Vector2List& currentPath = GetCurrentPath();
int currentPathIndex = GetCurrentPathIndex();
//otherwise, head toward our current pathnode
move.MoveDir = Vector2::Normalize( currentPath[currentPathIndex] - GetCurrentPosition() );
return false;
}
void GremlinAI::MC_Fire_Stand()
{
if (m_bAnimating == DFALSE || m_nCurMetacmd != MC_FIRE_STAND)
{
DBOOL bRet = DFALSE;
DFLOAT fHeight = (DFLOAT)fabs(m_vTargetPos.y - m_MoveObj.GetPos().y);
DBOOL bAbove = (m_vTargetPos.y - m_MoveObj.GetPos().y) > 0;
if(m_nState == STATE_AttackFar || m_nState == STATE_GuardLocation || (bAbove && fHeight > m_vDims.y))
{
m_InventoryMgr.ChangeWeapon(WEAP_GREMLIN_ROCK);
bRet = SetAnimation(m_pAnim_Sound->m_nAnim_FIRE_STAND[4]);
}
else
{
m_InventoryMgr.ChangeWeapon(WEAP_SHIKARI_CLAW);
bRet = SetAnimation(m_pAnim_Sound->m_nAnim_FIRE_STAND[4]);
}
//SCHLEGZ 4/22/98 3:27:12 PM: if we can't stand up, crawl out from underneath
if(!bRet)
{
SetNewState(STATE_CrawlUnderObj);
return;
}
m_pServerDE->SetModelLooping(m_hObject, DFALSE);
m_bAnimating = DTRUE;
m_nCurMetacmd = MC_FIRE_STAND;
}
else
{
if(m_pServerDE->GetModelPlaybackState(m_hObject) & MS_PLAYDONE)
{
m_InventoryMgr.ChangeWeapon(WEAP_SHIKARI_CLAW);
m_bAnimating = DFALSE;
Metacmd++;
return;
}
}
return;
}
void Naga::AI_STATE_AttackFar()
{
//SCHLEGZ 4/22/98 4:51:21 PM: sanity check
if(m_hTarget == DNULL && m_nCurMetacmd != MC_FIRE_STAND)
{
SetNewState(STATE_SearchVisualTarget);
return;
}
switch(Metacmd)
{
case 1: MC_FaceTarget(); break;
case 2: MC_Fire_Stand(); break;
case 3: ComputeState(); break;
}
return;
}
void UndeadGideon::AI_STATE_Dodge()
{
switch(Metacmd)
{
case 1: m_nDodgeFlags = CalculateDodge(m_vTrackObjPos);
Metacmd++; break;
case 2: if(m_nDodgeFlags & RIGHT)
MC_Dodge_Right();
else if(m_nDodgeFlags & LEFT)
MC_Dodge_Left();
else
Metacmd++;
break;
case 3: SetNewState(STATE_Idle); break;
}
return;
}
virtual bool Update( PathFinderMove& move )
{
//are we back in pathable space?
if( theSpatialGraph.IsInPathableSpace( GetCurrentPosition() ) )
{
SetNewState( PathFinder::PFMS_START );
return true;
}
//find the nearest non-blocked neighbor I can move to
Vector2 vGoTo;
if( theSpatialGraph.FindNearestNonBlocked( GetCurrentPosition(), vGoTo) )
{
move.MoveDir = Vector2::Normalize( vGoTo - GetCurrentPosition() );
}
else
{
move.LastResult = PathFinder::PFMR_PATH_NOT_FOUND;
}
return false;
}
void Naga::ComputeState(int nStimType)
{
int nStim = nStimType;
if(nStimType == -1)
nStim = ComputeStimuli();
if(!nStim)
{
switch(m_nState)
{
case STATE_Idle: SetNewState(STATE_Idle); break;
case STATE_SearchVisualTarget: SetNewState(STATE_Idle); break;
default: SetNewState(STATE_SearchVisualTarget); break;
}
}
else
{
if(m_fStimuli[SENSE] > 0.0f && m_fStimuli[SIGHT] <= 0.0f)
{
SetNewState(STATE_AttackFar);
return;
}
//if health is low or threat is high, attack close
if(m_fStimuli[HEALTH] < 0.25f || m_fStimuli[THREAT] > 0.75f)
{
SetNewState(STATE_AttackClose);
return;
}
if(m_fStimuli[SIGHT] > 0.85f)
SetNewState(STATE_AttackClose);
else
SetNewState(STATE_AttackFar);
}
return;
}
void CivilianAI::AI_STATE_Escape_RunAway()
{
DVector vDims;
m_pServerDE->GetObjectDims(m_hObject,&vDims);
DFLOAT fDim = (DFLOAT)sqrt((vDims.x * vDims.x) + (vDims.z * vDims.z)) + 0.1f;
switch(Metacmd)
{
case 1:
{
m_hTrackObject = FindObjectInRadius(m_pServerDE->GetClass("ExitHint"), m_fSeeingDist, FIND_VISIBLE);
if(m_hTrackObject)
{
m_pServerDE->GetObjectPos(m_hTrackObject,&m_vTrackObjPos);
DFLOAT fDist = VEC_DIST(m_vTrackObjPos, m_MoveObj.GetPos());
if(fDist <= fDim/2)
{
SetNewState(STATE_Escape_Hide);
break;
}
MC_FacePos(m_vTrackObjPos);
DRotation rRot;
DVector vU, vR, vF, vMyF;
m_pServerDE->GetObjectRotation(m_hTrackObject, &rRot);
m_pServerDE->GetRotationVectors(&rRot, &vU, &vR, &vF);
VEC_COPY(vMyF, m_MoveObj.GetForwardVector());
DFLOAT fHintDp = (vMyF.x * vF.x) + (vMyF.y * vF.y) + (vMyF.z * vF.z);
if(fHintDp > 0)
{
if(!m_MoveObj.CalculatePath(m_vTrackObjPos))
SetNewState(STATE_Escape_Hide);
}
else
SetNewState(STATE_Escape_Hide);
}
else
SetNewState(STATE_Escape_Hide);
break;
}
case 2:
{
DVector* pvPos = m_MoveObj.GetNextPathPoint();
if(pvPos)
MC_FacePos(*pvPos);
else
SetNewState(STATE_Escape_RunAway);
break;
}
case 3:
{
DVector vPoint = *m_MoveObj.GetNextPathPoint();
vPoint.y = m_MoveObj.GetPos().y;
if(VEC_DIST(vPoint, m_MoveObj.GetPos()) <= fDim/2)
{
if(!m_MoveObj.MoveToNextPathPoint())
{
MC_FacePos(m_vTargetPos);
}
else
{
Metacmd = 2;
}
}
else
MC_Run();
break;
}
case 4: ComputeState(); break;
}
return;
}
void OpheliaREV::AI_STATE_AttackFar()
{
DFLOAT fHeight = (DFLOAT)fabs(m_vTargetPos.y - m_MoveObj.GetPos().y);
//SCHLEGZ 4/22/98 4:51:21 PM: sanity check
if(m_hTarget == DNULL)
{
if(fHeight <= m_vDims.y)
SetNewState(STATE_SearchVisualTarget);
else
ComputeState();
return;
}
m_fStimuli[SIGHT] = VEC_DIST(m_MoveObj.GetPos(),m_vTargetPos);
DBOOL bAbove = (m_vTargetPos.y - m_MoveObj.GetPos().y) > 0;
CWeapon* pW = m_InventoryMgr.GetCurrentWeapon();
if(pW == DNULL)
{
SetNewState(STATE_Idle);
return;
}
switch(Metacmd)
{
case 1: MC_FaceTarget(); break;
case 2: MC_BestWeapon(); break;
case 3: if(m_fStimuli[SIGHT] <= (m_fSeeingDist * 0.75) || m_nCurMetacmd == MC_FIRE_STAND
|| m_nCurMetacmd == MC_FIRE_CROUCH || fHeight > m_vDims.y)
{
if((fHeight > m_vDims.y && !bAbove) || m_nCurMetacmd == MC_FIRE_CROUCH
|| m_fStimuli[HEALTH] < 0.5f || pW->GetType() == WEAP_SNIPERRIFLE)
{
MC_Fire_Crouch();
}
else
{
MC_Fire_Stand();
}
}
else
Metacmd++;
break;
case 4: if(m_fStimuli[SIGHT] > (m_fSeeingDist * 0.75))
{
MC_FaceTarget();
Metacmd--;
if(!IsLedge(m_MoveObj.GetForwardVector()) && fHeight <= m_vDims.y
&& m_nCurMetacmd != MC_FIRE_CROUCH && pW->GetType() != WEAP_SNIPERRIFLE)
{
if(m_nInjuredLeg)
MC_Walk();
else
MC_Fire_Run();
}
else
{
MC_Fire_Crouch();
}
}
else
Metacmd++;
break;
case 5: ComputeState(); break;
}
return;
}
void OpheliaREV::AI_STATE_Escape_RunAway()
{
if(Metacmd > 1)
{
int nStimType = ComputeStimuli();
if(nStimType > 0)
{
ComputeState(nStimType);
return;
}
}
DFLOAT fDim = (DFLOAT)sqrt((m_vDims.x * m_vDims.x) + (m_vDims.z * m_vDims.z)) + 0.1f;
switch(Metacmd)
{
case 1: m_hTrackObject = FindObjectInRadius(m_pServerDE->GetClass("ExitHint"), m_fSeeingDist, FIND_VISIBLE | FIND_AVOID_TARGET);
if(m_hTrackObject)
{
m_pServerDE->GetObjectPos(m_hTrackObject,&m_vTrackObjPos);
MC_FacePos(m_vTrackObjPos);
if(!m_MoveObj.CalculatePath(m_vTrackObjPos))
SetNewState(STATE_Idle);
}
else
SetNewState(STATE_AttackFar);
break;
case 2:
{
DVector* pvPos = m_MoveObj.GetNextPathPoint();
if(pvPos)
MC_FacePos(*pvPos);
else
SetNewState(STATE_Escape_RunAway);
break;
}
case 3:
{
DVector vPoint = *m_MoveObj.GetNextPathPoint();
vPoint.y = m_MoveObj.GetPos().y;
if(VEC_DIST(vPoint, m_MoveObj.GetPos()) <= fDim/2)
{
if(!m_MoveObj.MoveToNextPathPoint())
{
MC_FacePos(m_vTargetPos);
}
else
{
Metacmd = 2;
}
}
else
MC_Run();
break;
}
case 4: ComputeState(); break;
}
return;}
