BVB Source Codes

CRYENGINE Show GameClientChannel.h Source code

Return Download CRYENGINE: download GameClientChannel.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: Implements a client-side IGameChannel interface.
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 11:8:2004   11:38 : Created by M谩rcio Martins
  12.  
  13. *************************************************************************/
  14. #ifndef __GAMECLIENTCHANNEL_H__
  15. #define __GAMECLIENTCHANNEL_H__
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include <CryNetwork/INetworkService.h>
  22. #include "GameChannel.h"
  23.  
  24. struct SBasicSpawnParams;
  25. class CGameClientNub;
  26. struct SFileDownloadParameters;
  27.  
  28. struct SGameTypeParams : public ISerializable
  29. {
  30.         SGameTypeParams() {}
  31.         SGameTypeParams(uint16 rules, const string& level, bool imm) : rulesClass(rules), levelName(level), immersive(imm) {}
  32.  
  33.         uint16 rulesClass;
  34.         string levelName;
  35.         bool   immersive;
  36.  
  37.         virtual void SerializeWith(TSerialize ser)
  38.         {
  39.                 ser.Value("rules", rulesClass);
  40.                 ser.Value("level", levelName);
  41.                 ser.Value("immersive", immersive);
  42.         }
  43. };
  44.  
  45. struct SEntityClassRegistration : public ISerializable
  46. {
  47.         SEntityClassRegistration() {}
  48.         SEntityClassRegistration(uint16 i, const string& n) : id(i), name(n)
  49.         {
  50.         }
  51.  
  52.         string name;
  53.         uint16 id;
  54.  
  55.         virtual void SerializeWith(TSerialize ser)
  56.         {
  57.                 ser.Value("id", id);
  58.                 ser.Value("name", name);
  59.         }
  60. };
  61.  
  62. struct SEntityClassHashRegistration : public ISerializable
  63. {
  64.         SEntityClassHashRegistration() {}
  65.         SEntityClassHashRegistration(uint32 _crc) : crc(_crc)
  66.         {
  67.         }
  68.  
  69.         uint32 crc;
  70.  
  71.         virtual void SerializeWith(TSerialize ser)
  72.         {
  73.                 ser.Value("crc", crc);
  74.         }
  75. };
  76.  
  77. struct SEntityIdParams : public ISerializable
  78. {
  79.         SEntityIdParams() : id(0) {}
  80.         SEntityIdParams(EntityId e) : id(e) {}
  81.  
  82.         EntityId id;
  83.  
  84.         virtual void SerializeWith(TSerialize ser)
  85.         {
  86.                 ser.Value("id", id, 'eid');
  87.         }
  88. };
  89.  
  90. struct SClientConsoleVariableParams : public ISerializable
  91. {
  92.         SClientConsoleVariableParams() {}
  93.         SClientConsoleVariableParams(const string& key_, const string& value_) : key(key_), value(value_) {}
  94.  
  95.         string key, value;
  96.  
  97.         virtual void SerializeWith(TSerialize ser)
  98.         {
  99.                 ser.Value("key", key);
  100.                 ser.Value("value", value);
  101.         }
  102. };
  103.  
  104. #define VARS_BATCH_PROFILE 0
  105.  
  106. struct SClientBatchConsoleVariablesParams : public ISerializable
  107. {
  108.         SClientBatchConsoleVariablesParams()
  109.         {
  110.                 Reset();
  111.         }
  112.  
  113.         bool Add(const string& k, const string& v)
  114.         {
  115.                 if (batchLimit == actual)
  116.                 {
  117. #if VARS_BATCH_PROFILE
  118.                         size_t s = GetSize();
  119.  
  120.                         if (s < dataLimit)
  121.                         {
  122.                                 size_t left = dataLimit - s;
  123.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "[SClientBatchConsoleVariablesParams]: data limit isn't used effectively, left [%d], try to add more vars in batch.", left);
  124.                         }
  125. #endif
  126.                         return false;
  127.                 }
  128.  
  129.                 if ((GetSize() + k.size() + v.size()) > dataLimit)
  130.                 {
  131. #if VARS_BATCH_PROFILE
  132.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "[SClientBatchConsoleVariablesParams]: exceeded data limit at count [%d]", actual);
  133. #endif
  134.                         return false;
  135.                 }
  136.  
  137.                 assert(actual < batchLimit);
  138.                 vars[actual].key = k;
  139.                 vars[actual].value = v;
  140.                 actual++;
  141.  
  142.                 return true;
  143.         }
  144.  
  145.         void Reset()
  146.         {
  147.                 actual = 0;
  148.  
  149.                 for (int i = 0; i < batchLimit; ++i)
  150.                 {
  151.                         vars[i].key.resize(0);
  152.                         vars[i].value.resize(0);
  153.                 }
  154.         }
  155.  
  156.         size_t GetSize()
  157.         {
  158.                 size_t res = sizeof(actual);
  159.  
  160.                 for (int i = 0; i < batchLimit; ++i)
  161.                 {
  162.                         res += vars[i].key.size();
  163.                         res += vars[i].value.size();
  164.                 }
  165.                 return res;
  166.         }
  167.  
  168.         int                          actual;
  169.         static const int             dataLimit = 1200;
  170.         static const int             batchLimit = 50;
  171.  
  172.         SClientConsoleVariableParams vars[batchLimit];
  173.  
  174.         virtual void SerializeWith(TSerialize ser)
  175.         {
  176.                 ser.Value("actual", actual);
  177.  
  178.                 for (int i = 0; i < batchLimit; ++i)
  179.                         vars[i].SerializeWith(ser);
  180.         }
  181. };
  182.  
  183. struct SBreakEvent;
  184.  
  185. struct STimeOfDayInitParams
  186. {
  187.         float tod;
  188.  
  189.         void  SerializeWith(TSerialize ser)
  190.         {
  191.                 ser.Value("TimeOfDay", tod);
  192.         }
  193. };
  194.  
  195. #if defined(GAME_CHANNEL_SYNC_CLIENT_SERVER_TIME)
  196.  
  197. struct SSyncTimeClient
  198. {
  199.         SSyncTimeClient() {};
  200.         SSyncTimeClient(int id, int64 originTime, int64 serverTimeGuess, int64 serverTimeActual)
  201.         {
  202.                 this->id = id;
  203.                 this->originTime = originTime;
  204.                 this->serverTimeGuess = serverTimeGuess;
  205.                 this->serverTimeActual = serverTimeActual;
  206.         };
  207.  
  208.         int          id;
  209.         int64        originTime;
  210.         int64        serverTimeGuess;
  211.         int64        serverTimeActual;
  212.  
  213.         virtual void SerializeWith(TSerialize ser)
  214.         {
  215.                 ser.Value("id", id);
  216.                 ser.Value("clientTime", originTime);
  217.                 ser.Value("serverTimeGuess", serverTimeGuess);
  218.                 ser.Value("serverTimeActual", serverTimeActual);
  219.         }
  220. };
  221.  
  222. class CGameClientChannel;
  223.  
  224. class CClientClock
  225. {
  226. public:
  227.         enum eSyncState
  228.         {
  229.                 eSS_NotDone,
  230.                 eSS_Pinging,
  231.                 eSS_Refining,
  232.                 eSS_Done
  233.         };
  234.  
  235.         CClientClock(CGameClientChannel& clientChannel);
  236.  
  237.         void             StartSync();
  238.         ILINE eSyncState GetSyncState() const        { return m_syncState; }
  239.         ILINE CTimeValue GetServerTimeOffset() const { return m_serverTimeOffset; }
  240.  
  241.         bool             OnSyncTimeMessage(const SSyncTimeClient& messageParams);
  242.  
  243. private:
  244.         void SendSyncPing(const int id, const CTimeValue currentTime, const CTimeValue serverTime = CTimeValue());
  245.  
  246.         CGameClientChannel&     m_clientChannel;
  247.  
  248.         int                     m_pings;
  249.         eSyncState              m_syncState;
  250.  
  251.         std::vector<CTimeValue> m_timeOffsets;
  252.         CTimeValue              m_serverTimeOffset;
  253.  
  254.         // Used for debug, see 'OnSyncTimeMessage'
  255.         //std::vector<float>      m_diffs;
  256. };
  257.  
  258. #endif //GAME_CHANNEL_SYNC_CLIENT_SERVER_TIME
  259.  
  260. class CGameClientChannel :
  261.         public CNetMessageSinkHelper<CGameClientChannel, CGameChannel>
  262. {
  263. public:
  264.         CGameClientChannel(INetChannel* pNetChannel, CGameContext* pContext, CGameClientNub* pNub);
  265.         virtual ~CGameClientChannel();
  266.  
  267.         void ClearPlayer() { SetPlayerId(0); }
  268.  
  269.         // IGameChannel
  270.         virtual void Release() override;
  271.         virtual void OnDisconnect(EDisconnectionCause cause, const char* description) override;
  272.         // ~IGameChannel
  273.  
  274.         // INetMessageSink
  275.         virtual void DefineProtocol(IProtocolBuilder* pBuilder) override;
  276.         // ~INetMessageSink
  277.  
  278.         void GetMemoryStatistics(ICrySizer* s)
  279.         {
  280.                 s->Add(*this);
  281.         }
  282.  
  283.         void AddUpdateLevelLoaded(IContextEstablisher* pEst);
  284.         bool CheckLevelLoaded() const;
  285.  
  286.         // GameChannel
  287.         virtual bool IsServer() const override { return false; }
  288.         //~GameChannel
  289.  
  290.         // simple messages
  291.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(RegisterEntityClass, SEntityClassRegistration);
  292.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(RegisterEntityClassHash, SEntityClassHashRegistration);
  293.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(SetGameType, SGameTypeParams);
  294.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(ResetMap, SNoParams);
  295.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(SetConsoleVariable, SClientConsoleVariableParams);
  296.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(SetBatchConsoleVariables, SClientBatchConsoleVariablesParams);
  297.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(SetPlayerId_LocalOnly, SEntityIdParams);
  298.  
  299.         NET_DECLARE_ATSYNC_MESSAGE(ConfigureContextMessage);
  300.  
  301.         // spawners - must be unreliable ordered
  302.         // (the net framework takes care of reliability in a special way for
  303.         //  these - as there is a group of messages that must be reliably sent)
  304.         NET_DECLARE_IMMEDIATE_MESSAGE(DefaultSpawn);
  305.  
  306. #if defined(GAME_CHANNEL_SYNC_CLIENT_SERVER_TIME)
  307.         NET_DECLARE_SIMPLE_ATSYNC_MESSAGE(SyncTimeClient, SSyncTimeClient);
  308.  
  309.         CClientClock& GetClock() { return m_clock; }
  310. #endif
  311.  
  312.         void SetPlayerIdOnMigration(EntityId id) { m_playerId = id; }
  313. private:
  314.         CGameClientNub* m_pNub;
  315.  
  316.         void        SetPlayerId(EntityId id);
  317.         void        CallOnSetPlayerId();
  318.         bool        SetConsoleVar(const string& key, const string& val);
  319.  
  320.         static bool HookCreateActor(IEntity*, IGameObject*, void*);
  321.  
  322.         bool                     m_hasLoadedLevel;
  323.         std::map<string, string> m_originalCVarValues;
  324.  
  325. #if defined(GAME_CHANNEL_SYNC_CLIENT_SERVER_TIME)
  326.         CClientClock m_clock;
  327. #endif
  328. };
  329.  
  330. #endif //__GAMECLIENTCHANNEL_H__
  331.  
downloadGameClientChannel.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