You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
243 lines
12 KiB
243 lines
12 KiB
//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= |
|
// |
|
// Purpose: |
|
// |
|
//============================================================================= |
|
|
|
#ifndef STEAM_GAMESERVER_H |
|
#define STEAM_GAMESERVER_H |
|
#ifdef _WIN32 |
|
#pragma once |
|
#endif |
|
|
|
#include "steam_api.h" |
|
#include "isteamgameserver.h" |
|
#include "isteamgameserverstats.h" |
|
|
|
enum EServerMode |
|
{ |
|
eServerModeInvalid = 0, // DO NOT USE |
|
eServerModeNoAuthentication = 1, // Don't authenticate user logins and don't list on the server list |
|
eServerModeAuthentication = 2, // Authenticate users, list on the server list, don't run VAC on clients that connect |
|
eServerModeAuthenticationAndSecure = 3, // Authenticate users, list on the server list and VAC protect clients |
|
}; |
|
|
|
// Initialize ISteamGameServer interface object, and set server properties which may not be changed. |
|
// |
|
// After calling this function, you should set any additional server parameters, and then |
|
// call ISteamGameServer::LogOnAnonymous() or ISteamGameServer::LogOn() |
|
// |
|
// - usSteamPort is the local port used to communicate with the steam servers. |
|
// - usGamePort is the port that clients will connect to for gameplay. |
|
// - usQueryPort is the port that will manage server browser related duties and info |
|
// pings from clients. If you pass MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE for usQueryPort, then it |
|
// will use "GameSocketShare" mode, which means that the game is responsible for sending and receiving |
|
// UDP packets for the master server updater. See references to GameSocketShare in isteamgameserver.h. |
|
// - The version string is usually in the form x.x.x.x, and is used by the master server to detect when the |
|
// server is out of date. (Only servers with the latest version will be listed.) |
|
|
|
inline bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString ); |
|
|
|
S_API void SteamGameServer_Shutdown(); |
|
S_API void SteamGameServer_RunCallbacks(); |
|
|
|
// Most Steam API functions allocate some amount of thread-local memory for |
|
// parameter storage. Calling SteamGameServer_ReleaseCurrentThreadMemory() |
|
// will free all API-related memory associated with the calling thread. |
|
// This memory is released automatically by SteamGameServer_RunCallbacks(), |
|
// so single-threaded servers do not need to explicitly call this function. |
|
inline void SteamGameServer_ReleaseCurrentThreadMemory(); |
|
|
|
S_API bool SteamGameServer_BSecure(); |
|
S_API uint64 SteamGameServer_GetSteamID(); |
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------// |
|
// Global accessors for game server C++ APIs. See individual isteam*.h files for details. |
|
// You should not cache the results of these accessors or pass the result pointers across |
|
// modules! Different modules may be compiled against different SDK header versions, and |
|
// the interface pointers could therefore be different across modules. Every line of code |
|
// which calls into a Steamworks API should retrieve the interface from a global accessor. |
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------// |
|
#if !defined( STEAM_API_EXPORTS ) |
|
inline ISteamClient *SteamGameServerClient(); |
|
inline ISteamGameServer *SteamGameServer(); |
|
inline ISteamUtils *SteamGameServerUtils(); |
|
inline ISteamNetworking *SteamGameServerNetworking(); |
|
inline ISteamGameServerStats *SteamGameServerStats(); |
|
inline ISteamHTTP *SteamGameServerHTTP(); |
|
inline ISteamInventory *SteamGameServerInventory(); |
|
inline ISteamUGC *SteamGameServerUGC(); |
|
inline ISteamApps *SteamGameServerApps(); |
|
#endif |
|
|
|
class CSteamGameServerAPIContext |
|
{ |
|
public: |
|
CSteamGameServerAPIContext() { Clear(); } |
|
inline void Clear(); |
|
inline bool Init(); |
|
|
|
ISteamClient *SteamClient() const { return m_pSteamClient; } |
|
ISteamGameServer *SteamGameServer() const { return m_pSteamGameServer; } |
|
ISteamUtils *SteamGameServerUtils() const { return m_pSteamGameServerUtils; } |
|
ISteamNetworking *SteamGameServerNetworking() const { return m_pSteamGameServerNetworking; } |
|
ISteamGameServerStats *SteamGameServerStats() const { return m_pSteamGameServerStats; } |
|
ISteamHTTP *SteamHTTP() const { return m_pSteamHTTP; } |
|
ISteamInventory *SteamInventory() const { return m_pSteamInventory; } |
|
ISteamUGC *SteamUGC() const { return m_pSteamUGC; } |
|
ISteamApps *SteamApps() const { return m_pSteamApps; } |
|
|
|
private: |
|
ISteamClient *m_pSteamClient; |
|
ISteamGameServer *m_pSteamGameServer; |
|
ISteamUtils *m_pSteamGameServerUtils; |
|
ISteamNetworking *m_pSteamGameServerNetworking; |
|
ISteamGameServerStats *m_pSteamGameServerStats; |
|
ISteamHTTP *m_pSteamHTTP; |
|
ISteamInventory *m_pSteamInventory; |
|
ISteamUGC *m_pSteamUGC; |
|
ISteamApps *m_pSteamApps; |
|
}; |
|
|
|
|
|
// Older SDKs exported this global pointer, but it is no longer supported. |
|
// You should use SteamGameServerClient() or CSteamGameServerAPIContext to |
|
// safely access the ISteamClient APIs from your game server application. |
|
//S_API ISteamClient *g_pSteamClientGameServer; |
|
|
|
// SteamGameServer_InitSafe has been replaced with SteamGameServer_Init and |
|
// is no longer supported. Use SteamGameServer_Init instead. |
|
//S_API void S_CALLTYPE SteamGameServer_InitSafe(); |
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------// |
|
// These macros are similar to the STEAM_CALLBACK_* macros in steam_api.h, but only trigger for gameserver callbacks |
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------// |
|
#define STEAM_GAMESERVER_CALLBACK( thisclass, func, /*callback_type, [deprecated] var*/... ) \ |
|
_STEAM_CALLBACK_SELECT( ( __VA_ARGS__, GS, 3 ), ( this->SetGameserverFlag();, thisclass, func, __VA_ARGS__ ) ) |
|
|
|
#define STEAM_GAMESERVER_CALLBACK_MANUAL( thisclass, func, callback_type, var ) \ |
|
CCallbackManual< thisclass, callback_type, true > var; void func( callback_type *pParam ) |
|
|
|
|
|
#define _STEAM_CALLBACK_GS( _, thisclass, func, param, var ) \ |
|
CCallback< thisclass, param, true > var; void func( param *pParam ) |
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------// |
|
// steamclient.dll private wrapper functions |
|
// |
|
// The following functions are part of abstracting API access to the steamclient.dll, but should only be used in very specific cases |
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------// |
|
S_API HSteamPipe S_CALLTYPE SteamGameServer_GetHSteamPipe(); |
|
S_API HSteamUser S_CALLTYPE SteamGameServer_GetHSteamUser(); |
|
S_API bool S_CALLTYPE SteamInternal_GameServer_Init( uint32 unIP, uint16 usPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString ); |
|
|
|
|
|
#if !defined( STEAM_API_EXPORTS ) |
|
inline void S_CALLTYPE SteamGameServerInternal_OnContextInit( void* p ) |
|
{ |
|
((CSteamGameServerAPIContext*)p)->Clear(); |
|
if ( SteamGameServer_GetHSteamPipe() ) |
|
((CSteamGameServerAPIContext*)p)->Init(); |
|
} |
|
inline CSteamGameServerAPIContext& SteamGameServerInternal_ModuleContext() |
|
{ |
|
// SteamInternal_ContextInit takes a base pointer for the equivalent of |
|
// struct { void (*pFn)(void* pCtx); uintp counter; CSteamAPIContext ctx; } |
|
// Do not change layout of 2 + sizeof... or add non-pointer aligned data! |
|
// NOTE: declaring "static CSteamAPIConext" creates a large function |
|
// which queries the initialization status of the object. We know that |
|
// it is pointer-aligned and fully memset with zeros, so just alias a |
|
// static buffer of the appropriate size and call it a CSteamAPIContext. |
|
static void* s_CallbackCounterAndContext[2 + sizeof( CSteamGameServerAPIContext ) / sizeof( void* )] = { (void*)&SteamGameServerInternal_OnContextInit, 0 }; |
|
return *(CSteamGameServerAPIContext*)SteamInternal_ContextInit( s_CallbackCounterAndContext ); |
|
} |
|
inline ISteamClient *SteamGameServerClient() { return SteamGameServerInternal_ModuleContext().SteamClient(); } |
|
inline ISteamGameServer *SteamGameServer() { return SteamGameServerInternal_ModuleContext().SteamGameServer(); } |
|
inline ISteamUtils *SteamGameServerUtils() { return SteamGameServerInternal_ModuleContext().SteamGameServerUtils(); } |
|
inline ISteamNetworking *SteamGameServerNetworking() { return SteamGameServerInternal_ModuleContext().SteamGameServerNetworking(); } |
|
inline ISteamGameServerStats *SteamGameServerStats() { return SteamGameServerInternal_ModuleContext().SteamGameServerStats(); } |
|
inline ISteamHTTP *SteamGameServerHTTP() { return SteamGameServerInternal_ModuleContext().SteamHTTP(); } |
|
inline ISteamInventory *SteamGameServerInventory() { return SteamGameServerInternal_ModuleContext().SteamInventory(); } |
|
inline ISteamUGC *SteamGameServerUGC() { return SteamGameServerInternal_ModuleContext().SteamUGC(); } |
|
inline ISteamApps *SteamGameServerApps() { return SteamGameServerInternal_ModuleContext().SteamApps(); } |
|
#endif // !defined( STEAM_API_EXPORTS ) |
|
|
|
|
|
inline void CSteamGameServerAPIContext::Clear() |
|
{ |
|
m_pSteamClient = NULL; |
|
m_pSteamGameServer = NULL; |
|
m_pSteamGameServerUtils = NULL; |
|
m_pSteamGameServerNetworking = NULL; |
|
m_pSteamGameServerStats = NULL; |
|
m_pSteamHTTP = NULL; |
|
m_pSteamInventory = NULL; |
|
m_pSteamUGC = NULL; |
|
m_pSteamApps = NULL; |
|
} |
|
|
|
// This function must be declared inline in the header so the module using steam_api.dll gets the version names they want. |
|
inline bool CSteamGameServerAPIContext::Init() |
|
{ |
|
HSteamUser hSteamUser = SteamGameServer_GetHSteamUser(); |
|
HSteamPipe hSteamPipe = SteamGameServer_GetHSteamPipe(); |
|
if ( !hSteamPipe ) |
|
return false; |
|
|
|
m_pSteamClient = (ISteamClient*) SteamInternal_CreateInterface( STEAMCLIENT_INTERFACE_VERSION ); |
|
if ( !m_pSteamClient ) |
|
return false; |
|
|
|
m_pSteamGameServer = m_pSteamClient->GetISteamGameServer( hSteamUser, hSteamPipe, STEAMGAMESERVER_INTERFACE_VERSION ); |
|
if ( !m_pSteamGameServer ) |
|
return false; |
|
|
|
m_pSteamGameServerUtils = m_pSteamClient->GetISteamUtils( hSteamPipe, STEAMUTILS_INTERFACE_VERSION ); |
|
if ( !m_pSteamGameServerUtils ) |
|
return false; |
|
|
|
m_pSteamGameServerNetworking = m_pSteamClient->GetISteamNetworking( hSteamUser, hSteamPipe, STEAMNETWORKING_INTERFACE_VERSION ); |
|
if ( !m_pSteamGameServerNetworking ) |
|
return false; |
|
|
|
m_pSteamGameServerStats = m_pSteamClient->GetISteamGameServerStats( hSteamUser, hSteamPipe, STEAMGAMESERVERSTATS_INTERFACE_VERSION ); |
|
if ( !m_pSteamGameServerStats ) |
|
return false; |
|
|
|
m_pSteamHTTP = m_pSteamClient->GetISteamHTTP( hSteamUser, hSteamPipe, STEAMHTTP_INTERFACE_VERSION ); |
|
if ( !m_pSteamHTTP ) |
|
return false; |
|
|
|
m_pSteamInventory = m_pSteamClient->GetISteamInventory( hSteamUser, hSteamPipe, STEAMINVENTORY_INTERFACE_VERSION ); |
|
if ( !m_pSteamInventory ) |
|
return false; |
|
|
|
m_pSteamUGC = m_pSteamClient->GetISteamUGC( hSteamUser, hSteamPipe, STEAMUGC_INTERFACE_VERSION ); |
|
if ( !m_pSteamUGC ) |
|
return false; |
|
|
|
m_pSteamApps = m_pSteamClient->GetISteamApps( hSteamUser, hSteamPipe, STEAMAPPS_INTERFACE_VERSION ); |
|
if ( !m_pSteamApps ) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
|
|
inline bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString ) |
|
{ |
|
if ( !SteamInternal_GameServer_Init( unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString ) ) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
|
|
inline void SteamGameServer_ReleaseCurrentThreadMemory() |
|
{ |
|
SteamAPI_ReleaseCurrentThreadMemory(); |
|
} |
|
|
|
#endif // STEAM_GAMESERVER_H
|
|
|