BVB Source Codes

CRYENGINE Show VehicleDamagesGroup.cpp Source code

Return Download CRYENGINE: download VehicleDamagesGroup.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: Implements the base of the vehicle damages group
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 23:02:2006: Created by Mathieu Pinard
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15. #include "CryAction.h"
  16. #include "IVehicleSystem.h"
  17. #include "VehicleDamagesGroup.h"
  18. #include "Vehicle.h"
  19. #include "VehicleDamageBehaviorDestroy.h"
  20. #include "VehicleDamageBehaviorDetachPart.h"
  21. #include "VehiclePartAnimatedJoint.h"
  22.  
  23. //------------------------------------------------------------------------
  24. CVehicleDamagesGroup::~CVehicleDamagesGroup()
  25. {
  26.         for (TDamagesSubGroupVector::iterator ite = m_damageSubGroups.begin();
  27.              ite != m_damageSubGroups.end(); ++ite)
  28.         {
  29.                 SDamagesSubGroup& subGroup = *ite;
  30.                 TVehicleDamageBehaviorVector& damageBehaviors = subGroup.m_damageBehaviors;
  31.  
  32.                 for (TVehicleDamageBehaviorVector::iterator behaviorIte = damageBehaviors.begin(); behaviorIte != damageBehaviors.end(); ++behaviorIte)
  33.                 {
  34.                         IVehicleDamageBehavior* pBehavior = *behaviorIte;
  35.                         pBehavior->Release();
  36.                 }
  37.         }
  38.  
  39.         m_delayedSubGroups.clear();
  40. }
  41.  
  42. //------------------------------------------------------------------------
  43. bool CVehicleDamagesGroup::Init(CVehicle* pVehicle, const CVehicleParams& table)
  44. {
  45.         m_pVehicle = pVehicle;
  46.         m_name = table.getAttr("name");
  47.         m_damageSubGroups.clear();
  48.  
  49.         return !m_name.empty() && ParseDamagesGroup(table);
  50. }
  51.  
  52. //------------------------------------------------------------------------
  53. bool CVehicleDamagesGroup::ParseDamagesGroup(const CVehicleParams& table)
  54. {
  55.         if (table.haveAttr("useTemplate"))
  56.         {
  57.                 IVehicleSystem* pVehicleSystem = gEnv->pGameFramework->GetIVehicleSystem();
  58.                 CRY_ASSERT(pVehicleSystem);
  59.  
  60.                 if (IVehicleDamagesTemplateRegistry* pDamageTemplReg = pVehicleSystem->GetDamagesTemplateRegistry())
  61.                         pDamageTemplReg->UseTemplate(table.getAttr("useTemplate"), this);
  62.         }
  63.  
  64.         if (CVehicleParams damagesSubGroupsTable = table.findChild("DamagesSubGroups"))
  65.         {
  66.                 int i = 0;
  67.                 int c = damagesSubGroupsTable.getChildCount();
  68.  
  69.                 for (; i < c; i++)
  70.                 {
  71.                         if (CVehicleParams groupTable = damagesSubGroupsTable.getChild(i))
  72.                         {
  73.                                 m_damageSubGroups.resize(m_damageSubGroups.size() + 1);
  74.                                 SDamagesSubGroup& subGroup = m_damageSubGroups.back();
  75.  
  76.                                 subGroup.id = static_cast<TDamagesSubGroupId>(m_damageSubGroups.size() - 1);
  77.                                 subGroup.m_isAlreadyInProcess = false;
  78.  
  79.                                 if (!groupTable.getAttr("delay", subGroup.m_delay))
  80.                                         subGroup.m_delay = 0.0f;
  81.  
  82.                                 if (!groupTable.getAttr("randomness", subGroup.m_randomness))
  83.                                         subGroup.m_randomness = 0.0f;
  84.  
  85.                                 if (CVehicleParams damageBehaviorsTable = groupTable.findChild("DamageBehaviors"))
  86.                                 {
  87.                                         int k = 0;
  88.                                         int numDamageBehaviors = damageBehaviorsTable.getChildCount();
  89.  
  90.                                         subGroup.m_damageBehaviors.reserve(c);
  91.  
  92.                                         for (; k < numDamageBehaviors; k++)
  93.                                         {
  94.                                                 if (CVehicleParams behaviorTable = damageBehaviorsTable.getChild(k))
  95.                                                 {
  96.                                                         if (IVehicleDamageBehavior* pDamageBehavior = ParseDamageBehavior(behaviorTable))
  97.                                                         {
  98.                                                                 subGroup.m_damageBehaviors.push_back(pDamageBehavior);
  99.  
  100.                                                                 CVehicleDamageBehaviorDestroy* pDamageDestroy = CAST_VEHICLEOBJECT(CVehicleDamageBehaviorDestroy, pDamageBehavior);
  101.                                                                 if (pDamageDestroy)
  102.                                                                 {
  103.                                                                         TVehiclePartVector& parts = m_pVehicle->GetParts();
  104.                                                                         for (TVehiclePartVector::iterator ite = parts.begin(); ite != parts.end(); ++ite)
  105.                                                                         {
  106.                                                                                 IVehiclePart* pPart = ite->second;
  107.                                                                                 if (CVehiclePartAnimatedJoint* pAnimJoint = CAST_VEHICLEOBJECT(CVehiclePartAnimatedJoint, pPart))
  108.                                                                                 {
  109.                                                                                         if (pAnimJoint->IsPhysicalized() && !pAnimJoint->GetDetachBaseForce().IsZero())
  110.                                                                                         {
  111.                                                                                                 CVehicleDamageBehaviorDetachPart* pDetachBehavior = new CVehicleDamageBehaviorDetachPart;
  112.                                                                                                 pDetachBehavior->Init(m_pVehicle, pAnimJoint->GetName(), pDamageDestroy->GetEffectName());
  113.  
  114.                                                                                                 subGroup.m_damageBehaviors.push_back(pDetachBehavior);
  115.                                                                                         }
  116.                                                                                 }
  117.                                                                         }
  118.                                                                 }
  119.                                                         }
  120.                                                 }
  121.                                         }
  122.                                 }
  123.                         }
  124.                 }
  125.         }
  126.  
  127.         return true;
  128. }
  129.  
  130. //------------------------------------------------------------------------
  131. IVehicleDamageBehavior* CVehicleDamagesGroup::ParseDamageBehavior(const CVehicleParams& table)
  132. {
  133.         string className = table.getAttr("class");
  134.         if (!className.empty())
  135.         {
  136.                 IVehicleSystem* pVehicleSystem = CCryAction::GetCryAction()->GetIVehicleSystem();
  137.  
  138.                 if (IVehicleDamageBehavior* pDamageBehavior = pVehicleSystem->CreateVehicleDamageBehavior(className))
  139.                 {
  140.                         if (pDamageBehavior->Init((IVehicle*) m_pVehicle, table))
  141.                                 return pDamageBehavior;
  142.                         else
  143.                                 pDamageBehavior->Release();
  144.                 }
  145.         }
  146.  
  147.         return NULL;
  148. }
  149.  
  150. //------------------------------------------------------------------------
  151. void CVehicleDamagesGroup::Reset()
  152. {
  153.         for (TDamagesSubGroupVector::iterator ite = m_damageSubGroups.begin();
  154.              ite != m_damageSubGroups.end(); ++ite)
  155.         {
  156.                 SDamagesSubGroup& subGroup = *ite;
  157.                 TVehicleDamageBehaviorVector& damageBehaviors = subGroup.m_damageBehaviors;
  158.  
  159.                 for (TVehicleDamageBehaviorVector::iterator behaviorIte = damageBehaviors.begin(); behaviorIte != damageBehaviors.end(); ++behaviorIte)
  160.                 {
  161.                         IVehicleDamageBehavior* pBehavior = *behaviorIte;
  162.                         pBehavior->Reset();
  163.                 }
  164.  
  165.                 subGroup.m_isAlreadyInProcess = false;
  166.         }
  167.  
  168.         m_delayedSubGroups.clear();
  169. }
  170.  
  171. //------------------------------------------------------------------------
  172. void CVehicleDamagesGroup::Serialize(TSerialize ser, EEntityAspects aspects)
  173. {
  174.         ser.BeginGroup("SubGroups");
  175.         for (TDamagesSubGroupVector::iterator ite = m_damageSubGroups.begin();
  176.              ite != m_damageSubGroups.end(); ++ite)
  177.         {
  178.                 ser.BeginGroup("SubGroup");
  179.  
  180.                 SDamagesSubGroup& subGroup = *ite;
  181.                 TVehicleDamageBehaviorVector& damageBehaviors = subGroup.m_damageBehaviors;
  182.  
  183.                 for (TVehicleDamageBehaviorVector::iterator behaviorIte = damageBehaviors.begin(); behaviorIte != damageBehaviors.end(); ++behaviorIte)
  184.                 {
  185.                         IVehicleDamageBehavior* pBehavior = *behaviorIte;
  186.                         ser.BeginGroup("Behavior");
  187.                         pBehavior->Serialize(ser, aspects);
  188.                         ser.EndGroup();
  189.                 }
  190.                 ser.EndGroup();
  191.         }
  192.         ser.EndGroup();
  193.  
  194.         int size = m_delayedSubGroups.size();
  195.         ser.Value("DelayedSubGroupEntries", size);
  196.         if (ser.IsWriting())
  197.         {
  198.                 for (TDelayedDamagesSubGroupList::iterator ite = m_delayedSubGroups.begin(); ite != m_delayedSubGroups.end(); ++ite)
  199.                 {
  200.                         ser.BeginGroup("SubGroup");
  201.                         SDelayedDamagesSubGroupInfo& delayedInfo = *ite;
  202.                         ser.Value("delayedInfoId", delayedInfo.subGroupId);
  203.                         ser.Value("delayedInfoDelay", delayedInfo.delay);
  204.                         delayedInfo.behaviorParams.Serialize(ser, m_pVehicle);
  205.                         ser.EndGroup();
  206.                 }
  207.         }
  208.         else if (ser.IsReading())
  209.         {
  210.                 m_delayedSubGroups.clear();
  211.                 for (int i = 0; i < size; ++i)
  212.                 {
  213.                         ser.BeginGroup("SubGroup");
  214.                         SDelayedDamagesSubGroupInfo delayInfo;
  215.                         ser.Value("delayedInfoId", delayInfo.subGroupId);
  216.                         ser.Value("delayedInfoDelay", delayInfo.delay);
  217.                         delayInfo.behaviorParams.Serialize(ser, m_pVehicle);
  218.                         ser.EndGroup();
  219.                 }
  220.         }
  221. }
  222.  
  223. //------------------------------------------------------------------------
  224. void CVehicleDamagesGroup::OnDamageEvent(EVehicleDamageBehaviorEvent event, const SVehicleDamageBehaviorEventParams& behaviorParams)
  225. {
  226.         if (m_pVehicle->IsDestroyed() || event == eVDBE_VehicleDestroyed)
  227.                 return;
  228.  
  229.         if (event == eVDBE_Repair)
  230.         {
  231.                 m_delayedSubGroups.clear();
  232.         }
  233.  
  234.         for (TDamagesSubGroupVector::iterator subGroupIte = m_damageSubGroups.begin(); subGroupIte != m_damageSubGroups.end(); ++subGroupIte)
  235.         {
  236.                 SDamagesSubGroup& subGroup = *subGroupIte;
  237.                 TVehicleDamageBehaviorVector& damageBehaviors = subGroup.m_damageBehaviors;
  238.  
  239.                 if (!subGroup.m_isAlreadyInProcess && subGroup.m_delay > 0.f && event != eVDBE_Repair)
  240.                 {
  241.                         m_delayedSubGroups.resize(m_delayedSubGroups.size() + 1);
  242.                         subGroup.m_isAlreadyInProcess = true;
  243.  
  244.                         SDelayedDamagesSubGroupInfo& delayedSubGroupInfo = m_delayedSubGroups.back();
  245.  
  246.                         delayedSubGroupInfo.delay = subGroup.m_delay;
  247.                         delayedSubGroupInfo.behaviorParams = behaviorParams;
  248.                         delayedSubGroupInfo.subGroupId = subGroup.id;
  249.                 }
  250.                 else
  251.                 {
  252.                         SVehicleDamageBehaviorEventParams params(behaviorParams);
  253.                         params.randomness = subGroup.m_randomness;
  254.  
  255.                         for (TVehicleDamageBehaviorVector::iterator behaviorIte = damageBehaviors.begin(); behaviorIte != damageBehaviors.end(); ++behaviorIte)
  256.                         {
  257.                                 IVehicleDamageBehavior* pBehavior = *behaviorIte;
  258.                                 pBehavior->OnDamageEvent(event, params);
  259.                         }
  260.                 }
  261.         }
  262. }
  263.  
  264. //------------------------------------------------------------------------
  265. void CVehicleDamagesGroup::Update(float frameTime)
  266. {
  267.         FUNCTION_PROFILER(gEnv->pSystem, PROFILE_ACTION);
  268.  
  269.         TDelayedDamagesSubGroupList::iterator ite = m_delayedSubGroups.begin();
  270.         TDelayedDamagesSubGroupList::iterator next;
  271.         for (; ite != m_delayedSubGroups.end(); ite = next)
  272.         {
  273.                 next = ite;
  274.                 ++next;
  275.  
  276.                 SDelayedDamagesSubGroupInfo& delayedInfo = *ite;
  277.                 delayedInfo.delay -= frameTime;
  278.  
  279.                 if (delayedInfo.delay <= 0.0f)
  280.                 {
  281.                         TDamagesSubGroupId id = delayedInfo.subGroupId;
  282.                         SDamagesSubGroup* pSubGroup = &m_damageSubGroups[id];
  283.                         delayedInfo.behaviorParams.randomness = pSubGroup->m_randomness;
  284.                         TVehicleDamageBehaviorVector& damageBehaviors = pSubGroup->m_damageBehaviors;
  285.  
  286.                         for (TVehicleDamageBehaviorVector::iterator behaviorIte = damageBehaviors.begin(); behaviorIte != damageBehaviors.end(); ++behaviorIte)
  287.                         {
  288.                                 IVehicleDamageBehavior* pBehavior = *behaviorIte;
  289.                                 pBehavior->OnDamageEvent(eVDBE_ComponentDestroyed, delayedInfo.behaviorParams);
  290.                         }
  291.  
  292.                         m_delayedSubGroups.erase(ite);
  293.                 }
  294.         }
  295.  
  296.         if (!m_delayedSubGroups.empty())
  297.                 m_pVehicle->NeedsUpdate();
  298. }
  299.  
  300. //------------------------------------------------------------------------
  301. bool CVehicleDamagesGroup::IsPotentiallyFatal()
  302. {
  303.         for (TDamagesSubGroupVector::iterator subGroupIte = m_damageSubGroups.begin(); subGroupIte != m_damageSubGroups.end(); ++subGroupIte)
  304.         {
  305.                 SDamagesSubGroup& subGroup = *subGroupIte;
  306.                 TVehicleDamageBehaviorVector& damageBehaviors = subGroup.m_damageBehaviors;
  307.  
  308.                 for (TVehicleDamageBehaviorVector::iterator behaviorIte = damageBehaviors.begin(); behaviorIte != damageBehaviors.end(); ++behaviorIte)
  309.                 {
  310.                         //IVehicleDamageBehavior* pBehavio
  311.                         if (CVehicleDamageBehaviorDestroy* pBehaviorDestroy =
  312.                               CAST_VEHICLEOBJECT(CVehicleDamageBehaviorDestroy, (*behaviorIte)))
  313.                         {
  314.                                 return true;
  315.                         }
  316.                 }
  317.         }
  318.  
  319.         return false;
  320. }
  321.  
  322. //------------------------------------------------------------------------
  323. void CVehicleDamagesGroup::GetMemoryUsage(ICrySizer* pSizer) const
  324. {
  325.         pSizer->AddObject(m_damageSubGroups);
  326. }
  327.  
downloadVehicleDamagesGroup.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