diff options
Diffstat (limited to 'common/netmessages.h')
| -rw-r--r-- | common/netmessages.h | 917 |
1 files changed, 917 insertions, 0 deletions
diff --git a/common/netmessages.h b/common/netmessages.h new file mode 100644 index 0000000..b9064ba --- /dev/null +++ b/common/netmessages.h @@ -0,0 +1,917 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=============================================================================// + +#ifndef NETMESSAGES_H +#define NETMESSAGES_H + +#ifdef _WIN32 +#pragma once +#pragma warning(disable : 4100) // unreferenced formal parameter +#endif + +#include <inetmessage.h> +#include <checksum_crc.h> +#include <checksum_md5.h> +#include <const.h> +#include <utlvector.h> +#include "qlimits.h" +#include "mathlib/vector.h" +#include <soundflags.h> +#include <bitbuf.h> +#include <inetchannel.h> +#include "protocol.h" +#include <inetmsghandler.h> +#include <igameevents.h> +#include <bitvec.h> +#include <engine/iserverplugin.h> +#include <Color.h> +#include "proto_version.h" + +#if !defined( _X360 ) +#include "xbox/xboxstubs.h" +#endif + +class SendTable; +class KeyValue; +class KeyValues; +class INetMessageHandler; +class IServerMessageHandler; +class IClientMessageHandler; + +#define DECLARE_BASE_MESSAGE( msgtype ) \ + public: \ + bool ReadFromBuffer( bf_read &buffer ); \ + bool WriteToBuffer( bf_write &buffer ); \ + const char *ToString() const; \ + int GetType() const { return msgtype; } \ + const char *GetName() const { return #msgtype;}\ + +#define DECLARE_NET_MESSAGE( name ) \ + DECLARE_BASE_MESSAGE( net_##name ); \ + INetMessageHandler *m_pMessageHandler; \ + bool Process() { return m_pMessageHandler->Process##name( this ); }\ + +#define DECLARE_SVC_MESSAGE( name ) \ + DECLARE_BASE_MESSAGE( svc_##name ); \ + IServerMessageHandler *m_pMessageHandler;\ + bool Process() { return m_pMessageHandler->Process##name( this ); }\ + +#define DECLARE_CLC_MESSAGE( name ) \ + DECLARE_BASE_MESSAGE( clc_##name ); \ + IClientMessageHandler *m_pMessageHandler;\ + bool Process() { return m_pMessageHandler->Process##name( this ); }\ + +#define DECLARE_MM_MESSAGE( name ) \ + DECLARE_BASE_MESSAGE( mm_##name ); \ + IMatchmakingMessageHandler *m_pMessageHandler;\ + bool Process() { return m_pMessageHandler->Process##name( this ); }\ + +class CNetMessage : public INetMessage +{ +public: + CNetMessage() { m_bReliable = true; + m_NetChannel = NULL; } + + virtual ~CNetMessage() {}; + + virtual int GetGroup() const { return INetChannelInfo::GENERIC; } + INetChannel *GetNetChannel() const { return m_NetChannel; } + + virtual void SetReliable( bool state) {m_bReliable = state;}; + virtual bool IsReliable() const { return m_bReliable; }; + virtual void SetNetChannel(INetChannel * netchan) { m_NetChannel = netchan; } + virtual bool Process() { Assert( 0 ); return false; }; // no handler set + +protected: + bool m_bReliable; // true if message should be send reliable + INetChannel *m_NetChannel; // netchannel this message is from/for +}; + + +/////////////////////////////////////////////////////////////////////////////////////// +// bidirectional net messages: +/////////////////////////////////////////////////////////////////////////////////////// + + +class NET_SetConVar : public CNetMessage +{ + DECLARE_NET_MESSAGE( SetConVar ); + + int GetGroup() const { return INetChannelInfo::STRINGCMD; } + + NET_SetConVar() {} + NET_SetConVar( const char * name, const char * value) + { + cvar_t localCvar; + Q_strncpy( localCvar.name, name, MAX_OSPATH ); + Q_strncpy( localCvar.value, value, MAX_OSPATH ); + m_ConVars.AddToTail( localCvar ); + } + +public: + + typedef struct cvar_s + { + char name[MAX_OSPATH]; + char value[MAX_OSPATH]; + } cvar_t; + + CUtlVector<cvar_t> m_ConVars; +}; + +class NET_StringCmd : public CNetMessage +{ + DECLARE_NET_MESSAGE( StringCmd ); + + int GetGroup() const { return INetChannelInfo::STRINGCMD; } + + NET_StringCmd() { m_szCommand = NULL; }; + NET_StringCmd(const char *cmd) { m_szCommand = cmd; }; + +public: + const char *m_szCommand; // execute this command + +private: + char m_szCommandBuffer[1024]; // buffer for received messages + +}; + +class NET_Tick : public CNetMessage +{ + DECLARE_NET_MESSAGE( Tick ); + + NET_Tick() + { + m_bReliable = false; +#if PROTOCOL_VERSION > 10 + m_flHostFrameTime = 0; + m_flHostFrameTimeStdDeviation = 0; +#endif + }; + + NET_Tick( int tick, float hostFrametime, float hostFrametime_stddeviation ) + { + m_bReliable = false; + m_nTick = tick; +#if PROTOCOL_VERSION > 10 + m_flHostFrameTime = hostFrametime; + m_flHostFrameTimeStdDeviation = hostFrametime_stddeviation; +#else + NOTE_UNUSED( hostFrametime ); + NOTE_UNUSED( hostFrametime_stddeviation ); +#endif + }; + +public: + int m_nTick; +#if PROTOCOL_VERSION > 10 + float m_flHostFrameTime; + float m_flHostFrameTimeStdDeviation; +#endif +}; + +class NET_SignonState : public CNetMessage +{ + DECLARE_NET_MESSAGE( SignonState ); + + int GetGroup() const { return INetChannelInfo::SIGNON; } + + NET_SignonState() {}; + NET_SignonState( int state, int spawncount ) { m_nSignonState = state; m_nSpawnCount = spawncount; }; + +public: + int m_nSignonState; // See SIGNONSTATE_ defines + int m_nSpawnCount; // server spawn count (session number) +}; + + +/////////////////////////////////////////////////////////////////////////////////////// +// Client messages: +/////////////////////////////////////////////////////////////////////////////////////// + +class CLC_ClientInfo : public CNetMessage +{ + DECLARE_CLC_MESSAGE( ClientInfo ); + +public: + CRC32_t m_nSendTableCRC; + int m_nServerCount; + bool m_bIsHLTV; +#if defined( REPLAY_ENABLED ) + bool m_bIsReplay; +#endif + uint32 m_nFriendsID; + char m_FriendsName[MAX_PLAYER_NAME_LENGTH]; + CRC32_t m_nCustomFiles[MAX_CUSTOM_FILES]; +}; + + + +class CLC_Move : public CNetMessage +{ + DECLARE_CLC_MESSAGE( Move ); + + int GetGroup() const { return INetChannelInfo::MOVE; } + + CLC_Move() { m_bReliable = false; } + +public: + int m_nBackupCommands; + int m_nNewCommands; + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; +}; + +class CLC_VoiceData : public CNetMessage +{ + DECLARE_CLC_MESSAGE( VoiceData ); + + int GetGroup() const { return INetChannelInfo::VOICE; } + + CLC_VoiceData() { m_bReliable = false; }; + +public: + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; + uint64 m_xuid; +}; + +class CLC_BaselineAck : public CNetMessage +{ + DECLARE_CLC_MESSAGE( BaselineAck ); + + CLC_BaselineAck() {}; + CLC_BaselineAck(int tick, int baseline ) { m_nBaselineTick = tick; m_nBaselineNr = baseline; } + + int GetGroup() const { return INetChannelInfo::ENTITIES; } + +public: + int m_nBaselineTick; // sequence number of baseline + int m_nBaselineNr; // 0 or 1 +}; + +class CLC_ListenEvents : public CNetMessage +{ + DECLARE_CLC_MESSAGE( ListenEvents ); + + int GetGroup() const { return INetChannelInfo::SIGNON; } + +public: + CBitVec<MAX_EVENT_NUMBER> m_EventArray; +}; + +#if defined( REPLAY_ENABLED ) +class CLC_SaveReplay : public CNetMessage +{ + DECLARE_CLC_MESSAGE( SaveReplay ); + + CLC_SaveReplay() {} + + int m_nStartSendByte; + char m_szFilename[ MAX_OSPATH ]; + float m_flPostDeathRecordTime; +}; +#endif + +class CLC_RespondCvarValue : public CNetMessage +{ +public: + DECLARE_CLC_MESSAGE( RespondCvarValue ); + + QueryCvarCookie_t m_iCookie; + + const char *m_szCvarName; + const char *m_szCvarValue; // The sender sets this, and it automatically points it at m_szCvarNameBuffer when receiving. + + EQueryCvarValueStatus m_eStatusCode; + +private: + char m_szCvarNameBuffer[256]; + char m_szCvarValueBuffer[256]; +}; + +class CLC_FileCRCCheck : public CNetMessage +{ +public: + DECLARE_CLC_MESSAGE( FileCRCCheck ); + char m_szPathID[MAX_PATH]; + char m_szFilename[MAX_PATH]; + MD5Value_t m_MD5; + CRC32_t m_CRCIOs; + int m_eFileHashType; + int m_cbFileLen; + int m_nPackFileNumber; + int m_PackFileID; + int m_nFileFraction; +}; + +class CLC_FileMD5Check : public CNetMessage +{ +public: + DECLARE_CLC_MESSAGE( FileMD5Check ); + + char m_szPathID[MAX_PATH]; + char m_szFilename[MAX_PATH]; + MD5Value_t m_MD5; +}; + +class Base_CmdKeyValues : public CNetMessage +{ +protected: + explicit Base_CmdKeyValues( KeyValues *pKeyValues = NULL ); // takes ownership + ~Base_CmdKeyValues(); + +public: + KeyValues * GetKeyValues() const { return m_pKeyValues; } + +public: + bool ReadFromBuffer( bf_read &buffer ); + bool WriteToBuffer( bf_write &buffer ); + const char * ToString() const; + +protected: + KeyValues *m_pKeyValues; +}; + +class CLC_CmdKeyValues : public Base_CmdKeyValues +{ +public: + DECLARE_CLC_MESSAGE( CmdKeyValues ); + +public: + explicit CLC_CmdKeyValues( KeyValues *pKeyValues = NULL ); // takes ownership +}; + +class SVC_CmdKeyValues : public Base_CmdKeyValues +{ +public: + DECLARE_SVC_MESSAGE( CmdKeyValues ); + +public: + explicit SVC_CmdKeyValues( KeyValues *pKeyValues = NULL ); // takes ownership +}; + +/////////////////////////////////////////////////////////////////////////////////////// +// server messages: +/////////////////////////////////////////////////////////////////////////////////////// + + + +class SVC_Print : public CNetMessage +{ + DECLARE_SVC_MESSAGE( Print ); + + SVC_Print() { m_bReliable = false; m_szText = NULL; }; + + SVC_Print(const char * text) { m_bReliable = false; m_szText = text; }; + +public: + const char *m_szText; // show this text + +private: + char m_szTextBuffer[2048]; // buffer for received messages +}; + +class SVC_ServerInfo : public CNetMessage +{ + DECLARE_SVC_MESSAGE( ServerInfo ); + + int GetGroup() const { return INetChannelInfo::SIGNON; } + +public: // member vars are public for faster handling + int m_nProtocol; // protocol version + int m_nServerCount; // number of changelevels since server start + bool m_bIsDedicated; // dedicated server ? + bool m_bIsHLTV; // HLTV server ? +#if defined( REPLAY_ENABLED ) + bool m_bIsReplay; // Replay server ? +#endif + char m_cOS; // L = linux, W = Win32 + CRC32_t m_nMapCRC; // server map CRC (only used by older demos) + MD5Value_t m_nMapMD5; // server map MD5 + int m_nMaxClients; // max number of clients on server + int m_nMaxClasses; // max number of server classes + int m_nPlayerSlot; // our client slot number + float m_fTickInterval;// server tick interval + const char *m_szGameDir; // game directory eg "tf2" + const char *m_szMapName; // name of current map + const char *m_szSkyName; // name of current skybox + const char *m_szHostName; // server name + +private: + char m_szGameDirBuffer[MAX_OSPATH];// game directory eg "tf2" + char m_szMapNameBuffer[MAX_OSPATH];// name of current map + char m_szSkyNameBuffer[MAX_OSPATH];// name of current skybox + char m_szHostNameBuffer[MAX_OSPATH];// name of current skybox +}; + +class SVC_SendTable : public CNetMessage +{ + DECLARE_SVC_MESSAGE( SendTable ); + + int GetGroup() const { return INetChannelInfo::SIGNON; } + +public: + bool m_bNeedsDecoder; + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; +}; + +class SVC_ClassInfo : public CNetMessage +{ + DECLARE_SVC_MESSAGE( ClassInfo ); + + int GetGroup() const { return INetChannelInfo::SIGNON; } + + SVC_ClassInfo() {}; + SVC_ClassInfo( bool createFromSendTables, int numClasses ) + { m_bCreateOnClient = createFromSendTables; + m_nNumServerClasses = numClasses; }; + +public: + + typedef struct class_s + { + int classID; + char datatablename[256]; + char classname[256]; + } class_t; + + bool m_bCreateOnClient; // if true, client creates own SendTables & classinfos from game.dll + CUtlVector<class_t> m_Classes; + int m_nNumServerClasses; +}; + + +class SVC_SetPause : public CNetMessage +{ + DECLARE_SVC_MESSAGE( SetPause ); + + SVC_SetPause() {} + SVC_SetPause( bool state, float end = -1.f ) { m_bPaused = state; } + +public: + bool m_bPaused; // true or false, what else +}; + +class SVC_SetPauseTimed : public CNetMessage +{ + DECLARE_SVC_MESSAGE( SetPauseTimed ); + + SVC_SetPauseTimed() {} + SVC_SetPauseTimed( bool bState, float flExpireTime = -1.f ) { m_bPaused = bState; m_flExpireTime = flExpireTime; } + +public: + bool m_bPaused; + float m_flExpireTime; +}; + + +class CNetworkStringTable; + +class SVC_CreateStringTable : public CNetMessage +{ + DECLARE_SVC_MESSAGE( CreateStringTable ); + + int GetGroup() const { return INetChannelInfo::SIGNON; } + +public: + + SVC_CreateStringTable(); + +public: + + const char *m_szTableName; + int m_nMaxEntries; + int m_nNumEntries; + bool m_bUserDataFixedSize; + int m_nUserDataSize; + int m_nUserDataSizeBits; + bool m_bIsFilenames; + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; + bool m_bDataCompressed; + +private: + char m_szTableNameBuffer[256]; +}; + +class SVC_UpdateStringTable : public CNetMessage +{ + DECLARE_SVC_MESSAGE( UpdateStringTable ); + + int GetGroup() const { return INetChannelInfo::STRINGTABLE; } + +public: + int m_nTableID; // table to be updated + int m_nChangedEntries; // number of how many entries has changed + int m_nLength; // data length in bits + bf_read m_DataIn; + bf_write m_DataOut; +}; + +// SVC_VoiceInit +// v2 - 2017/02/07 +// - Can detect v2 packets by nLegacyQuality == 255 and presence of additional nSampleRate field. +// - Added nSampleRate field. Previously, nSampleRate was hard-coded per codec type. ::ReadFromBuffer does a +// one-time conversion of these old types (which can no longer change) +// - Marked quality field as deprecated. This was already being ignored. v2 clients send 255 +// - Prior to this the sv_use_steam_voice convar was used to switch to steam voice. With this, we properly set +// szVoiceCodec to "steam". See ::ReadFromBuffer for shim to fallback to the convar for old streams. +// - We no longer pass "svc_voiceinit NULL" as szVoiceCodec if it is not selected, just the empty string. Nothing +// used this that I could find. +class SVC_VoiceInit : public CNetMessage +{ + DECLARE_SVC_MESSAGE( VoiceInit ); + + int GetGroup() const { return INetChannelInfo::SIGNON; } + + SVC_VoiceInit() + : m_nSampleRate( 0 ) + { + V_memset( m_szVoiceCodec, 0, sizeof( m_szVoiceCodec ) ); + } + + SVC_VoiceInit( const char * codec, int nSampleRate ) + : m_nSampleRate( nSampleRate ) + { + V_strncpy( m_szVoiceCodec, codec ? codec : "", sizeof( m_szVoiceCodec ) ); + } + + +public: + // Used voice codec for voice_init. + // + // This used to be a DLL name, then became a whitelisted list of codecs. + char m_szVoiceCodec[MAX_OSPATH]; + + // DEPRECATED: + // + // This field used to be a custom quality setting, but it was not honored for a long time: codecs use their own + // pre-configured quality settings. We never sent anything besides 5, which was then ignored for some codecs. + // + // New clients always set 255 here, old clients probably send 5. This could be re-purposed in the future, but beware + // that very old demos may have non-5 values. It would take more archaeology to determine how to properly interpret + // those packets -- they're probably using settings we simply don't support any longer. + // + // int m_nQuality; + + // The sample rate we are using + int m_nSampleRate; +}; + +class SVC_VoiceData : public CNetMessage +{ + DECLARE_SVC_MESSAGE( VoiceData ); + + int GetGroup() const { return INetChannelInfo::VOICE; } + + SVC_VoiceData() { m_bReliable = false; } + +public: + int m_nFromClient; // client who has spoken + bool m_bProximity; + int m_nLength; // data length in bits + uint64 m_xuid; // X360 player ID + + bf_read m_DataIn; + void *m_DataOut; +}; + +class SVC_Sounds : public CNetMessage +{ + DECLARE_SVC_MESSAGE( Sounds ); + + int GetGroup() const { return INetChannelInfo::SOUNDS; } + +public: + + bool m_bReliableSound; + int m_nNumSounds; + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; +}; + +class SVC_Prefetch : public CNetMessage +{ + DECLARE_SVC_MESSAGE( Prefetch ); + + int GetGroup() const { return INetChannelInfo::SOUNDS; } + + enum + { + SOUND = 0, + }; + +public: + + unsigned short m_fType; + unsigned short m_nSoundIndex; +}; + +class SVC_SetView : public CNetMessage +{ + DECLARE_SVC_MESSAGE( SetView ); + + SVC_SetView() {} + SVC_SetView( int entity ) { m_nEntityIndex = entity; } + +public: + int m_nEntityIndex; + +}; + +class SVC_FixAngle: public CNetMessage +{ + DECLARE_SVC_MESSAGE( FixAngle ); + + SVC_FixAngle() { m_bReliable = false; }; + SVC_FixAngle( bool bRelative, QAngle angle ) + { m_bReliable = false; m_bRelative = bRelative; m_Angle = angle; } + +public: + bool m_bRelative; + QAngle m_Angle; +}; + +class SVC_CrosshairAngle : public CNetMessage +{ + DECLARE_SVC_MESSAGE( CrosshairAngle ); + + SVC_CrosshairAngle() {} + SVC_CrosshairAngle( QAngle angle ) { m_Angle = angle; } + +public: + QAngle m_Angle; +}; + +class SVC_BSPDecal : public CNetMessage +{ + DECLARE_SVC_MESSAGE( BSPDecal ); + +public: + Vector m_Pos; + int m_nDecalTextureIndex; + int m_nEntityIndex; + int m_nModelIndex; + bool m_bLowPriority; +}; + +class SVC_GameEvent : public CNetMessage +{ + DECLARE_SVC_MESSAGE( GameEvent ); + + int GetGroup() const { return INetChannelInfo::EVENTS; } + +public: + int m_nLength; // data length in bits + bf_read m_DataIn; + bf_write m_DataOut; +}; + +class SVC_UserMessage: public CNetMessage +{ + DECLARE_SVC_MESSAGE( UserMessage ); + + SVC_UserMessage() { m_bReliable = false; } + + int GetGroup() const { return INetChannelInfo::USERMESSAGES; } + +public: + int m_nMsgType; + int m_nLength; // data length in bits + bf_read m_DataIn; + bf_write m_DataOut; +}; + +class SVC_EntityMessage : public CNetMessage +{ + DECLARE_SVC_MESSAGE( EntityMessage ); + + SVC_EntityMessage() { m_bReliable = false; } + + int GetGroup() const { return INetChannelInfo::ENTMESSAGES ; } + +public: + int m_nEntityIndex; + int m_nClassID; + int m_nLength; // data length in bits + bf_read m_DataIn; + bf_write m_DataOut; +}; + +/* class SVC_SpawnBaseline: public CNetMessage +{ + DECLARE_SVC_MESSAGE( SpawnBaseline ); + + int GetGroup() const { return INetChannelInfo::SIGNON; } + +public: + int m_nEntityIndex; + int m_nClassID; + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; + +}; */ + +class SVC_PacketEntities: public CNetMessage +{ + DECLARE_SVC_MESSAGE( PacketEntities ); + + int GetGroup() const { return INetChannelInfo::ENTITIES ; } + +public: + + int m_nMaxEntries; + int m_nUpdatedEntries; + bool m_bIsDelta; + bool m_bUpdateBaseline; + int m_nBaseline; + int m_nDeltaFrom; + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; +}; + +class SVC_TempEntities: public CNetMessage +{ + DECLARE_SVC_MESSAGE( TempEntities ); + + SVC_TempEntities() { m_bReliable = false; } + + int GetGroup() const { return INetChannelInfo::EVENTS; } + + int m_nNumEntries; + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; +}; + +class SVC_Menu : public CNetMessage +{ +public: + DECLARE_SVC_MESSAGE( Menu ); + + SVC_Menu() { m_bReliable = true; m_Type = DIALOG_MENU; m_MenuKeyValues = NULL; }; + SVC_Menu( DIALOG_TYPE type, KeyValues *data ); + ~SVC_Menu(); + + KeyValues *m_MenuKeyValues; + DIALOG_TYPE m_Type; + int m_iLength; +}; + +class SVC_GameEventList : public CNetMessage +{ +public: + DECLARE_SVC_MESSAGE( GameEventList ); + + int m_nNumEvents; + int m_nLength; + bf_read m_DataIn; + bf_write m_DataOut; +}; + +/////////////////////////////////////////////////////////////////////////////////////// +// Matchmaking messages: +/////////////////////////////////////////////////////////////////////////////////////// + +class MM_Heartbeat : public CNetMessage +{ +public: + DECLARE_MM_MESSAGE( Heartbeat ); +}; + +class MM_ClientInfo : public CNetMessage +{ +public: + DECLARE_MM_MESSAGE( ClientInfo ); + + XNADDR m_xnaddr; // xbox net address + uint64 m_id; // machine ID + uint64 m_xuids[MAX_PLAYERS_PER_CLIENT]; + byte m_cVoiceState[MAX_PLAYERS_PER_CLIENT]; + bool m_bInvited; + char m_cPlayers; + char m_iControllers[MAX_PLAYERS_PER_CLIENT]; + char m_iTeam[MAX_PLAYERS_PER_CLIENT]; + char m_szGamertags[MAX_PLAYERS_PER_CLIENT][MAX_PLAYER_NAME_LENGTH]; +}; + +class MM_RegisterResponse : public CNetMessage +{ +public: + DECLARE_MM_MESSAGE( RegisterResponse ); +}; + +class MM_Mutelist : public CNetMessage +{ +public: + DECLARE_MM_MESSAGE( Mutelist ); + + uint64 m_id; + byte m_cPlayers; + byte m_cRemoteTalkers[MAX_PLAYERS_PER_CLIENT]; + XUID m_xuid[MAX_PLAYERS_PER_CLIENT]; + byte m_cMuted[MAX_PLAYERS_PER_CLIENT]; + CUtlVector< XUID > m_Muted[MAX_PLAYERS_PER_CLIENT]; +}; + +class MM_Checkpoint : public CNetMessage +{ +public: + DECLARE_MM_MESSAGE( Checkpoint ); + + enum eCheckpoint + { + CHECKPOINT_CHANGETEAM, + CHECKPOINT_GAME_LOBBY, + CHECKPOINT_PREGAME, + CHECKPOINT_LOADING_COMPLETE, + CHECKPOINT_CONNECT, + CHECKPOINT_SESSION_DISCONNECT, + CHECKPOINT_REPORT_STATS, + CHECKPOINT_REPORTING_COMPLETE, + CHECKPOINT_POSTGAME, + }; + + byte m_Checkpoint; +}; + +// NOTE: The following messages are not network-endian compliant, due to the +// transmission of structures instead of their component parts +class MM_JoinResponse : public CNetMessage +{ +public: + DECLARE_MM_MESSAGE( JoinResponse ); + + MM_JoinResponse() + { + m_ContextCount = 0; + m_PropertyCount = 0; + } + + enum + { + JOINRESPONSE_APPROVED, + JOINRESPONSE_APPROVED_JOINGAME, + JOINRESPONSE_SESSIONFULL, + JOINRESPONSE_NOTHOSTING, + JOINRESPONSE_MODIFY_SESSION, + }; + uint m_ResponseType; + + // host info + uint64 m_id; // Host's machine ID + uint64 m_Nonce; // Session nonce + uint m_SessionFlags; + uint m_nOwnerId; + int m_iTeam; + int m_nTotalTeams; + int m_PropertyCount; + int m_ContextCount; + CUtlVector< XUSER_PROPERTY >m_SessionProperties; + CUtlVector< XUSER_CONTEXT >m_SessionContexts; +}; + +class MM_Migrate : public CNetMessage +{ +public: + DECLARE_MM_MESSAGE( Migrate ); + + enum eMsgType + { + MESSAGE_HOSTING, + MESSAGE_MIGRATED, + MESSAGE_STANDBY, + }; + + byte m_MsgType; + uint64 m_Id; + XNKID m_sessionId; + XNADDR m_xnaddr; + XNKEY m_key; +}; + +class SVC_GetCvarValue : public CNetMessage +{ +public: + DECLARE_SVC_MESSAGE( GetCvarValue ); + + QueryCvarCookie_t m_iCookie; + const char *m_szCvarName; // The sender sets this, and it automatically points it at m_szCvarNameBuffer when receiving. + +private: + char m_szCvarNameBuffer[256]; +}; + +#endif // NETMESSAGES_H |