From ceeaf66b95456b34b5b7a510ab5b491f91a6d515 Mon Sep 17 00:00:00 2001 From: Nicholas Hastings Date: Sun, 12 Jul 2026 13:31:37 -0400 Subject: [PATCH] Add function docs to inc --- Pawn/includes/SteamWorks.inc | 566 +++++++++++++++++++++++++++++++++++ 1 file changed, 566 insertions(+) diff --git a/Pawn/includes/SteamWorks.inc b/Pawn/includes/SteamWorks.inc index 224bb40..0239777 100644 --- a/Pawn/includes/SteamWorks.inc +++ b/Pawn/includes/SteamWorks.inc @@ -245,6 +245,12 @@ enum EHTTPStatusCode k_EHTTPStatusCode5xxUnknown = 599, }; +/** + * Returns whether an HTTP status code represents success (a 2xx code). + * + * @param eStatusCode HTTP status code to test. + * @return True if the code is in the 2xx range, false otherwise. + */ stock bool IsHTTPStatusSuccess(EHTTPStatusCode eStatusCode) { return (eStatusCode >= k_EHTTPStatusCode200OK && eStatusCode < k_EHTTPStatusCode300MultipleChoices); @@ -260,41 +266,316 @@ enum EGCResults k_EGCResultInvalidMessage = 4, // Something was wrong with the message being sent with SendMessage }; +/** + * Returns whether the server is VAC (Valve Anti-Cheat) secured. + * + * @return True if the server is VAC secured, false otherwise (including + * when not yet connected to Steam). + */ native bool SteamWorks_IsVACEnabled(); + +/** + * Retrieves the server's public IP address as four octets. + * + * @param ipaddr Array that receives the IP address, most-significant octet first + * (e.g. 127.0.0.1 becomes {127, 0, 0, 1}). + * @return True on success, false if not connected to Steam or the public + * IP is not yet known. + */ native bool SteamWorks_GetPublicIP(int ipaddr[4]); + +/** + * Retrieves the server's public IP address packed into a single cell. + * + * @return The IPv4 address as a 32-bit value (host byte order), or 0 if not + * connected to Steam or the public IP is not yet known. + */ native int SteamWorks_GetPublicIPCell(); + +/** + * Returns whether the Steam client library has been loaded by the extension. + * + * @return True if the Steam library is loaded, false otherwise. + */ native bool SteamWorks_IsLoaded(); + +/** + * Sets the "gamedata" string for the server, used for matchmaking/server-browser filtering. + * + * @param sData Game data string. + * @return True on success, false if not connected to Steam. + */ native bool SteamWorks_SetGameData(const char[] sData); + +/** + * Sets the game description reported to the server browser and client queries. + * + * @param sDesc Game description string. + * @return True on success, false if not connected to Steam. + */ native bool SteamWorks_SetGameDescription(const char[] sDesc); + +/** + * Sets the map name reported to the server browser and client queries. + * + * @param sMapName Map name string. + * @return True on success, false if not connected to Steam. + */ native bool SteamWorks_SetMapName(const char[] sMapName); + +/** + * Returns whether the server is currently logged on to Steam. + * + * @return True if logged on to Steam, false otherwise. + */ native bool SteamWorks_IsConnected(); + +/** + * Adds or updates a key/value pair sent in A2S rules queries. + * + * @param sKey Rule key. + * @param sValue Rule value. + * @return True on success, false if not connected to Steam. + */ native bool SteamWorks_SetRule(const char[] sKey, const char[] sValue); + +/** + * Clears the entire list of key/value pairs sent in rules queries. + * + * @return True on success, false if not connected to Steam. + */ native bool SteamWorks_ClearRules(); + +/** + * Deprecated no-op. Newer Steamworks SDKs removed ForceHeartbeat; server list + * heartbeats are now sent implicitly by Steam. + * + * @return Always false. + */ #pragma deprecated This function is deprecated in the SDK and no longer does anything in this extension native bool SteamWorks_ForceHeartbeat(); + +/** + * Asynchronously requests whether a client is a member of a given Steam group. + * The result is delivered through the SteamWorks_OnClientGroupStatus forward. + * + * @param client Client index. + * @param groupid 32-bit account ID of the Steam group. + * @return True if the request was sent, false if not connected to Steam. + * @error Invalid client index. + */ native bool SteamWorks_GetUserGroupStatus(int client, int groupid); + +/** + * Asynchronously requests whether a user is a member of a given Steam group. + * The result is delivered through the SteamWorks_OnClientGroupStatus forward. + * + * @param authid 32-bit account ID of the user to query. + * @param groupid 32-bit account ID of the Steam group. + * @return True if the request was sent, false if not connected to Steam. + */ native bool SteamWorks_GetUserGroupStatusAuthID(int authid, int groupid); +/** + * Returns whether a client owns/has a license for the given application. + * + * @param client Client index. + * @param app Application (AppID) to check ownership of. + * @return An EUserHasLicenseForAppResult value; k_EUserHasLicenseResultNoAuth + * if not connected to Steam. + * @error Invalid client index. + */ native EUserHasLicenseForAppResult SteamWorks_HasLicenseForApp(int client, int app); + +/** + * Returns whether a user owns/has a license for the given application. + * + * @param authid 32-bit account ID of the user to check. + * @param app Application (AppID) to check ownership of. + * @return An EUserHasLicenseForAppResult value; k_EUserHasLicenseResultNoAuth + * if not connected to Steam. + */ native EUserHasLicenseForAppResult SteamWorks_HasLicenseForAppId(int authid, int app); + +/** + * Retrieves a client's 64-bit Steam ID (community ID) as a string. + * + * @param client Client index. + * @param sSteamID Buffer to store the rendered 64-bit Steam ID. + * @param length Maximum length of the buffer. + * @return Number of bytes written, including the null terminator. + * @error Invalid client index. + */ native int SteamWorks_GetClientSteamID(int client, char[] sSteamID, int length); +/** + * Asynchronously requests the stats of a user from Steam. Stats become available + * afterwards through SteamWorks_GetStatAuthIDCell / SteamWorks_GetStatAuthIDFloat. + * + * @param authid 32-bit account ID of the user whose stats to request. + * @param appid Application (AppID) to request stats for. + * @return True if the request was sent, false if not connected to Steam. + */ native bool SteamWorks_RequestStatsAuthID(int authid, int appid); + +/** + * Asynchronously requests the stats of a client from Steam. Stats become available + * afterwards through SteamWorks_GetStatCell / SteamWorks_GetStatFloat. + * + * @param client Client index. + * @param appid Application (AppID) to request stats for. + * @return True if the request was sent, false if not connected to Steam. + * @error Invalid client index. + */ native bool SteamWorks_RequestStats(int client, int appid); + +/** + * Retrieves an integer stat for a client. The client's stats must have been + * requested first with SteamWorks_RequestStats. + * + * @param client Client index. + * @param sKey Stat name. + * @param value Variable to store the stat value in. + * @return True on success, false on failure or if not connected to Steam. + * @error Invalid client index. + */ native bool SteamWorks_GetStatCell(int client, const char[] sKey, int &value); + +/** + * Retrieves an integer stat for a user. The user's stats must have been + * requested first with SteamWorks_RequestStatsAuthID. + * + * @param authid 32-bit account ID of the user. + * @param sKey Stat name. + * @param value Variable to store the stat value in. + * @return True on success, false on failure or if not connected to Steam. + */ native bool SteamWorks_GetStatAuthIDCell(int authid, const char[] sKey, int &value); + +/** + * Retrieves a floating-point stat for a client. The client's stats must have been + * requested first with SteamWorks_RequestStats. + * + * @param client Client index. + * @param sKey Stat name. + * @param value Variable to store the stat value in. + * @return True on success, false on failure or if not connected to Steam. + * @error Invalid client index. + */ native bool SteamWorks_GetStatFloat(int client, const char[] sKey, float &value); + +/** + * Retrieves a floating-point stat for a user. The user's stats must have been + * requested first with SteamWorks_RequestStatsAuthID. + * + * @param authid 32-bit account ID of the user. + * @param sKey Stat name. + * @param value Variable to store the stat value in. + * @return True on success, false on failure or if not connected to Steam. + */ native bool SteamWorks_GetStatAuthIDFloat(int authid, const char[] sKey, float &value); +/** + * Creates a new HTTP request. The URL must be absolute and start with http:// or https://. + * + * The returned handle must be freed with CloseHandle/delete once the request is finished. + * + * @param method HTTP method to use. + * @param sURL Absolute URL for the request. + * @return A handle to the new HTTP request, or INVALID_HANDLE on failure + * (including when not connected to Steam). + */ native Handle SteamWorks_CreateHTTPRequest(EHTTPMethod method, const char[] sURL); + +/** + * Sets one or two context values that will be passed back to the request's callbacks. + * These let you associate arbitrary data with a request. + * + * @param hHandle HTTP request handle. + * @param data1 First context value. + * @param data2 Second context value. + * @return True on success, false on an invalid handle or if the request was + * already sent. + */ native bool SteamWorks_SetHTTPRequestContextValue(Handle hHandle, any data1, any data2=0); + +/** + * Sets a network-activity timeout, in seconds, for the request. Must be called before sending. + * The default is 60 seconds. The timer resets whenever more data is received. + * + * @param hHandle HTTP request handle. + * @param timeout Timeout in seconds. + * @return True on success, false on an invalid handle or if the request was + * already sent. + */ native bool SteamWorks_SetHTTPRequestNetworkActivityTimeout(Handle hHandle, int timeout); + +/** + * Sets a request header value. Must be called before sending the request. + * + * @param hHandle HTTP request handle. + * @param sName Header name. + * @param sValue Header value. + * @return True on success, false on an invalid handle or if the request was + * already sent. + */ native bool SteamWorks_SetHTTPRequestHeaderValue(Handle hHandle, const char[] sName, const char[] sValue); + +/** + * Sets a GET or POST parameter on the request (which is used depends on the request method). + * Must be called before sending the request. + * + * @param hHandle HTTP request handle. + * @param sName Parameter name. + * @param sValue Parameter value. + * @return True on success, false on an invalid handle or if the request was + * already sent. + */ native bool SteamWorks_SetHTTPRequestGetOrPostParameter(Handle hHandle, const char[] sName, const char[] sValue); + +/** + * Appends extra user-agent info to the request. This does not clobber the normal user + * agent; it is added to the end. + * + * @param hHandle HTTP request handle. + * @param sUserAgentInfo Extra user-agent info string. + * @return True on success, false on an invalid handle. + */ native bool SteamWorks_SetHTTPRequestUserAgentInfo(Handle hHandle, const char[] sUserAgentInfo); + +/** + * Enables or disables verification of SSL/TLS certificates. By default, certificates + * are verified for all HTTPS requests. + * + * @param hHandle HTTP request handle. + * @param bRequireVerifiedCertificate True to require a verified certificate, false to disable. + * @return True on success, false on an invalid handle. + */ native bool SteamWorks_SetHTTPRequestRequiresVerifiedCertificate(Handle hHandle, bool bRequireVerifiedCertificate); + +/** + * Sets an absolute timeout, in milliseconds, on the request. Unlike the network-activity + * timeout, this is a total time limit that does not reset as data arrives. + * + * @param hHandle HTTP request handle. + * @param unMilliseconds Total timeout in milliseconds. + * @return True on success, false on an invalid handle. + */ native bool SteamWorks_SetHTTPRequestAbsoluteTimeoutMS(Handle hHandle, int unMilliseconds); +/** + * Called when an HTTP request has completed (or failed). The number of trailing context + * parameters matches how many values were passed to SteamWorks_SetHTTPRequestContextValue. + * + * @param hRequest HTTP request handle. + * @param bFailure True if the request failed due to an internal or network + * error (no response from the server). + * @param bRequestSuccessful True if any response was received from the server (even an + * error response). + * @param eStatusCode HTTP status code returned by the server. + * @param data1 First context value, if one was set. + * @param data2 Second context value, if one was set. + */ typeset SteamWorksHTTPRequestCompleted { function void (Handle hRequest, bool bFailure, bool bRequestSuccessful, EHTTPStatusCode eStatusCode); @@ -302,6 +583,15 @@ typeset SteamWorksHTTPRequestCompleted function void (Handle hRequest, bool bFailure, bool bRequestSuccessful, EHTTPStatusCode eStatusCode, any data1, any data2); }; +/** + * Called when the response headers for a streaming request have been received. The number + * of trailing context parameters matches the context values set on the request. + * + * @param hRequest HTTP request handle. + * @param bFailure True if the request failed due to an internal or network error. + * @param data1 First context value, if one was set. + * @param data2 Second context value, if one was set. + */ typeset SteamWorksHTTPHeadersReceived { function void (Handle hRequest, bool bFailure); @@ -309,6 +599,18 @@ typeset SteamWorksHTTPHeadersReceived function void (Handle hRequest, bool bFailure, any data1, any data2); }; +/** + * Called when a chunk of data for a streaming request has been received. Pass the offset + * and byte count to SteamWorks_GetHTTPStreamingResponseBodyData to read the chunk. The + * number of trailing context parameters matches the context values set on the request. + * + * @param hRequest HTTP request handle. + * @param bFailure True if the request failed due to an internal or network error. + * @param offset Offset of this chunk within the response body. + * @param bytesreceived Number of bytes in this chunk. + * @param data1 First context value, if one was set. + * @param data2 Second context value, if one was set. + */ typeset SteamWorksHTTPDataReceived { function void (Handle hRequest, bool bFailure, int offset, int bytesreceived); @@ -316,6 +618,15 @@ typeset SteamWorksHTTPDataReceived function void (Handle hRequest, bool bFailure, int offset, int bytesreceived, any data1, any data2); }; +/** + * Called by SteamWorks_GetHTTPResponseBodyCallback with the response body. Use the string + * overload for text bodies or the int[] overload for binary bodies. + * + * @param sData Response body as a string (text overload). + * @param data Response body as a byte array (binary overload). + * @param value The context value passed to SteamWorks_GetHTTPResponseBodyCallback. + * @param datalen Length of the body, in bytes (binary overload). + */ typeset SteamWorksHTTPBodyCallback { function void (const char[] sData); @@ -323,39 +634,294 @@ typeset SteamWorksHTTPBodyCallback function void (const int[] data, any value, int datalen); }; +/** + * Sets the callbacks fired for a request. Must be called before sending the request. + * The completion callback is used by both regular and streaming requests; the headers and + * data callbacks are only fired for streaming requests. + * + * @param hHandle HTTP request handle. + * @param fCompleted Callback fired when the request completes, or INVALID_FUNCTION. + * @param fHeaders Callback fired when streaming headers arrive, or INVALID_FUNCTION. + * @param fData Callback fired when a streaming data chunk arrives, or INVALID_FUNCTION. + * @param hCalling Handle of the plugin that owns the callbacks, or INVALID_HANDLE for + * the calling plugin. + * @return True on success, false on an invalid handle. + * @error Invalid plugin handle or invalid function. + */ native bool SteamWorks_SetHTTPCallbacks(Handle hHandle, SteamWorksHTTPRequestCompleted fCompleted = INVALID_FUNCTION, SteamWorksHTTPHeadersReceived fHeaders = INVALID_FUNCTION, SteamWorksHTTPDataReceived fData = INVALID_FUNCTION, Handle hCalling = INVALID_HANDLE); + +/** + * Sends an HTTP request. The result is delivered asynchronously to the completion callback + * set with SteamWorks_SetHTTPCallbacks. + * + * @param hRequest HTTP request handle. + * @return True if the request was sent, false on an invalid handle. + */ native bool SteamWorks_SendHTTPRequest(Handle hRequest); + +/** + * Sends an HTTP request and streams the response. Headers and data are delivered + * asynchronously to the callbacks set with SteamWorks_SetHTTPCallbacks. + * + * @param hRequest HTTP request handle. + * @return True if the request was sent, false on an invalid handle. + */ native bool SteamWorks_SendHTTPRequestAndStreamResponse(Handle hRequest); + +/** + * Moves an already-sent request to the tail of the client's request queue. + * + * @param hRequest HTTP request handle. + * @return True on success, false on an invalid handle or if the request has + * not been sent. + */ native bool SteamWorks_DeferHTTPRequest(Handle hRequest); + +/** + * Moves an already-sent request to the head of the client's request queue. + * + * @param hRequest HTTP request handle. + * @return True on success, false on an invalid handle or if the request has + * not been sent. + */ native bool SteamWorks_PrioritizeHTTPRequest(Handle hRequest); + +/** + * Checks whether a response header is present and retrieves the size of its value, so a + * correctly-sized buffer can be allocated for SteamWorks_GetHTTPResponseHeaderValue. + * Call from the completion callback. + * + * @param hRequest HTTP request handle. + * @param sHeader Header name. + * @param size Variable to store the header value size in. + * @return True if the header is present, false otherwise. + */ native bool SteamWorks_GetHTTPResponseHeaderSize(Handle hRequest, const char[] sHeader, int &size); + +/** + * Retrieves a response header value. Call from the completion callback. Use + * SteamWorks_GetHTTPResponseHeaderSize first to size the buffer. + * + * @param hRequest HTTP request handle. + * @param sHeader Header name. + * @param sValue Buffer to store the header value in. + * @param size Maximum length of the buffer. + * @return True on success, false if the header is not present or the buffer + * is too small. + */ native bool SteamWorks_GetHTTPResponseHeaderValue(Handle hRequest, const char[] sHeader, char[] sValue, int size); + +/** + * Retrieves the size of the response body. Call from the completion callback. + * + * @param hRequest HTTP request handle. + * @param size Variable to store the body size in. + * @return True on success, false on an invalid handle. + */ native bool SteamWorks_GetHTTPResponseBodySize(Handle hRequest, int &size); + +/** + * Retrieves the response body. Call from the completion callback. Use + * SteamWorks_GetHTTPResponseBodySize first to size the buffer. Not valid for streaming + * responses. + * + * @param hRequest HTTP request handle. + * @param sBody Buffer to store the body in. + * @param length Length of the buffer, which must match the body size. + * @return True on success, false on an invalid handle, a streaming response, + * or an incorrectly-sized buffer. + */ native bool SteamWorks_GetHTTPResponseBodyData(Handle hRequest, char[] sBody, int length); + +/** + * Retrieves a chunk of a streaming response body. Call from the data-received callback, + * passing the offset and length reported by that callback. + * + * @param hRequest HTTP request handle. + * @param cOffset Offset of the chunk, as provided by the data-received callback. + * @param sBody Buffer to store the chunk in. + * @param length Length of the chunk, as provided by the data-received callback. + * @return True on success, false on an invalid handle, a non-streaming + * response, or a mismatched offset/length. + */ native bool SteamWorks_GetHTTPStreamingResponseBodyData(Handle hRequest, int cOffset, char[] sBody, int length); + +/** + * Retrieves download progress for the request. This is zero until a response header with a + * content-length has been received; for responses with no content-length it stays zero. + * + * @param hRequest HTTP request handle. + * @param percent Variable to store the progress percentage in. + * @return True on success, false on an invalid handle. + */ native bool SteamWorks_GetHTTPDownloadProgressPct(Handle hRequest, float &percent); + +/** + * Checks whether the request failed because it timed out (rather than a harder failure). + * + * @param hRequest HTTP request handle. + * @param bWasTimedOut Variable to store the result in. + * @return True on success, false on an invalid handle. + */ native bool SteamWorks_GetHTTPRequestWasTimedOut(Handle hRequest, bool &bWasTimedOut); + +/** + * Sets a raw body for a POST request. Fails on a GET request or if GET/POST parameters + * were already set. This makes the raw body the entire contents of the POST. + * + * @param hRequest HTTP request handle. + * @param sContentType Value for the Content-Type header. + * @param sBody Raw body data. + * @param bodylen Length of the body, in bytes. + * @return True on success, false on failure. + */ native bool SteamWorks_SetHTTPRequestRawPostBody(Handle hRequest, const char[] sContentType, const char[] sBody, int bodylen); + +/** + * Sets a raw POST body read from a file (relative to the game directory). Same constraints + * as SteamWorks_SetHTTPRequestRawPostBody. + * + * @param hRequest HTTP request handle. + * @param sContentType Value for the Content-Type header. + * @param sFileName Path to the file, relative to the game directory. + * @return True on success, false on failure (e.g. an empty file). + * @error Unable to open the file for reading. + */ native bool SteamWorks_SetHTTPRequestRawPostBodyFromFile(Handle hRequest, const char[] sContentType, const char[] sFileName); +/** + * Retrieves the full response body and passes it to a callback. Useful for bodies larger + * than a single fixed buffer. Call from the completion callback. + * + * @param hRequest HTTP request handle. + * @param fCallback Callback that receives the body. + * @param data Context value passed through to the callback. + * @param hPlugin Handle of the plugin that owns the callback, or INVALID_HANDLE for + * the calling plugin. + * @return True on success, false on an invalid handle or if the body could not + * be retrieved. + * @error Invalid plugin handle or invalid function. + */ native bool SteamWorks_GetHTTPResponseBodyCallback(Handle hRequest, SteamWorksHTTPBodyCallback fCallback, any data = 0, Handle hPlugin = INVALID_HANDLE); + +/** + * Writes the full response body to a file (relative to the game directory). Call from the + * completion callback. + * + * @param hRequest HTTP request handle. + * @param sFileName Path to the output file, relative to the game directory. + * @return True on success, false on an invalid handle or if the body could not + * be retrieved. + * @error Unable to open the file for writing. + */ native bool SteamWorks_WriteHTTPResponseBodyToFile(Handle hRequest, const char[] sFileName); +/** + * Deprecated alias for SteamWorks_OnValidateClient, kept for backwards compatibility. + * Use SteamWorks_OnValidateClient in new code. + * + * @param ownerauthid 32-bit account ID of the account that owns the game license. + * @param authid 32-bit account ID of the validated client. + */ forward void SW_OnValidateClient(int ownerauthid, int authid); + +/** + * Called when a client has been validated by Steam. For clients playing on a borrowed + * (Family Sharing) license, the owner and client account IDs differ. + * + * @param ownerauthid 32-bit account ID of the account that owns the game license. + * @param authid 32-bit account ID of the validated client. + */ forward void SteamWorks_OnValidateClient(int ownerauthid, int authid); + +/** + * Called when the server successfully connects (logs on) to Steam. + */ forward void SteamWorks_SteamServersConnected(); + +/** + * Called when the server fails to connect to Steam. + * + * @param result Result code describing the failure. + */ forward void SteamWorks_SteamServersConnectFailure(EResult result); + +/** + * Called when the server is disconnected from Steam. + * + * @param result Result code describing the disconnection. + */ forward void SteamWorks_SteamServersDisconnected(EResult result); +/** + * Called when the Steam master server has requested that the server restart. Return + * Plugin_Handled or higher to indicate the restart request has been handled. + * + * @return Plugin_Handled or higher to signal the restart was handled, + * Plugin_Continue otherwise. + */ forward Action SteamWorks_RestartRequested(); + +/** + * Called when the server is about to log on anonymously, giving a plugin the chance to + * supply a Game Server Login Token (GSLT) instead. Write the token into sToken. + * + * @param sToken Buffer to write the login token into. + * @param maxlen Maximum length of the buffer. + */ forward void SteamWorks_TokenRequested(char[] sToken, int maxlen); +/** + * Called with the result of a SteamWorks_GetUserGroupStatus / + * SteamWorks_GetUserGroupStatusAuthID request. + * + * @param authid 32-bit account ID of the user. + * @param groupid 32-bit account ID of the group. + * @param isMember True if the user is a member of the group. + * @param isOfficer True if the user is an officer of the group. + */ forward void SteamWorks_OnClientGroupStatus(int authid, int groupid, bool isMember, bool isOfficer); +/** + * Called when the game code sends a message to the Game Coordinator, letting a plugin + * observe or override it. Return a non-OK EGCResults value to supersede the send, or + * k_EGCResultOK to let it proceed. + * + * @param unMsgType Message type. + * @param pubData Message payload. + * @param cubData Size of the payload, in bytes. + * @return An EGCResults value to override the send, or k_EGCResultOK to allow it. + */ forward EGCResults SteamWorks_GCSendMessage(int unMsgType, const char[] pubData, int cubData); + +/** + * Called when a message from the Game Coordinator is available to be retrieved. + * + * @param cubData Size of the available message, in bytes. + */ forward void SteamWorks_GCMsgAvailable(int cubData); + +/** + * Called when the game code retrieves a message from the Game Coordinator, letting a plugin + * observe or override it. Return a non-OK EGCResults value to supersede the retrieval. + * + * @param punMsgType Message type. + * @param pubDest Message payload. + * @param cubDest Size of the destination buffer, in bytes. + * @param pcubMsgSize Size of the message, in bytes. + * @return An EGCResults value to override the retrieval, or k_EGCResultOK to + * allow it. + */ forward EGCResults SteamWorks_GCRetrieveMessage(int punMsgType, const char[] pubDest, int cubDest, int pcubMsgSize); +/** + * Sends a message to the Game Coordinator. + * + * @param unMsgType Message type. + * @param pubData Message payload. + * @param cubData Size of the payload, in bytes. + * @return An EGCResults value; k_EGCResultNotLoggedOn if not connected to Steam. + */ native EGCResults SteamWorks_SendMessageToGC(int unMsgType, const char[] pubData, int cubData); public Extension __ext_SteamWorks =