BVB Source Codes

CRYENGINE Show CryAction.h Source code

Return Download CRYENGINE: download CryAction.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: Implementation of the IGameFramework interface. CCryAction
  8.                 provides a generic game framework for action based games
  9.                 such as 1st and 3rd person shooters.
  10.  
  11.    -------------------------------------------------------------------------
  12.    History:
  13.    - 20:7:2004   10:51 : Created by Marco Koegler
  14.    - 3:8:2004           11:11 : Taken-over by Marcio Martins
  15.  
  16. *************************************************************************/
  17. #ifndef __CRYACTION_H__
  18. #define __CRYACTION_H__
  19.  
  20. #if _MSC_VER > 1000
  21.         #pragma once
  22. #endif
  23.  
  24. #include <CrySystem/ISystem.h>
  25. #include <CrySystem/ICmdLine.h>
  26.  
  27. #include <CryGame/IGameFramework.h>
  28. #include <CrySystem/File/ICryPak.h>
  29. #include "ISaveGame.h"
  30. #include <CrySystem/ITestSystem.h>
  31.  
  32. struct IFlowSystem;
  33. struct IGameTokenSystem;
  34. struct IEffectSystem;
  35. struct IBreakableGlassSystem;
  36. struct IForceFeedbackSystem;
  37. struct IGameVolumes;
  38.  
  39. class CAIDebugRenderer;
  40. class CAINetworkDebugRenderer;
  41. class CGameRulesSystem;
  42. class CScriptBind_Action;
  43. class CScriptBind_ActorSystem;
  44. class CScriptBind_ItemSystem;
  45. class CScriptBind_ActionMapManager;
  46. class CScriptBind_Network;
  47. class CScriptBind_VehicleSystem;
  48. class CScriptBind_Vehicle;
  49. class CScriptBind_VehicleSeat;
  50. class CScriptBind_Inventory;
  51. class CScriptBind_DialogSystem;
  52. class CScriptBind_MaterialEffects;
  53. class CScriptBind_UIAction;
  54.  
  55. class CFlowSystem;
  56. class CDevMode;
  57. class CTimeDemoRecorder;
  58. class CGameQueryListener;
  59. class CScriptRMI;
  60. class CGameSerialize;
  61. class CMaterialEffects;
  62. class CMaterialEffectsCVars;
  63. class CGameObjectSystem;
  64. class CActionMapManager;
  65. class CActionGame;
  66. class CActorSystem;
  67. class CallbackTimer;
  68. class CGameClientNub;
  69. class CGameContext;
  70. class CGameServerNub;
  71. class CItemSystem;
  72. class CLevelSystem;
  73. class CUIDraw;
  74. class CVehicleSystem;
  75. class CViewSystem;
  76. class CGameplayRecorder;
  77. class CPersistantDebug;
  78. class CPlayerProfileManager;
  79. class CDialogSystem;
  80. class CSubtitleManager;
  81. class CGameplayAnalyst;
  82. class CTimeOfDayScheduler;
  83. class CNetworkCVars;
  84. class CCryActionCVars;
  85. class CGameStatsConfig;
  86. class CSignalTimer;
  87. class CRangeSignaling;
  88. class CAIProxy;
  89. class CommunicationVoiceLibrary;
  90. class CCustomActionManager;
  91. class CCustomEventManager;
  92. class CAIProxyManager;
  93. class CForceFeedBackSystem;
  94. class CCryActionPhysicQueues;
  95. class CNetworkStallTickerThread;
  96. class CSharedParamsManager;
  97. struct ICooperativeAnimationManager;
  98. struct IGameSessionHandler;
  99. class CRuntimeAreaManager;
  100. class CColorGradientManager;
  101.  
  102. struct CAnimationGraphCVars;
  103. struct IRealtimeRemoteUpdate;
  104. struct ISerializeHelper;
  105. struct ITimeDemoRecorder;
  106.  
  107. class CSegmentedWorld;
  108.  
  109. class CNetMessageDistpatcher;
  110. class CManualFrameStepController;
  111.  
  112. class CCryAction :
  113.         public IGameFramework
  114. {
  115.  
  116. public:
  117.         CCryAction();
  118.  
  119.         // IGameFramework
  120.         void                                  ClearTimers();
  121.         virtual TimerID                       AddTimer(CTimeValue interval, bool repeat, TimerCallback callback, void* userdata);
  122.         virtual void*                         RemoveTimer(TimerID timerID);
  123.  
  124.         virtual uint32                        GetPreUpdateTicks();
  125.  
  126.         virtual void                          RegisterFactory(const char* name, IActorCreator* pCreator, bool isAI);
  127.         virtual void                          RegisterFactory(const char* name, IItemCreator* pCreator, bool isAI);
  128.         virtual void                          RegisterFactory(const char* name, IVehicleCreator* pCreator, bool isAI);
  129.         virtual void                          RegisterFactory(const char* name, IGameObjectExtensionCreator* pCreator, bool isAI);
  130.         virtual void                          RegisterFactory(const char* name, ISaveGame*(*func)(), bool);
  131.         virtual void                          RegisterFactory(const char* name, ILoadGame*(*func)(), bool);
  132.  
  133.         virtual bool                          StartEngine(SSystemInitParams& startupParams);
  134.         virtual void                          InitGameType(bool multiplayer, bool fromInit);
  135.         virtual bool                          CompleteInit();
  136.         virtual void                          ShutdownEngine();
  137.         virtual void                          ShutdownEngineFast();
  138.         virtual void                          PrePhysicsUpdate() /*override*/;
  139.         virtual int                           ManualFrameUpdate(bool haveFocus, unsigned int updateFlags);
  140.         virtual void                          Reset(bool clients);
  141.         virtual void                          GetMemoryUsage(ICrySizer* pSizer) const;
  142.  
  143.         virtual void                          PauseGame(bool pause, bool force, unsigned int nFadeOutInMS = 0);
  144.         virtual bool                          IsGamePaused();
  145.         virtual bool                          IsGameStarted();
  146.         virtual bool                          IsInLevelLoad();
  147.         virtual bool                          IsLoadingSaveGame();
  148.         virtual const char*                   GetLevelName();
  149.         virtual void                          GetAbsLevelPath(char* pPathBuffer, uint32 pathBufferSize);
  150.         virtual bool                          IsInTimeDemo();        // Check if time demo is in progress (either playing or recording);
  151.         virtual bool                          IsTimeDemoRecording(); // Check if time demo is recording;
  152.  
  153.         virtual ISystem*                      GetISystem()           { return m_pSystem; };
  154.         virtual ILanQueryListener*            GetILanQueryListener() { return m_pLanQueryListener; }
  155.         virtual IUIDraw*                      GetIUIDraw();
  156.         virtual IMannequin&                   GetMannequinInterface();
  157.         virtual ILevelSystem*                 GetILevelSystem();
  158.         virtual IActorSystem*                 GetIActorSystem();
  159.         virtual IItemSystem*                  GetIItemSystem();
  160.         virtual IBreakReplicator*             GetIBreakReplicator();
  161.         virtual IVehicleSystem*               GetIVehicleSystem();
  162.         virtual IActionMapManager*            GetIActionMapManager();
  163.         virtual IViewSystem*                  GetIViewSystem();
  164.         virtual IGameplayRecorder*            GetIGameplayRecorder();
  165.         virtual IGameRulesSystem*             GetIGameRulesSystem();
  166.         virtual IGameObjectSystem*            GetIGameObjectSystem();
  167.         virtual IFlowSystem*                  GetIFlowSystem();
  168.         virtual IGameTokenSystem*             GetIGameTokenSystem();
  169.         virtual IEffectSystem*                GetIEffectSystem();
  170.         virtual IMaterialEffects*             GetIMaterialEffects();
  171.         virtual IBreakableGlassSystem*        GetIBreakableGlassSystem();
  172.         virtual IPlayerProfileManager*        GetIPlayerProfileManager();
  173.         virtual ISubtitleManager*             GetISubtitleManager();
  174.         virtual IDialogSystem*                GetIDialogSystem();
  175.         virtual ICooperativeAnimationManager* GetICooperativeAnimationManager();
  176.         virtual ICheckpointSystem*            GetICheckpointSystem();
  177.         virtual IForceFeedbackSystem*         GetIForceFeedbackSystem() const;
  178.         virtual ICustomActionManager*         GetICustomActionManager() const;
  179.         virtual ICustomEventManager*          GetICustomEventManager() const;
  180.         virtual IRealtimeRemoteUpdate*        GetIRealTimeRemoteUpdate();
  181.         virtual ITimeDemoRecorder*            GetITimeDemoRecorder() const;
  182.  
  183.         virtual bool                          StartGameContext(const SGameStartParams* pGameStartParams);
  184.         virtual bool                          ChangeGameContext(const SGameContextParams* pGameContextParams);
  185.         virtual void                          EndGameContext();
  186.         virtual bool                          StartedGameContext() const;
  187.         virtual bool                          StartingGameContext() const;
  188.         virtual bool                          BlockingSpawnPlayer();
  189.  
  190.         virtual void                          ReleaseGameStats();
  191.  
  192.         virtual void                          ResetBrokenGameObjects();
  193.         virtual void                          CloneBrokenObjectsAndRevertToStateAtTime(int32 iFirstBreakEventIndex, uint16* pBreakEventIndices, int32& iNumBreakEvents, IRenderNode** outClonedNodes, int32& iNumClonedNodes, SRenderNodeCloneLookup& renderNodeLookup);
  194.         virtual void                          ApplySingleProceduralBreakFromEventIndex(uint16 uBreakEventIndex, const SRenderNodeCloneLookup& renderNodeLookup);
  195.         virtual void                          UnhideBrokenObjectsByIndex(uint16* ObjectIndicies, int32 iNumObjectIndices);
  196.  
  197.         void                                  Serialize(TSerialize ser); // defined in ActionGame.cpp
  198.         virtual void                          FlushBreakableObjects();   // defined in ActionGame.cpp
  199.         void                                  ClearBreakHistory();
  200.  
  201.         virtual void                          InitEditor(IGameToEditorInterface* pGameToEditor);
  202.         virtual void                          SetEditorLevel(const char* levelName, const char* levelFolder);
  203.         virtual void                          GetEditorLevel(char** levelName, char** levelFolder);
  204.  
  205.         virtual void                          BeginLanQuery();
  206.         virtual void                          EndCurrentQuery();
  207.  
  208.         virtual IActor*                       GetClientActor() const;
  209.         virtual EntityId                      GetClientActorId() const;
  210.         virtual IEntity*                      GetClientEntity() const;
  211.         virtual EntityId                      GetClientEntityId() const;
  212.         virtual INetChannel*                  GetClientChannel() const;
  213.         virtual CTimeValue                    GetServerTime();
  214.         virtual uint16                        GetGameChannelId(INetChannel* pNetChannel);
  215.         virtual INetChannel*                  GetNetChannel(uint16 channelId);
  216.         virtual bool                          IsChannelOnHold(uint16 channelId);
  217.         virtual IGameObject*                  GetGameObject(EntityId id);
  218.         virtual bool                          GetNetworkSafeClassId(uint16& id, const char* className);
  219.         virtual bool                          GetNetworkSafeClassName(char* className, size_t classNameSizeInBytes, uint16 id);
  220.         virtual IGameObjectExtension*         QueryGameObjectExtension(EntityId id, const char* name);
  221.  
  222.         virtual void                          DelegateAuthority(EntityId entityId, uint16 channelId);
  223.  
  224.         virtual INetContext*                  GetNetContext();
  225.  
  226.         virtual bool                          SaveGame(const char* path, bool bQuick = false, bool bForceImmediate = false, ESaveGameReason reason = eSGR_QuickSave, bool ignoreDelay = false, const char* checkpointName = NULL);
  227.         virtual ELoadGameResult               LoadGame(const char* path, bool quick = false, bool ignoreDelay = false);
  228.         virtual TSaveGameName                 CreateSaveGameName();
  229.  
  230.         virtual void                          ScheduleEndLevel(const char* nextLevel = "");
  231.         virtual void                          ScheduleEndLevelNow(const char* nextLevel);
  232.  
  233.         virtual void                          OnEditorSetGameMode(int iMode);
  234.         virtual bool                          IsEditing() { return m_isEditing; }
  235.  
  236.         virtual void                          OnBreakageSpawnedEntity(IEntity* pEntity, IPhysicalEntity* pPhysEntity, IPhysicalEntity* pSrcPhysEntity);
  237.  
  238.         bool                                  IsImmersiveMPEnabled();
  239.  
  240.         virtual void                          AllowSave(bool bAllow = true)
  241.         {
  242.                 m_bAllowSave = bAllow;
  243.         }
  244.  
  245.         virtual void AllowLoad(bool bAllow = true)
  246.         {
  247.                 m_bAllowLoad = bAllow;
  248.         }
  249.  
  250.         virtual bool                  CanSave();
  251.         virtual bool                  CanLoad();
  252.  
  253.         virtual ISerializeHelper*     GetSerializeHelper() const;
  254.  
  255.         virtual bool                  CanCheat();
  256.  
  257.         INetNub*                      GetServerNetNub();
  258.         INetNub*                      GetClientNetNub();
  259.  
  260.         void                          SetGameGUID(const char* gameGUID);
  261.         const char*                   GetGameGUID()             { return m_gameGUID; }
  262.  
  263.         virtual bool                  IsVoiceRecordingEnabled() { return m_VoiceRecordingEnabled != 0; }
  264.  
  265.         virtual bool                  IsGameSession(CrySessionHandle sessionHandle);
  266.         virtual bool                  ShouldMigrateNub(CrySessionHandle sessionHandle);
  267.  
  268.         virtual ISharedParamsManager* GetISharedParamsManager();
  269.  
  270.         virtual IGame*                GetIGame();
  271.  
  272.         virtual float                 GetLoadSaveDelay() const { return m_lastSaveLoad; }
  273.  
  274.         virtual IGameVolumes*         GetIGameVolumesManager() const;
  275.  
  276.         virtual void                  PreloadAnimatedCharacter(IScriptTable* pEntityScript);
  277.         virtual void                  PrePhysicsTimeStep(float deltaTime);
  278.  
  279.         virtual void                  RegisterExtension(ICryUnknownPtr pExtension);
  280.         virtual void                  ReleaseExtensions();
  281. protected:
  282.         virtual ICryUnknownPtr        QueryExtensionInterfaceById(const CryInterfaceID& interfaceID) const;
  283.         // ~IGameFramework
  284.  
  285. public:
  286.  
  287.         static CCryAction*          GetCryAction() { return m_pThis; }
  288.  
  289.         bool                        ControlsEntity(EntityId id) const;
  290.  
  291.         virtual CGameServerNub*     GetGameServerNub();
  292.         CGameClientNub*             GetGameClientNub();
  293.         CGameContext*               GetGameContext();
  294.         CScriptBind_Vehicle*        GetVehicleScriptBind()     { return m_pScriptBindVehicle; }
  295.         CScriptBind_VehicleSeat*    GetVehicleSeatScriptBind() { return m_pScriptBindVehicleSeat; }
  296.         CScriptBind_Inventory*      GetInventoryScriptBind()   { return m_pScriptInventory; }
  297.         CPersistantDebug*           GetPersistantDebug()       { return m_pPersistantDebug; }
  298.         CSignalTimer*               GetSignalTimer();
  299.         CRangeSignaling*            GetRangeSignaling();
  300.         virtual IPersistantDebug*   GetIPersistantDebug();
  301.         virtual IGameStatsConfig*   GetIGameStatsConfig();
  302.         CColorGradientManager*      GetColorGradientManager() const { return m_pColorGradientManager; }
  303.  
  304.         virtual void                AddBreakEventListener(IBreakEventListener* pListener);
  305.         virtual void                RemoveBreakEventListener(IBreakEventListener* pListener);
  306.  
  307.         void                        OnBreakEvent(uint16 uBreakEventIndex);
  308.         void                        OnPartRemoveEvent(int32 iPartRemoveEventIndex);
  309.  
  310.         virtual void                RegisterListener(IGameFrameworkListener* pGameFrameworkListener, const char* name, EFRAMEWORKLISTENERPRIORITY eFrameworkListenerPriority);
  311.         virtual void                UnregisterListener(IGameFrameworkListener* pGameFrameworkListener);
  312.  
  313.         CDialogSystem*              GetDialogSystem()             { return m_pDialogSystem; }
  314.         CTimeOfDayScheduler*        GetTimeOfDayScheduler() const { return m_pTimeOfDayScheduler; }
  315.  
  316.         CGameStatsConfig*           GetGameStatsConfig();
  317.         IGameStatistics*            GetIGameStatistics();
  318.  
  319.         IGameSessionHandler*        GetIGameSessionHandler();
  320.         void                        SetGameSessionHandler(IGameSessionHandler* pSessionHandler);
  321.  
  322.         CNetMessageDistpatcher*     GetNetMessageDispatcher()      { return m_pNetMsgDispatcher; }
  323.         CManualFrameStepController* GetManualFrameStepController() { return m_pManualFrameStepController; }
  324.  
  325.         //      INetQueryListener* GetLanQueryListener() {return m_pLanQueryListener;}
  326.         bool                          LoadingScreenEnabled() const;
  327.  
  328.         int                           NetworkExposeClass(IFunctionHandler* pFH);
  329.  
  330.         void                          NotifyGameFrameworkListeners(ISaveGame* pSaveGame);
  331.         void                          NotifyGameFrameworkListeners(ILoadGame* pLoadGame);
  332.         void                          NotifySavegameFileLoadedToListeners(const char* pLevelName);
  333.         void                          NotifyForceFlashLoadingListeners();
  334.         virtual void                  EnableVoiceRecording(const bool enable);
  335.         virtual void                  MutePlayerById(EntityId mutePlayer);
  336.         virtual IDebugHistoryManager* CreateDebugHistoryManager();
  337.         virtual void                  ExecuteCommandNextFrame(const char* cmd);
  338.         virtual const char*           GetNextFrameCommand() const;
  339.         virtual void                  ClearNextFrameCommand();
  340.         virtual void                  PrefetchLevelAssets(const bool bEnforceAll);
  341.  
  342.         virtual void                  ShowPageInBrowser(const char* URL);
  343.         virtual bool                  StartProcess(const char* cmd_line);
  344.         virtual bool                  SaveServerConfig(const char* path);
  345.  
  346.         void                          OnActionEvent(const SActionEvent& ev);
  347.  
  348.         bool                          IsPbSvEnabled() const { return m_pbSvEnabled; }
  349.         bool                          IsPbClEnabled() const { return m_pbClEnabled; }
  350.  
  351.         void                          DumpMemInfo(const char* format, ...) PRINTF_PARAMS(2, 3);
  352.  
  353.         const char*                   GetStartLevelSaveGameName();
  354.  
  355.         virtual IAIActorProxy*        GetAIActorProxy(EntityId entityid) const;
  356.         CAIProxyManager*              GetAIProxyManager()       { return m_pAIProxyManager; }
  357.         const CAIProxyManager*        GetAIProxyManager() const { return m_pAIProxyManager; }
  358.  
  359.         void                          CreatePhysicsQueues();
  360.         void                          ClearPhysicsQueues();
  361.         CCryActionPhysicQueues& GetPhysicQueues();
  362.         bool                    IsGameSessionMigrating();
  363.  
  364.         void                    StartNetworkStallTicker(bool includeMinimalUpdate);
  365.         void                    StopNetworkStallTicker();
  366.         void                    GoToSegment(int x, int y);
  367.  
  368.         bool                    PreUpdate(bool haveFocus, unsigned int updateFlags);
  369.         int                     Update(bool haveFocus, unsigned int updateFlags);
  370.         void                    PostUpdate(bool haveFocus, unsigned int updateFlags);
  371.  
  372. private:
  373.         void InitScriptBinds();
  374.         void ReleaseScriptBinds();
  375.  
  376.         bool InitGame(SSystemInitParams& startupParams);
  377.         bool ShutdownGame();
  378.  
  379.         int  Run(const char* szAutoStartLevelName);
  380.  
  381.         void InitForceFeedbackSystem();
  382.         void InitGameVolumesManager();
  383.  
  384.         void InitCVars();
  385.         void ReleaseCVars();
  386.  
  387.         void InitCommands();
  388.  
  389.         // TODO: remove
  390.         static void FlowTest(IConsoleCmdArgs*);
  391.  
  392.         // console commands provided by CryAction
  393.         static void DumpMapsCmd(IConsoleCmdArgs* args);
  394.         static void MapCmd(IConsoleCmdArgs* args);
  395.         static void ReloadReadabilityXML(IConsoleCmdArgs* args);
  396.         static void UnloadCmd(IConsoleCmdArgs* args);
  397.         static void PlayCmd(IConsoleCmdArgs* args);
  398.         static void ConnectCmd(IConsoleCmdArgs* args);
  399.         static void DisconnectCmd(IConsoleCmdArgs* args);
  400.         static void DisconnectChannelCmd(IConsoleCmdArgs* args);
  401.         static void StatusCmd(IConsoleCmdArgs* args);
  402.         static void LegacyStatusCmd(IConsoleCmdArgs* args);
  403.         static void VersionCmd(IConsoleCmdArgs* args);
  404.         static void SaveTagCmd(IConsoleCmdArgs* args);
  405.         static void LoadTagCmd(IConsoleCmdArgs* args);
  406.         static void SaveGameCmd(IConsoleCmdArgs* args);
  407.         static void GenStringsSaveGameCmd(IConsoleCmdArgs* args);
  408.         static void LoadGameCmd(IConsoleCmdArgs* args);
  409.         static void KickPlayerCmd(IConsoleCmdArgs* args);
  410.         static void LegacyKickPlayerCmd(IConsoleCmdArgs* args);
  411.         static void KickPlayerByIdCmd(IConsoleCmdArgs* args);
  412.         static void LegacyKickPlayerByIdCmd(IConsoleCmdArgs* args);
  413.         static void BanPlayerCmd(IConsoleCmdArgs* args);
  414.         static void LegacyBanPlayerCmd(IConsoleCmdArgs* args);
  415.         static void BanStatusCmd(IConsoleCmdArgs* args);
  416.         static void LegacyBanStatusCmd(IConsoleCmdArgs* args);
  417.         static void UnbanPlayerCmd(IConsoleCmdArgs* args);
  418.         static void LegacyUnbanPlayerCmd(IConsoleCmdArgs* args);
  419.         static void OpenURLCmd(IConsoleCmdArgs* args);
  420.         static void TestResetCmd(IConsoleCmdArgs* args);
  421.  
  422.         static void DumpAnalysisStatsCmd(IConsoleCmdArgs* args);
  423.  
  424. #if !defined(_RELEASE)
  425.         static void ConnectRepeatedlyCmd(IConsoleCmdArgs* args);
  426. #endif
  427.  
  428.         static void TestTimeout(IConsoleCmdArgs* args);
  429.         static void TestNSServerBrowser(IConsoleCmdArgs* args);
  430.         static void TestNSServerReport(IConsoleCmdArgs* args);
  431.         static void TestNSChat(IConsoleCmdArgs* args);
  432.         static void TestNSStats(IConsoleCmdArgs* args);
  433.         static void TestNSNat(IConsoleCmdArgs* args);
  434.         static void TestPlayerBoundsCmd(IConsoleCmdArgs* args);
  435.         static void DelegateCmd(IConsoleCmdArgs* args);
  436.         static void DumpStatsCmd(IConsoleCmdArgs* args);
  437.  
  438.         // console commands for the remote control system
  439.         //static void rcon_password(IConsoleCmdArgs* args);
  440.         static void rcon_startserver(IConsoleCmdArgs* args);
  441.         static void rcon_stopserver(IConsoleCmdArgs* args);
  442.         static void rcon_connect(IConsoleCmdArgs* args);
  443.         static void rcon_disconnect(IConsoleCmdArgs* args);
  444.         static void rcon_command(IConsoleCmdArgs* args);
  445.  
  446.         static struct IRemoteControlServer* s_rcon_server;
  447.         static struct IRemoteControlClient* s_rcon_client;
  448.  
  449.         static class CRConClientListener*   s_rcon_client_listener;
  450.  
  451.         //static string s_rcon_password;
  452.  
  453.         // console commands for the simple http server
  454.         static void http_startserver(IConsoleCmdArgs* args);
  455.         static void http_stopserver(IConsoleCmdArgs* args);
  456.  
  457.         static struct ISimpleHttpServer* s_http_server;
  458.  
  459.         // change the game query (better than setting it explicitly)
  460.         void SetGameQueryListener(CGameQueryListener*);
  461.  
  462.         void CheckEndLevelSchedule();
  463.  
  464. #if !defined(_RELEASE)
  465.         void CheckConnectRepeatedly();
  466. #endif
  467.  
  468.         static void MutePlayer(IConsoleCmdArgs* pArgs);
  469.  
  470.         static void VerifyMaxPlayers(ICVar* pVar);
  471.         static void ResetComments(ICVar* pVar);
  472.  
  473.         static void StaticSetPbSvEnabled(IConsoleCmdArgs* pArgs);
  474.         static void StaticSetPbClEnabled(IConsoleCmdArgs* pArgs);
  475.  
  476.         // NOTE: anything owned by this class should be a pointer or a simple
  477.         // type - nothing that will need its constructor called when CryAction's
  478.         // constructor is called (we don't have access to malloc() at that stage)
  479.  
  480.         bool                          m_paused;
  481.         bool                          m_forcedpause;
  482.  
  483.         static CCryAction*            m_pThis;
  484.  
  485.         ISystem*                      m_pSystem;
  486.         INetwork*                     m_pNetwork;
  487.         I3DEngine*                    m_p3DEngine;
  488.         IScriptSystem*                m_pScriptSystem;
  489.         IEntitySystem*                m_pEntitySystem;
  490.         ITimer*                       m_pTimer;
  491.         ILog*                         m_pLog;
  492.         void*                         m_systemDll;
  493.  
  494.         _smart_ptr<CActionGame>       m_pGame;
  495.  
  496.         char                          m_editorLevelName[512]; // to avoid having to call string constructor, or allocating memory.
  497.         char                          m_editorLevelFolder[512];
  498.         char                          m_gameGUID[128];
  499.  
  500.         CLevelSystem*                 m_pLevelSystem;
  501.         CActorSystem*                 m_pActorSystem;
  502.         CItemSystem*                  m_pItemSystem;
  503.         CVehicleSystem*               m_pVehicleSystem;
  504.         CSharedParamsManager*         m_pSharedParamsManager;
  505.         CActionMapManager*            m_pActionMapManager;
  506.         CViewSystem*                  m_pViewSystem;
  507.         CGameplayRecorder*            m_pGameplayRecorder;
  508.         CGameRulesSystem*             m_pGameRulesSystem;
  509.         CFlowSystem*                  m_pFlowSystem;
  510.         CGameObjectSystem*            m_pGameObjectSystem;
  511.         CUIDraw*                      m_pUIDraw;
  512.         CScriptRMI*                   m_pScriptRMI;
  513.         CAnimationGraphCVars*         m_pAnimationGraphCvars;
  514.         IMannequin*                   m_pMannequin;
  515.         CMaterialEffects*             m_pMaterialEffects;
  516.         IBreakableGlassSystem*        m_pBreakableGlassSystem;
  517.         CPlayerProfileManager*        m_pPlayerProfileManager;
  518.         CDialogSystem*                m_pDialogSystem;
  519.         CSubtitleManager*             m_pSubtitleManager;
  520.         IGameTokenSystem*             m_pGameTokenSystem;
  521.         IEffectSystem*                m_pEffectSystem;
  522.         CGameSerialize*               m_pGameSerialize;
  523.         CallbackTimer*                m_pCallbackTimer;
  524.         CGameplayAnalyst*             m_pGameplayAnalyst;
  525.         CForceFeedBackSystem*         m_pForceFeedBackSystem;
  526.         //      INetQueryListener *m_pLanQueryListener;
  527.         ILanQueryListener*            m_pLanQueryListener;
  528.         CCustomActionManager*         m_pCustomActionManager;
  529.         CCustomEventManager*          m_pCustomEventManager;
  530.  
  531.         CGameStatsConfig*             m_pGameStatsConfig;
  532.  
  533.         IGameStatistics*              m_pGameStatistics;
  534.  
  535.         ICooperativeAnimationManager* m_pCooperativeAnimationManager;
  536.         IGameSessionHandler*          m_pGameSessionHandler;
  537.  
  538.         CAIProxyManager*              m_pAIProxyManager;
  539.         CSegmentedWorld*              m_pSegmentedWorld;
  540.  
  541.         IGameVolumes*                 m_pGameVolumesManager;
  542.  
  543.         // developer mode
  544.         CDevMode* m_pDevMode;
  545.  
  546.         // TimeDemo recorder.
  547.         CTimeDemoRecorder* m_pTimeDemoRecorder;
  548.  
  549.         // game queries
  550.         CGameQueryListener* m_pGameQueryListener;
  551.  
  552.         // Currently handles the automatic creation of vegetation areas
  553.         CRuntimeAreaManager* m_pRuntimeAreaManager;
  554.  
  555.         // script binds
  556.         CScriptBind_Action*           m_pScriptA;
  557.         CScriptBind_ItemSystem*       m_pScriptIS;
  558.         CScriptBind_ActorSystem*      m_pScriptAS;
  559.         CScriptBind_Network*          m_pScriptNet;
  560.         CScriptBind_ActionMapManager* m_pScriptAMM;
  561.         CScriptBind_VehicleSystem*    m_pScriptVS;
  562.         CScriptBind_Vehicle*          m_pScriptBindVehicle;
  563.         CScriptBind_VehicleSeat*      m_pScriptBindVehicleSeat;
  564.         CScriptBind_Inventory*        m_pScriptInventory;
  565.         CScriptBind_DialogSystem*     m_pScriptBindDS;
  566.         CScriptBind_MaterialEffects*  m_pScriptBindMFX;
  567.         CScriptBind_UIAction*         m_pScriptBindUIAction;
  568.         CTimeOfDayScheduler*          m_pTimeOfDayScheduler;
  569.         CPersistantDebug*             m_pPersistantDebug;
  570.  
  571.         CAIDebugRenderer*             m_pAIDebugRenderer;
  572.         CAINetworkDebugRenderer*      m_pAINetworkDebugRenderer;
  573.  
  574.         CNetworkCVars*                m_pNetworkCVars;
  575.         CCryActionCVars*              m_pCryActionCVars;
  576.  
  577.         CColorGradientManager*        m_pColorGradientManager;
  578.  
  579.         //-- Network Stall ticker thread
  580. #ifdef USE_NETWORK_STALL_TICKER_THREAD
  581.         CNetworkStallTickerThread* m_pNetworkStallTickerThread;
  582.         uint32                     m_networkStallTickerReferences;
  583. #endif // #ifdef USE_NETWORK_STALL_TICKER_THREAD
  584.  
  585.         // Console Variables with some CryAction as owner
  586.         CMaterialEffectsCVars*  m_pMaterialEffectsCVars;
  587.  
  588.         CCryActionPhysicQueues* m_pPhysicsQueues;
  589.  
  590.         typedef std::vector<ICryUnknownPtr> TFrameworkExtensions;
  591.         TFrameworkExtensions m_frameworkExtensions;
  592.  
  593.         // console variables
  594.         ICVar* m_pEnableLoadingScreen;
  595.         ICVar* m_pCheats;
  596.         ICVar* m_pShowLanBrowserCVAR;
  597.         ICVar* m_pDebugSignalTimers;
  598.         ICVar* m_pDebugRangeSignaling;
  599.         ICVar* m_pAsyncLevelLoad;
  600.  
  601.         bool   m_bShowLanBrowser;
  602.         //
  603.         bool   m_isEditing;
  604.         bool   m_bScheduleLevelEnd;
  605.  
  606.         enum ESaveGameMethod
  607.         {
  608.                 eSGM_NoSave = 0,
  609.                 eSGM_QuickSave,
  610.                 eSGM_Save
  611.         };
  612.  
  613.         ESaveGameMethod m_delayedSaveGameMethod;     // 0 -> no save, 1=quick save, 2=save, not quick
  614.         ESaveGameReason m_delayedSaveGameReason;
  615.         int             m_delayedSaveCountDown;
  616.  
  617.         struct SExternalGameLibrary
  618.         {
  619.                 string        dllName;
  620.                 HMODULE       dllHandle;
  621.                 IGameStartup* pGameStartup;
  622.                 IGame*        pGame;
  623.  
  624.                 SExternalGameLibrary() : dllName(""), dllHandle(0), pGameStartup(nullptr), pGame(nullptr) {}
  625.                 bool IsValid() const { return (pGameStartup != nullptr && pGame != nullptr); }
  626.                 void Reset()         { dllName = ""; dllHandle = 0; pGameStartup = nullptr; pGame = nullptr; }
  627.         };
  628.  
  629.         struct SLocalAllocs
  630.         {
  631.                 string m_delayedSaveGameName;
  632.                 string m_checkPointName;
  633.                 string m_nextLevelToLoad;
  634.         };
  635.         SLocalAllocs* m_pLocalAllocs;
  636.  
  637.         struct SGameFrameworkListener
  638.         {
  639.                 IGameFrameworkListener*    pListener;
  640.                 CryStackStringT<char, 64>  name;
  641.                 EFRAMEWORKLISTENERPRIORITY eFrameworkListenerPriority;
  642.                 SGameFrameworkListener() : pListener(0), eFrameworkListenerPriority(FRAMEWORKLISTENERPRIORITY_DEFAULT) {}
  643.                 void                       GetMemoryUsage(ICrySizer* pSizer) const {}
  644.         };
  645.  
  646.         typedef std::vector<SGameFrameworkListener> TGameFrameworkListeners;
  647.         TGameFrameworkListeners* m_pGFListeners;
  648.         IBreakEventListener*     m_pBreakEventListener;
  649.         std::vector<bool>        m_validListeners;
  650.  
  651.         int                      m_VoiceRecordingEnabled;
  652.  
  653.         bool                     m_bAllowSave;
  654.         bool                     m_bAllowLoad;
  655.         string*                  m_nextFrameCommand;
  656.         string*                  m_connectServer;
  657.  
  658. #if !defined(_RELEASE)
  659.         struct SConnectRepeatedly
  660.         {
  661.                 bool  m_enabled;
  662.                 int   m_numAttemptsLeft;
  663.                 float m_timeForNextAttempt;
  664.  
  665.                 SConnectRepeatedly() : m_enabled(false), m_numAttemptsLeft(0), m_timeForNextAttempt(0.0f) {}
  666.         } m_connectRepeatedly;
  667. #endif
  668.  
  669.         float                       m_lastSaveLoad;
  670.         float                       m_lastFrameTimeUI;
  671.  
  672.         bool                        m_pbSvEnabled;
  673.         bool                        m_pbClEnabled;
  674.         uint32                      m_PreUpdateTicks;
  675.  
  676.         CNetMessageDistpatcher*     m_pNetMsgDispatcher;
  677.         CManualFrameStepController* m_pManualFrameStepController;
  678.         SExternalGameLibrary        m_externalGameLibrary;
  679.  
  680.         CTimeValue                  m_levelStartTime;
  681. };
  682.  
  683. #endif //__CRYACTION_H__
  684.  
downloadCryAction.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