| public static TestIfAvailableGameServer ( ) : void | ||
| return | void | |
/// <summary>
/// <para> Returns previously entered text & length</para>
/// </summary>
public static uint GetEnteredGamepadTextLength()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_GetEnteredGamepadTextLength(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> returns true if that app is installed (not necessarily owned)</para>
/// </summary>
public static bool BIsAppInstalled(AppId_t appID)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamApps_BIsAppInstalled(CSteamGameServerAPIContext.GetSteamApps(), appID));
}
/// <summary>
/// <para> returns the SteamID of the original owner. If different from current user, it's borrowed</para>
/// </summary>
public static CSteamID GetAppOwner()
{
InteropHelp.TestIfAvailableGameServer();
return((CSteamID)NativeMethods.ISteamApps_GetAppOwner(CSteamGameServerAPIContext.GetSteamApps()));
}
public static void UninstallDLC(AppId_t nAppID)
{
InteropHelp.TestIfAvailableGameServer();
NativeMethods.ISteamApps_UninstallDLC(CSteamGameServerAPIContext.GetSteamApps(), nAppID);
}
/// <summary>
/// <para> signal Steam that game files seems corrupt or missing</para>
/// </summary>
public static bool MarkContentCorrupt(bool bMissingFilesOnly)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamApps_MarkContentCorrupt(CSteamGameServerAPIContext.GetSteamApps(), bMissingFilesOnly));
}
/// <summary>
/// <para> returns true if the image exists, and valid sizes were filled out</para>
/// </summary>
public static bool GetImageSize(int iImage, out uint pnWidth, out uint pnHeight)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_GetImageSize(CSteamGameServerAPIContext.GetSteamUtils(), iImage, out pnWidth, out pnHeight));
}
/// <summary>
/// <para> return the amount of battery power left in the current system in % [0..100], 255 for being on AC power</para>
/// </summary>
public static byte GetCurrentBatteryPower()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_GetCurrentBatteryPower(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> Set whether the HMD content will be streamed via Steam Remote Play</para>
/// <para> If this is set to true, then the scene in the HMD headset will be streamed, and remote input will not be allowed.</para>
/// <para> If this is set to false, then the application window will be streamed instead, and remote input will be allowed.</para>
/// <para> The default is true unless "VRHeadsetStreaming" "0" is in the extended appinfo for a game.</para>
/// <para> (this is useful for games that have asymmetric multiplayer gameplay)</para>
/// </summary>
public static void SetVRHeadsetStreamingEnabled(bool bEnabled)
{
InteropHelp.TestIfAvailableGameServer();
NativeMethods.ISteamUtils_SetVRHeadsetStreamingEnabled(CSteamGameServerAPIContext.GetSteamUtils(), bEnabled);
}
/// <summary>
/// <para> Returns whether this steam client is a Steam China specific client, vs the global client.</para>
/// </summary>
public static bool IsSteamChinaLauncher()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_IsSteamChinaLauncher(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> ask SteamUI to create and render its OpenVR dashboard</para>
/// </summary>
public static void StartVRDashboard()
{
InteropHelp.TestIfAvailableGameServer();
NativeMethods.ISteamUtils_StartVRDashboard(CSteamGameServerAPIContext.GetSteamUtils());
}
/// <summary>
/// <para> Returns true if the HMD content will be streamed via Steam Remote Play</para>
/// </summary>
public static bool IsVRHeadsetStreamingEnabled()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_IsVRHeadsetStreamingEnabled(CSteamGameServerAPIContext.GetSteamUtils()));
}
public static uint GetSecondsSinceComputerActive()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_GetSecondsSinceComputerActive(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> returns true if Steam & the Steam Overlay are running in Big Picture mode</para>
/// <para> Games much be launched through the Steam client to enable the Big Picture overlay. During development,</para>
/// <para> a game can be added as a non-steam game to the developers library to test this feature</para>
/// </summary>
public static bool IsSteamInBigPictureMode()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_IsSteamInBigPictureMode(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition.</para>
/// </summary>
public static void SetOverlayNotificationInset(int nHorizontalInset, int nVerticalInset)
{
InteropHelp.TestIfAvailableGameServer();
NativeMethods.ISteamUtils_SetOverlayNotificationInset(CSteamGameServerAPIContext.GetSteamUtils(), nHorizontalInset, nVerticalInset);
}
/// <summary>
/// <para> Steam server time. Number of seconds since January 1, 1970, GMT (i.e unix time)</para>
/// </summary>
public static uint GetServerRealTime()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_GetServerRealTime(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> Initializes text filtering, loading dictionaries for the language the game is running in.</para>
/// <para> unFilterOptions are reserved for future use and should be set to 0</para>
/// <para> Returns false if filtering is unavailable for the game's language, in which case FilterText() will act as a passthrough.</para>
/// <para> Users can customize the text filter behavior in their Steam Account preferences:</para>
/// <para> https://store.steampowered.com/account/preferences#CommunityContentPreferences</para>
/// </summary>
public static bool InitFilterText(uint unFilterOptions = 0)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_InitFilterText(CSteamGameServerAPIContext.GetSteamUtils(), unFilterOptions));
}
/// <summary>
/// <para> returns the 2 digit ISO 3166-1-alpha-2 format country code this client is running in (as looked up via an IP-to-location database)</para>
/// <para> e.g "US" or "UK".</para>
/// </summary>
public static string GetIPCountry()
{
InteropHelp.TestIfAvailableGameServer();
return(InteropHelp.PtrToStringUTF8(NativeMethods.ISteamUtils_GetIPCountry(CSteamGameServerAPIContext.GetSteamUtils())));
}
/// <summary>
/// <para> Return what we believe your current ipv6 connectivity to "the internet" is on the specified protocol.</para>
/// <para> This does NOT tell you if the Steam client is currently connected to Steam via ipv6.</para>
/// </summary>
public static ESteamIPv6ConnectivityState GetIPv6ConnectivityState(ESteamIPv6ConnectivityProtocol eProtocol)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_GetIPv6ConnectivityState(CSteamGameServerAPIContext.GetSteamUtils(), eProtocol));
}
/// <summary>
/// <para> returns true if the image exists, and the buffer was successfully filled out</para>
/// <para> results are returned in RGBA format</para>
/// <para> the destination buffer size should be 4 * height * width * sizeof(char)</para>
/// </summary>
public static bool GetImageRGBA(int iImage, byte[] pubDest, int nDestBufferSize)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_GetImageRGBA(CSteamGameServerAPIContext.GetSteamUtils(), iImage, pubDest, nDestBufferSize));
}
/// <summary>
/// <para> returns true if currently running on the Steam Deck device</para>
/// </summary>
public static bool IsSteamRunningOnSteamDeck()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_IsSteamRunningOnSteamDeck(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> returns the appID of the current process</para>
/// </summary>
public static AppId_t GetAppID()
{
InteropHelp.TestIfAvailableGameServer();
return((AppId_t)NativeMethods.ISteamUtils_GetAppID(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> the universe this client is connecting to</para>
/// </summary>
public static EUniverse GetConnectedUniverse()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_GetConnectedUniverse(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> Request legacy cd-key for yourself or owned DLC. If you are interested in this</para>
/// <para> data then make sure you provide us with a list of valid keys to be distributed</para>
/// <para> to users when they purchase the game, before the game ships.</para>
/// <para> You'll receive an AppProofOfPurchaseKeyResponse_t callback when</para>
/// <para> the key is available (which may be immediately).</para>
/// </summary>
public static void RequestAppProofOfPurchaseKey(AppId_t nAppID)
{
InteropHelp.TestIfAvailableGameServer();
NativeMethods.ISteamApps_RequestAppProofOfPurchaseKey(CSteamGameServerAPIContext.GetSteamApps(), nAppID);
}
/// <summary>
/// <para> Opens a floating keyboard over the game content and sends OS keyboard keys directly to the game.</para>
/// <para> The text field position is specified in pixels relative the origin of the game window and is used to position the floating keyboard in a way that doesn't cover the text field</para>
/// </summary>
public static bool ShowFloatingGamepadTextInput(EFloatingGamepadTextInputMode eKeyboardMode, int nTextFieldXPosition, int nTextFieldYPosition, int nTextFieldWidth, int nTextFieldHeight)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_ShowFloatingGamepadTextInput(CSteamGameServerAPIContext.GetSteamUtils(), eKeyboardMode, nTextFieldXPosition, nTextFieldYPosition, nTextFieldWidth, nTextFieldHeight));
}
/// <summary>
/// <para> return installed depots in mount order</para>
/// </summary>
public static uint GetInstalledDepots(AppId_t appID, DepotId_t[] pvecDepots, uint cMaxDepots)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamApps_GetInstalledDepots(CSteamGameServerAPIContext.GetSteamApps(), appID, pvecDepots, cMaxDepots));
}
/// <summary>
/// <para> In game launchers that don't have controller support you can call this to have Steam Input translate the controller input into mouse/kb to navigate the launcher</para>
/// </summary>
public static void SetGameLauncherMode(bool bLauncherMode)
{
InteropHelp.TestIfAvailableGameServer();
NativeMethods.ISteamUtils_SetGameLauncherMode(CSteamGameServerAPIContext.GetSteamUtils(), bLauncherMode);
}
public static bool BIsSubscribed()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamApps_BIsSubscribed(CSteamGameServerAPIContext.GetSteamApps()));
}
/// <summary>
/// <para> Dismisses the floating keyboard.</para>
/// </summary>
public static bool DismissFloatingGamepadTextInput()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_DismissFloatingGamepadTextInput(CSteamGameServerAPIContext.GetSteamUtils()));
}
/// <summary>
/// <para> get download progress for optional DLC</para>
/// </summary>
public static bool GetDlcDownloadProgress(AppId_t nAppID, out ulong punBytesDownloaded, out ulong punBytesTotal)
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamApps_GetDlcDownloadProgress(CSteamGameServerAPIContext.GetSteamApps(), nAppID, out punBytesDownloaded, out punBytesTotal));
}
/// <summary>
/// <para> Normally this call is unneeded if your game has a constantly running frame loop that calls the</para>
/// <para> D3D Present API, or OGL SwapBuffers API every frame.</para>
/// <para> However, if you have a game that only refreshes the screen on an event driven basis then that can break</para>
/// <para> the overlay, as it uses your Present/SwapBuffers calls to drive it's internal frame loop and it may also</para>
/// <para> need to Present() to the screen any time an even needing a notification happens or when the overlay is</para>
/// <para> brought up over the game by a user. You can use this API to ask the overlay if it currently need a present</para>
/// <para> in that case, and then you can check for this periodically (roughly 33hz is desirable) and make sure you</para>
/// <para> refresh the screen with Present or SwapBuffers to allow the overlay to do it's work.</para>
/// </summary>
public static bool BOverlayNeedsPresent()
{
InteropHelp.TestIfAvailableGameServer();
return(NativeMethods.ISteamUtils_BOverlayNeedsPresent(CSteamGameServerAPIContext.GetSteamUtils()));
}