BVB Source Codes

CRYENGINE Show BreakReplicator.cpp Source code

Return Download CRYENGINE: download BreakReplicator.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 "BreakReplicator.h"
  5. #include "GameContext.h"
  6.  
  7. #include "NullListener.h"
  8. #include "NullStream.h"
  9. #include "GenericRecordingListener.h"
  10. #include "GenericPlaybackListener.h"
  11. #include "ProceduralBreakingPlaybackListener.h"
  12. #include "ProceduralBreakingRecordingListener.h"
  13. #include "NetworkCVars.h"
  14. #include "ObjectSelector.h"
  15. #include "DebugBreakage.h"
  16.  
  17. #include "JointBreak.h"
  18. #include "BreakReplicatorGameObject.h"
  19.  
  20. void CBreakReplicator::RegisterClasses()
  21. {
  22.         // Register the GameObjectExtension
  23.         static bool once = true;
  24.         if (once)
  25.         {
  26.                 once = false;
  27.                 IEntityClassRegistry::SEntityClassDesc serializerClass;
  28.                 serializerClass.sName = "BreakRepGameObject";
  29.                 serializerClass.sScriptFile = "";
  30.                 serializerClass.flags = ECLF_INVISIBLE;
  31.                 static IGameFramework::CGameObjectExtensionCreator<CBreakRepGameObject> creator;
  32.                 CCryAction::GetCryAction()->GetIGameObjectSystem()->RegisterExtension(serializerClass.sName, &creator, &serializerClass);
  33.         }
  34. }
  35.  
  36. #if !NET_USE_SIMPLE_BREAKAGE
  37.  
  38. //**=======================================================**
  39. //**                                                       **
  40. //**     OLD BREAKREPLICATOR                               **
  41. //**                                                       **
  42. //**     Deprecated !                                      **
  43. //**                                                       **
  44. //**                                                       **
  45. //**=======================================================**
  46.  
  47. CBreakReplicator* CBreakReplicator::m_pThis = 0;
  48.  
  49. static const int RECORDING_TIMEOUT = 120;
  50.  
  51. CBreakReplicator::CBreakReplicator(CGameContext* pCtx)
  52.         : m_bDefineProtocolMode_server(false)
  53. {
  54.         CRY_ASSERT(!m_pThis);
  55.         m_pThis = this;
  56.         m_pContext = pCtx;
  57.  
  58.         m_nextOrderId = 0;
  59.         m_loggedOrderId = -1;
  60.  
  61.         m_pActiveListener = 0;
  62.         m_pNullListener = new CNullListener();
  63.         m_pNullPlayback = new CNullStream();
  64.         if (pCtx->HasContextFlag(eGSF_Server))
  65.                 m_pGenericJointBroken = m_pGenericCreateEntityPart = m_pGenericUpdateMesh = m_pGenericRemoveEntityParts = new CGenericRecordingListener();
  66.         else
  67.                 m_pGenericJointBroken = m_pGenericCreateEntityPart = m_pGenericUpdateMesh = m_pGenericRemoveEntityParts = m_pNullListener;
  68.         if (pCtx->HasContextFlag(eGSF_Client) && !pCtx->HasContextFlag(eGSF_Server))
  69.                 m_pGenericPlaybackListener = new CGenericPlaybackListener();
  70.  
  71.         if (gEnv->pPhysicalWorld)
  72.         {
  73.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysCreateEntityPart::id, OnCreatePhysEntityPart_Begin, true, 100000.f);
  74.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysRemoveEntityParts::id, OnRemovePhysEntityParts_Begin, true, 100000.f);
  75.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysUpdateMesh::id, OnUpdateMesh_Begin, true, 100000.f);
  76.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysUpdateMesh::id, OnUpdateMesh_End, true, -100000.f);
  77.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysJointBroken::id, OnJointBroken_Begin, true, 100000.f);
  78.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysJointBroken::id, OnJointBroken_End, true, -100000.f);
  79.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysRemoveEntityParts::id, OnRemovePhysEntityParts_End, true, -100000.f);
  80.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysCreateEntityPart::id, OnCreatePhysEntityPart_End, true, -100000.f);
  81.  
  82.                 gEnv->pPhysicalWorld->AddEventClient(EventPhysPostStep::id, OnPostStepEvent, true);
  83.         }
  84.  
  85.         if (DEBUG_NET_BREAKAGE)
  86.         {
  87.                 CNetworkCVars::Get().BreakageLog = 1;
  88.         }
  89.  
  90.         m_entitiesToRemove.reserve(16);
  91.  
  92.         m_removePartEvents.reserve(100);
  93. }
  94.  
  95. CBreakReplicator::~CBreakReplicator()
  96. {
  97.         m_pThis = 0;
  98.  
  99.         if (gEnv->pPhysicalWorld)
  100.         {
  101.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysCreateEntityPart::id, OnCreatePhysEntityPart_Begin, true);
  102.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysCreateEntityPart::id, OnCreatePhysEntityPart_End, true);
  103.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysRemoveEntityParts::id, OnRemovePhysEntityParts_Begin, true);
  104.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysRemoveEntityParts::id, OnRemovePhysEntityParts_End, true);
  105.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysUpdateMesh::id, OnUpdateMesh_Begin, true);
  106.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysUpdateMesh::id, OnUpdateMesh_End, true);
  107.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysJointBroken::id, OnJointBroken_Begin, true);
  108.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysJointBroken::id, OnJointBroken_End, true);
  109.  
  110.                 gEnv->pPhysicalWorld->RemoveEventClient(EventPhysPostStep::id, OnPostStepEvent, true);
  111.         }
  112.  
  113.         while (!m_pendingLogs.empty())
  114.         {
  115.                 delete m_pendingLogs.begin()->second;
  116.                 m_pendingLogs.erase(m_pendingLogs.begin());
  117.         }
  118. }
  119.  
  120. const EventPhysRemoveEntityParts* CBreakReplicator::GetRemovePartEvents(int& iNumEvents)
  121. {
  122.         iNumEvents = m_removePartEvents.size();
  123.         if (iNumEvents)
  124.                 return &(m_removePartEvents[0]);
  125.         else
  126.                 return NULL;
  127. }
  128.  
  129. void CBreakReplicator::Reset()
  130. {
  131. }
  132.  
  133. int CBreakReplicator::PullOrderId()
  134. {
  135.         return m_nextOrderId++;
  136. }
  137.  
  138. void CBreakReplicator::PushBreak(int orderId, const SNetBreakDescription& desc)
  139. {
  140.         if (orderId == m_loggedOrderId + 1)
  141.         {
  142.                 CCryAction::GetCryAction()->GetNetContext()->LogBreak(desc);
  143.                 m_loggedOrderId++;
  144.                 FlushPendingLogs();
  145.         }
  146.         else
  147.         {
  148.                 m_pendingLogs[orderId] = new SNetBreakDescription(desc);
  149.         }
  150. }
  151.  
  152. void CBreakReplicator::PushAbandonment(int orderId)
  153. {
  154.         if (orderId == m_loggedOrderId + 1)
  155.         {
  156.                 m_loggedOrderId++;
  157.                 FlushPendingLogs();
  158.         }
  159.         else
  160.         {
  161.                 m_pendingLogs[orderId] = 0;
  162.         }
  163. }
  164.  
  165. void CBreakReplicator::FlushPendingLogs()
  166. {
  167.         while (!m_pendingLogs.empty() && m_pendingLogs.begin()->first == m_loggedOrderId + 1)
  168.         {
  169.                 if (m_pendingLogs.begin()->second)
  170.                         CCryAction::GetCryAction()->GetNetContext()->LogBreak(*m_pendingLogs.begin()->second);
  171.                 m_loggedOrderId++;
  172.                 m_pendingLogs.erase(m_pendingLogs.begin());
  173.         }
  174. }
  175.  
  176. void CBreakReplicator::OnBrokeSomething(const SBreakEvent& be, EventPhysMono* pMono, bool isPlane)
  177. {
  178.         LOGBREAK("CBreakReplicator::OnBrokeSomething(isPlane: %d)", isPlane);
  179.  
  180.         if (!gEnv->bServer)
  181.                 return;
  182.  
  183.         if (isPlane)
  184.                 AddProceduralBreakTypeListener(new CPlaneBreak(be));
  185.         else
  186.                 AddProceduralBreakTypeListener(new CDeformingBreak(be));
  187. }
  188.  
  189. IBreakReplicatorListenerPtr CBreakReplicator::AddProceduralBreakTypeListener(const IProceduralBreakTypePtr& pBT)
  190. {
  191.         for (ListenerInfos::iterator it = m_listenerInfos.begin(); it != m_listenerInfos.end(); ++it)
  192.         {
  193.                 if (it->pListener->AttemptAbsorb(pBT))
  194.                 {
  195.                         if (CNetworkCVars::Get().BreakageLog)
  196.                                 CryLogAlways("[brk] absorbed into listener %p", (void*)it->pListener);
  197.                         return it->pListener;
  198.                 }
  199.         }
  200.  
  201.         CProceduralBreakingBaseListener* pListener = new CProceduralBreakingRecordingListener(pBT);
  202.         if (CNetworkCVars::Get().BreakageLog)
  203.                 CryLogAlways("[brk] add listener %p", pListener);
  204.         m_listenerInfos.push_back(SListenerInfo(pListener, RECORDING_TIMEOUT));
  205.         return pListener;
  206. }
  207.  
  208. void CBreakReplicator::OnSpawn(IEntity* pEntity, SEntitySpawnParams& params)
  209. {
  210.         if (m_pActiveListener)
  211.         {
  212.                 if (CNetworkCVars::Get().BreakageLog)
  213.                         CryLogAlways("[brk] spawn %s and pass to %s @ %p", pEntity->GetName(), m_pActiveListener->GetName(), &*m_pActiveListener);
  214.                 m_pActiveListener->OnSpawn(pEntity, params);
  215.         }
  216. }
  217.  
  218. void CBreakReplicator::OnSpawn(IEntity* pEntity, IPhysicalEntity* pPhysEntity, IPhysicalEntity* pSrcPhysEntity)
  219. {
  220. }
  221.  
  222. void CBreakReplicator::OnRemove(IEntity* pEntity)
  223. {
  224.         if (m_pActiveListener)
  225.         {
  226.                 if (CNetworkCVars::Get().BreakageLog)
  227.                         CryLogAlways("[brk] remove %s and pass to %s @ %p", pEntity->GetName(), m_pActiveListener->GetName(), &*m_pActiveListener);
  228.                 m_pActiveListener->OnRemove(pEntity);
  229.         }
  230. }
  231.  
  232. void CBreakReplicator::RemoveEntity(IEntity* pEntity)
  233. {
  234.         m_entitiesToRemove.push_back(pEntity->GetId());
  235.  
  236. }
  237.  
  238. void CBreakReplicator::OnReuse(IEntity* pEntity, SEntitySpawnParams& params)
  239. {
  240.         OnSpawn(pEntity, params);
  241. }
  242.  
  243. void CBreakReplicator::OnStartFrame()
  244. {
  245.         CRY_ASSERT(!m_pActiveListener);
  246.         for (ListenerInfos::iterator it = m_listenerInfos.begin(); it != m_listenerInfos.end(); ++it)
  247.                 it->pListener->OnStartFrame();
  248. }
  249.  
  250. void CBreakReplicator::OnEndFrame()
  251. {
  252.         CRY_ASSERT(!m_pActiveListener);
  253.         bool hdr = false;
  254.         for (ListenerInfos::iterator it = m_listenerInfos.begin(); it != m_listenerInfos.end(); ++it)
  255.         {
  256.                 if (--it->timeout)
  257.                 {
  258.                         if (it->pListener->OnEndFrame())
  259.                         {
  260.                                 m_listenerInfos_temp.push_back(*it);
  261.  
  262.                                 if (CNetworkCVars::Get().BreakageLog)
  263.                                 {
  264.                                         if (!hdr)
  265.                                         {
  266.                                                 CryLogAlways("[brk] end frame");
  267.                                                 hdr = true;
  268.                                         }
  269.                                         CryLogAlways("[brk] still active for %d is %s @ %p", it->timeout, it->pListener->GetName(), &*it->pListener);
  270.                                 }
  271.                         }
  272.                         else if (CNetworkCVars::Get().BreakageLog)
  273.                         {
  274.                                 CryLogAlways("[brk] %p claims completion", it->pListener.get());
  275.                         }
  276.                 }
  277.                 else
  278.                 {
  279.                         CryLogAlways("[brk] %p times out", it->pListener.get());
  280.                         it->pListener->OnTimeout();
  281.                 }
  282.         }
  283.         m_listenerInfos_temp.swap(m_listenerInfos);
  284.         m_listenerInfos_temp.resize(0);
  285.  
  286.         SpinPendingStreams();
  287.  
  288.         //================================
  289.         // Process Entities To be Removed
  290.         //================================
  291.         // If the object is bound to the network then it must not be deleted. Instead the game object
  292.         // serialises the state and frees the statobj slot on all machines. This is used when the
  293.         // breakage system is consuming too much memory.
  294.         for (int i = 0; i < (const int)m_entitiesToRemove.size(); i++)
  295.         {
  296.                 EntityId entId = m_entitiesToRemove[i];
  297.                 IEntity* pEntity = gEnv->pEntitySystem->GetEntity(entId);
  298.                 if (pEntity)
  299.                 {
  300.                         if ((pEntity->GetFlags() & (ENTITY_FLAG_CLIENT_ONLY | ENTITY_FLAG_SERVER_ONLY)) == 0)
  301.                         {
  302.                                 if (CGameObject* pGameObject = (CGameObject*) pEntity->GetProxy(ENTITY_PROXY_USER))
  303.                                 {
  304.                                         if (IGameObjectExtension* pExtension = pGameObject->QueryExtension("BreakRepGameObject"))
  305.                                         {
  306.                                                 // Net serialise that this entity should free its breakage statobj slot
  307.                                                 static_cast<CBreakRepGameObject*>(pExtension)->m_removed = true;
  308.                                         }
  309.                                 }
  310.                         }
  311.                         else
  312.                         {
  313.                                 // Entities that are not bound to the network can be deleted
  314.                                 gEnv->pEntitySystem->RemoveEntity(entId);
  315.                         }
  316.                 }
  317.         }
  318.         m_entitiesToRemove.clear();
  319. }
  320.  
  321. void CBreakReplicator::BeginEvent(IBreakReplicatorListenerPtr pListener)
  322. {
  323.         CRY_ASSERT(!m_pActiveListener);
  324.         CRY_ASSERT(pListener != NULL);
  325.         m_pActiveListener = pListener;
  326.         if (CNetworkCVars::Get().BreakageLog)
  327.                 CryLogAlways("[brk] BeginEvent with listener %s @ %p", pListener->GetName(), &*pListener);
  328. }
  329.  
  330. void CBreakReplicator::EnterEvent()
  331. {
  332. }
  333.  
  334. void CBreakReplicator::EndEvent()
  335. {
  336.         if (!m_pActiveListener)
  337.         {
  338.                 GameWarning("CBreakReplicator::EndEvent: No active listener during end event, this is wrong (ignored)");
  339.                 return;
  340.         }
  341.  
  342.         CRY_ASSERT(m_pActiveListener != NULL);
  343.         if (CNetworkCVars::Get().BreakageLog)
  344.                 CryLogAlways("[brk] EndEvent");
  345.         m_pActiveListener->EndEvent(CCryAction::GetCryAction()->GetGameContext()->GetNetContext());
  346.         m_pActiveListener = 0;
  347. }
  348.  
  349. ILINE void CBreakReplicator::OnUpdateMesh(const EventPhysUpdateMesh* pEvent)
  350. {
  351.         EnterEvent();
  352.         if (CNetworkCVars::Get().BreakageLog)
  353.                 CryLogAlways("[brk] OnUpdateMesh %s", CObjectSelector::GetDescription(pEvent->pEntity).c_str());
  354.         for (ListenerInfos::reverse_iterator iter = m_listenerInfos.rbegin(); iter != m_listenerInfos.rend(); ++iter)
  355.         {
  356.                 if (iter->pListener->AcceptUpdateMesh(pEvent))
  357.                 {
  358.                         BeginEvent(iter->pListener);
  359.                         return;
  360.                 }
  361.         }
  362.         if (m_pGenericUpdateMesh->AcceptUpdateMesh(pEvent))
  363.                 BeginEvent(m_pGenericUpdateMesh);
  364.         else
  365.                 BeginEvent(m_pNullListener);
  366. }
  367.  
  368. ILINE void CBreakReplicator::OnJointBroken(const EventPhysJointBroken* pEvent)
  369. {
  370.         EnterEvent();
  371.         if (CNetworkCVars::Get().BreakageLog)
  372.                 CryLogAlways("[brk] OnJointBroken %s", CObjectSelector::GetDescription(pEvent->pEntity[0]).c_str());
  373.         LOGBREAK("OnJointBroken, pent0: %p, pent1: %p, newpent0: %p, newpent1: %p", pEvent->pEntity[0], pEvent->pEntity[1], pEvent->pNewEntity[0], pEvent->pNewEntity[1]);
  374.  
  375.         for (ListenerInfos::reverse_iterator iter = m_listenerInfos.rbegin(); iter != m_listenerInfos.rend(); ++iter)
  376.         {
  377.                 if (iter->pListener->AcceptJointBroken(pEvent))
  378.                 {
  379.                         BeginEvent(iter->pListener);
  380.                         return;
  381.                 }
  382.         }
  383.  
  384.         if (m_pContext->HasContextFlag(eGSF_Server))
  385.         {
  386.                 CJointBreak* pJointBreak = new CJointBreak(pEvent->pEntity[0]);
  387.                 IBreakReplicatorListenerPtr pListener = AddProceduralBreakTypeListener(pJointBreak);
  388.                 if (pListener->AcceptJointBroken(pEvent))
  389.                         BeginEvent(m_listenerInfos.back().pListener);
  390.                 else
  391.                         GameWarning("CBreakReplicator::OnJointBroken: created listener is non-accepting");
  392.         }
  393.         else if (m_pGenericJointBroken->AcceptJointBroken(pEvent))
  394.                 BeginEvent(m_pGenericJointBroken);
  395.         else
  396.                 BeginEvent(m_pNullListener);
  397. }
  398.  
  399. ILINE void CBreakReplicator::OnCreatePhysEntityPart(const EventPhysCreateEntityPart* pEvent)
  400. {
  401.         EnterEvent();
  402.         if (CNetworkCVars::Get().BreakageLog)
  403.                 CryLogAlways("[brk] OnCreatePhysEntityPart %s%s part[src=%d,new=%d]", CObjectSelector::GetDescription(pEvent->pEntity).c_str(), pEvent->iReason == EventPhysCreateEntityPart::ReasonJointsBroken ? " due to joint break" : "", pEvent->partidSrc, pEvent->partidNew);
  404.  
  405.         for (ListenerInfos::reverse_iterator iter = m_listenerInfos.rbegin(); iter != m_listenerInfos.rend(); ++iter)
  406.         {
  407.                 if (iter->pListener->AcceptCreateEntityPart(pEvent))
  408.                 {
  409.                         BeginEvent(iter->pListener);
  410.                         return;
  411.                 }
  412.         }
  413.  
  414.         if (m_pContext->HasContextFlag(eGSF_Server) && pEvent->iReason == EventPhysCreateEntityPart::ReasonJointsBroken)
  415.         {
  416.                 CJointBreak* pJointBreak = new CJointBreak(pEvent->pEntity);
  417.                 IBreakReplicatorListenerPtr pListener = AddProceduralBreakTypeListener(pJointBreak);
  418.                 if (pListener->AcceptCreateEntityPart(pEvent))
  419.                         BeginEvent(m_listenerInfos.back().pListener);
  420.                 else
  421.                         GameWarning("CBreakReplicator::OnCreatePhysEntityPart: created listener is non-accepting");
  422.         }
  423.         else if (m_pGenericCreateEntityPart->AcceptCreateEntityPart(pEvent))
  424.                 BeginEvent(m_pGenericCreateEntityPart);
  425.         else
  426.                 BeginEvent(m_pNullListener);
  427. }
  428.  
  429. static string RemovePartsBitString(const uint32* p, int n)
  430. {
  431.         string x;
  432.         for (int i = 0; i < n; i++)
  433.         {
  434.                 for (int j = 0; j < 32; j++)
  435.                 {
  436.                         if (p[i] & (1 << j))
  437.                         {
  438.                                 int idx = i * 32 + j;
  439.                                 if (x.empty())
  440.                                         x += string().Format("%d", idx);
  441.                                 else
  442.                                         x += string().Format(", %d", idx);
  443.                         }
  444.                 }
  445.         }
  446.         return x;
  447. }
  448.  
  449. ILINE void CBreakReplicator::OnRemovePhysEntityParts(const EventPhysRemoveEntityParts* pEvent)
  450. {
  451.         const int oldSize = m_removePartEvents.size();
  452.         BreakLogAlways("PR: Storing RemovePart event index %d,  'foreign data': 0x%p   iForeignType: %d", oldSize, pEvent->pForeignData, pEvent->iForeignData);
  453.         m_removePartEvents.push_back(*pEvent);
  454.  
  455.         EnterEvent();
  456.         if (CNetworkCVars::Get().BreakageLog)
  457.                 CryLogAlways("[brk] OnRemovePhysEntityParts %s (%s)", CObjectSelector::GetDescription(pEvent->pEntity).c_str(), RemovePartsBitString(pEvent->partIds, sizeof(pEvent->partIds) / sizeof(*pEvent->partIds)).c_str());
  458.         LOGBREAK("OnRemovePhysEntityParts: physEnt=%p", pEvent->pEntity);
  459.         for (ListenerInfos::reverse_iterator iter = m_listenerInfos.rbegin(); iter != m_listenerInfos.rend(); ++iter)
  460.         {
  461.                 if (iter->pListener->AcceptRemoveEntityParts(pEvent))
  462.                 {
  463.                         BeginEvent(iter->pListener);
  464.                         return;
  465.                 }
  466.         }
  467.         if (m_pGenericRemoveEntityParts->AcceptRemoveEntityParts(pEvent))
  468.                 BeginEvent(m_pGenericRemoveEntityParts);
  469.         else
  470.                 BeginEvent(m_pNullListener);
  471. }
  472.  
  473. ILINE void CBreakReplicator::OnPostStep(const EventPhysPostStep* pEvent)
  474. {
  475.         #if BREAK_HIERARCHICAL_TRACKING
  476.         for (ListenerInfos::reverse_iterator iter = m_listenerInfos.rbegin(); iter != m_listenerInfos.rend(); ++iter)
  477.         {
  478.                 iter->pListener->OnPostStep();
  479.         }
  480.         #endif
  481. }
  482.  
  483. int CBreakReplicator::OnPostStepEvent(const EventPhys* pEvent)
  484. {
  485.         m_pThis->OnPostStep(static_cast<const EventPhysPostStep*>(pEvent));
  486.         return 1;
  487. }
  488.  
  489. int CBreakReplicator::OnJointBroken_Begin(const EventPhys* pEvent)
  490. {
  491.         m_pThis->OnJointBroken(static_cast<const EventPhysJointBroken*>(pEvent));
  492.         return 1;
  493. }
  494.  
  495. int CBreakReplicator::OnJointBroken_End(const EventPhys* pEvent)
  496. {
  497.         m_pThis->EndEvent();
  498.         return 1;
  499. }
  500.  
  501. int CBreakReplicator::OnUpdateMesh_Begin(const EventPhys* pEvent)
  502. {
  503.         m_pThis->OnUpdateMesh(static_cast<const EventPhysUpdateMesh*>(pEvent));
  504.         return 1;
  505. }
  506.  
  507. int CBreakReplicator::OnUpdateMesh_End(const EventPhys* pEvent)
  508. {
  509.         m_pThis->EndEvent();
  510.         return 1;
  511. }
  512.  
  513. int CBreakReplicator::OnCreatePhysEntityPart_Begin(const EventPhys* pEvent)
  514. {
  515.         m_pThis->OnCreatePhysEntityPart(static_cast<const EventPhysCreateEntityPart*>(pEvent));
  516.         return 1;
  517. }
  518.  
  519. int CBreakReplicator::OnCreatePhysEntityPart_End(const EventPhys* pEvent)
  520. {
  521.         m_pThis->EndEvent();
  522.         return 1;
  523. }
  524.  
  525. int CBreakReplicator::OnRemovePhysEntityParts_Begin(const EventPhys* pEvent)
  526. {
  527.         m_pThis->OnRemovePhysEntityParts(static_cast<const EventPhysRemoveEntityParts*>(pEvent));
  528.         return 1;
  529. }
  530.  
  531. int CBreakReplicator::OnRemovePhysEntityParts_End(const EventPhys* pEvent)
  532. {
  533.         m_pThis->EndEvent();
  534.         return 1;
  535. }
  536.  
  537. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, DeformingBreak, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  538. {
  539.         CRY_ASSERT(!CCryAction::GetCryAction()->IsGamePaused());
  540.         return BeginStream(param.breakId, new CDeformingBreak(param.breakEvent));
  541. }
  542.  
  543. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, PlaneBreak, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  544. {
  545.         CRY_ASSERT(!CCryAction::GetCryAction()->IsGamePaused());
  546.         return BeginStream(param.breakId, new CPlaneBreak(param.breakEvent));
  547. }
  548.  
  549. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, JointBreak, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  550. {
  551.         CRY_ASSERT(!CCryAction::GetCryAction()->IsGamePaused());
  552.         return BeginStream(param.breakId, new CJointBreak());
  553. }
  554.  
  555. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, DeclareProceduralSpawnRec, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  556. {
  557.         return GetStream(param.breakId)->GotProceduralSpawnRec(&param);
  558. }
  559.  
  560. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, DeclareJointBreakRec, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  561. {
  562.         return GetStream(param.breakId)->GotJointBreakRec(&param);
  563. }
  564.  
  565. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, DeclareJointBreakParticleRec, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  566. {
  567.         return GetStream(param.breakId)->GotJointBreakParticleRec(&param);
  568. }
  569.  
  570. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, DeclareExplosiveObjectState, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  571. {
  572.         return GetStream(param.breakId)->GotExplosiveObjectState(&param);
  573. }
  574.  
  575. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, SimulateRemoveEntityParts, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  576. {
  577.         return false;
  578.         /*
  579.            CRY_ASSERT(false);
  580.            IBreakPlaybackStreamPtr pStream = new CGenericPlaybackStream<SSimulateRemoveEntityParts>(param);
  581.            return BeginStream( param.breakId, pStream );
  582.          */
  583. }
  584.  
  585. NET_IMPLEMENT_SIMPLE_ATSYNC_MESSAGE(CBreakReplicator, SetMagicId, eNRT_ReliableUnordered, eMPF_BlocksStateChange)
  586. {
  587.         return GetStream(param.breakId)->SetMagicId(param.magicId);
  588. }
  589.  
  590. void CBreakReplicator::GetMemoryStatistics(ICrySizer* s)
  591. {
  592. }
  593.  
  594. void CBreakReplicator::DefineProtocol(IProtocolBuilder* pBuilder)
  595. {
  596.         static SNetProtocolDef nullDef = { 0, 0 };
  597.  
  598.         if (m_bDefineProtocolMode_server)
  599.                 pBuilder->AddMessageSink(this, GetProtocolDef(), nullDef);
  600.         else
  601.                 pBuilder->AddMessageSink(this, nullDef, GetProtocolDef());
  602. }
  603.  
  604. bool CBreakReplicator::BeginStream(int idx, const IProceduralBreakTypePtr& pBT)
  605. {
  606.         if (idx < 0)
  607.                 return false;
  608.         if (m_playbackMessageHandlers.size() <= idx)
  609.                 m_playbackMessageHandlers.resize(idx + 1);
  610.         if (m_playbackMessageHandlers[idx])
  611.                 return m_playbackMessageHandlers[idx]->AttemptAbsorb(pBT);
  612.         m_playbackMessageHandlers[idx] = new CProceduralBreakingPlaybackStream(pBT);
  613.         return true;
  614. }
  615.  
  616. IBreakPlaybackStreamPtr CBreakReplicator::GetStream(int idx)
  617. {
  618.         if (idx < 0 || idx >= m_playbackMessageHandlers.size())
  619.                 return m_pNullPlayback;
  620.         if (!m_playbackMessageHandlers[idx])
  621.                 return m_pNullPlayback;
  622.         return m_playbackMessageHandlers[idx];
  623. }
  624.  
  625. IBreakPlaybackStreamPtr CBreakReplicator::PullStream(int idx)
  626. {
  627.         if (idx < 0 || idx >= m_playbackMessageHandlers.size())
  628.                 return m_pNullPlayback;
  629.         if (!m_playbackMessageHandlers[idx])
  630.                 return m_pNullPlayback;
  631.         IBreakPlaybackStreamPtr pBrk = NULL;
  632.         std::swap(pBrk, m_playbackMessageHandlers[idx]);
  633.         return pBrk;
  634. }
  635.  
  636. void CBreakReplicator::PlaybackBreakage(int breakId, INetBreakagePlaybackPtr pBreakage)
  637. {
  638.         SPendingPlayback pp;
  639.         pp.pNetBreakage = pBreakage;
  640.         pp.pStream = PullStream(breakId);
  641.         m_pendingPlayback.push_back(pp);
  642.         SpinPendingStreams();
  643. }
  644.  
  645. void* CBreakReplicator::ReceiveSimpleBreakage(TSerialize ser)
  646. {
  647.         CryFatalError("This code shouldn't be called unless NET_USE_SIMPLE_BREAKAGE is defined");
  648.         return NULL;
  649. }
  650.  
  651. void CBreakReplicator::PlaybackSimpleBreakage(void* userData, INetBreakageSimplePlaybackPtr pBreakage)
  652. {
  653.         CryFatalError("This code shouldn't be called unless NET_USE_SIMPLE_BREAKAGE is defined");
  654. }
  655.  
  656. void CBreakReplicator::SpinPendingStreams()
  657. {
  658.         while (true)
  659.         {
  660.                 bool stillRunning = false;
  661.                 if (m_pPlaybackListener)
  662.                 {
  663.                         for (ListenerInfos::iterator it = m_listenerInfos.begin(); !stillRunning && it != m_listenerInfos.end(); ++it)
  664.                                 if (it->pListener == m_pPlaybackListener)
  665.                                         stillRunning = true;
  666.                         if (!stillRunning)
  667.                                 m_pPlaybackListener = 0;
  668.                 }
  669.  
  670.                 if (stillRunning)
  671.                         break;
  672.                 if (m_pendingPlayback.empty())
  673.                         break;
  674.  
  675.                 SPendingPlayback pp = m_pendingPlayback.front();
  676.                 m_pendingPlayback.erase(m_pendingPlayback.begin());
  677.  
  678.                 m_pPlaybackListener = pp.pStream->Playback(this, pp.pNetBreakage);
  679.         }
  680. }
  681.  
  682. void CBreakReplicator::AddListener(IBreakReplicatorListenerPtr pListener, int nFrames)
  683. {
  684.         m_listenerInfos.push_back(SListenerInfo(pListener, nFrames));
  685. }
  686.  
  687. #endif // !NET_USE_SIMPLE_BREAKAGE
  688.  
downloadBreakReplicator.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