Constants

Pass to SteamGameServer_Init to indicate that the same UDP port will be used for game traffic UDP queries for server browser pings and LAN discovery. In this case, Steam will not open up a socket to handle server browser queries, and you must use ISteamGameServer::HandleIncomingPacket and ISteamGameServer::GetNextOutgoingPacket to handle packets related to server discovery on your socket.

public const ushort STEAMGAMESERVER_QUERY_PORT_SHARED = 65535

Silence some warnings

public const string STEAMNETWORKINGSOCKETS_INTERFACE_VERSION = "SteamNetworkingSockets012"

Silence some warnings

public const string STEAMNETWORKINGUTILS_INTERFACE_VERSION = "SteamNetworkingUtils004"

When sending an option to a specific controller handle, you can send to all devices via this command

public const ulong STEAM_INPUT_HANDLE_ALL_CONTROLLERS = 18446744073709551615

Required with of a thumbnail provided to AddScreenshotToLibrary. If you do not provide a thumbnail one will be generated.

public const int k_ScreenshotThumbWidth = 200

maximum number of groups a single user is allowed

public const int k_cFriendsGroupLimit = 100

maximum number of details int32's storable for a single leaderboard entry

public const int k_cLeaderboardDetailsMax = 64

Network messages Max size of a single message that we can SEND. Note: We might be wiling to receive larger messages, and our peer might, too.

public const int k_cbMaxSteamNetworkingSocketsMessageSizeSend = 524288

maximum number of bytes for a leaderboard name (UTF-8 encoded)

public const int k_cchLeaderboardNameMax = 128

maximum length of friend group name (not including terminating nul!)

public const int k_cchMaxFriendsGroupName = 64

size limits on Rich Presence data

public const int k_cchMaxRichPresenceKeys = 30

A fixed size buffer to receive an error message that is returned by some API calls.

public const int k_cchMaxSteamErrMsg = 1024

Max length of diagnostic error message

public const int k_cchMaxSteamNetworkingErrMsg = 1024

Max possible length of a ping location, in string format. This is an extremely conservative worst case value which leaves room for future syntax enhancements. Most strings in practice are a lot shorter. If you are storing many of these, you will very likely benefit from using dynamic memory.

public const int k_cchMaxSteamNetworkingPingLocationString = 1024

maximum number of characters in a user's name. Two flavors; one for UTF-8 and one for UTF-16. The UTF-8 version has to be very generous to accomodate characters that get large when encoded in UTF-8.

public const int k_cchPersonaNameMax = 128

size limit on stat or achievement name (UTF-8 encoded)

public const int k_cchStatNameMax = 128

Max length of the app's part of the description

public const int k_cchSteamNetworkingMaxConnectionAppName = 32

Max length, in bytes (including null terminator) of the reason string when a connection is closed.

public const int k_cchSteamNetworkingMaxConnectionCloseReason = 128

Max length, in bytes (include null terminator) of debug description of a connection.

public const int k_cchSteamNetworkingMaxConnectionDescription = 128

max supported length of a legacy cd key

public const int k_cubAppProofOfPurchaseKeyMax = 240

size limit on chat room or member metadata

public const int k_cubChatMetadataMax = 8192

NOTE: 2500-2599 are reserved

public const int k_iSteamStreamLauncherCallbacks = 2600

Forward declare types Base values for callback identifiers, each callback must have a unique ID.

public const int k_iSteamUserCallbacks = 100

Port number(s) assigned to us. Only the first entries will contain nonzero values. Entries corresponding to ports beyond what was allocated for you will be zero. (NOTE: At the time of this writing, the maximum number of ports you may request is 4.)

public const int k_nMaxReturnPorts = 8

We're taking advantage of dual-wifi multi-path

public const int k_nSteamNetworkConnectionInfoFlags_DualWifi = 32

The connection is "fast" and "reliable". Either internal/localhost (check the address to find out), or the peer is on the same LAN. (Probably. It's based on the address and the ping time, this is actually hard to determine unambiguously).

public const int k_nSteamNetworkConnectionInfoFlags_Fast = 8

Internal loopback buffers. Won't be true for localhost. (You can check the address to determine that.) This implies k_nSteamNetworkConnectionInfoFlags_FastLAN

public const int k_nSteamNetworkConnectionInfoFlags_LoopbackBuffers = 4

The connection is relayed somehow (SDR or TURN).

public const int k_nSteamNetworkConnectionInfoFlags_Relayed = 16

We don't have a certificate for the remote host.

public const int k_nSteamNetworkConnectionInfoFlags_Unauthenticated = 1

Information is being sent out over a wire unencrypted (by this library)

public const int k_nSteamNetworkConnectionInfoFlags_Unencrypted = 2

Bitmask of types to share Special value - use user defaults

public const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Default = -1

Do not do any ICE work at all or share any IP addresses with peer

public const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Disable = 0

host addresses that appear to be link-local or RFC1918 addresses

public const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Private = 2

STUN reflexive addresses, or host address that isn't a "private" address

public const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Public = 4

Relayed connection via TURN server.

public const int k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Relay = 1

Special values that are returned by some functions that return a ping.

public const int k_nSteamNetworkingPing_Failed = -1

When sending a message using ISteamNetworkingMessages, automatically re-establish a broken session, without returning k_EResultNoConnection. Without this flag, if you attempt to send a message, and the session was proactively closed by the peer, or an error occurred that disrupted communications, then you must close the session using ISteamNetworkingMessages::CloseSessionWithUser before attempting to send another message. (Or you can simply add this flag and retry.) In this way, the disruption cannot go unnoticed, and a more clear order of events can be ascertained. This is especially important when reliable messages are used, since if the connection is disrupted, some of those messages will not have been delivered, and it is in general not possible to know which. Although a SteamNetworkingMessagesSessionFailed_t callback will be posted when an error occurs to notify you that a failure has happened, callbacks are asynchronous, so it is not possible to tell exactly when it happened. And because the primary purpose of ISteamNetworkingMessages is to be like UDP, there is no notification when a peer closes the session. If you are not using any reliable messages (e.g. you are using ISteamNetworkingMessages exactly as a transport replacement for UDP-style datagrams only), you may not need to know when an underlying connection fails, and so you may not need this notification.

public const int k_nSteamNetworkingSend_AutoRestartBrokenSession = 32

If the message cannot be sent very soon (because the connection is still doing some initial handshaking, route negotiations, etc), then just drop it. This is only applicable for unreliable messages. Using this flag on reliable messages is invalid.

public const int k_nSteamNetworkingSend_NoDelay = 4

Disable Nagle's algorithm. By default, Nagle's algorithm is applied to all outbound messages. This means that the message will NOT be sent immediately, in case further messages are sent soon after you send this, which can be grouped together. Any time there is enough buffered data to fill a packet, the packets will be pushed out immediately, but partially-full packets not be sent until the Nagle timer expires. See ISteamNetworkingSockets::FlushMessagesOnConnection, ISteamNetworkingMessages::FlushMessagesToUser NOTE: Don't just send every message without Nagle because you want packets to get there quicker. Make sure you understand the problem that Nagle is solving before disabling it. If you are sending small messages, often many at the same time, then it is very likely that it will be more efficient to leave Nagle enabled. A typical proper use of this flag is when you are sending what you know will be the last message sent for a while (e.g. the last in the server simulation tick to a particular client), and you use this flag to flush all messages.

public const int k_nSteamNetworkingSend_NoNagle = 1

Reliable message send. Can send up to k_cbMaxSteamNetworkingSocketsMessageSizeSend bytes in a single message. Does fragmentation/re-assembly of messages under the hood, as well as a sliding window for efficient sends of large chunks of data. The Nagle algorithm is used. See notes on k_ESteamNetworkingSendType_Unreliable for more details. See k_ESteamNetworkingSendType_ReliableNoNagle, ISteamNetworkingSockets::FlushMessagesOnConnection, ISteamNetworkingMessages::FlushMessagesToUser Migration note: This is NOT the same as k_EP2PSendReliable, it's more like k_EP2PSendReliableWithBuffering

public const int k_nSteamNetworkingSend_Reliable = 8

Send a message reliably, but bypass Nagle's algorithm. Migration note: This is equivalent to k_EP2PSendReliable

public const int k_nSteamNetworkingSend_ReliableNoNagle = 9

Flags used to set options for message sending Send the message unreliably. Can be lost. Messages *can* be larger than a single MTU (UDP packet), but there is no retransmission, so if any piece of the message is lost, the entire message will be dropped. The sending API does have some knowledge of the underlying connection, so if there is no NAT-traversal accomplished or there is a recognized adjustment happening on the connection, the packet will be batched until the connection is open again. Migration note: This is not exactly the same as k_EP2PSendUnreliable! You probably want k_ESteamNetworkingSendType_UnreliableNoNagle

public const int k_nSteamNetworkingSend_Unreliable = 0

Send an unreliable message, but if it cannot be sent relatively quickly, just drop it instead of queuing it. This is useful for messages that are not useful if they are excessively delayed, such as voice data. NOTE: The Nagle algorithm is not used, and if the message is not dropped, any messages waiting on the Nagle timer are immediately flushed. A message will be dropped under the following circumstances: - the connection is not fully connected. (E.g. the "Connecting" or "FindingRoute" states) - there is a sufficiently large number of messages queued up already such that the current message will not be placed on the wire in the next ~200ms or so. If a message is dropped for these reasons, k_EResultIgnored will be returned.

public const int k_nSteamNetworkingSend_UnreliableNoDelay = 5

Send a message unreliably, bypassing Nagle's algorithm for this message and any messages currently pending on the Nagle timer. This is equivalent to using k_ESteamNetworkingSend_Unreliable and then immediately flushing the messages using ISteamNetworkingSockets::FlushMessagesOnConnection or ISteamNetworkingMessages::FlushMessagesToUser. (But using this flag is more efficient since you only make one API call.)

public const int k_nSteamNetworkingSend_UnreliableNoNagle = 1

By default, message sending is queued, and the work of encryption and talking to the operating system sockets, etc is done on a service thread. This is usually a a performance win when messages are sent from the "main thread". However, if this flag is set, and data is ready to be sent immediately (either from this message or earlier queued data), then that work will be done in the current thread, before the current call returns. If data is not ready to be sent (due to rate limiting or Nagle), then this flag has no effect. This is an advanced flag used to control performance at a very low level. For most applications running on modern hardware with more than one CPU core, doing the work of sending on a service thread will yield the best performance. Only use this flag if you have a really good reason and understand what you are doing. Otherwise you will probably just make performance worse.

public const int k_nSteamNetworkingSend_UseCurrentThread = 16

Defines the largest allowed file size. Cloud files cannot be written in a single chunk over 100MB (and cannot be over 200MB total.)

public const int k_unMaxCloudFileChunkSize = 104857600

fixed instance for all individual users

public const int k_unSteamUserDefaultInstance = 1

Use with UpdateRangeTimelineEvent to not change the priority

public const int k_unTimelinePriority_KeepCurrentValue = 1000000

We were unable to get the query port for this server. Was #define QUERY_PORT_ERROR in older versions of Steamworks SDK.

public const ushort k_usFriendGameInfoQueryPort_Error = 65534

special values for FriendGameInfo_t::m_usQueryPort We haven't asked the GS for this query port's actual value yet. Was #define QUERY_PORT_NOT_INITIALIZED in older versions of Steamworks SDK.

public const ushort k_usFriendGameInfoQueryPort_NotInitialized = 65535