BVB Source Codes

CRYENGINE Show TargetTrackGroup.cpp Source code

Return Download CRYENGINE: download TargetTrackGroup.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: Contains an agent's target tracks and handles updating them
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 02:01:2010: Created by Kevin Kirst
  12.  
  13. *************************************************************************/
  14.  
  15. #include "StdAfx.h"
  16. #include "TargetTrackGroup.h"
  17. #include "TargetTrackManager.h"
  18. #include "TargetTrack.h"
  19. #include "ObjectContainer.h"
  20.  
  21. #ifdef TARGET_TRACK_DOTARGETTHREAT
  22.         #include "Puppet.h"
  23. #endif //TARGET_TRACK_DOTARGETTHREAT
  24.  
  25. #ifdef TARGET_TRACK_DEBUG
  26.         #include "DebugDrawContext.h"
  27.         #include <CryAction/IDebugHistory.h>
  28.         #include <CryGame/IGame.h>
  29.         #include <CryGame/IGameFramework.h>
  30. #endif //TARGET_TRACK_DEBUG
  31.  
  32. //////////////////////////////////////////////////////////////////////////
  33. CTargetTrackGroup::CTargetTrackGroup(TargetTrackHelpers::ITargetTrackPoolProxy* pTrackPoolProxy, tAIObjectID aiObjectId, uint32 uConfigHash, int nTargetLimit)
  34.         : m_pTrackPoolProxy(pTrackPoolProxy)
  35.         , m_aiObjectId(aiObjectId)
  36.         , m_aiLastBestTargetId(0)
  37.         , m_uConfigHash(uConfigHash)
  38.         , m_nTargetLimit(max(nTargetLimit, 0))
  39.         , m_bNeedSort(false)
  40.         , m_bEnabled(true)
  41. {
  42.         assert(m_pTrackPoolProxy);
  43.         assert(m_aiObjectId > 0);
  44.         assert(m_uConfigHash > 0);
  45.  
  46.         CAISystem* pAISystem = GetAISystem();
  47.         assert(pAISystem);
  48.  
  49.         CWeakRef<CAIObject> refAIObject = gAIEnv.pObjectContainer->GetWeakRef(aiObjectId);
  50.         const bool bAIObjectValid = refAIObject.IsValid();
  51.  
  52.         // Create dummy representation for the dummy potential target
  53.         //      NB: during serialization, dummy objects are created after loading to
  54.         //      ensure we keep the same AI object id
  55.         if (!gEnv->pSystem->IsSerializingFile())
  56.         {
  57.                 gAIEnv.pAIObjectManager->CreateDummyObject(m_dummyPotentialTarget.refDummyRepresentation, "Target Track Dummy");
  58.                 if (bAIObjectValid)
  59.                         InitDummy();
  60.         }
  61.  
  62. #ifdef TARGET_TRACK_DEBUG
  63.         m_fLastGraphUpdate = 0.0f;
  64.         m_pDebugHistoryManager = gEnv->pGameFramework->CreateDebugHistoryManager();
  65.         assert(m_pDebugHistoryManager);
  66.  
  67.         memset(m_bDebugGraphOccupied, 0, sizeof(m_bDebugGraphOccupied));
  68. #endif //TARGET_TRACK_DEBUG
  69. }
  70.  
  71. //////////////////////////////////////////////////////////////////////////
  72. CTargetTrackGroup::~CTargetTrackGroup()
  73. {
  74.         Reset();
  75.  
  76. #ifdef TARGET_TRACK_DEBUG
  77.         SAFE_RELEASE(m_pDebugHistoryManager);
  78. #endif //TARGET_TRACK_DEBUG
  79. }
  80.  
  81. //////////////////////////////////////////////////////////////////////////
  82. void CTargetTrackGroup::Reset()
  83. {
  84.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  85.  
  86.         // Add all active tracks back to the pool
  87.         TTargetTrackContainer::iterator itTrack = m_TargetTracks.begin();
  88.         TTargetTrackContainer::iterator itTrackEnd = m_TargetTracks.end();
  89.         for (; itTrack != itTrackEnd; ++itTrack)
  90.         {
  91.                 CTargetTrack* pTrack = itTrack->second;
  92.                 assert(pTrack);
  93.  
  94.                 m_pTrackPoolProxy->AddTargetTrackToPool(pTrack);
  95.         }
  96.  
  97.         m_TargetTracks.clear();
  98.         m_SortedTracks.clear();
  99.         m_bNeedSort = false;
  100.  
  101. #ifdef TARGET_TRACK_DEBUG
  102.         m_pDebugHistoryManager->Clear();
  103. #endif //TARGET_TRACK_DEBUG
  104. }
  105.  
  106. //////////////////////////////////////////////////////////////////////////
  107. void CTargetTrackGroup::Serialize_Write(TSerialize ser)
  108. {
  109.         assert(ser.IsWriting());
  110.  
  111.         int iTrackCount = m_TargetTracks.size();
  112.         ser.Value("iTrackCount", iTrackCount);
  113.  
  114.         TTargetTrackContainer::iterator itTrack = m_TargetTracks.begin();
  115.         TTargetTrackContainer::iterator itTrackEnd = m_TargetTracks.end();
  116.         for (; itTrack != itTrackEnd; ++itTrack)
  117.         {
  118.                 tAIObjectID targetId = itTrack->first;
  119.                 CTargetTrack* pTrack = itTrack->second;
  120.                 assert(targetId > 0 && pTrack);
  121.  
  122.                 ser.BeginGroup("Track");
  123.                 {
  124.                         ser.Value("targetId", targetId);
  125.  
  126.                         pTrack->Serialize(ser);
  127.                 }
  128.                 ser.EndGroup();
  129.         }
  130.  
  131.         m_dummyPotentialTarget.Serialize(ser);
  132. }
  133.  
  134. //////////////////////////////////////////////////////////////////////////
  135. void CTargetTrackGroup::Serialize_Read(TSerialize ser)
  136. {
  137.         assert(ser.IsReading());
  138.  
  139.         assert(m_TargetTracks.empty());
  140.  
  141.         int iTrackCount = 0;
  142.         ser.Value("iTrackCount", iTrackCount);
  143.  
  144.         for (int iTrack = 0; iTrack < iTrackCount; ++iTrack)
  145.         {
  146.                 tAIObjectID targetId;
  147.  
  148.                 ser.BeginGroup("Track");
  149.                 {
  150.                         ser.Value("targetId", targetId);
  151.                         assert(targetId != INVALID_AIOBJECTID);
  152.  
  153.                         CTargetTrack* pTrack = GetTargetTrack(targetId);
  154.                         assert(pTrack);
  155.                         if (pTrack)
  156.                         {
  157.                                 pTrack->Serialize(ser);
  158.                         }
  159.                 }
  160.                 ser.EndGroup();
  161.         }
  162.  
  163.         m_dummyPotentialTarget.Serialize(ser);
  164.  
  165.         InitDummy();
  166. }
  167.  
  168. //////////////////////////////////////////////////////////////////////////
  169. void CTargetTrackGroup::InitDummy()
  170. {
  171.         CAIObject* pDummyRep = m_dummyPotentialTarget.refDummyRepresentation.GetAIObject();
  172.         assert(pDummyRep);
  173.         if (pDummyRep)
  174.         {
  175.                 CWeakRef<CAIObject> refAIObject = gAIEnv.pObjectContainer->GetWeakRef(m_aiObjectId);
  176.                 pDummyRep->SetAssociation(refAIObject);
  177.  
  178.                 pDummyRep->SetShouldSerialize(false);
  179.         }
  180. }
  181.  
  182. //////////////////////////////////////////////////////////////////////////
  183. void CTargetTrackGroup::Update(TargetTrackHelpers::ITargetTrackConfigProxy* pConfigProxy)
  184. {
  185.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  186.  
  187.         const float fCurrTime = GetAISystem()->GetFrameStartTimeSeconds();
  188.  
  189.         m_SortedTracks.clear();
  190.         m_SortedTracks.reserve(m_TargetTracks.size());
  191.  
  192.         // Update the tracks
  193.         TTargetTrackContainer::iterator itTrack = m_TargetTracks.begin();
  194.         TTargetTrackContainer::iterator itTrackEnd = m_TargetTracks.end();
  195.         for (; itTrack != itTrackEnd; ++itTrack)
  196.         {
  197.                 CTargetTrack* pTrack = itTrack->second;
  198.                 assert(pTrack);
  199.  
  200.                 if (pTrack->Update(fCurrTime, pConfigProxy))
  201.                 {
  202.                         m_SortedTracks.push_back(pTrack);
  203.                 }
  204.         }
  205.  
  206.         m_bNeedSort = (!m_SortedTracks.empty());
  207. }
  208.  
  209. struct TargetTrackSorter
  210. {
  211.         bool operator()(const CTargetTrack* left, const CTargetTrack* right) const
  212.         {
  213.                 if (left && right)
  214.                         return *left < *right;
  215.  
  216.                 assert(false);
  217.                 return left < right;
  218.         }
  219. };
  220.  
  221. //////////////////////////////////////////////////////////////////////////
  222. void CTargetTrackGroup::UpdateSortedTracks(bool bForced)
  223. {
  224.         if (m_bNeedSort || bForced)
  225.         {
  226.                 m_bNeedSort = false;
  227.                 std::sort(m_SortedTracks.begin(), m_SortedTracks.end(), TargetTrackSorter());
  228.         }
  229. }
  230.  
  231. //////////////////////////////////////////////////////////////////////////
  232. CTargetTrack* CTargetTrackGroup::GetTargetTrack(tAIObjectID aiTargetId)
  233. {
  234.         CTargetTrack* pTrack = NULL;
  235.  
  236.         TTargetTrackContainer::iterator itTrack = m_TargetTracks.find(aiTargetId);
  237.         if (itTrack != m_TargetTracks.end())
  238.         {
  239.                 pTrack = itTrack->second;
  240.         }
  241.         else
  242.         {
  243.                 // Request a new track to use from the pool
  244.                 pTrack = m_pTrackPoolProxy->GetUnusedTargetTrackFromPool();
  245.                 assert(pTrack);
  246.  
  247.                 pTrack->Init(m_aiObjectId, aiTargetId, m_uConfigHash);
  248.                 m_TargetTracks[aiTargetId] = pTrack;
  249.  
  250. #ifdef TARGET_TRACK_DEBUG
  251.                 // Create debug history for it
  252.                 uint32 uDebugGraphIndex;
  253.                 if (FindFreeGraphSlot(uDebugGraphIndex))
  254.                 {
  255.                         CWeakRef<CAIObject> refTarget = gAIEnv.pObjectContainer->GetWeakRef(aiTargetId);
  256.                         CAIObject* pTarget = refTarget.GetAIObject();
  257.                         if (pTarget) // might be null in the case of bookmarked entities
  258.                         {
  259.                                 m_bDebugGraphOccupied[uDebugGraphIndex] = true;
  260.                                 pTrack->SetDebugGraphIndex(uDebugGraphIndex);
  261.  
  262.                                 IDebugHistory* pDebugHistory = m_pDebugHistoryManager->CreateHistory(pTarget->GetName());
  263.                                 if (pDebugHistory)
  264.                                 {
  265.                                         pDebugHistory->SetVisibility(false);
  266.                                         pDebugHistory->SetupScopeExtent(-360.0f, 360.0f, 0.0f, 200.0f);
  267.                                 }
  268.                         }
  269.                 }
  270. #endif //TARGET_TRACK_DEBUG
  271.  
  272.         }
  273.  
  274.         assert(pTrack);
  275.         return pTrack;
  276. }
  277.  
  278. //////////////////////////////////////////////////////////////////////////
  279. bool CTargetTrackGroup::HandleStimulusEvent(const TargetTrackHelpers::STargetTrackStimulusEvent& stimulusEvent, uint32 uStimulusNameHash)
  280. {
  281.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  282.  
  283.         assert(!stimulusEvent.m_sStimulusName.empty());
  284.  
  285.         CTargetTrack* pTrack = GetTargetTrack(stimulusEvent.m_targetId);
  286.         return HandleStimulusEvent_Target(stimulusEvent, uStimulusNameHash, pTrack);
  287. }
  288.  
  289. bool CTargetTrackGroup::TriggerPulse(tAIObjectID targetID, uint32 uStimulusNameHash, uint32 uPulseNameHash)
  290. {
  291.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  292.  
  293.         bool bResult = false;
  294.  
  295.         if (CTargetTrack* pTrack = GetTargetTrack(targetID))
  296.                 bResult = pTrack->TriggerPulse(uStimulusNameHash, uPulseNameHash);
  297.  
  298.         return bResult;
  299. }
  300.  
  301. //////////////////////////////////////////////////////////////////////////
  302. bool CTargetTrackGroup::TriggerPulse(uint32 uStimulusNameHash, uint32 uPulseNameHash)
  303. {
  304.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  305.  
  306.         bool bResult = true;
  307.  
  308.         TTargetTrackContainer::iterator itTrack = m_TargetTracks.begin();
  309.         TTargetTrackContainer::iterator itTrackEnd = m_TargetTracks.end();
  310.         for (; itTrack != itTrackEnd; ++itTrack)
  311.         {
  312.                 CTargetTrack* pTrack = itTrack->second;
  313.                 assert(pTrack);
  314.  
  315.                 bResult &= pTrack->TriggerPulse(uStimulusNameHash, uPulseNameHash);
  316.         }
  317.  
  318.         return bResult;
  319. }
  320.  
  321. //////////////////////////////////////////////////////////////////////////
  322. bool CTargetTrackGroup::HandleStimulusEvent_All(const TargetTrackHelpers::STargetTrackStimulusEvent& stimulusEvent, uint32 uStimulusNameHash)
  323. {
  324.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  325.  
  326.         bool bResult = true;
  327.  
  328.         TTargetTrackContainer::iterator itTrack = m_TargetTracks.begin();
  329.         TTargetTrackContainer::iterator itTrackEnd = m_TargetTracks.end();
  330.         for (; itTrack != itTrackEnd; ++itTrack)
  331.         {
  332.                 bResult &= HandleStimulusEvent_Target(stimulusEvent, uStimulusNameHash, itTrack->second);
  333.         }
  334.  
  335.         return bResult;
  336. }
  337.  
  338. //////////////////////////////////////////////////////////////////////////
  339. bool CTargetTrackGroup::HandleStimulusEvent_Target(const TargetTrackHelpers::STargetTrackStimulusEvent& stimulusEvent, uint32 uStimulusNameHash, CTargetTrack* pTrack)
  340. {
  341.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  342.  
  343.         assert(pTrack);
  344.  
  345.         return (pTrack && pTrack->InvokeStimulus(stimulusEvent, uStimulusNameHash));
  346. }
  347.  
  348. //////////////////////////////////////////////////////////////////////////
  349. bool CTargetTrackGroup::IsPotentialTarget(tAIObjectID aiTargetId) const
  350. {
  351.         assert(aiTargetId > 0);
  352.  
  353.         TTargetTrackContainer::const_iterator itTrack = m_TargetTracks.find(aiTargetId);
  354.         return (itTrack != m_TargetTracks.end());
  355. }
  356.  
  357. //////////////////////////////////////////////////////////////////////////
  358. bool CTargetTrackGroup::IsDesiredTarget(tAIObjectID aiTargetId) const
  359. {
  360.         assert(aiTargetId > 0);
  361.  
  362.         return (aiTargetId == m_aiLastBestTargetId);
  363. }
  364.  
  365. //////////////////////////////////////////////////////////////////////////
  366. bool CTargetTrackGroup::GetDesiredTarget(TargetTrackHelpers::EDesiredTargetMethod eMethod, CWeakRef<CAIObject>& outTarget, SAIPotentialTarget*& pOutTargetInfo)
  367. {
  368.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  369.  
  370.         bool bResult = false;
  371.  
  372.         CTargetTrack* pBestTrack;
  373.         uint32 count = GetBestTrack(eMethod, &pBestTrack, 1);
  374.  
  375.         if (count)
  376.         {
  377.                 UpdateTargetRepresentation(pBestTrack, outTarget, pOutTargetInfo);
  378.                 bResult = true;
  379.         }
  380.  
  381.         m_aiLastBestTargetId = outTarget.GetObjectID();
  382.  
  383.         return bResult;
  384. }
  385.  
  386. //////////////////////////////////////////////////////////////////////////
  387. uint32 CTargetTrackGroup::GetBestTrack(TargetTrackHelpers::EDesiredTargetMethod eMethod,
  388.                                        CTargetTrack** tracks, uint32 maxCount)
  389. {
  390.         UpdateSortedTracks();
  391.  
  392.         uint32 count = 0;
  393.         switch (eMethod & TargetTrackHelpers::eDTM_SELECTION_MASK)
  394.         {
  395.         case TargetTrackHelpers::eDTM_Select_Highest:
  396.                 {
  397.                         TSortedTracks::iterator itBestTrack = m_SortedTracks.begin();
  398.                         TSortedTracks::iterator itTrackEnd = m_SortedTracks.end();
  399.  
  400.                         for (; itBestTrack != itTrackEnd; ++itBestTrack)
  401.                         {
  402.                                 CTargetTrack* track(*itBestTrack);
  403.  
  404.                                 if (track && TestTrackAgainstFilters(track, eMethod))
  405.                                 {
  406.                                         tracks[count++] = track;
  407.  
  408.                                         if (count >= maxCount)
  409.                                                 break;
  410.                                 }
  411.                         }
  412.                 }
  413.                 break;
  414.  
  415.         case TargetTrackHelpers::eDTM_Select_Lowest:
  416.                 {
  417.                         TSortedTracks::reverse_iterator itBestTrack = m_SortedTracks.rbegin();
  418.                         TSortedTracks::reverse_iterator itTrackEnd = m_SortedTracks.rend();
  419.  
  420.                         for (; itBestTrack != itTrackEnd; ++itBestTrack)
  421.                         {
  422.                                 CTargetTrack* track(*itBestTrack);
  423.  
  424.                                 if (track && TestTrackAgainstFilters(track, eMethod))
  425.                                 {
  426.                                         tracks[count++] = track;
  427.  
  428.                                         if (count >= maxCount)
  429.                                                 break;
  430.                                 }
  431.                         }
  432.                 }
  433.                 break;
  434.  
  435.         default:
  436.                 CRY_ASSERT_MESSAGE(false, "CTargetTrackGroup::GetBestTrack Unhandled desired target method");
  437.                 break;
  438.         }
  439.  
  440.         return count;
  441. }
  442.  
  443. //////////////////////////////////////////////////////////////////////////
  444. bool CTargetTrackGroup::TestTrackAgainstFilters(CTargetTrack* pTrack, TargetTrackHelpers::EDesiredTargetMethod eMethod) const
  445. {
  446.         assert(pTrack);
  447.  
  448.         bool bResult = true;
  449.  
  450.         // [Kevin:26.02.2010] Need a better method than using the track manager here...
  451.         CTargetTrackManager* pManager = gAIEnv.pTargetTrackManager;
  452.         assert(pManager);
  453.  
  454.         const uint32 uFilterBitmask = eMethod & TargetTrackHelpers::eDTM_FILTER_MASK;
  455.  
  456.         if (uFilterBitmask & TargetTrackHelpers::eDTM_Filter_CanAquireTarget)
  457.         {
  458.                 CAIActor* pOwner = CastToCAIActorSafe(gAIEnv.pObjectContainer->GetAIObject(m_aiObjectId));
  459.                 IAIObject* pTargetAI = pTrack->GetAIObject().GetIAIObject();
  460.  
  461.                 if ((pOwner != NULL) && pTargetAI)
  462.                         bResult = pOwner->CanAcquireTarget(pTargetAI);
  463.         }
  464.  
  465.         if (uFilterBitmask & TargetTrackHelpers::eDTM_Filter_LimitDesired)
  466.         {
  467.                 /*const int iTargetLimit = pManager->GetTargetLimit(aiTargetId);
  468.                    bResult &= (iTargetLimit <= 0 || pManager->GetDesiredTargetCount(aiTargetId, m_aiObjectId) < iTargetLimit);*/
  469.         }
  470.  
  471.         if (uFilterBitmask & TargetTrackHelpers::eDTM_Filter_LimitPotential)
  472.         {
  473.                 /*const int iTargetLimit = pManager->GetTargetLimit(aiTargetId);
  474.                    bResult &= (iTargetLimit <= 0 || pManager->GetPotentialTargetCount(aiTargetId, m_aiObjectId) < iTargetLimit);*/
  475.         }
  476.  
  477.         return bResult;
  478. }
  479.  
  480. //////////////////////////////////////////////////////////////////////////
  481. void CTargetTrackGroup::UpdateTargetRepresentation(const CTargetTrack* pBestTrack, CWeakRef<CAIObject>& outTarget, SAIPotentialTarget*& pOutTargetInfo)
  482. {
  483.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  484.  
  485.         CWeakRef<CAIObject> refTarget = pBestTrack->GetAITarget();
  486.  
  487. #ifdef CRYAISYSTEM_DEBUG
  488.         CAIObject* pTarget = refTarget.GetAIObject();
  489. #endif
  490.  
  491.         CAIObject* pDummyRep = m_dummyPotentialTarget.refDummyRepresentation.GetAIObject();
  492.         assert(pDummyRep);
  493.         if (!pDummyRep)
  494.                 return;
  495.  
  496.         pDummyRep->SetPos(pBestTrack->GetTargetPos());
  497.         pDummyRep->SetEntityDir(pBestTrack->GetTargetDir());
  498.         pDummyRep->SetBodyDir(pBestTrack->GetTargetDir());
  499.         pDummyRep->SetViewDir(pBestTrack->GetTargetDir());
  500.         pDummyRep->SetFireDir(pBestTrack->GetTargetDir());
  501.         pDummyRep->SetAssociation(refTarget);
  502.  
  503. #ifdef CRYAISYSTEM_DEBUG
  504.         stack_string sDummyRepName;
  505. #endif
  506.  
  507.         const EAITargetType eTargetType = pBestTrack->GetTargetType();
  508.         const EAITargetContextType eTargetContextType = pBestTrack->GetTargetContext();
  509.         const EAITargetThreat eTargetThreat = pBestTrack->GetTargetThreat();
  510.  
  511.         switch (eTargetType)
  512.         {
  513.         case AITARGET_VISUAL:
  514.                 {
  515. #ifdef CRYAISYSTEM_DEBUG
  516.                         sDummyRepName.Format("Target Track Dummy - Visual \'%s\'", pTarget ? pTarget->GetName() : "(Null)");
  517. #endif
  518.                         pDummyRep->SetSubType(IAIObject::STP_NONE);
  519.                         outTarget = refTarget;
  520.                 }
  521.                 break;
  522.  
  523.         case AITARGET_MEMORY:
  524.                 {
  525. #ifdef CRYAISYSTEM_DEBUG
  526.                         sDummyRepName.Format("Target Track Dummy - Memory \'%s\'", pTarget ? pTarget->GetName() : "(Null)");
  527. #endif
  528.                         pDummyRep->SetSubType(IAIObject::STP_MEMORY);
  529.                         outTarget = pDummyRep->GetSelfReference();
  530.                 }
  531.                 break;
  532.  
  533.         case AITARGET_SOUND:
  534.                 {
  535. #ifdef CRYAISYSTEM_DEBUG
  536.                         sDummyRepName.Format("Target Track Dummy - Sound \'%s\'", pTarget ? pTarget->GetName() : "(Null)");
  537. #endif
  538.                         switch (eTargetContextType)
  539.                         {
  540.                         case AITARGET_CONTEXT_GUNFIRE:
  541.                                 pDummyRep->SetSubType(IAIObject::STP_GUNFIRE);
  542.                                 break;
  543.                         default:
  544.                                 pDummyRep->SetSubType(IAIObject::STP_SOUND);
  545.                                 break;
  546.                         }
  547.                         outTarget = pDummyRep->GetSelfReference();
  548.                 }
  549.                 break;
  550.  
  551.         case AITARGET_NONE:
  552.                 {
  553. #ifdef CRYAISYSTEM_DEBUG
  554.                         sDummyRepName.Format("Target Track Dummy - No Type \'%s\'", pTarget ? pTarget->GetName() : "(Null)");
  555. #endif
  556.                         pDummyRep->SetSubType(IAIObject::STP_NONE);
  557.                         outTarget = pDummyRep->GetSelfReference();
  558.                 }
  559.                 break;
  560.  
  561.         default:
  562.                 CRY_ASSERT_MESSAGE(0, "CTargetTrackGroup::UpdateDummyTargetRep Unhandled AI target type");
  563.                 break;
  564.         }
  565.  
  566. #ifdef CRYAISYSTEM_DEBUG
  567.         pDummyRep->SetName(sDummyRepName.c_str());
  568. #endif
  569.  
  570.         // Update the dummy target
  571.         m_dummyPotentialTarget.bNeedsUpdating = false;
  572.         m_dummyPotentialTarget.type = eTargetType;
  573.         m_dummyPotentialTarget.threat = eTargetThreat;
  574.         m_dummyPotentialTarget.exposureThreat = eTargetThreat;
  575.  
  576.         pOutTargetInfo = &m_dummyPotentialTarget;
  577. }
  578.  
  579. #ifdef TARGET_TRACK_DEBUG
  580. //////////////////////////////////////////////////////////////////////////
  581. bool CTargetTrackGroup::FindFreeGraphSlot(uint32& outIndex) const
  582. {
  583.         outIndex = UINT_MAX;
  584.  
  585.         for (uint32 i = 0; i < DEBUG_GRAPH_OCCUPIED_SIZE; ++i)
  586.         {
  587.                 if (!m_bDebugGraphOccupied[i])
  588.                 {
  589.                         outIndex = i;
  590.                         break;
  591.                 }
  592.         }
  593.  
  594.         return (outIndex < UINT_MAX);
  595. }
  596.  
  597. //////////////////////////////////////////////////////////////////////////
  598. void CTargetTrackGroup::DebugDrawTracks(TargetTrackHelpers::ITargetTrackConfigProxy* pConfigProxy, bool bLastDraw)
  599. {
  600.         CDebugDrawContext dc;
  601.         float fColumnX = 1.0f;
  602.         float fColumnY = 11.0f;
  603.         float fColumnGraphX = fColumnX + 475.0f;
  604.         float fColumnGraphY = fColumnY;
  605.         const float fGraphWidth = 150.0f;
  606.         const float fGraphHeight = 150.0f;
  607.         const float fGraphMargin = 5.0f;
  608.  
  609.         static float s_fGraphUpdateInterval = 0.125f;
  610.         bool bUpdateGraph = false;
  611.         const float fCurrTime = GetAISystem()->GetFrameStartTimeSeconds();
  612.         if (fCurrTime - m_fLastGraphUpdate >= s_fGraphUpdateInterval)
  613.         {
  614.                 m_fLastGraphUpdate = fCurrTime;
  615.                 bUpdateGraph = true;
  616.         }
  617.  
  618.         CWeakRef<CAIObject> refObject = gAIEnv.pObjectContainer->GetWeakRef(m_aiObjectId);
  619.         CAIObject* pObject = refObject.GetAIObject();
  620.         assert(pObject);
  621.         if (!pObject || !pObject->IsEnabled())
  622.                 return;
  623.  
  624.         const ColorB textCol(255, 255, 255, 255);
  625.         dc->Draw2dLabel(fColumnX, fColumnY, 1.5f, textCol, false, "Target Tracks for Agent \'%s\':", pObject->GetName());
  626.         fColumnY += 20.0f;
  627.  
  628.         UpdateSortedTracks();
  629.  
  630.         TTargetTrackContainer::const_iterator itTrack = m_TargetTracks.begin();
  631.         TTargetTrackContainer::const_iterator itTrackEnd = m_TargetTracks.end();
  632.         for (; itTrack != itTrackEnd; ++itTrack)
  633.         {
  634.                 const CTargetTrack* pTrack = itTrack->second;
  635.                 assert(pTrack);
  636.  
  637.                 // TODO Not returning right distance?
  638.                 const int iIndex = (int)std::distance(m_SortedTracks.begin(), std::find(m_SortedTracks.begin(), m_SortedTracks.end(), pTrack));
  639.                 pTrack->DebugDraw(dc, iIndex, fColumnX, fColumnY, pConfigProxy);
  640.                 fColumnY += 20.0f;
  641.  
  642.                 if (bUpdateGraph)
  643.                 {
  644.                         CWeakRef<CAIObject> refTarget = pTrack->GetAIObject();
  645.                         if (CAIObject* pTarget = refTarget.GetAIObject())
  646.                         {
  647.                                 const uint32 uDebugGraphIndex = pTrack->GetDebugGraphIndex();
  648.                                 const uint32 uGraphX = uDebugGraphIndex % 3;
  649.                                 const uint32 uGraphY = uDebugGraphIndex / 4;
  650.  
  651.                                 // Debug graph update
  652.                                 IDebugHistory* pDebugHistory = m_pDebugHistoryManager->GetHistory(pTarget->GetName());
  653.                                 if (pDebugHistory)
  654.                                 {
  655.                                         pDebugHistory->SetupLayoutAbs(fColumnGraphX + (fGraphWidth + fGraphMargin) * uGraphX, fColumnGraphY + (fGraphHeight + fGraphMargin) * uGraphY, fGraphWidth, fGraphHeight, fGraphMargin);
  656.                                         pDebugHistory->AddValue(pTrack->GetTrackValue());
  657.                                         pDebugHistory->SetVisibility(!bLastDraw);
  658.                                 }
  659.                         }
  660.                 }
  661.  
  662.                 pTrack->SetLastDebugDrawTime(fCurrTime);
  663.         }
  664. }
  665.  
  666. //////////////////////////////////////////////////////////////////////////
  667. void CTargetTrackGroup::DebugDrawTargets(int nMode, int nTargetedCount, bool bExtraInfo)
  668. {
  669.         assert(nMode > 0);
  670.  
  671.         CDebugDrawContext dc;
  672.         const ColorB visualColor(255, 0, 0, 255);
  673.         const ColorB memoryColor(255, 255, 0, 255);
  674.         const ColorB soundColor(0, 255, 0, 255);
  675.         const ColorB invalidColor(120, 120, 120, 255);
  676.         const float fProbableRatio = 0.45f;
  677.  
  678.         const float fCurrTime = GetAISystem()->GetFrameStartTimeSeconds();
  679.  
  680.         CWeakRef<CAIObject> refObject = gAIEnv.pObjectContainer->GetWeakRef(m_aiObjectId);
  681.         CAIObject* pObject = refObject.GetAIObject();
  682.         assert(pObject);
  683.         if (!pObject || !pObject->IsEnabled())
  684.                 return;
  685.  
  686.         const Vec3& vPos = pObject->GetPos();
  687.  
  688.         UpdateSortedTracks();
  689.  
  690.         TSortedTracks::const_iterator itTrack = m_SortedTracks.begin();
  691.         TSortedTracks::const_iterator itTrackEnd = m_SortedTracks.end();
  692.         bool bFirst = true;
  693.         for (; itTrack != itTrackEnd; ++itTrack)
  694.         {
  695.                 const CTargetTrack* pTrack = *itTrack;
  696.                 assert(pTrack);
  697.  
  698.                 ColorB drawColor;
  699.                 EAITargetType eType = pTrack->GetTargetType();
  700.  
  701.                 CWeakRef<CAIObject> refTarget = pTrack->GetAIObject();
  702.                 assert(refTarget.IsValid());
  703.                 CAIObject* pTarget = refTarget.GetAIObject();
  704.  
  705.                 switch (eType)
  706.                 {
  707.                 case AITARGET_VISUAL:
  708.                         {
  709.                                 drawColor = visualColor;
  710.                         }
  711.                         break;
  712.  
  713.                 case AITARGET_MEMORY:
  714.                         {
  715.                                 drawColor = memoryColor;
  716.                         }
  717.                         break;
  718.  
  719.                 case AITARGET_SOUND:
  720.                         {
  721.                                 drawColor = soundColor;
  722.                         }
  723.                         break;
  724.  
  725.                 case AITARGET_NONE:
  726.                         {
  727.                                 drawColor = invalidColor;
  728.                         }
  729.                         break;
  730.  
  731.                 default:
  732.                         CRY_ASSERT_MESSAGE(0, "CTargetTrackGroup::DebugDrawTargets Unhandled target type");
  733.                         break;
  734.                 }
  735.                 if (!bFirst)
  736.                 {
  737.                         drawColor.r = uint8((float)drawColor.r * fProbableRatio);
  738.                         drawColor.g = uint8((float)drawColor.g * fProbableRatio);
  739.                         drawColor.b = uint8((float)drawColor.b * fProbableRatio);
  740.                         drawColor.a = uint8((float)drawColor.a * fProbableRatio);
  741.                 }
  742.  
  743.                 const Vec3& vTargetPos = pTrack->GetTargetPos();
  744.                 const Vec3 vTargetToPos = (vPos - vTargetPos).GetNormalizedSafe();
  745.                 const Vec3 vTargetToPosRight = Vec3Constants<float>::fVec3_OneZ.Cross(vTargetToPos).GetNormalizedSafe();
  746.  
  747.                 dc->DrawLine(vPos, drawColor, vTargetPos, drawColor, 2.0f);
  748.                 dc->DrawLine(vTargetPos, drawColor, vTargetPos + vTargetToPos + vTargetToPosRight * 0.5f, drawColor, 2.0f);
  749.                 dc->DrawLine(vTargetPos, drawColor, vTargetPos + vTargetToPos - vTargetToPosRight * 0.5f, drawColor, 2.0f);
  750.  
  751.                 if (bExtraInfo)
  752.                 {
  753.                         string sExtraInfoText;
  754.                         sExtraInfoText.Format("%.3f", pTrack->GetTrackValue());
  755.  
  756.                         dc->Draw3dLabel(vTargetPos + (vPos - vTargetPos) * 0.5f, 1.25f, "%s", sExtraInfoText.c_str());
  757.                 }
  758.  
  759.                 pTrack->SetLastDebugDrawTime(fCurrTime);
  760.  
  761.                 if (bFirst && nMode == 1)
  762.                         break;
  763.                 bFirst = false;
  764.         }
  765.  
  766.         dc->Draw3dLabel(vPos + Vec3(0.0f, 0.0f, 1.0f), 1.5f, "%d", nTargetedCount);
  767. }
  768. #endif //TARGET_TRACK_DEBUG
  769.  
downloadTargetTrackGroup.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