1HEADmaster

1 files changed, 293 insertions, 0 deletions

diff --git a/engine/baseclient.h b/engine/baseclient.h
new file mode 100644
index 0000000..b399f9e
--- /dev/null
+++ b/engine/baseclient.h
@@ -0,0 +1,293 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef BASECLIENT_H
+#define BASECLIENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <const.h>
+#include <checksum_crc.h>
+#include <iclient.h>
+#include <protocol.h>
+#include <iservernetworkable.h>
+#include <bspfile.h>
+#include <KeyValues.h>
+#include <bitvec.h>
+#include <igameevents.h>
+#include "smartptr.h"
+#include "userid.h"
+#include "tier1/bitbuf.h"
+#include "steam/steamclientpublic.h"
+
+// class CClientFrame;
+class CBaseServer;
+class CClientFrame;
+struct player_info_s;
+class CFrameSnapshot;
+class CEventInfo;
+
+struct Spike_t
+{
+public:
+	Spike_t() : 
+		m_nBits( 0 )
+	{
+		m_szDesc[ 0 ] = 0;
+	}
+	char	m_szDesc[ 64 ];
+	int		m_nBits;
+};
+
+class CNetworkStatTrace
+{
+public:
+	CNetworkStatTrace() : 
+		m_nMinWarningBytes( 0 ), m_nStartBit( 0 ), m_nCurBit( 0 ), m_StartSendTime(0.0)
+	{
+	}
+	int						m_nMinWarningBytes;
+	int						m_nStartBit;
+	int						m_nCurBit;
+	CUtlVector< Spike_t >	m_Records;
+	double					m_StartSendTime;
+};
+
+
+class CBaseClient : public IGameEventListener2, public IClient, public IClientMessageHandler
+{
+	typedef struct CustomFile_s
+	{
+		CRC32_t			crc;	//file CRC
+		unsigned int	reqID;	// download request ID
+	} CustomFile_t;
+
+public:
+	CBaseClient();
+	virtual ~CBaseClient();
+
+public:
+
+	int			GetPlayerSlot() const { return m_nClientSlot; };
+	int			GetUserID() const { return m_UserID; };
+	const USERID_t	GetNetworkID() const;
+	const char		*GetClientName() const { return m_Name; };
+	INetChannel		*GetNetChannel() { return m_NetChannel; };
+	IServer			*GetServer() { return (IServer*)m_Server; };
+	const char		*GetUserSetting(const char *cvar) const;
+	const char		*GetNetworkIDString() const;
+	uint			GetFriendsID() const { return m_nFriendsID; }
+	const char		*GetFriendsName() const { return m_FriendsName; }
+	void			UpdateName( const char *pszDefault );
+	int				GetClientChallenge() const { return m_clientChallenge; }
+
+	void			SetReportThisFakeClient( bool bReport ) { m_bReportFakeClient = bReport; }
+	bool			ShouldReportThisFakeClient( void ) const { return m_bReportFakeClient; }
+
+	virtual	void	Connect( const char * szName, int nUserID, INetChannel *pNetChannel, bool bFakePlayer, int clientChallenge );
+	virtual	void	Inactivate( void );
+	virtual	void	Reconnect( void );
+	virtual	void	Disconnect( PRINTF_FORMAT_STRING const char *reason, ... );
+
+	virtual	void	SetRate( int nRate, bool bForce );
+	virtual	int		GetRate( void ) const;
+	
+	virtual void	SetUpdateRate( int nUpdateRate, bool bForce );
+	virtual int		GetUpdateRate( void ) const;
+
+	virtual void	Clear( void );
+	virtual void	DemoRestart( void ); // called when client started demo recording
+
+	virtual	int		GetMaxAckTickCount() const;
+
+	virtual bool	ExecuteStringCommand( const char *s );
+	virtual bool	SendNetMsg(INetMessage &msg, bool bForceReliable = false);
+	
+	virtual void	ClientPrintf (PRINTF_FORMAT_STRING const char *fmt, ...);
+
+	virtual	bool	IsConnected( void ) const { return m_nSignonState >= SIGNONSTATE_CONNECTED; };	
+	virtual	bool	IsSpawned( void ) const { return m_nSignonState >= SIGNONSTATE_NEW; };	
+	virtual	bool	IsActive( void ) const { return m_nSignonState == SIGNONSTATE_FULL; };
+	virtual	bool	IsFakeClient( void ) const { return m_bFakePlayer; };
+
+	virtual	bool	IsHLTV( void ) const { return m_bIsHLTV; }
+#if defined( REPLAY_ENABLED )
+	virtual bool	IsReplay() const { return m_bIsReplay; }
+#endif
+	void			OnSignonStateFull();
+
+	// Is an actual human player or splitscreen player (not a bot and not a HLTV slot)
+	virtual	bool	IsHearingClient( int index ) const { return false; };
+	virtual	bool	IsProximityHearingClient( int index ) const { return false; };
+
+	virtual void	SetMaxRoutablePayloadSize( int nMaxRoutablePayloadSize );
+
+	virtual bool	IsSplitScreenUser( void ) const { return false; } // !KLUDGE! We don't have splitscreen support, but this makes merges easier
+
+public: // IClientMessageHandlers
+	
+	PROCESS_NET_MESSAGE( Tick );
+	PROCESS_NET_MESSAGE( StringCmd );
+	PROCESS_NET_MESSAGE( SetConVar );
+	PROCESS_NET_MESSAGE( SignonState );
+	
+	PROCESS_CLC_MESSAGE( ClientInfo );
+	PROCESS_CLC_MESSAGE( BaselineAck );
+	PROCESS_CLC_MESSAGE( ListenEvents );
+	PROCESS_CLC_MESSAGE( CmdKeyValues );
+	
+	virtual void	ConnectionStart(INetChannel *chan);
+
+public: // IGameEventListener
+	virtual void	FireGameEvent( IGameEvent *event );
+
+public:
+
+	virtual	bool	UpdateAcknowledgedFramecount(int tick);
+	virtual bool	ShouldSendMessages( void );
+	virtual void	UpdateSendState( void );
+			void	ForceFullUpdate( void ) { UpdateAcknowledgedFramecount(-1); }
+	
+	virtual bool	FillUserInfo( player_info_s &userInfo );
+	virtual void	UpdateUserSettings();
+	virtual bool	SetSignonState(int state, int spawncount);
+	virtual void	WriteGameSounds(bf_write &buf);
+	
+	virtual CClientFrame *GetDeltaFrame( int nTick );
+	virtual void	SendSnapshot( CClientFrame *pFrame );
+	virtual bool	SendServerInfo( void );
+	virtual bool	SendSignonData( void );
+	virtual void	SpawnPlayer( void );
+	virtual void	ActivatePlayer( void );
+	virtual void	SetName( const char * playerName );
+	virtual void	SetUserCVar( const char *cvar, const char *value);
+	virtual void	FreeBaselines();
+	virtual bool	IgnoreTempEntity( CEventInfo *event );
+	
+	void			SetSteamID( const CSteamID &steamID );
+
+	void			ClientRequestNameChange( const char *pszName );
+
+	bool			IsTracing() const { return m_iTracing > 0; }
+	void			TraceNetworkData( bf_write &msg, PRINTF_FORMAT_STRING char const *fmt, ... ) FMTFUNCTION( 3, 4 );
+	void			TraceNetworkMsg( int nBits, PRINTF_FORMAT_STRING char const *fmt, ... ) FMTFUNCTION( 3, 4 );
+
+	bool			IsFullyAuthenticated( void ) { return m_bFullyAuthenticated; }
+	void			SetFullyAuthenticated( void ) { m_bFullyAuthenticated = true; }
+
+	void			CheckFlushNameChange( bool bShowStatusMessage = false );
+	bool			IsNameChangeOnCooldown( bool bShowStatusMessage = false );
+
+	void			SetPlayerNameLocked( bool bValue ) { m_bPlayerNameLocked = bValue; }
+	bool			IsPlayerNameLocked( void ) { return m_bPlayerNameLocked; }
+
+private:	
+
+	void			OnRequestFullUpdate();
+
+
+public:
+
+	// Array index in svs.clients:
+	int				m_nClientSlot;	
+	// entity index of this client (different from clientSlot+1 in HLTV and Replay mode):
+	int				m_nEntityIndex;	
+	
+	int				m_UserID;			// identifying number on server
+	char			m_Name[MAX_PLAYER_NAME_LENGTH];			// for printing to other people
+	char			m_GUID[SIGNED_GUID_LEN + 1]; // the clients CD key
+
+	CSteamID		m_SteamID;			// This is valid when the client is authenticated
+	
+	uint32			m_nFriendsID;		// client's friends' ID
+	char			m_FriendsName[MAX_PLAYER_NAME_LENGTH];
+
+	KeyValues		*m_ConVars;			// stores all client side convars
+	bool			m_bConVarsChanged;	// true if convars updated and not changes process yet
+	bool			m_bInitialConVarsSet; // Has the client sent their initial set of convars
+	bool			m_bSendServerInfo;	// true if we need to send server info packet to start connect
+	CBaseServer		*m_Server;			// pointer to server object
+	bool			m_bIsHLTV;			// if this a HLTV proxy ?
+#if defined( REPLAY_ENABLED )
+	bool			m_bIsReplay;		// if this is a Replay proxy ?
+#endif
+	int				m_clientChallenge;	// client's challenge he sent us, we use to auth replies
+	
+	// Client sends this during connection, so we can see if
+	//  we need to send sendtable info or if the .dll matches
+	CRC32_t			m_nSendtableCRC;
+
+	// a client can have couple of cutomized files distributed to all other players
+	CustomFile_t	m_nCustomFiles[MAX_CUSTOM_FILES];
+	int				m_nFilesDownloaded;	// counter of how many files we downloaded from this client
+
+	//===== NETWORK ============
+	INetChannel		*m_NetChannel;		// The client's net connection.
+	int				m_nSignonState;		// connection state
+	int				m_nDeltaTick;		// -1 = no compression.  This is where the server is creating the
+										// compressed info from.
+	int				m_nStringTableAckTick; // Highest tick acked for string tables (usually m_nDeltaTick, except when it's -1)
+	int				m_nSignonTick;		// tick the client got his signon data
+	CSmartPtr<CFrameSnapshot,CRefCountAccessorLongName> m_pLastSnapshot;	// last send snapshot
+
+	CFrameSnapshot	*m_pBaseline;			// current entity baselines as a snapshot
+	int				m_nBaselineUpdateTick;	// last tick we send client a update baseline signal or -1
+	CBitVec<MAX_EDICTS>	m_BaselinesSent;	// baselines sent with last update
+	int				m_nBaselineUsed;		// 0/1 toggling flag, singaling client what baseline to use
+	
+		
+	// This is used when we send out a nodelta packet to put the client in a state where we wait 
+	// until we get an ack from them on this packet.
+	// This is for 3 reasons:
+	// 1. A client requesting a nodelta packet means they're screwed so no point in deluging them with data.
+	//    Better to send the uncompressed data at a slow rate until we hear back from them (if at all).
+	// 2. Since the nodelta packet deletes all client entities, we can't ever delta from a packet previous to it.
+	// 3. It can eat up a lot of CPU on the server to keep building nodelta packets while waiting for
+	//    a client to get back on its feet.
+	int				m_nForceWaitForTick;
+	
+	bool			m_bFakePlayer;		// JAC: This client is a fake player controlled by the game DLL
+	bool			m_bReportFakeClient; // Should this fake client be reported 
+	bool		   m_bReceivedPacket;	// true, if client received a packet after the last send packet
+
+	bool			m_bFullyAuthenticated;
+
+	// Time when last name change was applied
+	double			m_fTimeLastNameChange;
+	bool			m_bPlayerNameLocked;
+
+	// Does this client have a name change that is pending?
+	// (Their 'name' convar differs from our value for their client name.)
+	char			m_szPendingNameChange[MAX_PLAYER_NAME_LENGTH];
+
+	// The datagram is written to after every frame, but only cleared
+	// when it is sent out to the client.  overflow is tolerated.
+
+	// Time when we should send next world state update ( datagram )
+	double         m_fNextMessageTime;   
+	// Default time to wait for next message
+	float          m_fSnapshotInterval;  
+
+	enum
+	{
+		SNAPSHOT_SCRATCH_BUFFER_SIZE = 160000,
+	};
+
+	unsigned int		m_SnapshotScratchBuffer[ SNAPSHOT_SCRATCH_BUFFER_SIZE / 4 ];
+
+private:
+	void				StartTrace( bf_write &msg );
+	void				EndTrace( bf_write &msg );
+
+
+	int					m_iTracing; // 0 = not active, 1 = active for this frame, 2 = forced active
+	CNetworkStatTrace	m_Trace;
+};
+
+
+
+#endif // BASECLIENT_H