BVB Source Codes

CRYENGINE Show ProceduralBreakingBaseListener.cpp Source code

Return Download CRYENGINE: download ProceduralBreakingBaseListener.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:  network breakability: common listener code for procedural breaks
  8.    -------------------------------------------------------------------------
  9.    History:
  10.    - 22/01/2007   10:34 : Created by Craig Tiller
  11. *************************************************************************/
  12.  
  13. #include "StdAfx.h"
  14.  
  15. #if !NET_USE_SIMPLE_BREAKAGE
  16.  
  17.         #include "ProceduralBreakingBaseListener.h"
  18.         #include "NetworkCVars.h"
  19.  
  20. CProceduralBreakingBaseListener::CProceduralBreakingBaseListener(IProceduralBreakTypePtr pBreakType)
  21.         : m_pBreakType(pBreakType)
  22.         #if BREAK_HIERARCHICAL_TRACKING
  23.         , m_physTime(gEnv->pPhysicalWorld->GetiPhysicsTime())
  24.         , m_activityThisStep(1)
  25.         , m_numEmptySteps(0)
  26.         #endif
  27.         , m_curBreakOp(eNBO_Create)
  28.         , m_curBreakId(-1)
  29.         , m_curBreakPart(-1)
  30.         , m_allowAdditions(true)
  31. {
  32. }
  33.  
  34. CProceduralBreakingBaseListener::~CProceduralBreakingBaseListener()
  35. {
  36.         if (CNetworkCVars::Get().BreakageLog)
  37.         {
  38.                 CryLogAlways("[brk] ~CProceduralBreakingBaseListener() %p", this);
  39.                 for (VectorMap<EntityId, int>::iterator it = m_localEntityIds.begin(); it != m_localEntityIds.end(); ++it)
  40.                 {
  41.                         int phys = -100;
  42.                         if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(it->first))
  43.                         {
  44.                                 ++phys;
  45.                                 if (IPhysicalEntity* pPhys = pEntity->GetPhysics())
  46.                                         phys = pPhys->GetType();
  47.                         }
  48.                         CryLogAlways("[brk] pbrk[%d]: %.8x phys=%d", it->second, it->first, phys);
  49.                 }
  50.         }
  51. }
  52.  
  53. bool CProceduralBreakingBaseListener::AcceptUpdateMesh(const EventPhysUpdateMesh* pEvent)
  54. {
  55.         return AcceptIfRelated(pEvent->pEntity, eNBO_Update, -1);
  56. }
  57.  
  58. bool CProceduralBreakingBaseListener::AcceptCreateEntityPart(const EventPhysCreateEntityPart* pEvent)
  59. {
  60.         return AcceptIfRelated(pEvent->pEntity, eNBO_Create, pEvent->partidSrc);
  61. }
  62.  
  63. bool CProceduralBreakingBaseListener::AcceptRemoveEntityParts(const EventPhysRemoveEntityParts* pEvent)
  64. {
  65.         return AcceptIfRelated(pEvent->pEntity, eNBO_Remove, -1);
  66. }
  67.  
  68. bool CProceduralBreakingBaseListener::AcceptJointBroken(const EventPhysJointBroken* pEvent)
  69. {
  70.         bool related = AcceptIfRelated(pEvent->pEntity[0], eNBO_JointBreak, -1);
  71.         if (related && 0 == (m_pBreakType->flags & ePBTF_NoJointBreaks))
  72.                 GotJointBreak(m_curBreakId, pEvent->idJoint, pEvent->partidEpicenter);
  73.         return related;
  74. }
  75.  
  76. void CProceduralBreakingBaseListener::OnSpawn(IEntity* pEntity, SEntitySpawnParams& params)
  77. {
  78.         int virtId = GotBreakOp(m_curBreakOp, m_curBreakId, m_curBreakPart, pEntity->GetId());
  79.         if (virtId >= 0)
  80.         {
  81.                 if (CNetworkCVars::Get().BreakageLog)
  82.                         CryLogAlways("[brk] spawned entity %.8x at index virtId: %d", pEntity->GetId(), virtId);
  83.                 pEntity->SetFlags(pEntity->GetFlags() & ~(ENTITY_FLAG_CLIENT_ONLY | ENTITY_FLAG_SERVER_ONLY));
  84.                 params.nFlags &= ~(ENTITY_FLAG_CLIENT_ONLY | ENTITY_FLAG_SERVER_ONLY);
  85.  
  86.                 IGameObject* pGameObject = CCryAction::GetCryAction()->GetIGameObjectSystem()->CreateGameObjectForEntity(pEntity->GetId());
  87.                 pGameObject->ActivateExtension("BreakRepGameObject");
  88.                 m_localEntityIds.insert(std::make_pair(pEntity->GetId(), virtId));
  89.         }
  90.         SJustSpawnedObject jso = { m_curBreakOp, m_curBreakId, pEntity->GetId(), virtId };
  91.         m_justSpawnedObjects.push_back(jso);
  92.         #if BREAK_HIERARCHICAL_TRACKING
  93.         m_activityThisStep++;
  94.         #endif
  95. }
  96.  
  97. void CProceduralBreakingBaseListener::OnRemove(IEntity* pEntity)
  98. {
  99. }
  100.  
  101. void CProceduralBreakingBaseListener::EndEvent(INetContext* pCtx)
  102. {
  103.         if (m_justSpawnedObjects.empty())
  104.         {
  105.                 if (BIT(m_curBreakOp) & OPS_WITH_NOSPAWN)
  106.                         GotBreakOp((ENetBreakOperation)(m_curBreakOp + 1), m_curBreakId, m_curBreakPart, 0);
  107.         }
  108.         else
  109.         {
  110.                 for (size_t i = 0; i < m_justSpawnedObjects.size(); i++)
  111.                 {
  112.                         SJustSpawnedObject o = m_justSpawnedObjects[i];
  113.                         FinishBreakOp(o.op, o.idxRef, o.to, o.virtId);
  114.                 }
  115.                 m_justSpawnedObjects.resize(0);
  116.         }
  117. }
  118.  
  119. void CProceduralBreakingBaseListener::OnPostStep()
  120. {
  121. }
  122.  
  123. void CProceduralBreakingBaseListener::OnStartFrame()
  124. {
  125. }
  126.  
  127. bool CProceduralBreakingBaseListener::OnEndFrame()
  128. {
  129.         #if BREAK_HIERARCHICAL_TRACKING
  130.         int physTime = gEnv->pPhysicalWorld->GetiPhysicsTime();
  131.         if (physTime != m_physTime)
  132.         {
  133.                 if (m_activityThisStep)
  134.                         m_numEmptySteps = 0;
  135.                 else
  136.                         m_numEmptySteps++;
  137.                 m_activityThisStep = 0;
  138.                 GotBreakOp(eNBO_PostStep, -1, -1, ~0);
  139.                 m_physTime = physTime;
  140.         }
  141.         #endif
  142.         bool canStop = AllowComplete();
  143.         if (canStop)
  144.         {
  145.                 Complete();
  146.                 return false;
  147.         }
  148.         return true;
  149. }
  150.  
  151. void CProceduralBreakingBaseListener::OnTimeout()
  152. {
  153.         Complete();
  154. }
  155.  
  156. bool CProceduralBreakingBaseListener::AcceptIfRelated(IPhysicalEntity* pEnt, ENetBreakOperation breakOp, int partid)
  157. {
  158.         if (!m_allowAdditions)
  159.                 return false;
  160.         int virtId = -m_pBreakType->GetVirtualId(pEnt);
  161.         if (virtId == 0)
  162.         {
  163.                 if ((m_pBreakType->flags & ePBTF_ChainBreaking) != 0)
  164.                 {
  165.                         if (pEnt->GetiForeignData() == PHYS_FOREIGN_ID_ENTITY)
  166.                         {
  167.                                 IEntity* pEntity = (IEntity*)pEnt->GetForeignData(PHYS_FOREIGN_ID_ENTITY);
  168.                                 if (!pEntity)
  169.                                         return false;
  170.                                 VectorMap<EntityId, int>::iterator iter = m_localEntityIds.find(pEntity->GetId());
  171.                                 if (iter == m_localEntityIds.end())
  172.                                         return false;
  173.                                 virtId = iter->second;
  174.                         }
  175.                         else
  176.                                 return false;
  177.                 }
  178.                 else
  179.                         return false;
  180.         }
  181.         m_curBreakOp = breakOp;
  182.         m_curBreakId = virtId;
  183.         m_curBreakPart = partid;
  184.         return true;
  185. }
  186.  
  187. CObjectSelector CProceduralBreakingBaseListener::GetObjectSelector(int idx)
  188. {
  189.         if (idx < 0)
  190.                 return m_pBreakType->GetObjectSelector(-idx);
  191.         else
  192.         {
  193.                 for (VectorMap<EntityId, int>::iterator iter = m_localEntityIds.begin(); iter != m_localEntityIds.end(); ++iter)
  194.                 {
  195.                         if (iter->second == idx)
  196.                                 return CObjectSelector(iter->first);
  197.                 }
  198.         }
  199.         return CObjectSelector();
  200. }
  201.  
  202. void DumpSpawnRecs(const DynArray<SProceduralSpawnRec>& recs, const DynArray<SJointBreakRec>& joints, const char* title)
  203. {
  204.         if (CNetworkCVars::Get().BreakageLog)
  205.         {
  206.                 CryLog("[brk] -- spawn records: %s --------------------------------------------", title);
  207.                 for (size_t i = 0; i < joints.size(); i++)
  208.                 {
  209.         #if BREAK_HIERARCHICAL_TRACKING
  210.                         CryLog("[brk]   .break %d on %d epipart=%d @ frame %d", int(joints[i].id), int(joints[i].idxRef), joints[i].epicenter, int(joints[i].frame));
  211.         #else
  212.                         CryLog("[brk]   .break %d on %d epipart=%d", int(joints[i].id), int(joints[i].idxRef), joints[i].epicenter);
  213.         #endif
  214.                 }
  215.         #if BREAK_HIERARCHICAL_TRACKING
  216.                 int frameno = 0;
  217.         #endif
  218.                 for (size_t i = 0; i < recs.size(); i++)
  219.                 {
  220.                         const char* name = "!!!!!!";
  221.                         switch (recs[i].op)
  222.                         {
  223.         #if BREAK_HIERARCHICAL_TRACKING
  224.                         case eNBO_FrameCounterFinished:
  225.                                 name = "xxxxxx";
  226.                                 break;
  227.                         case eNBO_PostStep:
  228.                                 name = "postep";
  229.                                 break;
  230.         #endif
  231.                         case eNBO_NUM_OPERATIONS:
  232.         #if BREAK_HIERARCHICAL_TRACKING
  233.                                 frameno = -1;
  234.         #endif
  235.                                 name = "......";
  236.                                 break;
  237.                         case eNBO_Create:
  238.                                 name = "create";
  239.                                 break;
  240.                         case eNBO_Create_NoSpawn:
  241.                                 name = "cre0te";
  242.                                 break;
  243.                         case eNBO_Remove:
  244.                                 name = "remove";
  245.                                 break;
  246.                         case eNBO_Remove_NoSpawn:
  247.                                 name = "rem0ve";
  248.                                 break;
  249.                         case eNBO_JointBreak:
  250.                                 name = "jbreak";
  251.                                 break;
  252.                         case eNBO_Update:
  253.                                 name = "update";
  254.                                 break;
  255.                         case eNBO_AbsorbStep:
  256.                                 name = "absorb";
  257.                                 break;
  258.                         }
  259.                         char buffer[256];
  260.                         char* p = buffer;
  261.                         p += sprintf(p, " [%03d] %s", (int)i, name);
  262.                         if (BIT(recs[i].op) & OPS_REFERENCING_ENTS)
  263.                                 p += sprintf(p, " on %d", int(recs[i].idxRef));
  264.                         if (BIT(recs[i].op) & OPS_WITH_PARTIDS)
  265.                                 p += sprintf(p, " part %d", recs[i].partid);
  266.                         if (BIT(recs[i].op) & OPS_CAUSING_ENTS)
  267.                                 p += sprintf(p, " -> %d", int(recs[i].idx));
  268.         #if BREAK_HIERARCHICAL_TRACKING
  269.                         if (frameno >= 0 && (BIT(recs[i].op) & OPS_JOINT_FRAME_COUNTERS))
  270.                         {
  271.                                 frameno++;
  272.                                 p += sprintf(p, " frame=%d", frameno);
  273.                         }
  274.         #endif
  275.                         CryLog("[brk] %s", buffer);
  276.                 }
  277.                 CryLog("[brk] -- end records  : %s --------------------------------------------", title);
  278.         }
  279. }
  280.  
  281. #endif // !NET_USE_SIMPLE_BREAKAGE
  282.  
downloadProceduralBreakingBaseListener.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