BVB Source Codes

CRYENGINE Show VehiclePartEntity.cpp Source code

Return Download CRYENGINE: download VehiclePartEntity.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: Vehicle part class that spawns an entity and attaches it to the vehicle.
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 01:09:2010: Created by Paul Slinger
  12.  
  13. *************************************************************************/
  14.  
  15. #include "StdAfx.h"
  16.  
  17. #include <IViewSystem.h>
  18. #include <IItemSystem.h>
  19. #include <IVehicleSystem.h>
  20. #include <CryPhysics/IPhysics.h>
  21. #include <CryAnimation/ICryAnimation.h>
  22. #include <IActorSystem.h>
  23. #include <CryNetwork/ISerialize.h>
  24. #include <CryAISystem/IAgent.h>
  25.  
  26. #include "CryAction.h"
  27. #include "Vehicle.h"
  28. #include "VehiclePartEntity.h"
  29. #include "VehicleUtils.h"
  30.  
  31. //------------------------------------------------------------------------
  32. CVehiclePartEntity::CVehiclePartEntity()
  33.         : m_entityId(0)
  34.         , m_pHelper(nullptr)
  35.         , m_pLink(nullptr)
  36.         , m_hidden(false)
  37.         , m_destroyed(false)
  38.         , m_entityAttached(false)
  39.         , m_constraintId(0)
  40.         , m_CollideWithParent(true)
  41.         , m_createBuddyConstraint(false)
  42.         , m_entityNetId(0)
  43.         , m_shouldDetachInsteadOfDestroy(false)
  44. {
  45. }
  46.  
  47. //------------------------------------------------------------------------
  48. CVehiclePartEntity::~CVehiclePartEntity()
  49. {
  50.         SafeRemoveBuddyConstraint();
  51.         DestroyEntity();
  52.  
  53.         m_pVehicle->UnregisterVehicleEventListener(this);
  54. }
  55.  
  56. //------------------------------------------------------------------------
  57. bool CVehiclePartEntity::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* parent, CVehicle::SPartInitInfo& initInfo, int partType)
  58. {
  59.         if (!CVehiclePartBase::Init(pVehicle, table, parent, initInfo, eVPT_Entity))
  60.         {
  61.                 return false;
  62.         }
  63.  
  64.         if (CVehicleParams params = table.findChild("Entity"))
  65.         {
  66.                 //prefer to use index, if not available try id
  67.                 bool found = params.getAttr("index", m_index);
  68.                 if (!found)
  69.                 {
  70.                         params.getAttr("id", m_index);
  71.                 }
  72.  
  73.                 m_entityName = params.getAttr("name");
  74.                 m_entityArchetype = params.getAttr("archetype");
  75.                 m_helperName = params.getAttr("helper");
  76.  
  77.                 //getAttr is confused by bitfield bool
  78.                 bool temp = true;
  79.                 params.getAttr("collideWithParent", temp);
  80.                 m_CollideWithParent = temp;
  81.  
  82.                 temp = false;
  83.                 params.getAttr("detachInsteadOfDestroy", temp);
  84.                 m_shouldDetachInsteadOfDestroy = temp;
  85.         }
  86.  
  87.         m_pVehicle->RegisterVehicleEventListener(this, "VehiclePartEntity");
  88.  
  89.         return true;
  90. }
  91.  
  92. //------------------------------------------------------------------------
  93. void CVehiclePartEntity::PostInit()
  94. {
  95.         if (!m_helperName.empty())
  96.         {
  97.                 m_pHelper = m_pVehicle->GetHelper(m_helperName.c_str());
  98.         }
  99.  
  100.         Reset();
  101. }
  102.  
  103. //------------------------------------------------------------------------
  104. void CVehiclePartEntity::Reset()
  105. {
  106.         if (m_entityId && !gEnv->pEntitySystem->GetEntity(m_entityId))
  107.         {
  108.                 m_entityId = 0;
  109.         }
  110.  
  111.         if (!m_entityId)
  112.         {
  113.                 SEntitySpawnParams entitySpawnParams;
  114.  
  115.                 entitySpawnParams.pArchetype = gEnv->pEntitySystem->LoadEntityArchetype(m_entityArchetype.c_str());
  116.  
  117.                 if (entitySpawnParams.pArchetype)
  118.                 {
  119.                         entitySpawnParams.pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(m_entityName.c_str());
  120.  
  121.                         if (entitySpawnParams.pClass)
  122.                         {
  123.                                 entitySpawnParams.vPosition = Vec3(0.0f, 0.0f, 0.0f);
  124.                                 entitySpawnParams.sName = m_entityName.c_str();
  125.                                 entitySpawnParams.nFlags |= (m_pVehicle->GetEntity()->GetFlags() & (ENTITY_FLAG_CLIENT_ONLY | ENTITY_FLAG_SERVER_ONLY)) | ENTITY_FLAG_NEVER_NETWORK_STATIC;
  126.  
  127.                                 //if the entity will be created by the server, don't create it on the clients
  128.                                 //we will receive an entity spawn from the server and join it on later
  129.                                 if (gEnv->bServer || (entitySpawnParams.nFlags & ENTITY_FLAG_CLIENT_ONLY))
  130.                                 {
  131.                                         if (IEntity* pEntity = gEnv->pEntitySystem->SpawnEntity(entitySpawnParams))
  132.                                         {
  133.                                                 m_entityId = pEntity->GetId();
  134.  
  135.                                                 //Create an entity link so the entity can find the Vehicle if it needs to
  136.                                                 m_pLink = pEntity->AddEntityLink("VehiclePartLink", m_pVehicle->GetEntityId());
  137.  
  138.                                                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  139.  
  140.                                                 pEntity->Hide(m_hidden);
  141.  
  142.                                                 if (m_CollideWithParent == false)
  143.                                                 {
  144.                                                         m_createBuddyConstraint = true;
  145.                                                 }
  146.  
  147.                                                 INetContext* pNetContext = gEnv->pGameFramework->GetNetContext();
  148.                                                 if (pNetContext)
  149.                                                 {
  150.                                                         SNetObjectID netId = pNetContext->GetNetID(m_entityId, false);
  151.                                                         m_entityNetId = netId.id;
  152.                                                 }
  153.  
  154.                                                 UpdateEntity();
  155.                                         }
  156.                                 }
  157.                         }
  158.                 }
  159.         }
  160.         else
  161.         {
  162.                 //this is required to handle resetting world in editor, should not be hit while running game
  163.                 if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_entityId))
  164.                 {
  165.                         if (!m_entityAttached)
  166.                         {
  167.                                 //Create an entity link so the entity can find the Vehicle if it needs to
  168.                                 m_pLink = pEntity->AddEntityLink("VehiclePartLink", m_pVehicle->GetEntityId());
  169.  
  170.                                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  171.  
  172.                                 pEntity->Hide(m_hidden);
  173.  
  174.                                 if (m_CollideWithParent == false)
  175.                                 {
  176.                                         m_createBuddyConstraint = true;
  177.                                 }
  178.  
  179.                                 INetContext* pNetContext = gEnv->pGameFramework->GetNetContext();
  180.                                 if (pNetContext)
  181.                                 {
  182.                                         SNetObjectID netId = pNetContext->GetNetID(m_entityId, false);
  183.                                         m_entityNetId = netId.id;
  184.                                 }
  185.  
  186.                                 UpdateEntity();
  187.                         }
  188.                         else
  189.                         {
  190.                                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  191.  
  192.                                 if (m_constraintId)
  193.                                 {
  194.                                         if (m_CollideWithParent == false)
  195.                                         {
  196.                                                 m_createBuddyConstraint = true;
  197.                                         }
  198.                                 }
  199.                         }
  200.                 }
  201.         }
  202.  
  203.         m_entityAttached = !!m_entityId;
  204. }
  205.  
  206. //------------------------------------------------------------------------
  207. void CVehiclePartEntity::Update(const float frameTime)
  208. {
  209.         CVehiclePartBase::Update(frameTime);
  210.  
  211.         if (m_createBuddyConstraint && GetPartEntity()) //Wait for part entity to be valid
  212.         {
  213.                 //stop collision between vehicle and part
  214.                 if (IPhysicalEntity* pVehiclePE = m_pVehicle->GetEntity()->GetPhysics())
  215.                 {
  216.                         IPhysicalEntity* pPartPE = GetPartEntity()->GetPhysics();
  217.                         pe_action_add_constraint ic;
  218.                         ic.flags = constraint_inactive | constraint_ignore_buddy;
  219.                         ic.pBuddy = pPartPE;
  220.                         ic.pt[0].Set(0, 0, 0);
  221.                         m_constraintId = pVehiclePE->Action(&ic);
  222.                 }
  223.  
  224.                 m_createBuddyConstraint = false;
  225.         }
  226.  
  227.         if (m_entityAttached)
  228.         {
  229.                 UpdateEntity();
  230.         }
  231. }
  232.  
  233. //------------------------------------------------------------------------
  234. void CVehiclePartEntity::OnVehicleEvent(EVehicleEvent event, const SVehicleEventParams& params)
  235. {
  236.         switch (event)
  237.         {
  238.         case eVE_Destroyed:
  239.                 {
  240.                         if (m_shouldDetachInsteadOfDestroy)
  241.                         {
  242.                                 TryDetachPart(params);
  243.                         }
  244.                         else
  245.                         {
  246.                                 DestroyEntity();
  247.                         }
  248.  
  249.                         break;
  250.                 }
  251.  
  252.         case eVE_TryDetachPartEntity:
  253.                 {
  254.                         if (params.iParam == m_index)
  255.                         {
  256.                                 TryDetachPart(params);
  257.                         }
  258.  
  259.                         break;
  260.                 }
  261.  
  262.         case eVE_OnDetachPartEntity:
  263.                 {
  264.                         if (m_entityAttached && params.entityId == m_entityId)
  265.                         {
  266.                                 m_entityAttached = false;
  267.  
  268.                                 SafeRemoveBuddyConstraint();
  269.                         }
  270.  
  271.                         break;
  272.                 }
  273.  
  274.         case eVE_TryAttachPartEntityNetID:
  275.                 {
  276.                         if (params.iParam == m_entityNetId && params.entityId != 0)
  277.                         {
  278.                                 //Can only attach an entity if we currently don't have one
  279.                                 if (m_entityId == 0)
  280.                                 {
  281.                                         if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(params.entityId))
  282.                                         {
  283.                                                 m_entityId = params.entityId;
  284.                                                 //Create an entity link so the entity can find the Vehicle if it needs to
  285.                                                 m_pLink = pEntity->AddEntityLink("VehiclePartLink", m_pVehicle->GetEntityId());
  286.  
  287.                                                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  288.  
  289.                                                 pEntity->Hide(m_hidden);
  290.  
  291.                                                 if (m_CollideWithParent == false)
  292.                                                 {
  293.                                                         m_createBuddyConstraint = true;
  294.                                                 }
  295.  
  296.                                                 m_entityAttached = true;
  297.  
  298.                                                 CryLog("VehiclePartEntity: Successfully attached part %d to entity %u", m_index, m_entityId);
  299.                                         }
  300.                                 }
  301.                                 else
  302.                                 {
  303.                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CVehiclePartEntity::OnVehicleEvent trying to attach an entity but part already has one");
  304.                                 }
  305.                         }
  306.  
  307.                         break;
  308.                 }
  309.  
  310.         case eVE_Hide:
  311.                 {
  312.                         m_hidden = !!params.iParam;
  313.  
  314.                         if (m_entityAttached)
  315.                         {
  316.                                 if (IEntity* pEntity = GetPartEntity())
  317.                                 {
  318.                                         pEntity->Hide(m_hidden);
  319.                                 }
  320.                         }
  321.  
  322.                         break;
  323.                 }
  324.         }
  325. }
  326.  
  327. //------------------------------------------------------------------------
  328. void CVehiclePartEntity::Serialize(TSerialize serializer, EEntityAspects aspects)
  329. {
  330.         CVehiclePartBase::Serialize(serializer, aspects);
  331.  
  332.         bool saveGame = serializer.GetSerializationTarget() != eST_Network;
  333.  
  334.         if (saveGame)
  335.         {
  336.                 uint32 flags = 0;
  337.  
  338.                 if (serializer.IsWriting())
  339.                 {
  340.                         if (m_hidden)
  341.                         {
  342.                                 flags |= Flags::Hidden;
  343.                         }
  344.  
  345.                         if (m_entityAttached)
  346.                         {
  347.                                 flags |= Flags::EntityAttached;
  348.                         }
  349.  
  350.                         if (m_destroyed)
  351.                         {
  352.                                 flags |= Flags::Destroyed;
  353.                         }
  354.                 }
  355.  
  356.                 serializer.Value("entityId", m_entityId);
  357.                 serializer.Value("flags", flags);
  358.  
  359.                 if (serializer.IsReading())
  360.                 {
  361.                         m_hidden = !!(flags & Flags::Hidden);
  362.                         m_entityAttached = !!(flags & Flags::EntityAttached);
  363.                         m_destroyed = !!(flags & Flags::Destroyed);
  364.                 }
  365.         }
  366.         else
  367.         {
  368.                 serializer.Value("netId", m_entityNetId, 'ui16');
  369.         }
  370.  
  371. }
  372.  
  373. //------------------------------------------------------------------------
  374. void CVehiclePartEntity::PostSerialize()
  375. {
  376.         CVehiclePartBase::PostSerialize();
  377.  
  378.         if (!m_destroyed)
  379.         {
  380.                 Reset();
  381.         }
  382. }
  383.  
  384. //------------------------------------------------------------------------
  385. void CVehiclePartEntity::GetMemoryUsage(ICrySizer* pSizer) const
  386. {
  387.         pSizer->Add(*this);
  388.  
  389.         CVehiclePartBase::GetMemoryUsageInternal(pSizer);
  390. }
  391.  
  392. //------------------------------------------------------------------------
  393. IEntity* CVehiclePartEntity::GetPartEntity() const
  394. {
  395.         return m_entityId ? gEnv->pEntitySystem->GetEntity(m_entityId) : NULL;
  396. }
  397.  
  398. //------------------------------------------------------------------------
  399. void CVehiclePartEntity::UpdateEntity()
  400. {
  401.         if (IEntity* pEntity = GetPartEntity())
  402.         {
  403.                 Matrix34 worldTM;
  404.  
  405.                 if (m_pHelper)
  406.                 {
  407.                         m_pHelper->GetWorldTM(worldTM);
  408.                 }
  409.                 else if (IVehiclePart* pParent = GetParent())
  410.                 {
  411.                         worldTM = pParent->GetWorldTM();
  412.                 }
  413.                 else
  414.                 {
  415.                         worldTM = GetEntity()->GetWorldTM();
  416.                 }
  417.  
  418.                 pEntity->SetWorldTM(worldTM);
  419.         }
  420. }
  421.  
  422. //------------------------------------------------------------------------
  423. void CVehiclePartEntity::DestroyEntity()
  424. {
  425.         m_destroyed = true;
  426.  
  427.         if (m_entityId)
  428.         {
  429.                 gEnv->pEntitySystem->RemoveEntity(m_entityId);
  430.  
  431.                 m_entityId = 0;
  432.         }
  433.  
  434.         m_entityAttached = false;
  435.         SafeRemoveBuddyConstraint();
  436.  
  437.         m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
  438. }
  439.  
  440. void CVehiclePartEntity::SafeRemoveBuddyConstraint()
  441. {
  442.         if (IEntity* pPartEntity = GetPartEntity())
  443.         {
  444.                 if (m_constraintId)
  445.                 {
  446.                         if (IPhysicalEntity* pPartPE = pPartEntity->GetPhysics())
  447.                         {
  448.                                 pe_action_update_constraint up;
  449.                                 up.bRemove = true;
  450.                                 up.idConstraint = m_constraintId;
  451.                                 m_constraintId = 0;
  452.                                 pPartPE->Action(&up);
  453.                         }
  454.                 }
  455.  
  456.                 if (m_pLink)
  457.                 {
  458.                         pPartEntity->RemoveEntityLink(m_pLink);
  459.                         m_pLink = NULL;
  460.                 }
  461.         }
  462. }
  463.  
  464. void CVehiclePartEntity::TryDetachPart(const SVehicleEventParams& params)
  465. {
  466.         SVehicleEventParams vehicleEventParams = params;
  467.  
  468.         vehicleEventParams.entityId = m_entityId;
  469.         vehicleEventParams.iParam = m_pVehicle->GetEntityId();
  470.  
  471.         m_pVehicle->BroadcastVehicleEvent(eVE_OnDetachPartEntity, vehicleEventParams);
  472.  
  473.         m_entityAttached = false;
  474.  
  475.         SafeRemoveBuddyConstraint();
  476. }
  477.  
  478. //------------------------------------------------------------------------
  479. DEFINE_VEHICLEOBJECT(CVehiclePartEntity)
  480.  
downloadVehiclePartEntity.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