BVB Source Codes

CRYENGINE Show ActionGame.h Source code

Return Download CRYENGINE: download ActionGame.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __ACTIONGAME_H__
  4. #define __ACTIONGAME_H__
  5.  
  6. #pragma once
  7.  
  8. #define MAX_CACHED_EFFECTS 8
  9.  
  10. #include "IGameRulesSystem.h"
  11. #include <CryAction/IMaterialEffects.h>
  12. #include <CryGame/IGameFramework.h>
  13.  
  14. struct SGameStartParams;
  15. struct SGameContextParams;
  16. struct INetNub;
  17. class CGameClientNub;
  18. class CGameServerNub;
  19. class CGameContext;
  20. class CGameClientChannel;
  21. class CGameServerChannel;
  22. struct IGameObject;
  23. struct INetContext;
  24. struct INetwork;
  25. struct IActor;
  26. struct IGameTokenSystem;
  27. struct IScriptTable;
  28. class CScriptRMI;
  29. class CGameStats;
  30.  
  31. //////////////////////////////////////////////////////////////////////////
  32. struct SProcBrokenObjRec
  33. {
  34.         int          itype;
  35.         IRenderNode* pBrush;
  36.         EntityId     idEnt;
  37.         int          islot;
  38.         IStatObj*    pStatObjOrg;
  39.         float        mass;
  40.  
  41.         void         GetMemoryUsage(ICrySizer* pSizer) const {}
  42. };
  43.  
  44. //////////////////////////////////////////////////////////////////////////
  45. enum EBreakEventState
  46. {
  47.         eBES_Generated,
  48.         eBES_Processed,
  49.         eBES_Max,
  50.         eBES_Invalid = eBES_Max
  51. };
  52.  
  53. //////////////////////////////////////////////////////////////////////////
  54. struct SBreakEvent
  55. {
  56.         SBreakEvent()
  57.                 : itype(0)
  58.                 , bFirstBreak(0)
  59.                 , idEnt()
  60.                 , eventPos(ZERO)
  61.                 , hash(0)
  62.                 , pos(ZERO)
  63.                 , rot(ZERO)
  64.                 , scale(ZERO)
  65.                 , pt(ZERO)
  66.                 , n(ZERO)
  67.                 , penetration(0.0f)
  68.                 , energy(0.0f)
  69.                 , radius(0.0f)
  70.                 , time(0.0f)
  71.                 , iBrokenObjectIndex(-1)
  72.                 , iState(-1)
  73.                 , seed(0)
  74.         {
  75.                 vloc[0] = vloc[1] = ZERO;
  76.                 mass[0] = mass[1] = ZERO;
  77.                 partid[0] = partid[1] = -1;
  78.                 idmat[0] = idmat[1] = -1;
  79.                 iPrim[0] = iPrim[1] = -1;
  80.         }
  81.  
  82.         SBreakEvent& operator=(const SBreakEvent& in)
  83.         {
  84.                 // Stop floating-point exceptions when copying this class around
  85.                 memcpy(this, &in, sizeof(in));
  86.                 return *this;
  87.         }
  88.  
  89.         void Serialize(TSerialize ser)
  90.         {
  91.                 ser.Value("type", itype);
  92.                 ser.Value("bFirstBreak", bFirstBreak);
  93.                 ser.Value("idEnt", idEnt);
  94.                 ser.Value("eventPos", eventPos);
  95.                 ser.Value("hash", hash);
  96.                 ser.Value("pos", pos);
  97.                 ser.Value("rot", rot);
  98.                 ser.Value("scale", scale);
  99.                 ser.Value("pt", pt);
  100.                 ser.Value("n", n);
  101.                 ser.Value("vloc0", vloc[0]);
  102.                 ser.Value("vloc1", vloc[1]);
  103.                 ser.Value("mass0", mass[0]);
  104.                 ser.Value("mass1", mass[1]);
  105.                 ser.Value("partid0", partid[0]);
  106.                 ser.Value("partid1", partid[1]);
  107.                 ser.Value("idmat0", idmat[0]);
  108.                 ser.Value("idmat1", idmat[1]);
  109.                 ser.Value("iPrim1", iPrim[1]);
  110.                 ser.Value("penetration", penetration);
  111.                 ser.Value("seed", seed);
  112.                 ser.Value("energy", energy);
  113.                 ser.Value("radius", radius);
  114.         }
  115.  
  116.         void GetMemoryUsage(ICrySizer* pSizer) const {}
  117.  
  118.         int16    itype;
  119.         int16    bFirstBreak; // For plane breaks record whether this is the first break
  120.         EntityId idEnt;
  121.         // For Static Entities
  122.         Vec3     eventPos;
  123.         uint32   hash;
  124.  
  125.         Vec3     pos;
  126.         Quat     rot;
  127.         Vec3     scale;
  128.  
  129.         Vec3     pt;
  130.         Vec3     n;
  131.         Vec3     vloc[2];
  132.         float    mass[2];
  133.         int      partid[2];
  134.         int      idmat[2];
  135.         float    penetration;
  136.         float    energy;
  137.         float    radius;
  138.         float    time;
  139.  
  140.         int16    iPrim[2];
  141.         int16    iBrokenObjectIndex;
  142.         int16    iState;
  143.         int      seed;
  144. };
  145.  
  146. struct SBrokenEntPart
  147. {
  148.         void Serialize(TSerialize ser)
  149.         {
  150.                 ser.Value("idSrcEnt", idSrcEnt);
  151.                 ser.Value("idNewEnt", idNewEnt);
  152.         }
  153.         void GetMemoryUsage(ICrySizer* pSizer) const {}
  154.  
  155.         EntityId idSrcEnt;
  156.         EntityId idNewEnt;
  157. };
  158.  
  159. struct SBrokenVegPart
  160. {
  161.         void Serialize(TSerialize ser)
  162.         {
  163.                 ser.Value("pos", pos);
  164.                 ser.Value("volume", volume);
  165.                 ser.Value("idNewEnt", idNewEnt);
  166.         }
  167.         void GetMemoryUsage(ICrySizer* pSizer) const {}
  168.  
  169.         Vec3     pos;
  170.         float    volume;
  171.         EntityId idNewEnt;
  172. };
  173.  
  174. struct SEntityCollHist
  175. {
  176.         SEntityCollHist* pnext;
  177.         float            velImpact, velSlide2, velRoll2;
  178.         int              imatImpact[2], imatSlide[2], imatRoll[2];
  179.         float            timeRolling, timeNotRolling;
  180.         float            rollTimeout, slideTimeout;
  181.         float            mass;
  182.  
  183.         void             GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  184. };
  185.  
  186. struct SEntityHits
  187. {
  188.         SEntityHits* pnext;
  189.         Vec3*        pHits, hit0;
  190.         int*         pnHits, nhits0;
  191.         int          nHits, nHitsAlloc;
  192.         float        hitRadius;
  193.         int          hitpoints;
  194.         int          maxdmg;
  195.         int          nMaxHits;
  196.         float        timeUsed, lifeTime;
  197.  
  198.         void         GetMemoryUsage(ICrySizer* pSizer) const
  199.         {
  200.                 //TODO
  201.         }
  202. };
  203.  
  204. struct STreeBreakInst;
  205. struct STreePieceThunk
  206. {
  207.         IPhysicalEntity* pPhysEntNew;
  208.         STreePieceThunk* pNext;
  209.         STreeBreakInst*  pParent;
  210. };
  211.  
  212. struct STreeBreakInst
  213. {
  214.         IPhysicalEntity* pPhysEntSrc;
  215.         IPhysicalEntity* pPhysEntNew0;
  216.         STreePieceThunk* pNextPiece;
  217.         STreeBreakInst*  pThis;
  218.         STreeBreakInst*  pNext;
  219.         IStatObj*        pStatObj;
  220.         float            cutHeight, cutSize;
  221. };
  222.  
  223. struct SBrokenMeshSize
  224. {
  225.         SBrokenMeshSize()
  226.                 : pent(nullptr)
  227.                 , partid(0)
  228.                 , size(0)
  229.                 , timeout(0.0f)
  230.                 , fractureFX(nullptr)
  231.         {
  232.         }
  233.         SBrokenMeshSize(IPhysicalEntity* _pent, int _size, int _partid, float _timeout, const char* _fractureFX)
  234.         { (pent = _pent)->AddRef(); size = _size; partid = _partid; timeout = _timeout; fractureFX = _fractureFX; }
  235.         SBrokenMeshSize(const SBrokenMeshSize& src) { if (pent = src.pent) pent->AddRef(); partid = src.partid; size = src.size; timeout = src.timeout; fractureFX = src.fractureFX; }
  236.         ~SBrokenMeshSize() { if (pent) pent->Release(); }
  237.         void Serialize(TSerialize ser)
  238.         {
  239.                 int id;
  240.                 if (ser.IsReading())
  241.                 {
  242.                         ser.Value("id", id);
  243.                         pent = gEnv->pPhysicalWorld->GetPhysicalEntityById(id);
  244.                 }
  245.                 else
  246.                         ser.Value("id", id = gEnv->pPhysicalWorld->GetPhysicalEntityId(pent));
  247.                 ser.Value("partid", partid);
  248.                 ser.Value("size", size);
  249.         }
  250.         IPhysicalEntity* pent;
  251.         int              partid;
  252.         int              size;
  253.         float            timeout;
  254.         const char*      fractureFX;
  255. };
  256.  
  257. //////////////////////////////////////////////////////////////////////////
  258. class CActionGame : public IHitListener, public CMultiThreadRefCount, public IHostMigrationEventListener
  259. {
  260. public:
  261.         CActionGame(CScriptRMI*);
  262.         ~CActionGame();
  263.  
  264.         bool          Init(const SGameStartParams*);
  265.         void          ServerInit(const SGameStartParams* pGameStartParams, bool* io_ok, bool* io_hasPbSvStarted);
  266.         void          ClientInit(const SGameStartParams* pGameStartParams, bool* io_ok, bool* io_hasPbSvStarted, bool* io_requireBlockingConnection);
  267.  
  268.         void          PostInit(const SGameStartParams* pGameStartParams, bool* io_ok, bool* io_requireBlockingConnection);
  269.  
  270.         bool          IsInited(void)  { return (m_initState == eIS_InitDone); }
  271.         bool          IsIniting(void) { return (m_initState > eIS_Uninited) && (m_initState < eIS_InitDone); }
  272.         bool          ChangeGameContext(const SGameContextParams*);
  273.         bool          BlockingSpawnPlayer();
  274.  
  275.         const string& GetLevelName() const { return m_levelName; }
  276.  
  277.         void          UnloadLevel();
  278.         void          UnloadPhysicsData();
  279.         void          FixBrokenObjects(bool bRestoreBroken);
  280.  
  281.         void          CloneBrokenObjectsByIndex(uint16* pBreakEventIndices, int32& iNumBreakEvents, IRenderNode** outClonedNodes, int32& iNumClonedNodes, SRenderNodeCloneLookup& nodeLookup);
  282.         void          HideBrokenObjectsByIndex(uint16* pObjectIndicies, int32 iNumObjectIndices);
  283.         void          UnhideBrokenObjectsByIndex(uint16* pObjectIndicies, int32 iNumObjectIndices);
  284.         void          ApplySingleProceduralBreakFromEventIndex(uint16 uBreakEventIndex, const SRenderNodeCloneLookup& renderNodeLookup);
  285.         void          ApplyBreaksUntilTimeToObjectList(int iFirstBreakEventIndex, const SRenderNodeCloneLookup& renderNodeLookup);
  286.  
  287.         SBreakEvent&  StoreBreakEvent(const SBreakEvent& breakEvent);
  288.  
  289.         // CryLobby
  290.         //void InitCryLobby( void );
  291.         void            CryLobbyServerInit(const SGameStartParams* pGameStartParams);
  292.  
  293.         bool            IsServer() const   { return m_pServerNub != 0; }
  294.         bool            IsClient() const   { return m_pClientNub != 0; }
  295.         CGameServerNub* GetGameServerNub() { return m_pGameServerNub; }
  296.         CGameClientNub* GetGameClientNub() { return m_pGameClientNub; }
  297.         CGameContext*   GetGameContext()   { return m_pGameContext; }
  298.         IActor*         GetClientActor();
  299.         bool ControlsEntity(EntityId);
  300.  
  301.         // returns true if should be let go
  302.         bool Update();
  303.  
  304.         void AddGlobalPhysicsCallback(int event, void (*)(const EventPhys*, void*), void*);
  305.         void RemoveGlobalPhysicsCallback(int event, void (*)(const EventPhys*, void*), void*);
  306.  
  307.         void     Serialize(TSerialize ser);
  308.         void     SerializeBreakableObjects(TSerialize ser);
  309.         void     FlushBreakableObjects();
  310.         void     ClearBreakHistory();
  311.  
  312.         void     OnBreakageSpawnedEntity(IEntity* pEntity, IPhysicalEntity* pPhysEntity, IPhysicalEntity* pSrcPhysEntity);
  313.  
  314.         void     InitImmersiveness();
  315.         void     UpdateImmersiveness();
  316.  
  317.         void     OnEditorSetGameMode(bool bGameMode);
  318.  
  319.         INetNub* GetServerNetNub() { return m_pServerNub; }
  320.         INetNub* GetClientNetNub() { return m_pClientNub; }
  321.  
  322.         void     DumpStats();
  323.  
  324.         void     GetMemoryUsage(ICrySizer* s) const;
  325.  
  326.         //
  327.         void                ReleaseGameStats();
  328.  
  329.         void                FreeBrokenMeshesForEntity(IPhysicalEntity* pEntity);
  330.  
  331.         void                OnEntitySystemReset();
  332.  
  333.         static CActionGame* Get() { return s_this; }
  334.  
  335.         static void         RegisterCVars();
  336.  
  337.         // helper functions
  338.         static IGameObject* GetEntityGameObject(IEntity* pEntity);
  339.         static IGameObject* GetPhysicalEntityGameObject(IPhysicalEntity* pPhysEntity);
  340.  
  341.         static void PerformPlaneBreak(const EventPhysCollision &epc, SBreakEvent * pRecordedEvent, int flags, class CDelayedPlaneBreak * pDelayedTask);
  342.  
  343. public:
  344.         enum EPeformPlaneBreakFlags
  345.         {
  346.                 ePPB_EnableParticleEffects = 0x1,    // Used to force particles for recorded/delayed/network events
  347.                 ePPB_PlaybackEvent         = 0x2,    // Used for event playbacks from the netork etc and to distinguish these as not events from serialisation/loading
  348.         };
  349.         static float g_glassAutoShatterMinArea;
  350.  
  351. private:
  352.         static IEntity* GetEntity(int i, void* p)
  353.         {
  354.                 if (i == PHYS_FOREIGN_ID_ENTITY)
  355.                         return (IEntity*)p;
  356.                 return NULL;
  357.         }
  358.  
  359.         void         EnablePhysicsEvents(bool enable);
  360.  
  361.         void         CreateGameStats();
  362.         void         ApplyBreakToClonedObjectFromEvent(const SRenderNodeCloneLookup& renderNodeLookup, int iBrokenObjIndex, int i);
  363.  
  364.         void         LogModeInformation(const bool isMultiplayer, const char* hostname) const;
  365.         static int   OnBBoxOverlap(const EventPhys* pEvent);
  366.         static int   OnCollisionLogged(const EventPhys* pEvent);
  367.         static int   OnPostStepLogged(const EventPhys* pEvent);
  368.         static int   OnStateChangeLogged(const EventPhys* pEvent);
  369.         static int   OnCreatePhysicalEntityLogged(const EventPhys* pEvent);
  370.         static int   OnUpdateMeshLogged(const EventPhys* pEvent);
  371.         static int   OnRemovePhysicalEntityPartsLogged(const EventPhys* pEvent);
  372.         static int   OnPhysEntityDeleted(const EventPhys* pEvent);
  373.  
  374.         static int   OnCollisionImmediate(const EventPhys* pEvent);
  375.         static int   OnPostStepImmediate(const EventPhys* pEvent);
  376.         static int   OnStateChangeImmediate(const EventPhys* pEvent);
  377.         static int   OnCreatePhysicalEntityImmediate(const EventPhys* pEvent);
  378.         static int   OnUpdateMeshImmediate(const EventPhys* pEvent);
  379.  
  380.         virtual void OnHit(const HitInfo&)                   {}
  381.         virtual void OnExplosion(const ExplosionInfo&);
  382.         virtual void OnServerExplosion(const ExplosionInfo&) {}
  383.  
  384.         static void  OnCollisionLogged_MaterialFX(const EventPhys* pEvent);
  385.         static void  OnCollisionLogged_Breakable(const EventPhys* pEvent);
  386.         static void  OnPostStepLogged_MaterialFX(const EventPhys* pEvent);
  387.         static void  OnStateChangeLogged_MaterialFX(const EventPhys* pEvent);
  388.  
  389.         // IHostMigrationEventListener
  390.         virtual EHostMigrationReturn OnInitiate(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  391.         virtual EHostMigrationReturn OnDisconnectClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  392.         virtual EHostMigrationReturn OnDemoteToClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  393.         virtual EHostMigrationReturn OnPromoteToServer(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  394.         virtual EHostMigrationReturn OnReconnectClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  395.         virtual EHostMigrationReturn OnFinalise(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  396.         virtual void                 OnComplete(SHostMigrationInfo& hostMigrationInfo) {}
  397.         virtual EHostMigrationReturn OnTerminate(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  398.         virtual EHostMigrationReturn OnReset(SHostMigrationInfo& hostMigrationInfo, HMStateType& state);
  399.         // ~IHostMigrationEventListener
  400.  
  401.         bool         ProcessHitpoints(const Vec3& pt, IPhysicalEntity* pent, int partid, ISurfaceType* pMat, int iDamage = 1);
  402.         SBreakEvent& RegisterBreakEvent(const EventPhysCollision* pColl, float energy);
  403.         int          ReuseBrokenTrees(const EventPhysCollision* pCEvent, float size, int flags);
  404.         EntityId     UpdateEntityIdForBrokenPart(EntityId idSrc);
  405.         EntityId     UpdateEntityIdForVegetationBreak(IRenderNode* pVeg);
  406.         void         RegisterEntsForBreakageReuse(IPhysicalEntity* pPhysEnt, int partid, IPhysicalEntity* pPhysEntNew, float h, float size);
  407.         void         RemoveEntFromBreakageReuse(IPhysicalEntity* pEntity, int bRemoveOnlyIfSecondary);
  408.         void         ClearTreeBreakageReuseLog();
  409.         int          FreeBrokenMesh(IPhysicalEntity* pent, SBrokenMeshSize& bm);
  410.         void         RegisterBrokenMesh(IPhysicalEntity*, IGeometry*, int partid = 0, IStatObj* pStatObj = 0, IGeometry* pSkel = 0, float timeout = 0.0f, const char* fractureFX = 0);
  411.         void         DrawBrokenMeshes();
  412.         static void  AddBroken2DChunkId(int id);
  413.         void         UpdateBrokenMeshes(float dt);
  414.         void         UpdateFadeEntities(float dt);
  415.  
  416.         bool         ConditionHavePlayer(CGameClientChannel*);
  417.         bool         ConditionHaveConnection(CGameClientChannel*);
  418.         bool         ConditionInGame(CGameClientChannel*);
  419.         typedef bool (CActionGame::* BlockingConditionFunction)(CGameClientChannel*);
  420.         bool BlockingConnect(BlockingConditionFunction, bool requireClientChannel, const char* conditionText);
  421.  
  422.         enum eInitTaskState
  423.         {
  424.                 eITS_InProgress,
  425.                 eITS_Done,
  426.                 eITS_Error
  427.         };
  428.  
  429.         eInitTaskState NonBlockingConnect(BlockingConditionFunction, bool requireClientChannel, const char* conditionText);
  430.  
  431.         void CallOnEditorSetGameMode(IEntity* pEntity, bool bGameMode);
  432.  
  433.         bool IsStale();
  434.  
  435.         void AddProtectedPath(const char* root);
  436.  
  437.         enum EProceduralBreakType
  438.         {
  439.                 ePBT_Normal = 0x10,
  440.                 ePBT_Glass  = 0x01,
  441.         };
  442.         enum EProceduralBreakFlags
  443.         {
  444.                 ePBF_ObeyCVar     = 0x01,
  445.                 ePBF_AllowGlass   = 0x02,
  446.                 ePBF_DefaultAllow = 0x08,
  447.         };
  448.         uint8 m_proceduralBreakFlags;
  449.         bool AllowProceduralBreaking(uint8 proceduralBreakType);
  450.  
  451.         static CActionGame* s_this;
  452.  
  453.         IEntitySystem*      m_pEntitySystem;
  454.         INetwork*           m_pNetwork;
  455.         INetNub*            m_pClientNub;
  456.         INetNub*            m_pServerNub;
  457.         CGameClientNub*     m_pGameClientNub;
  458.         CGameServerNub*     m_pGameServerNub;
  459.         CGameContext*       m_pGameContext;
  460.         INetContext*        m_pNetContext;
  461.         IGameTokenSystem*   m_pGameTokenSystem;
  462.         IPhysicalWorld*     m_pPhysicalWorld;
  463.  
  464.         typedef std::pair<void (*)(const EventPhys*, void*), void*> TGlobalPhysicsCallback;
  465.         typedef std::set<TGlobalPhysicsCallback>                    TGlobalPhysicsCallbackSet;
  466.         struct SPhysCallbacks
  467.         {
  468.                 TGlobalPhysicsCallbackSet collision[2];
  469.                 TGlobalPhysicsCallbackSet postStep[2];
  470.                 TGlobalPhysicsCallbackSet stateChange[2];
  471.                 TGlobalPhysicsCallbackSet createEntityPart[2];
  472.                 TGlobalPhysicsCallbackSet updateMesh[2];
  473.  
  474.         }                                            m_globalPhysicsCallbacks;
  475.  
  476.         std::vector<SProcBrokenObjRec>               m_brokenObjs;
  477.         std::vector<SBreakEvent>                     m_breakEvents;
  478.         std::vector<SBrokenEntPart>                  m_brokenEntParts;
  479.         std::vector<SBrokenVegPart>                  m_brokenVegParts;
  480.         std::vector<EntityId>                        m_broken2dChunkIds;
  481.         std::map<EntityId, int>                      m_entPieceIdx;
  482.         std::map<IPhysicalEntity*, STreeBreakInst*>  m_mapBrokenTreesByPhysEnt;
  483.         std::map<IStatObj*, STreeBreakInst*>         m_mapBrokenTreesByCGF;
  484.         std::map<IPhysicalEntity*, STreePieceThunk*> m_mapBrokenTreesChunks;
  485.         std::map<int, SBrokenMeshSize>               m_mapBrokenMeshes;
  486.         std::vector<int>                             m_brokenMeshRemovals;
  487.         std::vector<CDelayedPlaneBreak>              m_pendingPlaneBreaks;
  488.         bool                                         m_bLoading;
  489.         int                                          m_iCurBreakEvent;
  490.         int                                          m_totBreakageSize;
  491.         int                                          m_inDeleteEntityCallback;
  492.  
  493.         CGameStats*                                  m_pGameStats;
  494.  
  495.         SEntityCollHist*                             m_pCHSlotPool, * m_pFreeCHSlot0;
  496.         std::map<int, SEntityCollHist*>              m_mapECH;
  497.  
  498.         SEntityHits*                                 m_pEntHits0;
  499.         std::map<int, SEntityHits*>                  m_mapEntHits;
  500.         typedef struct SVegCollisionStatus
  501.         {
  502.                 IRenderNode* rn;
  503.                 IStatObj*    pStat;
  504.                 int          branchNum;
  505.                 SVegCollisionStatus()
  506.                 {
  507.                         branchNum = -1;
  508.                         rn = 0;
  509.                         pStat = 0;
  510.                 }
  511.                 void GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  512.  
  513.         } SVegCollisionStatus;
  514.         std::map<EntityId, Vec3>                 m_vegStatus;
  515.         std::map<EntityId, SVegCollisionStatus*> m_treeStatus;
  516.         std::map<EntityId, SVegCollisionStatus*> m_treeBreakStatus;
  517.  
  518.         int                     m_nEffectCounter;
  519.         SMFXRunTimeEffectParams m_lstCachedEffects[MAX_CACHED_EFFECTS];
  520.         static int              g_procedural_breaking;
  521.         static int              g_joint_breaking;
  522.         static float            g_tree_cut_reuse_dist;
  523.         static int              g_no_secondary_breaking;
  524.         static int              g_no_breaking_by_objects;
  525.         static int              g_breakage_mem_limit;
  526.         static int              g_breakage_debug;
  527.  
  528.         static int              s_waterMaterialId;
  529.  
  530.         enum eDisconnectState
  531.         {
  532.                 eDS_Disconnect,
  533.                 eDS_Disconnecting,
  534.                 eDS_Disconnected
  535.         };
  536.  
  537.         enum eReconnectState
  538.         {
  539.                 eRS_Reconnect,
  540.                 eRS_Reconnecting,
  541.                 eRS_Terminated,
  542.                 eRS_Reconnected
  543.         };
  544.  
  545.         enum eInitState
  546.         {
  547.                 eIS_Uninited,
  548.                 eIS_Initing,
  549.                 eIS_WaitForConnection,
  550.                 eIS_WaitForPlayer,
  551.                 eIS_WaitForInGame,
  552.                 eIS_InitDone,
  553.                 eIS_InitError
  554.         };
  555.  
  556.         eInitState m_initState;
  557.  
  558.         struct SEntityFadeState
  559.         {
  560.                 EntityId entId;       // Entity ID
  561.                 float    time;        // Time since spawned
  562.                 int      bCollisions; // Are collisions on
  563.         };
  564.         DynArray<SEntityFadeState> m_fadeEntities;
  565.  
  566.         void BackupGameStartParams(const SGameStartParams* pGameStartParams);
  567.  
  568.         SGameContextParams m_gameContextParams;
  569.         SGameStartParams   m_startGameParams;
  570.  
  571.         string             m_levelName;
  572.         string             m_gameRules;
  573.         string             m_demoRecorderFilename;
  574.         string             m_demoPlaybackFilename;
  575.         string             m_hostname;
  576.         string             m_connectionString;
  577.  
  578.         uint32             m_lastDynPoolSize;
  579.  
  580.         struct SBreakageThrottling
  581.         {
  582.                 int16 m_numGlassEvents;
  583.                 int16 m_brokenTreeCounter;
  584.         };
  585.  
  586.         SBreakageThrottling m_throttling;
  587.  
  588.         EntityId            m_clientActorID;
  589.         IActor*             m_pClientActor;
  590.  
  591. #ifndef _RELEASE
  592.         float        m_timeToPromoteToServer;
  593.         static float g_hostMigrationServerDelay;
  594. #endif
  595. };
  596.  
  597. #endif
  598.  
downloadActionGame.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