BVB Source Codes

CRYENGINE Show TargetTrackModifiers.cpp Source code

Return Download CRYENGINE: download TargetTrackModifiers.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: Definitions for various modifiers to target tracks
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 02:08:2010: Created by Kevin Kirst
  12.  
  13. *************************************************************************/
  14.  
  15. #include "StdAfx.h"
  16. #include "TargetTrackModifiers.h"
  17. #include "TargetTrackManager.h"
  18. #include "TargetTrack.h"
  19. #include "ObjectContainer.h"
  20.  
  21. //////////////////////////////////////////////////////////////////////////
  22. CTargetTrackDistanceModifier::CTargetTrackDistanceModifier()
  23. {
  24.  
  25. }
  26.  
  27. //////////////////////////////////////////////////////////////////////////
  28. CTargetTrackDistanceModifier::~CTargetTrackDistanceModifier()
  29. {
  30.  
  31. }
  32.  
  33. //////////////////////////////////////////////////////////////////////////
  34. bool CTargetTrackDistanceModifier::IsMatchingTag(const char* szTag) const
  35. {
  36.         return stricmp(szTag, GetTag()) == 0;
  37. }
  38.  
  39. //////////////////////////////////////////////////////////////////////////
  40. char const* CTargetTrackDistanceModifier::GetTag() const
  41. {
  42.         return "Distance";
  43. }
  44.  
  45. //////////////////////////////////////////////////////////////////////////
  46. float CTargetTrackDistanceModifier::GetModValue(const CTargetTrack* pTrack,
  47.                                                 TargetTrackHelpers::EAIEventStimulusType stimulusType,
  48.                                                 const Vec3& vPos, const TargetTrackHelpers::SEnvelopeData& envelopeData,
  49.                                                 const TargetTrackHelpers::STargetTrackModifierConfig& modConfig) const
  50. {
  51.         float modValue = 0.0f;
  52.  
  53.         CWeakRef<CAIObject> refOwner = pTrack->GetAIGroupOwner();
  54.         if (refOwner.IsValid())
  55.         {
  56.                 CAIObject* pOwner = refOwner.GetAIObject();
  57.                 assert(pOwner);
  58.  
  59.                 float distance = vPos.GetDistance(pOwner->GetPos());
  60.                 float range = -1.0f;
  61.                 float scale = 1.0f;
  62.  
  63.                 if (CAIActor* pOwnerActor = pOwner->CastToCAIActor())
  64.                 {
  65.                         const AgentParameters& parameters = pOwnerActor->GetParameters();
  66.  
  67.                         if (stimulusType == TargetTrackHelpers::eEST_Visual)
  68.                         {
  69.                                 range = parameters.m_PerceptionParams.sightRange;
  70.  
  71.                                 CWeakRef<CAIObject> refTarget = pTrack->GetAITarget();
  72.                                 if (refTarget.IsValid())
  73.                                 {
  74.                                         if ((parameters.m_PerceptionParams.sightRangeVehicle > 0.0f) &&
  75.                                             (refTarget.GetAIObject()->GetAIType() == AIOBJECT_VEHICLE))
  76.                                         {
  77.                                                 range = parameters.m_PerceptionParams.sightRangeVehicle;
  78.                                         }
  79.                                 }
  80.                         }
  81.                         else if (stimulusType == TargetTrackHelpers::eEST_Sound)
  82.                         {
  83.                                 scale = parameters.m_PerceptionParams.audioScale;
  84.                         }
  85.                 }
  86.  
  87.                 distance = (scale > 0.0001f) ? distance * (1.0f / scale) : FLT_MAX;
  88.  
  89.                 if (modConfig.m_fLimit > 0.0f)
  90.                         range = (float)__fsel(range, min(range, modConfig.m_fLimit), modConfig.m_fLimit);
  91.  
  92.                 modValue = (range > 0.0f) ? ((range - distance) / range) :
  93.                            (distance > 0.0001f) ? (1.0f / distance) : 1.0f;
  94.  
  95.                 modValue = clamp_tpl(modValue, 0.0f, 1.0f);
  96.         }
  97.  
  98.         return modValue * modConfig.m_fValue;
  99. }
  100.  
  101. //////////////////////////////////////////////////////////////////////////
  102. //////////////////////////////////////////////////////////////////////////
  103.  
  104. //////////////////////////////////////////////////////////////////////////
  105. CTargetTrackHostileModifier::CTargetTrackHostileModifier()
  106. {
  107.  
  108. }
  109.  
  110. //////////////////////////////////////////////////////////////////////////
  111. CTargetTrackHostileModifier::~CTargetTrackHostileModifier()
  112. {
  113.  
  114. }
  115.  
  116. //////////////////////////////////////////////////////////////////////////
  117. bool CTargetTrackHostileModifier::IsMatchingTag(const char* szTag) const
  118. {
  119.         return stricmp(szTag, GetTag()) == 0;
  120. }
  121.  
  122. //////////////////////////////////////////////////////////////////////////
  123. char const* CTargetTrackHostileModifier::GetTag() const
  124. {
  125.         return "Hostile";
  126. }
  127.  
  128. //////////////////////////////////////////////////////////////////////////
  129. float CTargetTrackHostileModifier::GetModValue(const CTargetTrack* pTrack,
  130.                                                TargetTrackHelpers::EAIEventStimulusType stimulusType,
  131.                                                const Vec3& vPos, const TargetTrackHelpers::SEnvelopeData& envelopeData,
  132.                                                const TargetTrackHelpers::STargetTrackModifierConfig& modConfig) const
  133. {
  134.         assert(pTrack);
  135.  
  136.         bool bIsHostile = false;
  137.  
  138.         CWeakRef<CAIObject> refOwner = pTrack->GetAIGroupOwner();
  139.         CWeakRef<CAIObject> refTarget = pTrack->GetAIObject();
  140.         if (refOwner.IsValid() && refTarget.IsValid())
  141.         {
  142.                 CAIObject* pOwner = refOwner.GetAIObject();
  143.                 CAIObject* pTarget = refTarget.GetAIObject();
  144.                 assert(pOwner);
  145.                 assert(pTarget);
  146.  
  147.                 bIsHostile = pOwner->IsHostile(pTarget);
  148.         }
  149.  
  150.         return (1.0f * (bIsHostile ? modConfig.m_fValue : 1.0f));
  151. }
  152.  
  153. //////////////////////////////////////////////////////////////////////////
  154. //////////////////////////////////////////////////////////////////////////
  155.  
  156. //////////////////////////////////////////////////////////////////////////
  157. CTargetTrackClassThreatModifier::CTargetTrackClassThreatModifier()
  158. {
  159.  
  160. }
  161.  
  162. //////////////////////////////////////////////////////////////////////////
  163. CTargetTrackClassThreatModifier::~CTargetTrackClassThreatModifier()
  164. {
  165.  
  166. }
  167.  
  168. //////////////////////////////////////////////////////////////////////////
  169. bool CTargetTrackClassThreatModifier::IsMatchingTag(const char* szTag) const
  170. {
  171.         return stricmp(szTag, GetTag()) == 0;
  172. }
  173.  
  174. //////////////////////////////////////////////////////////////////////////
  175. char const* CTargetTrackClassThreatModifier::GetTag() const
  176. {
  177.         return "ClassThreat";
  178. }
  179.  
  180. //////////////////////////////////////////////////////////////////////////
  181. float CTargetTrackClassThreatModifier::GetModValue(const CTargetTrack* pTrack,
  182.                                                    TargetTrackHelpers::EAIEventStimulusType stimulusType,
  183.                                                    const Vec3& vPos, const TargetTrackHelpers::SEnvelopeData& envelopeData,
  184.                                                    const TargetTrackHelpers::STargetTrackModifierConfig& modConfig) const
  185. {
  186.         assert(pTrack);
  187.  
  188.         tAIObjectID aiObjectId = pTrack->GetAIObject().GetObjectID();
  189.         const float fClassThreat = gAIEnv.pTargetTrackManager->GetTargetClassThreat(aiObjectId);
  190.  
  191.         return (fClassThreat * modConfig.m_fValue);
  192. }
  193.  
  194. //////////////////////////////////////////////////////////////////////////
  195. //////////////////////////////////////////////////////////////////////////
  196.  
  197. //////////////////////////////////////////////////////////////////////////
  198. CTargetTrackDistanceIgnoreModifier::CTargetTrackDistanceIgnoreModifier()
  199. {
  200.  
  201. }
  202.  
  203. //////////////////////////////////////////////////////////////////////////
  204. CTargetTrackDistanceIgnoreModifier::~CTargetTrackDistanceIgnoreModifier()
  205. {
  206.  
  207. }
  208.  
  209. //////////////////////////////////////////////////////////////////////////
  210. bool CTargetTrackDistanceIgnoreModifier::IsMatchingTag(const char* szTag) const
  211. {
  212.         return stricmp(szTag, GetTag()) == 0;
  213. }
  214.  
  215. //////////////////////////////////////////////////////////////////////////
  216. char const* CTargetTrackDistanceIgnoreModifier::GetTag() const
  217. {
  218.         return "DistanceIgnore";
  219. }
  220.  
  221. //////////////////////////////////////////////////////////////////////////
  222. float CTargetTrackDistanceIgnoreModifier::GetModValue(const CTargetTrack* pTrack,
  223.                                                       TargetTrackHelpers::EAIEventStimulusType stimulusType,
  224.                                                       const Vec3& vPos, const TargetTrackHelpers::SEnvelopeData& envelopeData,
  225.                                                       const TargetTrackHelpers::STargetTrackModifierConfig& modConfig) const
  226. {
  227.         // Ignore modifier doesn't run when the envelope was not fully released last time
  228.         if (envelopeData.m_fLastReleasingValue > 0.0f)
  229.                 return 1.0f;
  230.  
  231.         float modValue = 0.0f;
  232.  
  233.         CWeakRef<CAIObject> refOwner = pTrack->GetAIGroupOwner();
  234.         if (refOwner.IsValid())
  235.         {
  236.                 CAIObject* pOwner = refOwner.GetAIObject();
  237.                 assert(pOwner);
  238.  
  239.                 float distance = vPos.GetDistance(pOwner->GetPos());
  240.                 float range = -1.0f;
  241.                 float scale = 1.0f;
  242.  
  243.                 if (CAIActor* pOwnerActor = pOwner->CastToCAIActor())
  244.                 {
  245.                         const AgentParameters& parameters = pOwnerActor->GetParameters();
  246.  
  247.                         if (stimulusType == TargetTrackHelpers::eEST_Visual)
  248.                         {
  249.                                 range = parameters.m_PerceptionParams.sightRange;
  250.  
  251.                                 CWeakRef<CAIObject> refTarget = pTrack->GetAITarget();
  252.                                 if (refTarget.IsValid())
  253.                                 {
  254.                                         if ((parameters.m_PerceptionParams.sightRangeVehicle > 0.0f) &&
  255.                                             (refTarget.GetAIObject()->GetAIType() == AIOBJECT_VEHICLE))
  256.                                         {
  257.                                                 range = parameters.m_PerceptionParams.sightRangeVehicle;
  258.                                         }
  259.                                 }
  260.                         }
  261.                         else if (stimulusType == TargetTrackHelpers::eEST_Sound)
  262.                         {
  263.                                 scale = parameters.m_PerceptionParams.audioScale;
  264.                         }
  265.                 }
  266.  
  267.                 distance = (scale > 0.0001f) ? distance * (1.0f / scale) : FLT_MAX;
  268.  
  269.                 if (modConfig.m_fLimit > 0.0f)
  270.                         range = min(range, modConfig.m_fLimit);
  271.  
  272.                 modValue = (range > 0.0f) ? (distance / range) : distance;
  273.         }
  274.  
  275.         const float now = GetAISystem()->GetFrameStartTimeSeconds();
  276.         const float dt = (now - envelopeData.m_fStartTime);
  277.  
  278.         return (float)__fsel(modValue * modConfig.m_fValue - dt, 0.0f, 1.0f);
  279. }
  280.  
  281. bool CTargetTrackPlayerModifier::IsMatchingTag(const char* tag) const
  282. {
  283.         return stricmp(tag, GetTag()) == 0;
  284. }
  285.  
  286. char const* CTargetTrackPlayerModifier::GetTag() const
  287. {
  288.         return "Player";
  289. }
  290.  
  291. float CTargetTrackPlayerModifier::GetModValue(const CTargetTrack* pTrack,
  292.                                               TargetTrackHelpers::EAIEventStimulusType stimulusType,
  293.                                               const Vec3& vPos, const TargetTrackHelpers::SEnvelopeData& envelopeData,
  294.                                               const TargetTrackHelpers::STargetTrackModifierConfig& modConfig) const
  295. {
  296.         CWeakRef<CAIObject> ownerWeak = pTrack->GetAIGroupOwner();
  297.  
  298.         if (ownerWeak.IsValid())
  299.         {
  300.                 CAIObject* owner = ownerWeak.GetAIObject();
  301.  
  302.                 if (CAIActor* ownerActor = owner->CastToCAIActor())
  303.                 {
  304.                         CWeakRef<CAIObject> targetWeak = pTrack->GetAITarget();
  305.  
  306.                         if (targetWeak.IsValid())
  307.                         {
  308.                                 CAIObject* targetObject = targetWeak.GetAIObject();
  309.  
  310.                                 const bool targetIsPlayer = (targetObject->GetType() == AIOBJECT_PLAYER);
  311.  
  312.                                 return targetIsPlayer ? modConfig.m_fValue : 1.0f;
  313.                         }
  314.                 }
  315.         }
  316.  
  317.         return 1.0f;
  318. }
  319.  
downloadTargetTrackModifiers.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top