SteamGameServer
Class SteamGameServer
Namespace: SwiftlyS2.Shared.SteamAPI
Assembly: SwiftlyS2.CS2.dll
public static class SteamGameServerInheritance
Inherited Members
- object.Equals(object?)
- object.Equals(object?, object?)
- object.GetHashCode()
- object.GetType()
- object.MemberwiseClone()
- object.ReferenceEquals(object?, object?)
- object.ToString()
Methods
AssociateWithClan(CSteamID)
Server clan association
associate this game server with this clan for the purposes of computing player compat
public static SteamAPICall_t AssociateWithClan(CSteamID steamIDClan)- steamIDClan CSteamID
BLoggedOn()
status functions
public static bool BLoggedOn()BSecure()
public static bool BSecure()BUpdateUserData(CSteamID, string, uint)
Update the data to be displayed in the server browser and matchmaking interfaces for a user
currently connected to the server. For regular users you must call this after you receive a
GSUserValidationSuccess callback.
Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player)
public static bool BUpdateUserData(CSteamID steamIDUser, string pchPlayerName, uint uScore)BeginAuthSession(byte[], int, CSteamID)
Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused
Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
public static EBeginAuthSessionResult BeginAuthSession(byte[] pAuthTicket, int cbAuthTicket, CSteamID steamID)CancelAuthTicket(HAuthTicket)
Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
public static void CancelAuthTicket(HAuthTicket hAuthTicket)- hAuthTicket HAuthTicket
ClearAllKeyValues()
/ Call this to clear the whole list of key/values that are sent in rules queries.
public static void ClearAllKeyValues()ComputeNewPlayerCompatibility(CSteamID)
ask if any of the current players dont want to play with this new player - or vice versa
public static SteamAPICall_t ComputeNewPlayerCompatibility(CSteamID steamIDNewPlayer)- steamIDNewPlayer CSteamID
CreateUnauthenticatedUserConnection()
Creates a fake user (ie, a bot) which will be listed as playing on the server, but skips validation.
Return Value: Returns a SteamID for the user to be tracked with, you should call EndAuthSession()
when this user leaves the server just like you would for a real user.
public static CSteamID CreateUnauthenticatedUserConnection()EndAuthSession(CSteamID)
Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
public static void EndAuthSession(CSteamID steamID)- steamID CSteamID
GetAuthSessionTicket(byte[], int, out uint, ref SteamNetworkingIdentity)
Player list management / authentication.
Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ).
pcbTicket retrieves the length of the actual ticket.
SteamNetworkingIdentity is an optional parameter to hold the public IP address of the entity you are connecting to
if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address
public static HAuthTicket GetAuthSessionTicket(byte[] pTicket, int cbMaxTicket, out uint pcbTicket, ref SteamNetworkingIdentity pSnid)- pTicket byte[]
- cbMaxTicket int
- pcbTicket uint
- pSnid SteamNetworkingIdentity
GetGameplayStats()
these two functions s are deprecated, and will not return results
they will be removed in a future version of the SDK
public static void GetGameplayStats()GetNextOutgoingPacket(byte[], int, out uint, out ushort)
AFTER calling HandleIncomingPacket for any packets that came in that frame, call this.
This gets a packet that the master server updater needs to send out on UDP.
It returns the length of the packet it wants to send, or 0 if there are no more packets to send.
Call this each frame until it returns 0.
public static int GetNextOutgoingPacket(byte[] pOut, int cbMaxOut, out uint pNetAdr, out ushort pPort)GetPublicIP()
Returns the public IP of the server according to Steam, useful when the server is
behind NAT and you want to advertise its IP in a lobby for other clients to directly
connect to
public static SteamIPAddress_t GetPublicIP()GetServerReputation()
public static SteamAPICall_t GetServerReputation()GetSteamID()
public static CSteamID GetSteamID()HandleIncomingPacket(byte[], int, uint, ushort)
Server browser related query packet processing for shared socket mode. These are used
when you pass STEAMGAMESERVER_QUERY_PORT_SHARED as the query port to SteamGameServer_Init.
IP address and port are in host order, i.e 127.0.0.1 == 0x7f000001
These are used when you've elected to multiplex the game server's UDP socket
rather than having the master server updater use its own sockets.
Source games use this to simplify the job of the server admins, so they
don't have to open up more ports on their firewalls.
Call this when a packet that starts with 0xFFFFFFFF comes in. That means
it's for us.
public static bool HandleIncomingPacket(byte[] pData, int cbData, uint srcIP, ushort srcPort)LogOff()
/ Begin process of logging game server out of steam
public static void LogOff()LogOn(string)
Login
/ Begin process to login to a persistent game server account
/
/ You need to register for callbacks to determine the result of this operation.
/ @see SteamServersConnected_t
/ @see SteamServerConnectFailure_t
/ @see SteamServersDisconnected_t
public static void LogOn(string pszToken)- pszToken string
LogOnAnonymous()
/ Login to a generic, anonymous account.
/
/ Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init,
/ but this is no longer the case.
public static void LogOnAnonymous()RequestUserGroupStatus(CSteamID, CSteamID)
Ask if a user in in the specified group, results returns async by GSUserGroupStatus_t
returns false if we're not connected to the steam servers and thus cannot ask
public static bool RequestUserGroupStatus(CSteamID steamIDUser, CSteamID steamIDGroup)SendUserConnectAndAuthenticate_DEPRECATED(uint, byte[], uint, out CSteamID)
Handles receiving a new connection from a Steam user. This call will ask the Steam
servers to validate the users identity, app ownership, and VAC status. If the Steam servers
are off-line, then it will validate the cached ticket itself which will validate app ownership
and identity. The AuthBlob here should be acquired on the game client using SteamUser()->InitiateGameConnection()
and must then be sent up to the game server for authentication.
Return Value: returns true if the users ticket passes basic checks. pSteamIDUser will contain the Steam ID of this user. pSteamIDUser must NOT be NULL
If the call succeeds then you should expect a GSClientApprove_t or GSClientDeny_t callback which will tell you whether authentication
for the user has succeeded or failed (the steamid in the callback will match the one returned by this call)
DEPRECATED! This function will be removed from the SDK in an upcoming version.
Please migrate to BeginAuthSession and related functions.
public static bool SendUserConnectAndAuthenticate_DEPRECATED(uint unIPClient, byte[] pvAuthBlob, uint cubAuthBlobSize, out CSteamID pSteamIDUser)SendUserDisconnect_DEPRECATED(CSteamID)
Should be called whenever a user leaves our game server, this lets Steam internally
track which users are currently on which servers for the purposes of preventing a single
account being logged into multiple servers, showing who is currently on a server, etc.
DEPRECATED! This function will be removed from the SDK in an upcoming version.
Please migrate to BeginAuthSession and related functions.
public static void SendUserDisconnect_DEPRECATED(CSteamID steamIDUser)- steamIDUser CSteamID
SetAdvertiseServerActive(bool)
/ Indicate whether you wish to be listed on the master server list
/ and/or respond to server browser / LAN discovery packets.
/ The server starts with this value set to false. You should set all
/ relevant server parameters before enabling advertisement on the server.
/
/ (This function used to be named EnableHeartbeats, so if you are wondering
/ where that function went, it's right here. It does the same thing as before,
/ the old name was just confusing.)
public static void SetAdvertiseServerActive(bool bActive)- bActive bool
SetBotPlayerCount(int)
/ Number of bots. Default value is zero
public static void SetBotPlayerCount(int cBotplayers)- cBotplayers int
SetDedicatedServer(bool)
/ Is this is a dedicated server? The default value is false.
public static void SetDedicatedServer(bool bDedicated)- bDedicated bool
SetGameData(string)
/ Sets a string defining the "gamedata" for this server, this is optional, but if it is set
/ it allows users to filter in the matchmaking/server-browser interfaces based on the value
/
/ @see k_cbMaxGameServerGameData
public static void SetGameData(string pchGameData)- pchGameData string
SetGameDescription(string)
/ Description of the game. This is a required field and is displayed in the steam server browser....for now.
/ This is a required field, but it will go away eventually, as the data should be determined from the AppID.
public static void SetGameDescription(string pszGameDescription)- pszGameDescription string
SetGameTags(string)
/ Sets a string defining the "gametags" for this server, this is optional, but if it is set
/ it allows users to filter in the matchmaking/server-browser interfaces based on the value
/
/ @see k_cbMaxGameServerTags
public static void SetGameTags(string pchGameTags)- pchGameTags string
SetKeyValue(string, string)
/ Call this to add/update a key/value pair.
public static void SetKeyValue(string pKey, string pValue)SetMapName(string)
/ Set name of map to report in the server browser
/
/ @see k_cbMaxGameServerMapName
public static void SetMapName(string pszMapName)- pszMapName string
SetMaxPlayerCount(int)
Server state. These properties may be changed at any time.
/ Max player count that will be reported to server browser and client queries
public static void SetMaxPlayerCount(int cPlayersMax)- cPlayersMax int
SetModDir(string)
/ If your game is a "mod," pass the string that identifies it. The default is an empty string, meaning
/ this application is the original game, not a mod.
/
/ @see k_cbMaxGameServerGameDir
public static void SetModDir(string pszModDir)- pszModDir string
SetPasswordProtected(bool)
/ Let people know if your server will require a password
public static void SetPasswordProtected(bool bPasswordProtected)- bPasswordProtected bool
SetProduct(string)
/ Game product identifier. This is currently used by the master server for version checking purposes.
/ It's a required field, but will eventually will go away, and the AppID will be used for this purpose.
public static void SetProduct(string pszProduct)- pszProduct string
SetRegion(string)
/ Region identifier. This is an optional field, the default value is empty, meaning the "world" region
public static void SetRegion(string pszRegion)- pszRegion string
SetServerName(string)
/ Set the name of server as it will appear in the server browser
/
/ @see k_cbMaxGameServerName
public static void SetServerName(string pszServerName)- pszServerName string
SetSpectatorPort(ushort)
/ Spectator server port to advertise. The default value is zero, meaning the
/ service is not used. If your server receives any info requests on the LAN,
/ this is the value that will be placed into the reply for such local queries.
/
/ This is also the value that will be advertised by the master server.
/ The only exception is if your server is using a FakeIP. Then then the second
/ fake port number (index 1) assigned to your server will be listed on the master
/ server as the spectator port, if you set this value to any nonzero value.
/
/ This function merely controls the values that are advertised -- it's up to you to
/ configure the server to actually listen on this port and handle any spectator traffic
public static void SetSpectatorPort(ushort unSpectatorPort)- unSpectatorPort ushort
SetSpectatorServerName(string)
/ Name of the spectator server. (Only used if spectator port is nonzero.)
/
/ @see k_cbMaxGameServerMapName
public static void SetSpectatorServerName(string pszSpectatorServerName)- pszSpectatorServerName string
UserHasLicenseForApp(CSteamID, AppId_t)
After receiving a user's authentication data, and passing it to SendUserConnectAndAuthenticate, use this function
to determine if the user owns downloadable content specified by the provided AppID.
public static EUserHasLicenseForAppResult UserHasLicenseForApp(CSteamID steamID, AppId_t appID)WasRestartRequested()
/ Returns true if the master server has requested a restart.
/ Only returns true once per request.
public static bool WasRestartRequested()