CTargetTrackThreatModifier::CTargetTrackThreatModifier()
{
ITargetTrackManager *pTargetTrackManager = gEnv->pAISystem->GetTargetTrackManager();
if (pTargetTrackManager)
pTargetTrackManager->SetTargetTrackThreatModifier(this);
IConsole *pConsole = gEnv->pConsole;
assert(pConsole);
m_pCVar_CloakMinDist = pConsole->GetCVar("ai_CloakMinDist");
m_pCVar_CloakMaxDist = pConsole->GetCVar("ai_CloakMaxDist");
m_pCVar_SOMSpeedRelaxed = pConsole->GetCVar("ai_SOMSpeedRelaxed");
m_pCVar_SOMSpeedCombat = pConsole->GetCVar("ai_SOMSpeedCombat");
}
void CVisibleObjectsHelper::CheckVisibilityToAI(const TActiveVisibleObjects &activeVisibleObjects, const Agent& agent) const
{
assert(agent.IsValid());
IScriptSystem *pSS = gEnv->pScriptSystem;
assert(pSS);
IEntity *pAIEntity = gEnv->pEntitySystem->GetEntity(agent.GetEntityID());
TActiveVisibleObjects::const_iterator itObject = activeVisibleObjects.begin();
TActiveVisibleObjects::const_iterator itObjectEnd = activeVisibleObjects.end();
for (; itObject != itObjectEnd; ++itObject)
{
const SVisibleObject *visibleObject = (*itObject);
assert(visibleObject);
const bool bVisible = IsObjectVisible(agent, *visibleObject);
if (bVisible)
{
// Callback function
if (visibleObject->pFunc)
{
visibleObject->pFunc(agent, visibleObject->entityId, visibleObject->pFuncArg);
}
// Notify on seen
if (pAIEntity != NULL && eVOR_FlagNotifyOnSeen == (visibleObject->rule & eVOR_FlagNotifyOnSeen))
{
IVisionMap& visionMap = *gEnv->pAISystem->GetVisionMap();
const ObservableParams* pObservableParams = visionMap.GetObservableParams(visibleObject->visionId);
if (pObservableParams != NULL)
{
IEntity* pTargetEntity = gEnv->pEntitySystem->GetEntity(pObservableParams->entityId);
ITargetTrackManager *pTargetTrackManager = gEnv->pAISystem->GetTargetTrackManager();
if (pTargetEntity != NULL && pTargetTrackManager != NULL)
{
const tAIObjectID aiOwnerId = pAIEntity->GetAIObjectID();
const tAIObjectID aiTargetId = pTargetEntity->GetAIObjectID();
TargetTrackHelpers::SStimulusEvent eventInfo;
eventInfo.vPos = pTargetEntity->GetWorldPos();
eventInfo.eStimulusType = TargetTrackHelpers::eEST_Visual;
eventInfo.eTargetThreat = AITHREAT_INTERESTING;
pTargetTrackManager->HandleStimulusEventForAgent(aiOwnerId, aiTargetId, "SeeThrownObject", eventInfo);
IAIObject* pAIObjectSender = pAIEntity->GetAI();
if (pAIObjectSender)
{
IAISignalExtraData *pSignalData = gEnv->pAISystem->CreateSignalExtraData();
if (pSignalData)
{
pSignalData->nID = visibleObject->entityId;
}
gEnv->pAISystem->SendSignal(SIGNALFILTER_SENDER, 1, "OnSawObjectMove", pAIObjectSender, pSignalData);
}
}
}
}
}
}
}
CTargetTrackThreatModifier::~CTargetTrackThreatModifier()
{
ITargetTrackManager *pTargetTrackManager = gEnv->pAISystem->GetTargetTrackManager();
if (pTargetTrackManager)
pTargetTrackManager->ClearTargetTrackThreatModifier();
}
//------------------------------------------------------------------------
int CMelee::Hit(const Vec3 &pt, const Vec3 &dir, const Vec3 &normal, IPhysicalEntity *pCollider, EntityId collidedEntityId, int partId, int ipart, int surfaceIdx, bool remote)
{
MeleeDebugLog ("CMelee<%p> HitPointDirNormal(remote=%s)", this, remote ? "true" : "false");
int hitTypeID = 0;
CActor *pOwnerActor = m_pWeapon->GetOwnerActor();
if (pOwnerActor)
{
IActor* pTargetActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(collidedEntityId);
IEntity* pTarget = pTargetActor ? pTargetActor->GetEntity() : gEnv->pEntitySystem->GetEntity(collidedEntityId);
IEntity* pOwnerEntity = pOwnerActor->GetEntity();
IAIObject* pOwnerAI = pOwnerEntity->GetAI();
float damageScale = 1.0f;
bool silentHit = false;
if(pTargetActor)
{
IAnimatedCharacter* pTargetAC = pTargetActor->GetAnimatedCharacter();
IAnimatedCharacter* pOwnerAC = pOwnerActor->GetAnimatedCharacter();
if(pTargetAC && pOwnerAC)
{
Vec3 targetFacing(pTargetAC->GetAnimLocation().GetColumn1());
Vec3 ownerFacing(pOwnerAC->GetAnimLocation().GetColumn1());
float ownerFacingDot = ownerFacing.Dot(targetFacing);
float fromBehindDot = cos_tpl(DEG2RAD(g_pGameCVars->pl_melee.angle_limit_from_behind));
if(ownerFacingDot > fromBehindDot)
{
#ifndef _RELEASE
if (g_pGameCVars->g_LogDamage)
{
CryLog ("[DAMAGE] %s '%s' is%s meleeing %s '%s' from behind (because %f > %f)",
pOwnerActor->GetEntity()->GetClass()->GetName(), pOwnerActor->GetEntity()->GetName(), silentHit ? " silently" : "",
pTargetActor->GetEntity()->GetClass()->GetName(), pTargetActor->GetEntity()->GetName(),
ownerFacingDot, fromBehindDot);
}
#endif
damageScale *= g_pGameCVars->pl_melee.damage_multiplier_from_behind;
}
}
}
// Send target stimuli
if (!gEnv->bMultiplayer)
{
IAISystem *pAISystem = gEnv->pAISystem;
ITargetTrackManager *pTargetTrackManager = pAISystem ? pAISystem->GetTargetTrackManager() : NULL;
if (pTargetTrackManager && pOwnerAI)
{
IAIObject *pTargetAI = pTarget ? pTarget->GetAI() : NULL;
if (pTargetAI)
{
const tAIObjectID aiOwnerId = pOwnerAI->GetAIObjectID();
const tAIObjectID aiTargetId = pTargetAI->GetAIObjectID();
TargetTrackHelpers::SStimulusEvent eventInfo;
eventInfo.vPos = pt;
eventInfo.eStimulusType = TargetTrackHelpers::eEST_Generic;
eventInfo.eTargetThreat = AITHREAT_AGGRESSIVE;
pTargetTrackManager->HandleStimulusEventForAgent(aiTargetId, aiOwnerId, "MeleeHit",eventInfo);
pTargetTrackManager->HandleStimulusEventInRange(aiOwnerId, "MeleeHitNear", eventInfo, 5.0f);
}
}
}
//Check if is a friendly hit, in that case FX and Hit will be skipped
bool isFriendlyHit = (pOwnerEntity && pTarget) ? IsFriendlyHit(pOwnerEntity, pTarget) : false;
if(!isFriendlyHit)
{
CPlayer * pAttackerPlayer = pOwnerActor->IsPlayer() ? static_cast<CPlayer*>(pOwnerActor) : NULL;
float damage = m_pMeleeParams->meleeparams.damage_ai;
if(pOwnerActor->IsPlayer())
{
damage = m_slideKick ? m_pMeleeParams->meleeparams.slide_damage : GetMeleeDamage();
}
#ifndef _RELEASE
if (pTargetActor && g_pGameCVars->g_LogDamage)
{
CryLog ("[DAMAGE] %s '%s' is%s meleeing %s '%s' applying damage = %.3f x %.3f = %.3f",
pOwnerActor->GetEntity()->GetClass()->GetName(), pOwnerActor->GetEntity()->GetName(), silentHit ? " silently" : "",
pTargetActor->GetEntity()->GetClass()->GetName(), pTargetActor->GetEntity()->GetName(),
damage, damageScale, damage * damageScale);
}
#endif
//Generate Hit
if(pTarget)
{
CGameRules *pGameRules = g_pGame->GetGameRules();
CRY_ASSERT_MESSAGE(pGameRules, "No game rules! Melee can not apply hit damage");
if (pGameRules)
{
hitTypeID = silentHit ? CGameRules::EHitType::SilentMelee : m_hitTypeID;
HitInfo info(m_pWeapon->GetOwnerId(), pTarget->GetId(), m_pWeapon->GetEntityId(),
damage * damageScale, 0.0f, surfaceIdx, partId, hitTypeID, pt, dir, normal);
if (m_pMeleeParams->meleeparams.knockdown_chance>0 && Random(100) < m_pMeleeParams->meleeparams.knockdown_chance)
info.knocksDown = true;
info.remote = remote;
pGameRules->ClientHit(info);
}
if (pAttackerPlayer && pAttackerPlayer->IsClient())
{
const Vec3 posOffset = (pt - pTarget->GetWorldPos());
SMeleeHitParams params;
params.m_boostedMelee = false;
params.m_hitNormal = normal;
params.m_hitOffset = posOffset;
params.m_surfaceIdx = surfaceIdx;
params.m_targetId = pTarget->GetId();
pAttackerPlayer->OnMeleeHit(params);
}
}
else
{
//Play Material FX
PlayHitMaterialEffect(pt, normal, false, surfaceIdx);
}
}
if (pTarget)
{
CActor *pCTargetActor = static_cast<CActor*>(pTargetActor);
CPlayer* pTargetPlayer = (pTargetActor && pTargetActor->IsPlayer()) ? static_cast<CPlayer*>(pTargetActor) : NULL;
if(pTargetPlayer && pTargetPlayer->IsClient())
{
if(m_pMeleeParams->meleeparams.trigger_client_reaction)
{
pTargetPlayer->TriggerMeleeReaction();
}
}
}
}
return hitTypeID;
}