csgo/cstrike15_src/public/gcsdk/gcclient.h

//====== Copyright (c), Valve Corporation, All rights reserved. =======
//
// Purpose: Holds the CGCClient class
//
//=============================================================================

#ifndef GCCLIENT_H
#define GCCLIENT_H
#ifdef _WIN32
#pragma once
#endif

#include "steam/steam_api.h"
#include "jobmgr.h"
#include "sharedobject.h"

class ISteamGameCoordinator;
struct GCMessageAvailable_t;
class CTestEvent;

namespace GCSDK
{


//-----------------------------------------------------------------------------
// Purpose: Interface for communicating with the GC
//-----------------------------------------------------------------------------
class CGCClient
{
public:
	CGCClient( bool bGameserver = false );
	virtual ~CGCClient( );

	/// Call once at program startup
	bool BInit( uint32 unVersion, ISteamClient *pSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe );

	/// Cleanup
	void Uninit( );

	/// Call this to perform periodic service
	bool BMainLoop( uint64 ulLimitMicroseconds, uint64 ulFrameTimeMicroseconds = 0 );

	/// Set current session need state value that is sent in the HELLO message to
	/// determine login priority.  At this generic level we don't know what the
	/// game-specific client states mean, and  which states imply a need for a
	/// GC session, so you need to tell us that, too.  This decides whether we are
	/// aggressive at sending HELLO messages to try to establish the connection
	/// or not.
	void SetSessionNeed( uint32 nSessionNeed, bool bWantSession );

	/// Launcher value.  Sent in the HELLO message
	void SetLauncherType( uint32 nLauncherType ) { m_nLauncherType = nLauncherType; }

	/// Steam datagram port, for servers.  Sent in the HELLO message
	void SetServerSteamdatagramPort( uint16 usPort ) { m_usSteamdatagramPort = usPort; }

	CJobMgr &GetJobMgr() { return m_JobMgr; }

	/// Send a message to the GC.
	bool BSendMessage( uint32 unMsgType, const uint8 *pubData, uint32 cubData );
	bool BSendMessage( const CGCMsgBase& msg );
	bool BSendMessage( const CProtoBufMsgBase& msg );

	/// Locate a given shared object from the cache
	CSharedObject *FindSharedObject( SOID_t ID, const CSharedObject & soIndex );

	/// Find a shared object cache for the specified user.  Optionally, the cache will be
	/// created if it doesn't not currently exist.
	CGCClientSharedObjectCache *FindSOCache( SOID_t ID, bool bCreateIfMissing = true );

	/// Find a set of shared object caches for a specific type of SOID
	/// returns true if any were found
	typedef CUtlVectorFixedGrowable< CGCClientSharedObjectCache *, 1 > ClientSOCacheVec_t;
	bool FindSOCacheByType( uint32 type, ClientSOCacheVec_t &cacheList );

	/// Adds a listener to the shared object cache for the specified Steam ID.
	///
	/// @see CGCClientSharedObjectCache::AddListener
	bool AddSOCacheListener( ISharedObjectListener *pListener );

	/// Removes a listener for the shared object cache for the specified Steam ID.
	/// Returns true if we were listening and were successfully removed, false
	/// otherwise
	///
	/// @see CGCClientSharedObjectCache::RemoveListener
	bool RemoveSOCacheListener( ISharedObjectListener *pListener );

	void DispatchSOCreated( SOID_t owner, const CSharedObject *pObject, ESOCacheEvent eEvent );
	void DispatchSOUpdated( SOID_t owner, const CSharedObject *pObject, ESOCacheEvent eEvent );
	void DispatchSODestroyed( SOID_t owner, const CSharedObject *pObject, ESOCacheEvent eEvent );
	void DispatchSOCacheSubscribed( SOID_t owner, ESOCacheEvent eEvent );
	void DispatchSOCacheUnsubscribed( SOID_t owner, ESOCacheEvent eEvent );

	typedef CUtlVector< ISharedObjectListener * > SharedObjectListensersVec_t;
	const SharedObjectListensersVec_t & GetListeners() const { return m_vecListeners; }

	void OnGCMessageAvailable( GCMessageAvailable_t *pCallback );
	ISteamGameCoordinator *GetSteamGameCoordinator() { return m_pSteamGameCoordinator; }

	virtual void Test_AddEvent( CTestEvent *pEvent )	{}
	virtual void Test_CacheSubscribed( SOID_t ID ) {}

	void NotifySOCacheUnsubscribed( SOID_t ID );
	void NotifyResubscribedUpToDate( SOID_t ID );

	/// Send a HELLO message to the GC now.
	void SendHello();

	// Called when we receive a welcome message, to sync up our SO caches with the
	// what the GC is telling us we have.
	void ProcessSOCacheSubscribedMsg( const CMsgSOCacheSubscribed &msg );

	/// Simulate inability to connect to DOTA's GC.
	/// (But allow us to connect to Steam.)
	bool GetSimulateGCConnectionFailure() const { return m_bSimulateGCConnectionFailure; }
	void SetSimulateGCConnectionFailure( bool bForcedFailure );

	/// Called when any messages times out.  When this happens, it's usually
	/// safe to assume that the connection has been interrupted, and we should
	/// renegotiate.
	void MessageReplyTimedOut( uint32 nExpectedMsg, uint nTimeoutSecs );

	//
	// Logon queue stats.
	//
	// These return negative if quantities are not known.
	// All of these numbers can only be valid if we're in the
	// GCConnectionStatus_NO_SESSION_IN_LOGON_QUEUE state.  However,
	// just because we're in that state does NOT mean that they will be
	// available!
	int GetLogonQueuePosition() const { return m_nLogonQueuePosition; }
	int GetLogonQueueSize() const { return m_nLogonQueueSize; }
	int GetLogonQueueEstimatedSecondsRemaining() const;
	int GetLogonQueueApproxWaitSeconds() const;

protected:

	ISteamUser *m_pSteamUser;
	ISteamGameServer *m_pSteamGameserver;
	ISteamGameCoordinator *m_pSteamGameCoordinator;
	CUtlMemory<uint8> m_memMsg;

	// local job handling
	CJobMgr m_JobMgr;

	// Shared object caches
	typedef CUtlMap<SOID_t, CGCClientSharedObjectCache *> MapSOCache_t;
	MapSOCache_t m_mapSOCache;

	SharedObjectListensersVec_t m_vecListeners;

	uint64 m_timeLastSendHello;
	uint64 m_timeReceivedConnectionStatus;
	uint64 m_timeLoggedOn;
	uint32 m_unVersion;
	const bool m_bGameserver;
	bool m_bSimulateGCConnectionFailure;
	uint32 m_nSessionNeed;
	uint32 m_nLastSessionNeed; // last session need state sent / received from the GC
	bool m_bWantSession;
	uint32 m_nLauncherType;
	uint16 m_usSteamdatagramPort;

	int m_nLogonQueuePosition;
	int m_nLogonQueueSize;
	uint64 m_timeLogonQueueApproxTimeEnteredQueue;
	uint64 m_timeLogonQueueEstimatedTimeExitQueue;

	void ClearLogonQueueStats();

	void UpdateLogonState();
	void ThinkConnection();
	void DispatchPacket( IMsgNetPacket *pMsgNetPacket );

	// Steam callback for getting notified about messages available. Not part of the class
	// in Steam builds because we use the TestClientManager instead of steam_api.dll in Steam 
#ifndef STEAM
	CCallback< CGCClient, GCMessageAvailable_t, false > m_callbackGCMessageAvailable;
	STEAM_CALLBACK( CGCClient, OnSteamServersDisconnected, SteamServersDisconnected_t, m_CallbackSteamServersDisconnected );
	STEAM_CALLBACK( CGCClient, OnSteamServerConnectFailure, SteamServerConnectFailure_t, m_CallbackSteamServerConnectFailure );
	STEAM_CALLBACK( CGCClient, OnSteamServersConnected, SteamServersConnected_t, m_CallbackSteamServersConnected );
#endif

};

//utility to make defining client jobs more straight forward
#define GC_REG_CLIENT_JOB( JobClass, Msg )	\
	GC_REG_JOB( GCSDK::CGCClient, JobClass, #JobClass, Msg )


} // namespace GCSDK

#endif // GCCLIENT_H