1

engine/hltvserver.h

@@ -0,0 +1,262 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HLTVSERVER_H
+#define HLTVSERVER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "baseserver.h"
+#include "hltvclient.h"
+#include "hltvdemo.h"
+#include "hltvclientstate.h"
+#include "clientframe.h"
+#include "networkstringtable.h"
+#include <ihltv.h>
+#include <convar.h>
+
+#define HLTV_BUFFER_DIRECTOR		0	// director commands
+#define	HLTV_BUFFER_RELIABLE		1	// reliable messages
+#define HLTV_BUFFER_UNRELIABLE		2	// unreliable messages
+#define HLTV_BUFFER_VOICE			3	// player voice data
+#define HLTV_BUFFER_SOUNDS			4	// unreliable sounds
+#define HLTV_BUFFER_TEMPENTS		5	// temporary/event entities
+#define HLTV_BUFFER_MAX				6	// end marker
+
+// proxy dispatch modes
+#define DISPATCH_MODE_OFF			0
+#define DISPATCH_MODE_AUTO			1
+#define DISPATCH_MODE_ALWAYS		2
+
+extern ConVar tv_debug;
+
+class CHLTVFrame : public CClientFrame
+{
+public:
+	CHLTVFrame();
+	virtual ~CHLTVFrame();
+
+	void	Reset(); // resets all data & buffers
+	void	FreeBuffers();
+	void	AllocBuffers();
+	bool	HasData();
+	void	CopyHLTVData( CHLTVFrame &frame );
+	virtual bool IsMemPoolAllocated() { return false; }
+
+public:
+
+	// message buffers:
+	bf_write	m_Messages[HLTV_BUFFER_MAX];
+};
+
+struct CFrameCacheEntry_s
+{
+	CClientFrame* pFrame;
+	int	nTick;
+};
+
+class CDeltaEntityCache
+{
+	struct DeltaEntityEntry_s
+	{
+		DeltaEntityEntry_s *pNext;
+		int	nDeltaTick;
+		int nBits;
+	};
+
+public:
+	CDeltaEntityCache();
+	~CDeltaEntityCache();
+
+	void SetTick( int nTick, int nMaxEntities );
+	unsigned char* FindDeltaBits( int nEntityIndex, int nDeltaTick, int &nBits );
+	void AddDeltaBits( int nEntityIndex, int nDeltaTick, int nBits, bf_write *pBuffer );
+	void Flush();
+
+protected:
+	int	m_nTick;	// current tick
+	int	m_nMaxEntities;	// max entities = length of cache
+	int m_nCacheSize;
+	DeltaEntityEntry_s* m_Cache[MAX_EDICTS]; // array of pointers to delta entries
+};
+
+
+class CGameClient;
+class CGameServer;
+class IHLTVDirector;
+
+class CHLTVServer : public IGameEventListener2, public CBaseServer, public CClientFrameManager, public IHLTVServer, public IDemoPlayer
+{
+friend class CHLTVClientState;
+
+public:
+	CHLTVServer();
+	virtual ~CHLTVServer();
+
+public: // CBaseServer interface:
+	bool	ProcessConnectionlessPacket( netpacket_t * packet );
+
+	void	Init (bool bIsDedicated);
+	void	Shutdown( void );
+	void	Clear( void );
+	bool	IsHLTV( void ) const { return true; };
+	bool	IsMultiplayer( void ) const { return true; };
+	void	FillServerInfo(SVC_ServerInfo &serverinfo);
+	void	GetNetStats( float &avgIn, float &avgOut );
+	int		GetChallengeType ( netadr_t &adr );
+	const char *GetName( void ) const;
+	const char *GetPassword() const;
+	IClient *ConnectClient ( netadr_t &adr, int protocol, int challenge, int clientChallenge, int authProtocol, 
+		const char *name, const char *password, const char *hashedCDkey, int cdKeyLen );
+
+public:
+	void	FireGameEvent(IGameEvent *event);
+
+public: // IHLTVServer interface:
+	IServer	*GetBaseServer( void );
+	IHLTVDirector *GetDirector( void );
+	int		GetHLTVSlot( void ); // return entity index-1 of HLTV in game
+	float	GetOnlineTime( void ); // seconds since broadcast started
+	void	GetLocalStats( int &proxies, int &slots, int &clients ); 
+	void	GetGlobalStats( int &proxies, int &slots, int &clients );
+	void	GetRelayStats( int &proxies, int &slots, int &clients );
+
+	bool	IsMasterProxy( void ); // true, if this is the HLTV master proxy
+	bool	IsTVRelay();			// true if we're running a relay (i.e. this is the opposite of IsMasterProxy()).
+	bool	IsDemoPlayback( void ); // true if this is a HLTV demo
+
+	const netadr_t *GetRelayAddress( void ); // returns relay address
+
+	void	BroadcastEvent(IGameEvent *event);
+
+public: // IDemoPlayer interface
+	CDemoFile *GetDemoFile();
+	int		GetPlaybackStartTick( void );
+	int		GetPlaybackTick( void );
+	int		GetTotalTicks( void );
+	
+	bool	StartPlayback( const char *filename, bool bAsTimeDemo );
+
+	bool	IsPlayingBack( void ); // true if demo loaded and playing back
+	bool	IsPlaybackPaused( void ); // true if playback paused
+	bool	IsPlayingTimeDemo( void ) { return false; } // true if playing back in timedemo mode
+	bool	IsSkipping( void ) { return false; }; // true, if demo player skiiping trough packets
+	bool	CanSkipBackwards( void ) { return true; } // true if demoplayer can skip backwards
+
+	void	SetPlaybackTimeScale( float timescale ); // sets playback timescale
+	float	GetPlaybackTimeScale( void ); // get playback timescale
+
+	void	PausePlayback( float seconds ) {}
+	void	SkipToTick( int tick, bool bRelative, bool bPause ) {}
+	void	SetEndTick( int tick) {}
+	void	ResumePlayback( void ) {}
+	void	StopPlayback( void ) {}
+	void	InterpolateViewpoint() {}
+	netpacket_t *ReadPacket( void ) { return NULL; }
+
+	void	ResetDemoInterpolation( void ) {}
+	int		GetProtocolVersion();
+
+	bool	ShouldLoopDemos() { return true; }
+	void	OnLastDemoInLoopPlayed() {}
+
+	bool	IsLoading( void ) { return false; } // true if demo is currently loading
+
+public:
+	void	StartMaster(CGameClient *client); // start HLTV server as master proxy
+	void	ConnectRelay(const char *address); // connect to other HLTV proxy
+	void	StartDemo(const char *filename); // starts playing back a demo file
+	void    StartRelay( void ); // start HLTV server as relay proxy
+	bool	SendNetMsg( INetMessage &msg, bool bForceReliable = false );
+	void	RunFrame();
+	void	SetMaxClients( int number );
+	void	Changelevel( void );
+	
+	void	UserInfoChanged( int nClientIndex );
+	void	SendClientMessages ( bool bSendSnapshots );
+	CClientFrame *AddNewFrame( CClientFrame * pFrame ); // add new frame, returns HLTV's copy
+	void	SignonComplete( void );
+	void	LinkInstanceBaselines( void );
+	void	BroadcastEventLocal( IGameEvent *event, bool bReliable ); // broadcast event but not to relay proxies
+	void	BroadcastLocalChat( const char *pszChat, const char *pszGroup ); // broadcast event but not to relay proxies
+	void	BroadcastLocalTitle( CHLTVClient *client = NULL ); // NULL = broadcast to all
+	bool	DispatchToRelay( CHLTVClient *pClient);
+	bf_write *GetBuffer( int nBuffer);
+	CClientFrame *GetDeltaFrame( int nTick );
+		
+	inline  CHLTVClient* Client( int i ) { return static_cast<CHLTVClient*>(m_Clients[i]); }
+
+
+protected:
+	virtual bool ShouldUpdateMasterServer();
+	
+private:
+	CBaseClient *CreateNewClient( int slot );
+	void		UpdateTick( void );
+	void		UpdateStats( void );
+	void		InstallStringTables( void );
+	void		RestoreTick( int tick );
+	void		EntityPVSCheck( CClientFrame *pFrame );
+	void		InitClientRecvTables();
+	void		FreeClientRecvTables();
+	void		ReadCompleteDemoFile();
+	void		ResyncDemoClock();
+
+#ifndef NO_STEAM
+	void		ReplyInfo( const netadr_t &adr );
+#endif
+		
+
+	// Vector		GetOriginFromPackedEntity(PackedEntity* pe);
+
+public:
+
+	CGameClient		*m_MasterClient;		// if != NULL, this is the master HLTV 
+	CHLTVClientState m_ClientState;
+	CHLTVDemoRecorder m_DemoRecorder;			// HLTV demo object for recording and playback
+	CGameServer		*m_Server;		// pointer to source server (sv.)
+	IHLTVDirector	*m_Director;	// HTLV director exported by game.dll	
+	int				m_nFirstTick;	// first known server tick;
+	int				m_nLastTick;	// last tick from AddFrame()
+	CHLTVFrame		*m_CurrentFrame; // current delayed HLTV frame
+	int				m_nViewEntity;	// the current entity HLTV is tracking
+	int				m_nPlayerSlot;	// slot of HLTV client on game server
+	CHLTVFrame		m_HLTVFrame;	// all incoming messages go here until Snapshot is made
+
+	bool			m_bSignonState;	// true if connecting to server
+	float			m_flStartTime;
+	float			m_flFPS;		// FPS the proxy is running;
+	int				m_nGameServerMaxClients; // max clients on game server
+	float			m_fNextSendUpdateTime;	// time to send next HLTV status messages 
+	RecvTable		*m_pRecvTables[MAX_DATATABLES];
+	int				m_nRecvTables;
+	Vector			m_vPVSOrigin; 
+	bool			m_bMasterOnlyMode;
+
+	netadr_t		m_RootServer;		// HLTV root server
+	int				m_nGlobalSlots;
+	int				m_nGlobalClients;
+	int				m_nGlobalProxies;
+
+	CNetworkStringTableContainer m_NetworkStringTables;
+
+	CDeltaEntityCache				m_DeltaCache;
+	CUtlVector<CFrameCacheEntry_s>	m_FrameCache;
+
+	// demoplayer stuff:
+	CDemoFile		m_DemoFile;		// for demo playback
+	int				m_nStartTick;
+	democmdinfo_t	m_LastCmdInfo;
+	bool			m_bPlayingBack;
+	bool			m_bPlaybackPaused; // true if demo is paused right now
+	float			m_flPlaybackRateModifier;
+	int				m_nSkipToTick;	// skip to tick ASAP, -1 = off
+};
+
+extern CHLTVServer *hltv;	// The global HLTV server/object. NULL on xbox.
+
+#endif // HLTVSERVER_H