// checks if a local Steam client is running public static bool IsSteamRunning() { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.SteamAPI_IsSteamRunning()); }
// Many Steam API functions allocate a small amount of thread-local memory for parameter storage. // SteamAPI_ReleaseCurrentThreadMemory() will free API memory associated with the calling thread. // This function is also called automatically by SteamAPI_RunCallbacks(), so a single-threaded // program never needs to explicitly call this function. public static void ReleaseCurrentThreadMemory() { InteropHelp.TestIfPlatformSupported(); NativeMethods.SteamAPI_ReleaseCurrentThreadMemory(); }
//----------------------------------------------------------------------------------------------------------------------------------------------------------// // steam callback and call-result helpers // // The following macros and classes are used to register your application for // callbacks and call-results, which are delivered in a predictable manner. // // STEAM_CALLBACK macros are meant for use inside of a C++ class definition. // They map a Steam notification callback directly to a class member function // which is automatically prototyped as "void func( callback_type *pParam )". // // CCallResult is used with specific Steam APIs that return "result handles". // The handle can be passed to a CCallResult object's Set function, along with // an object pointer and member-function pointer. The member function will // be executed once the results of the Steam API call are available. // // CCallback and CCallbackManual classes can be used instead of STEAM_CALLBACK // macros if you require finer control over registration and unregistration. // // Callbacks and call-results are queued automatically and are only // delivered/executed when your application calls SteamAPI_RunCallbacks(). //----------------------------------------------------------------------------------------------------------------------------------------------------------// // SteamAPI_RunCallbacks is safe to call from multiple threads simultaneously, // but if you choose to do this, callback code may be executed on any thread. public static void RunCallbacks() { InteropHelp.TestIfPlatformSupported(); NativeMethods.SteamAPI_RunCallbacks(); }
public static void Shutdown() { InteropHelp.TestIfPlatformSupported(); NativeMethods.SteamAPI_Shutdown(); }
// SteamAPI_RestartAppIfNecessary ensures that your executable was launched through Steam. // // Returns true if the current process should terminate. Steam is now re-launching your application. // // Returns false if no action needs to be taken. This means that your executable was started through // the Steam client, or a steam_appid.txt file is present in your game's directory (for development). // Your current process should continue if false is returned. // // NOTE: If you use the Steam DRM wrapper on your primary executable file, this check is unnecessary // since the DRM wrapper will ensure that your application was launched properly through Steam. public static bool RestartAppIfNecessary(AppId_t unOwnAppID) { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.SteamAPI_RestartAppIfNecessary(unOwnAppID)); }
public static uint GetTicketIssueTime(byte[] rgubTicketDecrypted, uint cubTicketDecrypted) { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.SteamEncryptedAppTicket_GetTicketIssueTime(rgubTicketDecrypted, cubTicketDecrypted)); }
public static bool BUserIsVacBanned(byte[] rgubTicketDecrypted, uint cubTicketDecrypted) { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.BUserIsVacBanned(rgubTicketDecrypted, cubTicketDecrypted)); }
public static void GetTicketSteamID(byte[] rgubTicketDecrypted, uint cubTicketDecrypted, out CSteamID psteamID) { InteropHelp.TestIfPlatformSupported(); NativeMethods.GetTicketSteamID(rgubTicketDecrypted, cubTicketDecrypted, out psteamID); }
public static uint GetTicketAppID(byte[] rgubTicketDecrypted, uint cubTicketDecrypted) { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.GetTicketAppID(rgubTicketDecrypted, cubTicketDecrypted)); }
public static HSteamUser GetHSteamUser() { InteropHelp.TestIfPlatformSupported(); return((HSteamUser)NativeMethods.SteamGameServer_GetHSteamUser()); }
public static bool BDecryptTicket(byte[] rgubTicketEncrypted, uint cubTicketEncrypted, byte[] rgubTicketDecrypted, ref uint pcubTicketDecrypted, byte[] rgubKey, int cubKey) { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.BDecryptTicket(rgubTicketEncrypted, cubTicketEncrypted, rgubTicketDecrypted, ref pcubTicketDecrypted, rgubKey, cubKey)); }
public static CSteamID GetSteamID() { InteropHelp.TestIfPlatformSupported(); return((CSteamID)NativeMethods.SteamGameServer_GetSteamID()); }
public static bool BSecure() { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.SteamGameServer_BSecure()); }
// [Steamworks.NET] This is for Ease of use, since we don't need to care about the differences between them in C#. public static bool Init() { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.SteamAPI_InitSafe()); }
// returns the HSteamUser of the last user to dispatch a callback public static HSteamUser GetHSteamUserCurrent() { InteropHelp.TestIfPlatformSupported(); return((HSteamUser)NativeMethods.Steam_GetHSteamUserCurrent()); }
public static bool BUserOwnsAppInTicket(byte[] rgubTicketDecrypted, uint cubTicketDecrypted, AppId_t nAppID) { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.BUserOwnsAppInTicket(rgubTicketDecrypted, cubTicketDecrypted, nAppID)); }
// returns the pipe we are communicating to Steam with public static HSteamPipe GetHSteamPipe() { InteropHelp.TestIfPlatformSupported(); return((HSteamPipe)NativeMethods.SteamAPI_GetHSteamPipe()); }
public static bool BIsTicketForApp(byte[] rgubTicketDecrypted, uint cubTicketDecrypted, AppId_t nAppID) { InteropHelp.TestIfPlatformSupported(); return(NativeMethods.SteamEncryptedAppTicket_BIsTicketForApp(rgubTicketDecrypted, cubTicketDecrypted, nAppID)); }