BVB Source Codes

CRYENGINE Show CET_EntitySystem.cpp Source code

Return Download CRYENGINE: download CET_EntitySystem.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 "CET_EntitySystem.h"
  5. #include "GameContext.h"
  6. #include <CryNetwork/NetHelpers.h>
  7. #include "IGameRulesSystem.h"
  8. #include "ILevelSystem.h"
  9. #include "CryAction.h"
  10. #include <CryAudio/Dialog/IDialogSystem.h>
  11. #include <CryAction/IMaterialEffects.h>
  12. #include "ActionGame.h"
  13.  
  14. /*
  15.  * Reset entity system
  16.  */
  17.  
  18. class CCET_EntitySystemReset : public CCET_Base
  19. {
  20. public:
  21.         CCET_EntitySystemReset(bool skipPlayers, bool skipGameRules) : m_skipPlayers(skipPlayers), m_skipGameRules(skipGameRules) {}
  22.  
  23.         const char*                 GetName() { return "EntitySystemReset"; }
  24.  
  25.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  26.         {
  27.                 CScopedRemoveObjectUnlock unlockRemovals(CCryAction::GetCryAction()->GetGameContext());
  28.                 if (m_skipGameRules || m_skipPlayers)
  29.                 {
  30.                         IEntityItPtr i = gEnv->pEntitySystem->GetEntityIterator();
  31.  
  32.                         while (!i->IsEnd())
  33.                         {
  34.                                 IEntity* pEnt = i->Next();
  35.  
  36.                                 // skip gamerules
  37.                                 if (m_skipGameRules)
  38.                                         if (pEnt->GetId() == CCryAction::GetCryAction()->GetIGameRulesSystem()->GetCurrentGameRulesEntity()->GetId())
  39.                                                 continue;
  40.  
  41.                                 // skip players
  42.                                 if (m_skipPlayers)
  43.                                 {
  44.                                         IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(pEnt->GetId());
  45.                                         if (pActor && pActor->IsPlayer())
  46.                                                 continue;
  47.                                 }
  48.  
  49.                                 pEnt->ClearFlags(ENTITY_FLAG_UNREMOVABLE);
  50.  
  51.                                 // force remove all other entities
  52.                                 gEnv->pEntitySystem->RemoveEntity(pEnt->GetId(), true);
  53.                         }
  54.  
  55.                         if (!m_skipGameRules)
  56.                                 gEnv->pEntitySystem->ReserveEntityId(1);
  57.                 }
  58.                 else
  59.                 {
  60.                         if (!gEnv->pSystem->IsSerializingFile())
  61.                                 gEnv->pEntitySystem->Reset();
  62.                         gEnv->pEntitySystem->ReserveEntityId(1);
  63.                 }
  64.                 gEnv->pEntitySystem->ReserveEntityId(LOCAL_PLAYER_ENTITY_ID);
  65.  
  66.                 CActionGame::Get()->OnEntitySystemReset();
  67.  
  68.                 return eCETR_Ok;
  69.         }
  70.  
  71. private:
  72.         bool m_skipPlayers;
  73.         bool m_skipGameRules;
  74. };
  75.  
  76. void AddEntitySystemReset(IContextEstablisher* pEst, EContextViewState state, bool skipPlayers, bool skipGamerules)
  77. {
  78.         pEst->AddTask(state, new CCET_EntitySystemReset(skipPlayers, skipGamerules));
  79. }
  80.  
  81. /*
  82.  * Random system reset
  83.  */
  84.  
  85. class CCET_RandomSystemReset : public CCET_Base
  86. {
  87. public:
  88.         CCET_RandomSystemReset(bool loadingNewLevel) : m_loadingNewLevel(loadingNewLevel) {}
  89.  
  90.         const char*                 GetName() { return "RandomSystemReset"; }
  91.  
  92.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  93.         {
  94.                 // reset a bunch of subsystems
  95.                 gEnv->p3DEngine->ResetParticlesAndDecals();
  96.                 gEnv->pGameFramework->ResetBrokenGameObjects();
  97.                 gEnv->pPhysicalWorld->ResetDynamicEntities();
  98.                 gEnv->pFlowSystem->Reset(false);
  99.                 gEnv->pGameFramework->GetIItemSystem()->Reset();
  100.                 gEnv->pDialogSystem->Reset(false);
  101.                 gEnv->pGameFramework->GetIMaterialEffects()->Reset(false);
  102.  
  103.                 if (gEnv->pAISystem)
  104.                 {
  105.                         ILevelInfo* pLevel = gEnv->pGameFramework->GetILevelSystem()->GetCurrentLevel();
  106.                         if (pLevel)
  107.                         {
  108.                                 gEnv->pAISystem->FlushSystem();
  109.  
  110.                                 // Don't waste time reloading the current level's navigation data
  111.                                 // if we're about to load a new level and throw this data away
  112.                                 if (!m_loadingNewLevel)
  113.                                 {
  114.                                         const ILevelInfo::TGameTypeInfo* pGameTypeInfo = pLevel->GetDefaultGameType();
  115.                                         const char* const szGameTypeName = pGameTypeInfo ? pGameTypeInfo->name.c_str() : "";
  116.                                         gEnv->pAISystem->LoadLevelData(pLevel->GetPath(), szGameTypeName);
  117.                                 }
  118.                         }
  119.                 }
  120.  
  121.                 //m_pPersistantDebug->Reset();
  122.                 return eCETR_Ok;
  123.         }
  124.  
  125.         bool m_loadingNewLevel;
  126. };
  127.  
  128. void AddRandomSystemReset(IContextEstablisher* pEst, EContextViewState state, bool loadingNewLevel)
  129. {
  130.         pEst->AddTask(state, new CCET_RandomSystemReset(loadingNewLevel));
  131. }
  132.  
  133. /*
  134.  * Fake some spawns
  135.  */
  136.  
  137. class CCET_FakeSpawns : public CCET_Base
  138. {
  139. public:
  140.         CCET_FakeSpawns(unsigned what) : m_what(what) {}
  141.  
  142.         const char*                 GetName() { return "FakeSpawns"; }
  143.  
  144.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  145.         {
  146.                 bool allowPlayers = (m_what & eFS_Players) != 0;
  147.                 bool allowGameRules = (m_what & eFS_GameRules) != 0;
  148.                 bool allowOthers = (m_what & eFS_Others) != 0;
  149.                 EntityId gameRulesId = 0;
  150.                 if (IEntity* pGameRules = CCryAction::GetCryAction()->GetIGameRulesSystem()->GetCurrentGameRulesEntity())
  151.                         gameRulesId = pGameRules->GetId();
  152.  
  153.                 // we are in the editor, and that means that there have been entities spawned already
  154.                 // that are not bound to the network context... so lets bind them!
  155.                 IEntityItPtr pIt = gEnv->pEntitySystem->GetEntityIterator();
  156.                 while (IEntity* pEntity = pIt->Next())
  157.                 {
  158.                         bool isOther = true;
  159.  
  160.                         bool isPlayer = false;
  161.                         IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(pEntity->GetId());
  162.                         if (pActor && pActor->IsPlayer())
  163.                         {
  164.                                 isPlayer = true;
  165.                                 isOther = false;
  166.                         }
  167.                         if (isPlayer && !allowPlayers)
  168.                                 continue;
  169.  
  170.                         bool isGameRules = false;
  171.                         if (pEntity->GetId() == gameRulesId)
  172.                         {
  173.                                 isGameRules = true;
  174.                                 isOther = false;
  175.                         }
  176.                         if (isGameRules && !allowGameRules)
  177.                                 continue;
  178.  
  179.                         if (isOther && !allowOthers)
  180.                                 continue;
  181.  
  182.                         CGameObject* pGO = (CGameObject*) pEntity->GetProxy(ENTITY_PROXY_USER);
  183.                         if (pGO)
  184.                         {
  185.                                 if (pGO->IsBoundToNetwork())
  186.                                         pGO->BindToNetwork(eBTNM_Force); // force rebinding
  187.                         }
  188.  
  189.                         SEntitySpawnParams fakeParams;
  190.                         fakeParams.id = pEntity->GetId();
  191.                         fakeParams.nFlags = pEntity->GetFlags();
  192.                         fakeParams.pClass = pEntity->GetClass();
  193.                         fakeParams.qRotation = pEntity->GetRotation();
  194.                         fakeParams.sName = pEntity->GetName();
  195.                         fakeParams.vPosition = pEntity->GetPos();
  196.                         fakeParams.vScale = pEntity->GetScale();
  197.                         CCryAction::GetCryAction()->GetGameContext()->OnSpawn(pEntity, fakeParams);
  198.                 }
  199.                 return eCETR_Ok;
  200.         }
  201.  
  202. private:
  203.         unsigned m_what;
  204. };
  205.  
  206. void AddFakeSpawn(IContextEstablisher* pEst, EContextViewState state, unsigned what)
  207. {
  208.         pEst->AddTask(state, new CCET_FakeSpawns(what));
  209. }
  210.  
  211. /*
  212.  * load entities from the mission file
  213.  */
  214.  
  215. class CCET_LoadLevelEntities : public CCET_Base
  216. {
  217. public:
  218.         const char*                 GetName() { return "LoadLevelEntities"; }
  219.  
  220.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  221.         {
  222.                 ILevelInfo* pLevel = CCryAction::GetCryAction()->GetILevelSystem()->GetCurrentLevel();
  223.                 if (!pLevel)
  224.                 {
  225.                         GameWarning("levelInfo is null");
  226.                         return eCETR_Failed;
  227.                 }
  228.                 const char* levelName = CCryAction::GetCryAction()->GetLevelName();
  229.                 if (!levelName)
  230.                 {
  231.                         GameWarning("levelName is null");
  232.                         return eCETR_Failed;
  233.                 }
  234.  
  235.                 // delete any pending entities before reserving EntityIds in LoadEntities()
  236.                 gEnv->pEntitySystem->DeletePendingEntities();
  237.  
  238.                 string missionXml = pLevel->GetDefaultGameType()->xmlFile;
  239.                 string xmlFile = string(pLevel->GetPath()) + "/" + missionXml;
  240.  
  241.                 XmlNodeRef rootNode = GetISystem()->LoadXmlFromFile(xmlFile.c_str());
  242.  
  243.                 if (rootNode)
  244.                 {
  245.                         const char* script = rootNode->getAttr("Script");
  246.  
  247.                         if (script && script[0])
  248.                                 gEnv->pScriptSystem->ExecuteFile(script, true, true);
  249.  
  250.                         XmlNodeRef objectsNode = rootNode->findChild("Objects");
  251.  
  252.                         if (objectsNode)
  253.                                 gEnv->pEntitySystem->LoadEntities(objectsNode, false);
  254.                 }
  255.                 else
  256.                         return eCETR_Failed;
  257.  
  258.                 SEntityEvent loadingCompleteEvent(ENTITY_EVENT_LEVEL_LOADED);
  259.                 gEnv->pEntitySystem->SendEventToAll(loadingCompleteEvent);
  260.  
  261.                 return eCETR_Ok;
  262.         }
  263. };
  264.  
  265. void AddLoadLevelEntities(IContextEstablisher* pEst, EContextViewState state)
  266. {
  267.         pEst->AddTask(state, new CCET_LoadLevelEntities);
  268. }
  269.  
  270. /*
  271.  * send an event
  272.  */
  273.  
  274. class CCET_EntitySystemEvent : public CCET_Base, private SEntityEvent
  275. {
  276. public:
  277.         CCET_EntitySystemEvent(const SEntityEvent& evt) : SEntityEvent(evt) {}
  278.  
  279.         const char*                 GetName() { return "EntitySystemEvent"; }
  280.  
  281.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  282.         {
  283.                 gEnv->pEntitySystem->SendEventToAll(*this);
  284.                 return eCETR_Ok;
  285.         }
  286. };
  287.  
  288. void AddEntitySystemEvent(IContextEstablisher* pEst, EContextViewState state, const SEntityEvent& evt)
  289. {
  290.         pEst->AddTask(state, new CCET_EntitySystemEvent(evt));
  291. }
  292.  
downloadCET_EntitySystem.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