BVB Source Codes

CRYENGINE Show GameContext.h Source code

Return Download CRYENGINE: download GameContext.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description:
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 3:9:2004   11:24 : Created by M谩rcio Martins
  12.  
  13. *************************************************************************/
  14. #ifndef __GameContext_H__
  15. #define __GameContext_H__
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include <CryGame/IGameFramework.h>
  22. #include <CryEntitySystem/IEntitySystem.h>
  23. #include <CryScriptSystem/IScriptSystem.h>
  24. #include "SensedInclusionSet.h"
  25. #include "ClassRegistryReplicator.h"
  26. #include <CryNetwork/INetworkService.h>
  27.  
  28. // FIXME: Cell SDK GCC bug workaround.
  29. #ifndef __GAMEOBJECT_H__
  30.         #include "GameObjects/GameObject.h"
  31. #endif
  32.  
  33. class CScriptRMI;
  34. class CPhysicsSync;
  35. class CGameServerChannel;
  36. class CActionGame;
  37. #ifndef OLD_VOICE_SYSTEM_DEPRECATED
  38. class CVoiceController;
  39. #endif
  40.  
  41. #if ENABLE_NETDEBUG
  42. class CNetDebug;
  43. #endif
  44.  
  45. struct SBreakEvent;
  46. class CBreakReplicator;
  47.  
  48. struct SParsedConnectionInfo
  49. {
  50.         bool                allowConnect;
  51.         bool                isMigrating;
  52.         EDisconnectionCause cause;
  53.         string              gameConnectionString;
  54.         string              errmsg;
  55.         string              playerName;
  56. };
  57.  
  58. #ifdef USE_NETWORK_STALL_TICKER_THREAD
  59. struct SScopedTickerLock
  60. {
  61.         static CryLockT<CRYLOCK_RECURSIVE> s_tickerMutex;
  62.  
  63.         SScopedTickerLock(bool bForceLock) : m_bHasLock(false)
  64.         {
  65.                 if (bForceLock)
  66.                 {
  67.                         s_tickerMutex.Lock();
  68.                         m_bHasLock = true;
  69.                 }
  70.                 else
  71.                 {
  72.                         m_bHasLock = s_tickerMutex.TryLock();
  73.                 }
  74.         }
  75.         ~SScopedTickerLock()
  76.         {
  77.                 if (m_bHasLock)
  78.                 {
  79.                         s_tickerMutex.Unlock();
  80.                 }
  81.         }
  82.  
  83.         bool m_bHasLock;
  84. };
  85.  
  86.         #define SCOPED_TICKER_LOCK     SScopedTickerLock tickerLock(true);
  87.         #define SCOPED_TICKER_TRY_LOCK SScopedTickerLock tickerLock(false);
  88.         #define SCOPED_TICKER_HAS_LOCK tickerLock.m_bHasLock
  89. #else // #if USE_NETWORK_STALL_TICKER_THREAD
  90.         #define SCOPED_TICKER_LOCK     {}
  91.         #define SCOPED_TICKER_TRY_LOCK {}
  92.         #define SCOPED_TICKER_HAS_LOCK true
  93. #endif // #if USE_NETWORK_STALL_TICKER_THREAD
  94.  
  95. class CCryAction;
  96. class CGameContext :
  97.         public IGameContext,
  98.         public IGameQuery,
  99.         public IEntitySystemSink,
  100.         public IConsoleVarSink,
  101.         public IHostMigrationEventListener
  102. {
  103. public:
  104.         CGameContext(CCryAction* pFramework, CScriptRMI*, CActionGame* pGame);
  105.         virtual ~CGameContext();
  106.  
  107.         void Init(INetContext* pNetContext);
  108.  
  109.         // IGameContext
  110.         virtual bool                InitGlobalEstablishmentTasks(IContextEstablisher* pEst, int establishedToken);
  111.         virtual bool                InitChannelEstablishmentTasks(IContextEstablisher* pEst, INetChannel* pChannel, int establishedToken);
  112.         virtual ESynchObjectResult  SynchObject(EntityId id, NetworkAspectType nAspect, uint8 currentProfile, TSerialize pSerialize, bool verboseLogging);
  113.         virtual INetSendableHookPtr CreateObjectSpawner(EntityId id, INetChannel* pChannel);
  114.         virtual void                ObjectInitClient(EntityId id, INetChannel* pChannel);
  115.         virtual bool                SendPostSpawnObject(EntityId id, INetChannel* pChannel);
  116.         virtual uint8               GetDefaultProfileForAspect(EntityId id, NetworkAspectType aspectID);
  117.         virtual bool                SetAspectProfile(EntityId id, NetworkAspectType nAspect, uint8 profile);
  118.         virtual void                BoundObject(EntityId id, NetworkAspectType nAspects);
  119.         virtual void                UnboundObject(EntityId id);
  120.         virtual INetAtSyncItem*     HandleRMI(bool bClient, EntityId objID, uint8 funcID, TSerialize ser, INetChannel* pChannel);
  121.         virtual void                ControlObject(EntityId id, bool bHaveControl);
  122.         virtual void                PassDemoPlaybackMappedOriginalServerPlayer(EntityId id);
  123.         virtual void                OnStartNetworkFrame();
  124.         virtual void                OnEndNetworkFrame();
  125.         virtual void                ReconfigureGame(INetChannel* pNetChannel);
  126.         virtual uint32              HashAspect(EntityId id, NetworkAspectType nAspect);
  127.         virtual CTimeValue          GetPhysicsTime();
  128.         virtual void                BeginUpdateObjects(CTimeValue physTime, INetChannel* pChannel);
  129.         virtual void                EndUpdateObjects();
  130.         virtual void                PlaybackBreakage(int breakId, INetBreakagePlaybackPtr pBreakage);
  131.         virtual void*               ReceiveSimpleBreakage(TSerialize ser);
  132.         virtual void                PlaybackSimpleBreakage(void* userData, INetBreakageSimplePlaybackPtr pBreakage);
  133.         virtual void                CompleteUnbind(EntityId id);
  134.         // ~IGameContext
  135.  
  136.         // IGameQuery
  137.         XmlNodeRef GetGameState();
  138.         // ~IGameQuery
  139.  
  140.         // IEntitySystemSink
  141.         virtual bool OnBeforeSpawn(SEntitySpawnParams& params);
  142.         virtual void OnSpawn(IEntity* pEntity, SEntitySpawnParams& params);
  143.         virtual bool OnRemove(IEntity* pEntity);
  144.         virtual void OnReused(IEntity* pEntity, SEntitySpawnParams& params);
  145.         virtual void OnEvent(IEntity* pEntity, SEntityEvent& event);
  146.         // ~IEntitySystemSink
  147.  
  148.         // IConsoleVarSink
  149.         virtual bool OnBeforeVarChange(ICVar* pVar, const char* sNewValue);
  150.         virtual void OnAfterVarChange(ICVar* pVar);
  151.         // ~IConsoleVarSink
  152.  
  153.         // IHostMigrationEventListener
  154.         virtual EHostMigrationReturn OnInitiate(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  155.         virtual EHostMigrationReturn OnDisconnectClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  156.         virtual EHostMigrationReturn OnDemoteToClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  157.         virtual EHostMigrationReturn OnPromoteToServer(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  158.         virtual EHostMigrationReturn OnReconnectClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  159.         virtual EHostMigrationReturn OnFinalise(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  160.         virtual EHostMigrationReturn OnTerminate(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  161.         virtual void                 OnComplete(SHostMigrationInfo& hostMigrationInfo) {}
  162.         virtual EHostMigrationReturn OnReset(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  163.         // ~IHostMigrationEventListener
  164.  
  165.         INetContext*          GetNetContext()           { return m_pNetContext; }
  166.         CCryAction*           GetFramework()            { return m_pFramework; }
  167.         bool                  IsGameStarted() const     { return m_bStarted; }
  168.         bool                  IsInLevelLoad() const     { return m_isInLevelLoad; }
  169.         bool                  IsLoadingSaveGame() const { return m_bIsLoadingSaveGame; };
  170.  
  171.         SParsedConnectionInfo ParseConnectionInfo(const string& s);
  172.  
  173.         void                  SetLoadingSaveGame() { m_bIsLoadingSaveGame = true; }
  174.  
  175.         void                  OnBrokeSomething(const SBreakEvent& be, EventPhysMono* pMono, bool isPlane);
  176.         void                  PhysSimulateExplosion(pe_explosion* pexpl, IPhysicalEntity** pSkipEnts, int nSkipEnts, int iTypes);
  177.  
  178.         void                  ResetMap(bool isServer);
  179.         bool                  SetImmersive(bool immersive);
  180.  
  181.         string                GetLevelName()                      { return m_levelName; }
  182.         string                GetRequestedGameRules()             { return m_gameRules; }
  183.  
  184.         void                  SetLevelName(const char* levelName) { m_levelName = levelName; }
  185.         void                  SetGameRules(const char* gameRules) { m_gameRules = gameRules; }
  186.  
  187.         void                  SetPhysicsSync(CPhysicsSync* pSync) { m_pPhysicsSync = pSync; }
  188.  
  189.         // public so that GameClientChannel can call it
  190.         // -- registers a class in our class name <-> id database
  191.         bool   RegisterClassName(const string& name, uint16 id);
  192.         uint32 GetClassesHash();
  193.         void   DumpClasses();
  194.  
  195.         bool   Update();
  196.  
  197.         bool   ClassNameFromId(string& name, uint16 id) const;
  198.         bool   ClassIdFromName(uint16& id, const string& name) const;
  199.  
  200.         void   ChangedScript(EntityId id)
  201.         {
  202.                 m_pNetContext->ChangedAspects(id, eEA_Script);
  203.         }
  204.         void   EnablePhysics(EntityId id, bool enable);
  205.  
  206.         bool   ChangeContext(bool isServer, const SGameContextParams* pParams);
  207.  
  208.         void   SetContextInfo(unsigned flags, uint16 port, const char* connectionString);
  209.         bool   HasContextFlag(EGameStartFlags flag) const { return (m_flags & flag) != 0; }
  210.         uint16 GetServerPort() const                      { return m_port; }
  211.         string GetConnectionString(CryFixedStringT<HOST_MIGRATION_MAX_PLAYER_NAME_SIZE>* pNameOverride, bool fake) const;
  212.  
  213.         void   DefineContextProtocols(IProtocolBuilder* pBuilder, bool server);
  214.  
  215.         bool   ControlsEntity(EntityId id) const
  216.         {
  217.                 return m_controlledObjects.Get(id);
  218.         }
  219.  
  220.         void        EnableAspects(EntityId id, NetworkAspectType aspects, bool bEnable);
  221.         void        AddControlObjectCallback(EntityId id, bool willHaveControl, HSCRIPTFUNCTION func);
  222.  
  223.         static void RegisterExtensions(IGameFramework* pFW);
  224.  
  225.         void        AllowCallOnClientConnect();
  226.  
  227.         void        GetMemoryUsage(ICrySizer* pSizer) const;
  228.         void        GetMemoryStatistics(ICrySizer* pSizer) { GetMemoryUsage(pSizer); /*dummy till network module is updated*/ }
  229.         void        LockResources();
  230.         void        UnlockResources();
  231.  
  232. #if ENABLE_NETDEBUG
  233.         CNetDebug* GetNetDebug() { return m_pNetDebug; }
  234. #endif
  235.  
  236. private:
  237.         static IEntity* GetEntity(int i, void* p)
  238.         {
  239.                 if (i == PHYS_FOREIGN_ID_ENTITY)
  240.                         return (IEntity*)p;
  241.                 return NULL;
  242.         }
  243.  
  244.         IGameRules* GetGameRules();
  245.  
  246.         void        BeginChangeContext(const string& levelName);
  247.         void        CallOnClientEnteredGame(CGameServerChannel*);
  248.         void        CallOnSpawnComplete(IEntity* pEntity);
  249.         bool        HasSpawnPoint();
  250.  
  251.         void        AddLoadLevelTasks(IContextEstablisher* pEst, bool isServer, int flags, bool** ppLoadingStarted, int establishedToken, bool bChannelIsMigrating);
  252.         void        AddLoadingCompleteTasks(IContextEstablisher* pEst, int flags, bool* pLoadingStarted, bool bChannelIsMigrating);
  253.         std::set<INetChannel*> m_resetChannels;
  254.  
  255.         enum EEstablishmentFlags
  256.         {
  257.                 eEF_LevelLoaded  = 1 << 0,
  258.                 eEF_LoadNewLevel = 1 << 1,
  259.                 eEF_DemoPlayback = 1 << 2
  260.         };
  261.  
  262.         static const int EstablishmentFlags_InitialLoad = eEF_LoadNewLevel;
  263.         static const int EstablishmentFlags_LoadNextLevel = eEF_LoadNewLevel | eEF_LevelLoaded;
  264.         static const int EstablishmentFlags_ResetMap = eEF_LevelLoaded;
  265.  
  266.         int              m_loadFlags;
  267.  
  268.         static void OnCollision(const EventPhys* pEvent, void*);
  269.  
  270.         // singleton
  271.         static CGameContext* s_pGameContext;
  272.  
  273.         IEntitySystem*       m_pEntitySystem;
  274.         IPhysicalWorld*      m_pPhysicalWorld;
  275.         IActorSystem*        m_pActorSystem;
  276.         INetContext*         m_pNetContext;
  277.         CCryAction*          m_pFramework;
  278.         CActionGame*         m_pGame;
  279.         CScriptRMI*          m_pScriptRMI;
  280.         CPhysicsSync*        m_pPhysicsSync;
  281. #ifndef OLD_VOICE_SYSTEM_DEPRECATED
  282.         CVoiceController*    m_pVoiceController;
  283. #endif
  284. #if ENABLE_NETDEBUG
  285.         CNetDebug* m_pNetDebug;
  286. #endif
  287.  
  288.         CClassRegistryReplicator     m_classRegistry;
  289.  
  290.         SensedInclusionSet<EntityId> m_controlledObjects;
  291.  
  292.         // context parameters
  293.         string   m_levelName;
  294.         string   m_gameRules;
  295.  
  296.         unsigned m_flags;
  297.         uint16   m_port;
  298.         string   m_connectionString;
  299.         bool     m_isInLevelLoad;
  300.         bool     m_bStarted;
  301.         bool     m_bIsLoadingSaveGame;
  302.         bool     m_bHasSpawnPoint;
  303.         bool     m_bAllowSendClientConnect;
  304.         int      m_resourceLocks;
  305.         int      m_removeObjectUnlocks;
  306.         int      m_broadcastActionEventInGame;
  307.         friend class CScopedRemoveObjectUnlock;
  308.  
  309.         struct SDelegateCallbackIndex
  310.         {
  311.                 EntityId id;
  312.                 bool     bHaveControl;
  313.                 bool operator<(const SDelegateCallbackIndex& rhs) const
  314.                 {
  315.                         return bHaveControl < rhs.bHaveControl || (id < rhs.id);
  316.                 }
  317.                 bool operator==(const SDelegateCallbackIndex& rhs) const
  318.                 {
  319.                         return (bHaveControl == rhs.bHaveControl) && (id == rhs.id);
  320.                 }
  321.  
  322.                 void GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  323.         };
  324.         typedef std::multimap<SDelegateCallbackIndex, HSCRIPTFUNCTION> DelegateCallbacks;
  325.         DelegateCallbacks                    m_delegateCallbacks;
  326.  
  327.         std::unique_ptr<IContextEstablisher> m_pContextEstablisher;
  328.         std::unique_ptr<CBreakReplicator>    m_pBreakReplicator;
  329. };
  330.  
  331. class CScopedRemoveObjectUnlock
  332. {
  333. public:
  334.         CScopedRemoveObjectUnlock(CGameContext* pCtx) : m_pCtx(pCtx) { pCtx->m_removeObjectUnlocks++; }
  335.         ~CScopedRemoveObjectUnlock() { m_pCtx->m_removeObjectUnlocks--; }
  336.  
  337. private:
  338.         CScopedRemoveObjectUnlock(const CScopedRemoveObjectUnlock&);
  339.         CScopedRemoveObjectUnlock& operator=(const CScopedRemoveObjectUnlock&);
  340.  
  341.         CGameContext* m_pCtx;
  342. };
  343.  
  344. #endif //__GameContext_H__
  345.  
downloadGameContext.h 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