BVB Source Codes

CRYENGINE Show AIFlyingVehicle.cpp Source code

Return Download CRYENGINE: download AIFlyingVehicle.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "AIFlyingVehicle.h"
  5.  
  6. CAIFlyingVehicle::CAIFlyingVehicle()
  7.         : m_combatModeEnabled(false)
  8.         , m_firingAllowed(true)
  9. {
  10.         _fastcast_CAIFlyingVehicle = true;
  11. }
  12.  
  13. CAIFlyingVehicle::~CAIFlyingVehicle()
  14. {
  15.         SetObservable(false);
  16.         SetObserver(false);
  17. }
  18.  
  19. void CAIFlyingVehicle::SetObserver(bool observer)
  20. {
  21.         if (m_observer != observer)
  22.         {
  23.                 if (observer)
  24.                 {
  25.                         uint8 faction = GetFactionID();
  26.                         ObserverParams observerParams;
  27.                         observerParams.entityId = GetEntityID();
  28.                         observerParams.factionsToObserveMask = GetFactionVisionMask(faction);
  29.                         observerParams.faction = faction;
  30.                         observerParams.typesToObserveMask = GetObserverTypeMask();
  31.                         observerParams.typeMask = GetObservableTypeMask();
  32.                         observerParams.eyePosition = GetPos();
  33.                         observerParams.eyeDirection = GetViewDir();
  34.                         observerParams.sightRange = m_Parameters.m_PerceptionParams.sightRange;
  35.                         float secondaryFov;
  36.                         GetSightFOVCos(observerParams.fovCos, secondaryFov);
  37.                         observerParams.callback = functor(CAIFlyingVehicle::OnVisionChanged);
  38.  
  39.                         PhysSkipList skipList;
  40.                         GetPhysicalSkipEntities(skipList);
  41.  
  42.                         observerParams.skipListSize = std::min<size_t>(skipList.size(), ObserverParams::MaxSkipListSize);
  43.                         for (size_t i = 0; i < static_cast<size_t>(observerParams.skipListSize); ++i)
  44.                                 observerParams.skipList[i] = skipList[i];
  45.  
  46.                         VisionID visionID = GetVisionID();
  47.                         if (!visionID)
  48.                         {
  49.                                 visionID = gAIEnv.pVisionMap->CreateVisionID(GetName());
  50.  
  51.                                 SetVisionID(visionID);
  52.                         }
  53.  
  54.                         gAIEnv.pVisionMap->RegisterObserver(visionID, observerParams);
  55.                 }
  56.                 else
  57.                 {
  58.                         if (VisionID visionID = GetVisionID())
  59.                                 gAIEnv.pVisionMap->UnregisterObserver(visionID);
  60.                 }
  61.  
  62.                 m_observer = observer;
  63.         }
  64. }
  65.  
  66. // Sandy - Dec 2011: Unfortunately this code will cause Lua scripts to be reloaded
  67. // while they are running, causing all sorts of undefined behavior.
  68. // Not sure what this 'hot-fix' was supposed to do though, so I am
  69. // going to leave it here now as a warning!
  70. //
  71. ////This is a "hot-fix". Need to dig out the real issue
  72. //void  CAIFlyingVehicle::Reset(EObjectResetType type)
  73. //{
  74. //      if (AIOBJRESET_INIT == type)
  75. //      {
  76. //              if (IEntity *entity = GetEntity())
  77. //              {
  78. //                      if (IEntityComponent *proxy = entity->GetProxy(ENTITY_PROXY_SCRIPT))
  79. //                      {
  80. //                              SEntitySpawnParams params;
  81. //                              proxy->Reload(entity, params);
  82. //                      }
  83. //              }
  84. //      }
  85. //
  86. //      Base::Reset(type);
  87. //}
  88.  
  89. void CAIFlyingVehicle::OnVisionChanged(const VisionID& observerID, const ObserverParams& observerParams, const VisionID& observableID, const ObservableParams& observableParams, bool visible)
  90. {
  91.         const ObserverParams* params = gAIEnv.pVisionMap->GetObserverParams(observerID);
  92.  
  93.         if (params)
  94.         {
  95.                 IEntity* ent = gEnv->pEntitySystem->GetEntity(params->entityId);
  96.                 IAIObject* obj = ent->GetAI();
  97.  
  98.                 if (obj)
  99.                 {
  100.                         if (CPuppet* puppet = obj->CastToCPuppet())
  101.                         {
  102.                                 CAIFlyingVehicle* flyingAI = static_cast<CAIFlyingVehicle*>(puppet);
  103.  
  104.                                 const EntityId targetID = observableParams.entityId;
  105.                                 if (targetID != flyingAI->GetEntityID())
  106.                                 {
  107.                                         if (visible)
  108.                                         {
  109.                                                 if (targetID)
  110.                                                 {
  111.                                                         if (IEntity* entity = gEnv->pEntitySystem->GetEntity(observableParams.entityId))
  112.                                                         {
  113.                                                                 if (IAIObject* aiObject = entity->GetAI())
  114.                                                                 {
  115.                                                                         uint16 aiObjectType = aiObject->GetAIType();
  116.                                                                         if ((aiObjectType == AIOBJECT_GRENADE) || (aiObjectType == AIOBJECT_RPG))
  117.                                                                         {
  118.                                                                                 const Vec3& pos = entity->GetPos();
  119.                                                                                 const Vec3& ownPos = flyingAI->GetPos();
  120.                                                                                 Vec3 diff = ownPos - pos;
  121.                                                                                 diff.Normalize();
  122.  
  123.                                                                                 pe_status_dynamics dynamics;
  124.                                                                                 if (entity->GetPhysics())
  125.                                                                                 {
  126.                                                                                         entity->GetPhysics()->GetStatus(&dynamics);
  127.  
  128.                                                                                         if (dynamics.v.dot(diff) > 0.9f)
  129.                                                                                         {
  130.                                                                                                 GoalParams param;
  131.                                                                                                 param.SetName("params");
  132.  
  133.                                                                                                 GoalParams paramChild;
  134.                                                                                                 paramChild.SetName("impulse");
  135.                                                                                                 paramChild.SetValue(pos);
  136.  
  137.                                                                                                 GoalParams paramChild2;
  138.                                                                                                 paramChild2.SetName("dir");
  139.                                                                                                 paramChild2.SetValue(dynamics.v);
  140.                                                                                                 paramChild.AddChild(paramChild2);
  141.  
  142.                                                                                                 GoalParams paramChild3;
  143.                                                                                                 paramChild3.SetName("id");
  144.                                                                                                 paramChild3.SetValue(observableParams.entityId);
  145.                                                                                                 paramChild.AddChild(paramChild3);
  146.  
  147.                                                                                                 param.AddChild(paramChild);
  148.  
  149.                                                                                                 CGoalPipe* pipe = flyingAI->GetCurrentGoalPipe();
  150.                                                                                                 if (pipe)
  151.                                                                                                 {
  152.                                                                                                         pipe->ParseParams(param);
  153.                                                                                                 }
  154.                                                                                         }
  155.                                                                                 }
  156.                                                                         }
  157.                                                                 }
  158.                                                         }
  159.                                                 }
  160.                                         }
  161.                                 }
  162.                         }
  163.                 }
  164.         }
  165. }
  166.  
  167. void CAIFlyingVehicle::Serialize(TSerialize ser)
  168. {
  169.         Base::Serialize(ser);
  170.  
  171.         ser.Value("m_combatModeEnabled", m_combatModeEnabled);
  172.         ser.Value("m_firingAllowed", m_firingAllowed);
  173. }
  174.  
  175. namespace
  176. {
  177. void AISendSignal(CAIFlyingVehicle* const pFlyingVehicle, const char* const signalName)
  178. {
  179.         CRY_ASSERT(pFlyingVehicle);
  180.         CRY_ASSERT(signalName);
  181.  
  182.         const uint32 signalNameCrc = CCrc32::Compute(signalName);
  183.         gEnv->pAISystem->SendSignal(SIGNALFILTER_SENDER, 1, signalName, pFlyingVehicle, NULL, signalNameCrc);
  184. }
  185. }
  186.  
  187. void CAIFlyingVehicle::PostSerialize()
  188. {
  189.         Base::PostSerialize();
  190.  
  191.         if (m_combatModeEnabled)
  192.         {
  193.                 AISendSignal(this, "CombatTargetEnabled");
  194.         }
  195.         else
  196.         {
  197.                 AISendSignal(this, "CombatTargetDisabled");
  198.         }
  199.  
  200.         if (m_firingAllowed)
  201.         {
  202.                 AISendSignal(this, "FiringAllowed");
  203.         }
  204.         else
  205.         {
  206.                 AISendSignal(this, "FiringNotAllowed");
  207.         }
  208. }
  209.  
  210. void CAIFlyingVehicle::SetSignal(int nSignalID, const char* szText, IEntity* pSender, IAISignalExtraData* pData, uint32 crcCode)
  211. {
  212.         static const uint32 s_combatTargetEnabledCrc = CCrc32::Compute("CombatTargetEnabled");
  213.         static const uint32 s_combatTargetDisabledCrc = CCrc32::Compute("CombatTargetDisabled");
  214.         static const uint32 s_firingAllowedCrc = CCrc32::Compute("FiringAllowed");
  215.         static const uint32 s_firingNotAllowedCrc = CCrc32::Compute("FiringNotAllowed");
  216.  
  217.         if (crcCode == s_combatTargetEnabledCrc)
  218.         {
  219.                 m_combatModeEnabled = true;
  220.         }
  221.         else if (crcCode == s_combatTargetDisabledCrc)
  222.         {
  223.                 m_combatModeEnabled = false;
  224.         }
  225.         else if (crcCode == s_firingAllowedCrc)
  226.         {
  227.                 m_firingAllowed = true;
  228.         }
  229.         else if (crcCode == s_firingNotAllowedCrc)
  230.         {
  231.                 m_firingAllowed = false;
  232.         }
  233.  
  234.         Base::SetSignal(nSignalID, szText, pSender, pData, crcCode);
  235. }
  236.  
downloadAIFlyingVehicle.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