918 lines
21 KiB
C++
918 lines
21 KiB
C++
//========= 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
|