Started working on a Steam library
This commit is contained in:
@@ -9,6 +9,9 @@ This package provides a simple Steam API wrapper for common tasks like initializ
|
||||
- Safe shutdown with `SteamManager.Shutdown()`
|
||||
- Player persona name access with `SteamManager.GetSteamName()`
|
||||
- Achievement helpers via `AchievementManager`
|
||||
- Steam Workshop (UGC) helpers via `SteamManager.Instance.Ugc`
|
||||
- Steam Remote Play helpers via `SteamManager.Instance.RemotePlay`
|
||||
- Additional interface managers: Controller, Friends, GameServer, Input, Inventory, Matchmaking, Parties, RemoteStorage, Screenshots, UserStats, Utils, Video, and more.
|
||||
- Includes native Steam runtime files in NuGet package `runtimes/`
|
||||
|
||||
## Installation
|
||||
@@ -35,9 +38,59 @@ steam.Update();
|
||||
var achievements = new AchievementManager();
|
||||
achievements.UnlockAchievement("ACH_FIRST_WIN");
|
||||
|
||||
// Steam Workshop (UGC) example
|
||||
var subscribedIds = steam.Ugc.GetSubscribedItems();
|
||||
|
||||
// Steam Remote Play example
|
||||
var remotePlaySessionCount = steam.RemotePlay.GetSessionCount();
|
||||
|
||||
steam.Shutdown();
|
||||
```
|
||||
|
||||
## More API Examples
|
||||
```cs
|
||||
var steam = SteamManager.Instance;
|
||||
|
||||
// Friends / rich presence
|
||||
steam.Friends.SetRichPresence("status", "In Match");
|
||||
steam.Friends.SetRichPresence("map", "Arena_01");
|
||||
var friendName = steam.Friends.GetFriendPersonaName(76561198000000000UL);
|
||||
var friendStatus = steam.Friends.GetFriendRichPresence(76561198000000000UL, "status");
|
||||
|
||||
// Remote storage
|
||||
var saveBytes = System.Text.Encoding.UTF8.GetBytes("save-data-v1");
|
||||
steam.RemoteStorage.FileWrite("save_slot_1.dat", saveBytes);
|
||||
if (steam.RemoteStorage.FileRead("save_slot_1.dat", out var loadedBytes))
|
||||
{
|
||||
var loadedText = System.Text.Encoding.UTF8.GetString(loadedBytes);
|
||||
}
|
||||
|
||||
// User stats
|
||||
steam.UserStats.SetStatInt32("KILLS", 25);
|
||||
steam.UserStats.StoreStats();
|
||||
steam.UserStats.RequestGlobalStats(7);
|
||||
|
||||
// UGC update convenience APIs (existing item)
|
||||
var options = new SteamUgcItemUpdateOptions
|
||||
{
|
||||
Title = "My Workshop Item",
|
||||
Description = "Updated description.",
|
||||
Tags = new[] { "map", "coop" },
|
||||
ContentFolder = "/absolute/path/to/content",
|
||||
PreviewFile = "/absolute/path/to/preview.png"
|
||||
};
|
||||
var submitCallHandle = steam.Ugc.UpdateItem(480, 123456789012345678UL, options, "Updated content", out var failedStep);
|
||||
|
||||
// Fluent session alternative
|
||||
var session = steam.Ugc.BeginUpdateSession(480, 123456789012345678UL)
|
||||
.WithTitle("My Workshop Item")
|
||||
.WithDescription("Updated description")
|
||||
.WithTags("map", "coop")
|
||||
.WithContentFolder("/absolute/path/to/content")
|
||||
.WithPreviewFile("/absolute/path/to/preview.png");
|
||||
var submitCallHandle2 = session.Submit("Updated content", out var failedStep2);
|
||||
```
|
||||
|
||||
## Notes
|
||||
- Steam must be running and your app must be launched in a valid Steam context.
|
||||
- Configure your AppId before first access to `SteamManager.Instance`.
|
||||
|
||||
@@ -0,0 +1,401 @@
|
||||
using OmegaLeo.HelperLib.Shared.Attributes;
|
||||
|
||||
namespace OmegaLeo.HelperLib.Steamworks
|
||||
{
|
||||
[Documentation(nameof(SteamControllerManager), "Provides access checks for ISteamController.", null, null)]
|
||||
public class SteamControllerManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamControllerAvailable();
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamFriendsManager), "Provides access checks for ISteamFriends.", null, null)]
|
||||
public class SteamFriendsManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamFriendsAvailable();
|
||||
|
||||
[Documentation(nameof(GetFriendCount), "Gets the friend count filtered by Steam friend flags.", new[] { "friendFlags: Bitmask value matching Steam EFriendFlags." }, null)]
|
||||
public int GetFriendCount(int friendFlags)
|
||||
{
|
||||
return SteamNativeApi.GetFriendCount(friendFlags);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetFriendPersonaName), "Gets the persona name of a friend by SteamID64.", new[] { "steamIdFriend: Friend SteamID64." }, null)]
|
||||
public string GetFriendPersonaName(ulong steamIdFriend)
|
||||
{
|
||||
return SteamNativeApi.GetFriendPersonaName(steamIdFriend);
|
||||
}
|
||||
|
||||
[Documentation(nameof(ActivateGameOverlayInviteDialog), "Opens the Steam invite dialog for a lobby.", new[] { "steamIdLobby: Lobby SteamID64." }, null)]
|
||||
public void ActivateGameOverlayInviteDialog(ulong steamIdLobby)
|
||||
{
|
||||
SteamNativeApi.FriendsActivateGameOverlayInviteDialog(steamIdLobby);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetRichPresence), "Sets a rich presence key/value pair for the local user.", new[] { "key: Rich presence key.", "value: Rich presence value." }, null)]
|
||||
public bool SetRichPresence(string key, string value)
|
||||
{
|
||||
return SteamNativeApi.FriendsSetRichPresence(key, value);
|
||||
}
|
||||
|
||||
[Documentation(nameof(ClearRichPresence), "Clears all rich presence values for the local user.", null, null)]
|
||||
public void ClearRichPresence()
|
||||
{
|
||||
SteamNativeApi.FriendsClearRichPresence();
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetFriendRichPresence), "Gets a rich presence value for a specific friend.", new[] { "steamIdFriend: Friend SteamID64.", "key: Rich presence key." }, null)]
|
||||
public string GetFriendRichPresence(ulong steamIdFriend, string key)
|
||||
{
|
||||
return SteamNativeApi.FriendsGetFriendRichPresence(steamIdFriend, key);
|
||||
}
|
||||
|
||||
[Documentation(nameof(InviteUserToGame), "Invites a friend to the current game session using a connect string.", new[] { "steamIdFriend: Friend SteamID64.", "connectString: Game connect string passed through Steam invite." }, null)]
|
||||
public bool InviteUserToGame(ulong steamIdFriend, string connectString)
|
||||
{
|
||||
return SteamNativeApi.FriendsInviteUserToGame(steamIdFriend, connectString);
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamGameCoordinatorManager), "Provides access checks for ISteamGameCoordinator.", null, null)]
|
||||
public class SteamGameCoordinatorManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamGameCoordinatorAvailable();
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamGameServerManager), "Provides access checks for ISteamGameServer.", null, null)]
|
||||
public class SteamGameServerManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamGameServerAvailable();
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamGameServerStatsManager), "Provides access checks for ISteamGameServerStats.", null, null)]
|
||||
public class SteamGameServerStatsManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamGameServerStatsAvailable();
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamHtmlSurfaceManager), "Provides access checks for ISteamHTMLSurface.", null, null)]
|
||||
public class SteamHtmlSurfaceManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamHtmlSurfaceAvailable();
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamInputManager), "Provides access checks for ISteamInput.", null, null)]
|
||||
public class SteamInputManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamInputAvailable();
|
||||
|
||||
[Documentation(nameof(Init), "Initializes Steam Input for the application.", new[] { "explicitlyCallRunFrame: Set true when your game will manually call RunFrame each frame." }, null)]
|
||||
public bool Init(bool explicitlyCallRunFrame = false)
|
||||
{
|
||||
return SteamNativeApi.InputInit(explicitlyCallRunFrame);
|
||||
}
|
||||
|
||||
[Documentation(nameof(Shutdown), "Shuts down Steam Input.", null, null)]
|
||||
public bool Shutdown()
|
||||
{
|
||||
return SteamNativeApi.InputShutdown();
|
||||
}
|
||||
|
||||
[Documentation(nameof(RunFrame), "Runs a Steam Input frame update.", null, null)]
|
||||
public void RunFrame()
|
||||
{
|
||||
SteamNativeApi.InputRunFrame();
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamInventoryManager), "Provides access checks for ISteamInventory.", null, null)]
|
||||
public class SteamInventoryManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamInventoryAvailable();
|
||||
|
||||
[Documentation(nameof(LoadItemDefinitions), "Requests latest inventory item definitions from Steam.", null, null)]
|
||||
public bool LoadItemDefinitions()
|
||||
{
|
||||
return SteamNativeApi.InventoryLoadItemDefinitions();
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetAllItems), "Requests all inventory items and returns a result handle.", new[] { "inventoryResultHandle: Inventory result handle to use with additional inventory API calls." }, null)]
|
||||
public bool GetAllItems(out int inventoryResultHandle)
|
||||
{
|
||||
return SteamNativeApi.InventoryGetAllItems(out inventoryResultHandle);
|
||||
}
|
||||
|
||||
[Documentation(nameof(DestroyResult), "Releases an inventory result handle returned from Steam Inventory API calls.", new[] { "inventoryResultHandle: Inventory result handle to release." }, null)]
|
||||
public void DestroyResult(int inventoryResultHandle)
|
||||
{
|
||||
SteamNativeApi.InventoryDestroyResult(inventoryResultHandle);
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamMatchmakingManager), "Provides access checks for ISteamMatchmaking.", null, null)]
|
||||
public class SteamMatchmakingManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamMatchmakingAvailable();
|
||||
|
||||
[Documentation(nameof(RequestLobbyList), "Requests a lobby list and returns a Steam API call handle.", null, null)]
|
||||
public ulong RequestLobbyList()
|
||||
{
|
||||
return SteamNativeApi.MatchmakingRequestLobbyList();
|
||||
}
|
||||
|
||||
[Documentation(nameof(AddRequestLobbyListResultCountFilter), "Sets the maximum number of lobbies returned by RequestLobbyList.", new[] { "maxResults: Maximum number of lobby results." }, null)]
|
||||
public void AddRequestLobbyListResultCountFilter(int maxResults)
|
||||
{
|
||||
SteamNativeApi.MatchmakingAddRequestLobbyListResultCountFilter(maxResults);
|
||||
}
|
||||
|
||||
[Documentation(nameof(CreateLobby), "Creates a lobby and returns a Steam API call handle.", new[] { "lobbyType: Numeric ELobbyType value.", "maxMembers: Maximum lobby member count." }, null)]
|
||||
public ulong CreateLobby(int lobbyType, int maxMembers)
|
||||
{
|
||||
return SteamNativeApi.MatchmakingCreateLobby(lobbyType, maxMembers);
|
||||
}
|
||||
|
||||
[Documentation(nameof(JoinLobby), "Joins a lobby by SteamID64 and returns a Steam API call handle.", new[] { "steamIdLobby: Lobby SteamID64." }, null)]
|
||||
public ulong JoinLobby(ulong steamIdLobby)
|
||||
{
|
||||
return SteamNativeApi.MatchmakingJoinLobby(steamIdLobby);
|
||||
}
|
||||
|
||||
[Documentation(nameof(LeaveLobby), "Leaves a lobby by SteamID64.", new[] { "steamIdLobby: Lobby SteamID64." }, null)]
|
||||
public void LeaveLobby(ulong steamIdLobby)
|
||||
{
|
||||
SteamNativeApi.MatchmakingLeaveLobby(steamIdLobby);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetNumLobbyMembers), "Gets the number of members currently in a lobby.", new[] { "steamIdLobby: Lobby SteamID64." }, null)]
|
||||
public int GetNumLobbyMembers(ulong steamIdLobby)
|
||||
{
|
||||
return SteamNativeApi.MatchmakingGetNumLobbyMembers(steamIdLobby);
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamMatchmakingServersManager), "Provides access checks for ISteamMatchmakingServers.", null, null)]
|
||||
public class SteamMatchmakingServersManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamMatchmakingServersAvailable();
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamMusicManager), "Provides access checks for ISteamMusic.", null, null)]
|
||||
public class SteamMusicManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamMusicAvailable();
|
||||
|
||||
[Documentation(nameof(IsEnabled), "Checks whether Steam Music is enabled.", null, null)]
|
||||
public bool IsEnabled()
|
||||
{
|
||||
return SteamNativeApi.MusicIsEnabled();
|
||||
}
|
||||
|
||||
[Documentation(nameof(IsPlaying), "Checks whether Steam Music is currently playing.", null, null)]
|
||||
public bool IsPlaying()
|
||||
{
|
||||
return SteamNativeApi.MusicIsPlaying();
|
||||
}
|
||||
|
||||
[Documentation(nameof(Play), "Starts Steam Music playback.", null, null)]
|
||||
public void Play()
|
||||
{
|
||||
SteamNativeApi.MusicPlay();
|
||||
}
|
||||
|
||||
[Documentation(nameof(Pause), "Pauses Steam Music playback.", null, null)]
|
||||
public void Pause()
|
||||
{
|
||||
SteamNativeApi.MusicPause();
|
||||
}
|
||||
|
||||
[Documentation(nameof(PlayNext), "Advances to the next music track.", null, null)]
|
||||
public void PlayNext()
|
||||
{
|
||||
SteamNativeApi.MusicPlayNext();
|
||||
}
|
||||
|
||||
[Documentation(nameof(PlayPrevious), "Moves to the previous music track.", null, null)]
|
||||
public void PlayPrevious()
|
||||
{
|
||||
SteamNativeApi.MusicPlayPrevious();
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetVolume), "Gets Steam Music volume (0..1 range).", null, null)]
|
||||
public float GetVolume()
|
||||
{
|
||||
return SteamNativeApi.MusicGetVolume();
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetVolume), "Sets Steam Music volume (0..1 range).", new[] { "volume: New volume value." }, null)]
|
||||
public void SetVolume(float volume)
|
||||
{
|
||||
SteamNativeApi.MusicSetVolume(volume);
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamPartiesManager), "Provides access checks for ISteamParties.", null, null)]
|
||||
public class SteamPartiesManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamPartiesAvailable();
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamRemoteStorageManager), "Provides access checks for ISteamRemoteStorage.", null, null)]
|
||||
public class SteamRemoteStorageManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamRemoteStorageAvailable();
|
||||
|
||||
[Documentation(nameof(FileExists), "Checks whether a file exists in Steam Remote Storage.", new[] { "fileName: Cloud file path/name." }, null)]
|
||||
public bool FileExists(string fileName)
|
||||
{
|
||||
return SteamNativeApi.RemoteStorageFileExists(fileName);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetFileCount), "Gets the number of files in Steam Remote Storage for the current app/user context.", null, null)]
|
||||
public int GetFileCount()
|
||||
{
|
||||
return SteamNativeApi.RemoteStorageGetFileCount();
|
||||
}
|
||||
|
||||
[Documentation(nameof(IsCloudEnabledForApp), "Checks whether Steam Cloud is enabled for this app.", null, null)]
|
||||
public bool IsCloudEnabledForApp()
|
||||
{
|
||||
return SteamNativeApi.RemoteStorageIsCloudEnabledForApp();
|
||||
}
|
||||
|
||||
[Documentation(nameof(FileWrite), "Writes a byte array to a Steam Cloud file.", new[] { "fileName: Cloud file path/name.", "data: Raw file bytes to write." }, null)]
|
||||
public bool FileWrite(string fileName, byte[] data)
|
||||
{
|
||||
return SteamNativeApi.RemoteStorageFileWrite(fileName, data);
|
||||
}
|
||||
|
||||
[Documentation(nameof(FileRead), "Reads a Steam Cloud file into a byte array.", new[] { "fileName: Cloud file path/name.", "data: Output file bytes when read succeeds." }, null)]
|
||||
public bool FileRead(string fileName, out byte[] data)
|
||||
{
|
||||
return SteamNativeApi.RemoteStorageFileRead(fileName, out data);
|
||||
}
|
||||
|
||||
[Documentation(nameof(FileDelete), "Deletes a Steam Cloud file.", new[] { "fileName: Cloud file path/name." }, null)]
|
||||
public bool FileDelete(string fileName)
|
||||
{
|
||||
return SteamNativeApi.RemoteStorageFileDelete(fileName);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetFileSize), "Gets file size in bytes for a Steam Cloud file.", new[] { "fileName: Cloud file path/name." }, null)]
|
||||
public int GetFileSize(string fileName)
|
||||
{
|
||||
return SteamNativeApi.RemoteStorageGetFileSize(fileName);
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamScreenshotsManager), "Provides access checks for ISteamScreenshots.", null, null)]
|
||||
public class SteamScreenshotsManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamScreenshotsAvailable();
|
||||
|
||||
[Documentation(nameof(AddScreenshotToLibrary), "Adds an existing screenshot to the Steam screenshot library.", new[] { "fileNameJpg: Screenshot image path.", "fileNameThumbnail: Thumbnail path.", "width: Image width.", "height: Image height." }, null)]
|
||||
public uint AddScreenshotToLibrary(string fileNameJpg, string fileNameThumbnail, int width, int height)
|
||||
{
|
||||
return SteamNativeApi.ScreenshotsAddScreenshotToLibrary(fileNameJpg, fileNameThumbnail, width, height);
|
||||
}
|
||||
|
||||
[Documentation(nameof(TriggerScreenshot), "Triggers an in-game screenshot event.", null, null)]
|
||||
public void TriggerScreenshot()
|
||||
{
|
||||
SteamNativeApi.ScreenshotsTriggerScreenshot();
|
||||
}
|
||||
|
||||
[Documentation(nameof(HookScreenshots), "Enables or disables screenshot hooks for custom handling.", new[] { "hook: True to hook screenshots." }, null)]
|
||||
public void HookScreenshots(bool hook)
|
||||
{
|
||||
SteamNativeApi.ScreenshotsHookScreenshots(hook);
|
||||
}
|
||||
|
||||
[Documentation(nameof(IsScreenshotsHooked), "Checks whether screenshot hooks are currently enabled.", null, null)]
|
||||
public bool IsScreenshotsHooked()
|
||||
{
|
||||
return SteamNativeApi.ScreenshotsIsScreenshotsHooked();
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamUserStatsManager), "Provides access checks for ISteamUserStats.", null, null)]
|
||||
public class SteamUserStatsManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamUserStatsAvailable();
|
||||
|
||||
[Documentation(nameof(RequestUserStats), "Requests user stats for a target SteamID64 and returns a Steam API call handle.", new[] { "steamIdUser: Target SteamID64." }, null)]
|
||||
public ulong RequestUserStats(ulong steamIdUser)
|
||||
{
|
||||
return SteamNativeApi.UserStatsRequestUserStats(steamIdUser);
|
||||
}
|
||||
|
||||
[Documentation(nameof(RequestGlobalStats), "Requests global stats history and returns a Steam API call handle.", new[] { "historyDays: Number of days of history to request." }, null)]
|
||||
public ulong RequestGlobalStats(int historyDays)
|
||||
{
|
||||
return SteamNativeApi.UserStatsRequestGlobalStats(historyDays);
|
||||
}
|
||||
|
||||
[Documentation(nameof(ResetAllStats), "Resets local user stats, optionally including achievements.", new[] { "achievementsToo: True to also clear achievement state." }, null)]
|
||||
public bool ResetAllStats(bool achievementsToo)
|
||||
{
|
||||
return SteamNativeApi.UserStatsResetAllStats(achievementsToo);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetStatInt32), "Gets a named integer stat value.", new[] { "name: Stat API name.", "data: Output integer stat value." }, null)]
|
||||
public bool GetStatInt32(string name, out int data)
|
||||
{
|
||||
return SteamNativeApi.UserStatsGetStatInt32(name, out data);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetStatInt32), "Sets a named integer stat value.", new[] { "name: Stat API name.", "data: Integer stat value to set." }, null)]
|
||||
public bool SetStatInt32(string name, int data)
|
||||
{
|
||||
return SteamNativeApi.UserStatsSetStatInt32(name, data);
|
||||
}
|
||||
|
||||
[Documentation(nameof(StoreStats), "Stores pending stats and achievement changes to Steam.", null, null)]
|
||||
public bool StoreStats()
|
||||
{
|
||||
return SteamNativeApi.StoreStats();
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamUtilsManager), "Provides access checks for ISteamUtils.", null, null)]
|
||||
public class SteamUtilsManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamUtilsAvailable();
|
||||
|
||||
[Documentation(nameof(GetAppId), "Gets the current Steam AppId reported by SteamUtils.", null, null)]
|
||||
public uint GetAppId()
|
||||
{
|
||||
return SteamNativeApi.GetAppId();
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetIpCountry), "Gets the two-letter country code inferred by Steam based on the current IP.", null, null)]
|
||||
public string GetIpCountry()
|
||||
{
|
||||
return SteamNativeApi.GetIpCountry();
|
||||
}
|
||||
|
||||
[Documentation(nameof(IsOverlayEnabled), "Checks whether Steam Overlay is currently enabled.", null, null)]
|
||||
public bool IsOverlayEnabled()
|
||||
{
|
||||
return SteamNativeApi.IsOverlayEnabled();
|
||||
}
|
||||
}
|
||||
|
||||
[Documentation(nameof(SteamVideoManager), "Provides access checks for ISteamVideo.", null, null)]
|
||||
public class SteamVideoManager
|
||||
{
|
||||
public bool IsAvailable => SteamNativeApi.IsSteamVideoAvailable();
|
||||
|
||||
[Documentation(nameof(GetVideoUrl), "Requests a video URL for a given Steam video app id.", new[] { "videoAppId: Steam video app id." }, null)]
|
||||
public void GetVideoUrl(uint videoAppId)
|
||||
{
|
||||
SteamNativeApi.VideoGetVideoUrl(videoAppId);
|
||||
}
|
||||
|
||||
[Documentation(nameof(IsBroadcasting), "Checks whether the user is broadcasting and returns current viewer count.", new[] { "numberOfViewers: Viewer count output when broadcasting." }, null)]
|
||||
public bool IsBroadcasting(out int numberOfViewers)
|
||||
{
|
||||
return SteamNativeApi.VideoIsBroadcasting(out numberOfViewers);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,6 +17,25 @@ steam.Update();
|
||||
private static SteamManager _instance;
|
||||
private static uint? _configuredAppId;
|
||||
private static ILogger _logger = NullLogger.Instance;
|
||||
private static readonly SteamUgcManager UgcManager = new SteamUgcManager();
|
||||
private static readonly SteamRemotePlayManager RemotePlayManager = new SteamRemotePlayManager();
|
||||
private static readonly SteamControllerManager ControllerManager = new SteamControllerManager();
|
||||
private static readonly SteamFriendsManager FriendsManager = new SteamFriendsManager();
|
||||
private static readonly SteamGameCoordinatorManager GameCoordinatorManager = new SteamGameCoordinatorManager();
|
||||
private static readonly SteamGameServerManager GameServerManager = new SteamGameServerManager();
|
||||
private static readonly SteamGameServerStatsManager GameServerStatsManager = new SteamGameServerStatsManager();
|
||||
private static readonly SteamHtmlSurfaceManager HtmlSurfaceManager = new SteamHtmlSurfaceManager();
|
||||
private static readonly SteamInputManager InputManager = new SteamInputManager();
|
||||
private static readonly SteamInventoryManager InventoryManager = new SteamInventoryManager();
|
||||
private static readonly SteamMatchmakingManager MatchmakingManager = new SteamMatchmakingManager();
|
||||
private static readonly SteamMatchmakingServersManager MatchmakingServersManager = new SteamMatchmakingServersManager();
|
||||
private static readonly SteamMusicManager MusicManager = new SteamMusicManager();
|
||||
private static readonly SteamPartiesManager PartiesManager = new SteamPartiesManager();
|
||||
private static readonly SteamRemoteStorageManager RemoteStorageManager = new SteamRemoteStorageManager();
|
||||
private static readonly SteamScreenshotsManager ScreenshotsManager = new SteamScreenshotsManager();
|
||||
private static readonly SteamUserStatsManager UserStatsManager = new SteamUserStatsManager();
|
||||
private static readonly SteamUtilsManager UtilsManager = new SteamUtilsManager();
|
||||
private static readonly SteamVideoManager VideoManager = new SteamVideoManager();
|
||||
[Documentation(nameof(Instance), "Singleton access to the Steam manager.", null, null)]
|
||||
public static SteamManager Instance => _instance ??= new SteamManager();
|
||||
|
||||
@@ -50,6 +69,63 @@ steam.Update();
|
||||
[Documentation(nameof(IsSteamworksInitialized), "Indicates whether Steamworks is initialized and ready for API calls.", null, null)]
|
||||
public bool IsSteamworksInitialized { get; private set; }
|
||||
|
||||
[Documentation(nameof(Ugc), "Provides access to Steam Workshop (UGC) helper operations.", null, null)]
|
||||
public SteamUgcManager Ugc => UgcManager;
|
||||
|
||||
[Documentation(nameof(RemotePlay), "Provides access to Steam Remote Play helper operations.", null, null)]
|
||||
public SteamRemotePlayManager RemotePlay => RemotePlayManager;
|
||||
|
||||
[Documentation(nameof(Controller), "Provides access to ISteamController bindings.", null, null)]
|
||||
public SteamControllerManager Controller => ControllerManager;
|
||||
|
||||
[Documentation(nameof(Friends), "Provides access to ISteamFriends bindings.", null, null)]
|
||||
public SteamFriendsManager Friends => FriendsManager;
|
||||
|
||||
[Documentation(nameof(GameCoordinator), "Provides access to ISteamGameCoordinator bindings.", null, null)]
|
||||
public SteamGameCoordinatorManager GameCoordinator => GameCoordinatorManager;
|
||||
|
||||
[Documentation(nameof(GameServer), "Provides access to ISteamGameServer bindings.", null, null)]
|
||||
public SteamGameServerManager GameServer => GameServerManager;
|
||||
|
||||
[Documentation(nameof(GameServerStats), "Provides access to ISteamGameServerStats bindings.", null, null)]
|
||||
public SteamGameServerStatsManager GameServerStats => GameServerStatsManager;
|
||||
|
||||
[Documentation(nameof(HtmlSurface), "Provides access to ISteamHTMLSurface bindings.", null, null)]
|
||||
public SteamHtmlSurfaceManager HtmlSurface => HtmlSurfaceManager;
|
||||
|
||||
[Documentation(nameof(Input), "Provides access to ISteamInput bindings.", null, null)]
|
||||
public SteamInputManager Input => InputManager;
|
||||
|
||||
[Documentation(nameof(Inventory), "Provides access to ISteamInventory bindings.", null, null)]
|
||||
public SteamInventoryManager Inventory => InventoryManager;
|
||||
|
||||
[Documentation(nameof(Matchmaking), "Provides access to ISteamMatchmaking bindings.", null, null)]
|
||||
public SteamMatchmakingManager Matchmaking => MatchmakingManager;
|
||||
|
||||
[Documentation(nameof(MatchmakingServers), "Provides access to ISteamMatchmakingServers bindings.", null, null)]
|
||||
public SteamMatchmakingServersManager MatchmakingServers => MatchmakingServersManager;
|
||||
|
||||
[Documentation(nameof(Music), "Provides access to ISteamMusic bindings.", null, null)]
|
||||
public SteamMusicManager Music => MusicManager;
|
||||
|
||||
[Documentation(nameof(Parties), "Provides access to ISteamParties bindings.", null, null)]
|
||||
public SteamPartiesManager Parties => PartiesManager;
|
||||
|
||||
[Documentation(nameof(RemoteStorage), "Provides access to ISteamRemoteStorage bindings.", null, null)]
|
||||
public SteamRemoteStorageManager RemoteStorage => RemoteStorageManager;
|
||||
|
||||
[Documentation(nameof(Screenshots), "Provides access to ISteamScreenshots bindings.", null, null)]
|
||||
public SteamScreenshotsManager Screenshots => ScreenshotsManager;
|
||||
|
||||
[Documentation(nameof(UserStats), "Provides access to ISteamUserStats bindings.", null, null)]
|
||||
public SteamUserStatsManager UserStats => UserStatsManager;
|
||||
|
||||
[Documentation(nameof(Utils), "Provides access to ISteamUtils bindings.", null, null)]
|
||||
public SteamUtilsManager Utils => UtilsManager;
|
||||
|
||||
[Documentation(nameof(Video), "Provides access to ISteamVideo bindings.", null, null)]
|
||||
public SteamVideoManager Video => VideoManager;
|
||||
|
||||
private SteamManager()
|
||||
{
|
||||
try
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,49 @@
|
||||
using OmegaLeo.HelperLib.Shared.Attributes;
|
||||
|
||||
namespace OmegaLeo.HelperLib.Steamworks
|
||||
{
|
||||
[Documentation(nameof(SteamRemotePlayManager), "Provides helper methods for Steam Remote Play session inspection.", null,
|
||||
@"```csharp
|
||||
var remotePlay = SteamManager.Instance.RemotePlay;
|
||||
var sessionCount = remotePlay.GetSessionCount();
|
||||
```")]
|
||||
public class SteamRemotePlayManager
|
||||
{
|
||||
[Documentation(nameof(GetSessionCount), "Gets the number of active Remote Play sessions for the current user.", null, null)]
|
||||
public uint GetSessionCount()
|
||||
{
|
||||
return SteamNativeApi.GetRemotePlaySessionCount();
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetSessionId), "Gets a Remote Play session ID by zero-based session index.", new[] { "sessionIndex: Zero-based index into the active sessions list." }, null)]
|
||||
public uint GetSessionId(int sessionIndex)
|
||||
{
|
||||
return SteamNativeApi.GetRemotePlaySessionId(sessionIndex);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetSessionSteamId), "Gets the SteamID for the remote user in a session.", new[] { "sessionId: Remote Play session ID." }, null)]
|
||||
public ulong GetSessionSteamId(uint sessionId)
|
||||
{
|
||||
return SteamNativeApi.GetRemotePlaySessionSteamId(sessionId);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetSessionClientName), "Gets the client device name for a remote session.", new[] { "sessionId: Remote Play session ID." }, null)]
|
||||
public string GetSessionClientName(uint sessionId)
|
||||
{
|
||||
return SteamNativeApi.GetRemotePlaySessionClientName(sessionId);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetSessionClientFormFactor), "Gets the client form-factor value for a session (matches Steam's ESteamDeviceFormFactor numeric values).", new[] { "sessionId: Remote Play session ID." }, null)]
|
||||
public int GetSessionClientFormFactor(uint sessionId)
|
||||
{
|
||||
return SteamNativeApi.GetRemotePlaySessionClientFormFactor(sessionId);
|
||||
}
|
||||
|
||||
[Documentation(nameof(TryGetSessionClientResolution), "Gets the streaming client resolution for a session.", new[] { "sessionId: Remote Play session ID.", "resolutionX: Width output.", "resolutionY: Height output." }, null)]
|
||||
public bool TryGetSessionClientResolution(uint sessionId, out int resolutionX, out int resolutionY)
|
||||
{
|
||||
return SteamNativeApi.TryGetRemotePlaySessionClientResolution(sessionId, out resolutionX, out resolutionY);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
using OmegaLeo.HelperLib.Shared.Attributes;
|
||||
|
||||
namespace OmegaLeo.HelperLib.Steamworks
|
||||
{
|
||||
[Documentation(nameof(SteamUgcItemUpdateOptions), "Declarative update payload for workshop item editing convenience APIs.", null, null)]
|
||||
public class SteamUgcItemUpdateOptions
|
||||
{
|
||||
[Documentation(nameof(Title), "Workshop item title.", null, null)]
|
||||
public string Title { get; set; }
|
||||
|
||||
[Documentation(nameof(Description), "Workshop item description.", null, null)]
|
||||
public string Description { get; set; }
|
||||
|
||||
[Documentation(nameof(Metadata), "Workshop item metadata string.", null, null)]
|
||||
public string Metadata { get; set; }
|
||||
|
||||
[Documentation(nameof(Visibility), "Numeric ERemoteStoragePublishedFileVisibility value.", null, null)]
|
||||
public uint? Visibility { get; set; }
|
||||
|
||||
[Documentation(nameof(Tags), "Workshop tag list.", null, null)]
|
||||
public string[] Tags { get; set; }
|
||||
|
||||
[Documentation(nameof(ContentFolder), "Absolute path to workshop content folder.", null, null)]
|
||||
public string ContentFolder { get; set; }
|
||||
|
||||
[Documentation(nameof(PreviewFile), "Absolute path to workshop preview image.", null, null)]
|
||||
public string PreviewFile { get; set; }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,73 @@
|
||||
using OmegaLeo.HelperLib.Shared.Attributes;
|
||||
|
||||
namespace OmegaLeo.HelperLib.Steamworks
|
||||
{
|
||||
[Documentation(nameof(SteamUgcItemUpdateSession), "Fluent helper for editing and submitting a workshop item update.", null, null)]
|
||||
public class SteamUgcItemUpdateSession
|
||||
{
|
||||
private readonly SteamUgcManager _ugcManager;
|
||||
private readonly uint _consumerAppId;
|
||||
private readonly ulong _publishedFileId;
|
||||
private readonly SteamUgcItemUpdateOptions _options = new SteamUgcItemUpdateOptions();
|
||||
|
||||
internal SteamUgcItemUpdateSession(SteamUgcManager ugcManager, uint consumerAppId, ulong publishedFileId)
|
||||
{
|
||||
_ugcManager = ugcManager;
|
||||
_consumerAppId = consumerAppId;
|
||||
_publishedFileId = publishedFileId;
|
||||
}
|
||||
|
||||
public SteamUgcItemUpdateSession WithTitle(string title)
|
||||
{
|
||||
_options.Title = title;
|
||||
return this;
|
||||
}
|
||||
|
||||
public SteamUgcItemUpdateSession WithDescription(string description)
|
||||
{
|
||||
_options.Description = description;
|
||||
return this;
|
||||
}
|
||||
|
||||
public SteamUgcItemUpdateSession WithMetadata(string metadata)
|
||||
{
|
||||
_options.Metadata = metadata;
|
||||
return this;
|
||||
}
|
||||
|
||||
public SteamUgcItemUpdateSession WithVisibility(uint visibility)
|
||||
{
|
||||
_options.Visibility = visibility;
|
||||
return this;
|
||||
}
|
||||
|
||||
public SteamUgcItemUpdateSession WithTags(params string[] tags)
|
||||
{
|
||||
_options.Tags = tags;
|
||||
return this;
|
||||
}
|
||||
|
||||
public SteamUgcItemUpdateSession WithContentFolder(string contentFolder)
|
||||
{
|
||||
_options.ContentFolder = contentFolder;
|
||||
return this;
|
||||
}
|
||||
|
||||
public SteamUgcItemUpdateSession WithPreviewFile(string previewFile)
|
||||
{
|
||||
_options.PreviewFile = previewFile;
|
||||
return this;
|
||||
}
|
||||
|
||||
[Documentation(nameof(Submit), "Submits the fluent update session and returns a Steam API call handle.", new[]
|
||||
{
|
||||
"changeNote: Changelog note for this update.",
|
||||
"failedStep: Name of the failed step if submission returns 0."
|
||||
}, null)]
|
||||
public ulong Submit(string changeNote, out string failedStep)
|
||||
{
|
||||
return _ugcManager.UpdateItem(_consumerAppId, _publishedFileId, _options, changeNote, out failedStep);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,240 @@
|
||||
using OmegaLeo.HelperLib.Shared.Attributes;
|
||||
|
||||
namespace OmegaLeo.HelperLib.Steamworks
|
||||
{
|
||||
[Documentation(nameof(SteamUgcManager), "Provides helper methods for common Steam Workshop (UGC) operations such as queries and subscriptions.", null,
|
||||
@"```csharp
|
||||
var ugc = new SteamUgcManager();
|
||||
var items = ugc.GetSubscribedItems();
|
||||
```")]
|
||||
public class SteamUgcManager
|
||||
{
|
||||
[Documentation(nameof(BeginUpdateSession), "Begins a fluent UGC update session for an existing workshop item.", new[]
|
||||
{
|
||||
"consumerAppId: Your game AppId.",
|
||||
"publishedFileId: Existing workshop item ID."
|
||||
}, null)]
|
||||
public SteamUgcItemUpdateSession BeginUpdateSession(uint consumerAppId, ulong publishedFileId)
|
||||
{
|
||||
return new SteamUgcItemUpdateSession(this, consumerAppId, publishedFileId);
|
||||
}
|
||||
|
||||
[Documentation(nameof(ApplyItemUpdate), "Applies all non-null/non-empty fields from a UGC update options object to an existing update handle.", new[]
|
||||
{
|
||||
"updateHandle: Handle from StartItemUpdate.",
|
||||
"options: Options object containing fields to apply.",
|
||||
"failedStep: Name of the field that failed to apply, if any."
|
||||
}, null)]
|
||||
public bool ApplyItemUpdate(ulong updateHandle, SteamUgcItemUpdateOptions options, out string failedStep)
|
||||
{
|
||||
failedStep = string.Empty;
|
||||
|
||||
if (updateHandle == 0 || options == null)
|
||||
{
|
||||
failedStep = "InvalidArguments";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(options.Title) && !SetItemTitle(updateHandle, options.Title))
|
||||
{
|
||||
failedStep = nameof(options.Title);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(options.Description) && !SetItemDescription(updateHandle, options.Description))
|
||||
{
|
||||
failedStep = nameof(options.Description);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(options.Metadata) && !SetItemMetadata(updateHandle, options.Metadata))
|
||||
{
|
||||
failedStep = nameof(options.Metadata);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (options.Visibility.HasValue && !SetItemVisibility(updateHandle, options.Visibility.Value))
|
||||
{
|
||||
failedStep = nameof(options.Visibility);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (options.Tags != null && options.Tags.Length > 0 && !SetItemTags(updateHandle, options.Tags))
|
||||
{
|
||||
failedStep = nameof(options.Tags);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(options.ContentFolder) && !SetItemContent(updateHandle, options.ContentFolder))
|
||||
{
|
||||
failedStep = nameof(options.ContentFolder);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(options.PreviewFile) && !SetItemPreview(updateHandle, options.PreviewFile))
|
||||
{
|
||||
failedStep = nameof(options.PreviewFile);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
[Documentation(nameof(UpdateItem), "Convenience method that starts an item update, applies option fields, and submits the update in one call.", new[]
|
||||
{
|
||||
"consumerAppId: Your game AppId.",
|
||||
"publishedFileId: Existing workshop item ID.",
|
||||
"options: Options object containing fields to update.",
|
||||
"changeNote: Changelog note for submission.",
|
||||
"failedStep: Name of the failed step when the call returns 0."
|
||||
}, null)]
|
||||
public ulong UpdateItem(uint consumerAppId, ulong publishedFileId, SteamUgcItemUpdateOptions options, string changeNote, out string failedStep)
|
||||
{
|
||||
failedStep = string.Empty;
|
||||
|
||||
var updateHandle = StartItemUpdate(consumerAppId, publishedFileId);
|
||||
if (updateHandle == 0)
|
||||
{
|
||||
failedStep = nameof(StartItemUpdate);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!ApplyItemUpdate(updateHandle, options, out failedStep))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
var submitHandle = SubmitItemUpdate(updateHandle, changeNote);
|
||||
if (submitHandle == 0)
|
||||
{
|
||||
failedStep = nameof(SubmitItemUpdate);
|
||||
}
|
||||
|
||||
return submitHandle;
|
||||
}
|
||||
|
||||
[Documentation(nameof(CreateItem), "Creates a new Workshop item and returns a Steam API call handle.", new[]
|
||||
{
|
||||
"consumerAppId: Your game AppId.",
|
||||
"fileType: Numeric EWorkshopFileType value."
|
||||
}, null)]
|
||||
public ulong CreateItem(uint consumerAppId, uint fileType)
|
||||
{
|
||||
return SteamNativeApi.CreateItem(consumerAppId, fileType);
|
||||
}
|
||||
|
||||
[Documentation(nameof(StartItemUpdate), "Starts an update transaction for an existing Workshop item.", new[]
|
||||
{
|
||||
"consumerAppId: Your game AppId.",
|
||||
"publishedFileId: Existing workshop item ID."
|
||||
}, null)]
|
||||
public ulong StartItemUpdate(uint consumerAppId, ulong publishedFileId)
|
||||
{
|
||||
return SteamNativeApi.StartItemUpdate(consumerAppId, publishedFileId);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetItemTitle), "Sets workshop item title for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "title: New item title." }, null)]
|
||||
public bool SetItemTitle(ulong updateHandle, string title)
|
||||
{
|
||||
return SteamNativeApi.SetItemTitle(updateHandle, title);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetItemDescription), "Sets workshop item description for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "description: New item description." }, null)]
|
||||
public bool SetItemDescription(ulong updateHandle, string description)
|
||||
{
|
||||
return SteamNativeApi.SetItemDescription(updateHandle, description);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetItemMetadata), "Sets workshop item metadata for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "metadata: Metadata string (up to Steam's size limits)." }, null)]
|
||||
public bool SetItemMetadata(ulong updateHandle, string metadata)
|
||||
{
|
||||
return SteamNativeApi.SetItemMetadata(updateHandle, metadata);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetItemVisibility), "Sets workshop item visibility for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "visibility: Numeric ERemoteStoragePublishedFileVisibility value." }, null)]
|
||||
public bool SetItemVisibility(ulong updateHandle, uint visibility)
|
||||
{
|
||||
return SteamNativeApi.SetItemVisibility(updateHandle, visibility);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetItemTags), "Sets workshop item tags for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "tags: Array of tag strings." }, null)]
|
||||
public bool SetItemTags(ulong updateHandle, string[] tags)
|
||||
{
|
||||
return SteamNativeApi.SetItemTags(updateHandle, tags);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetItemContent), "Sets workshop item content folder path for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "contentFolder: Absolute path to content folder." }, null)]
|
||||
public bool SetItemContent(ulong updateHandle, string contentFolder)
|
||||
{
|
||||
return SteamNativeApi.SetItemContent(updateHandle, contentFolder);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SetItemPreview), "Sets workshop item preview image path for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "previewFile: Absolute path to preview image file." }, null)]
|
||||
public bool SetItemPreview(ulong updateHandle, string previewFile)
|
||||
{
|
||||
return SteamNativeApi.SetItemPreview(updateHandle, previewFile);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SubmitItemUpdate), "Submits a pending workshop item update and returns a Steam API call handle.", new[] { "updateHandle: Handle from StartItemUpdate.", "changeNote: Changelog note for the update." }, null)]
|
||||
public ulong SubmitItemUpdate(ulong updateHandle, string changeNote)
|
||||
{
|
||||
return SteamNativeApi.SubmitItemUpdate(updateHandle, changeNote);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetItemUpdateProgress), "Gets progress state for a pending item update upload.", new[] { "updateHandle: Handle from StartItemUpdate.", "bytesProcessed: Uploaded bytes output.", "bytesTotal: Total bytes output." }, null)]
|
||||
public uint GetItemUpdateProgress(ulong updateHandle, out ulong bytesProcessed, out ulong bytesTotal)
|
||||
{
|
||||
return SteamNativeApi.GetItemUpdateProgress(updateHandle, out bytesProcessed, out bytesTotal);
|
||||
}
|
||||
|
||||
[Documentation(nameof(CreateQueryAllUgcRequest), "Creates a UGC query request handle for workshop discovery.", new[]
|
||||
{
|
||||
"queryType: Numeric EUGCQuery value from Steamworks docs.",
|
||||
"matchingType: Numeric EUGCMatchingUGCType value from Steamworks docs.",
|
||||
"creatorAppId: AppId filter for creator app.",
|
||||
"consumerAppId: AppId filter for consumer app.",
|
||||
"page: Query page number, starting at 1."
|
||||
}, null)]
|
||||
public ulong CreateQueryAllUgcRequest(uint queryType, uint matchingType, uint creatorAppId, uint consumerAppId, uint page = 1)
|
||||
{
|
||||
return SteamNativeApi.CreateQueryAllUgcRequest(queryType, matchingType, creatorAppId, consumerAppId, page);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SendQueryUgcRequest), "Submits an existing UGC query request and returns a Steam API call handle.", new[] { "queryHandle: UGC query handle returned from CreateQueryAllUgcRequest." }, null)]
|
||||
public ulong SendQueryUgcRequest(ulong queryHandle)
|
||||
{
|
||||
return SteamNativeApi.SendQueryUgcRequest(queryHandle);
|
||||
}
|
||||
|
||||
[Documentation(nameof(ReleaseQueryUgcRequest), "Releases a UGC query handle after you are done with query results.", new[] { "queryHandle: UGC query handle to release." }, null)]
|
||||
public bool ReleaseQueryUgcRequest(ulong queryHandle)
|
||||
{
|
||||
return SteamNativeApi.ReleaseQueryUgcRequest(queryHandle);
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetNumSubscribedItems), "Gets the number of workshop items the current user is subscribed to.", null, null)]
|
||||
public uint GetNumSubscribedItems()
|
||||
{
|
||||
return SteamNativeApi.GetNumSubscribedItems();
|
||||
}
|
||||
|
||||
[Documentation(nameof(GetSubscribedItems), "Gets subscribed workshop item IDs for the current user.", new[] { "maxEntries: Maximum number of subscribed IDs to retrieve." }, null)]
|
||||
public ulong[] GetSubscribedItems(uint maxEntries = 1024)
|
||||
{
|
||||
return SteamNativeApi.GetSubscribedItems(maxEntries);
|
||||
}
|
||||
|
||||
[Documentation(nameof(SubscribeItem), "Subscribes the current user to a workshop item.", new[] { "publishedFileId: Published file ID of the workshop item." }, null)]
|
||||
public ulong SubscribeItem(ulong publishedFileId)
|
||||
{
|
||||
return SteamNativeApi.SubscribeItem(publishedFileId);
|
||||
}
|
||||
|
||||
[Documentation(nameof(UnsubscribeItem), "Unsubscribes the current user from a workshop item.", new[] { "publishedFileId: Published file ID of the workshop item." }, null)]
|
||||
public ulong UnsubscribeItem(ulong publishedFileId)
|
||||
{
|
||||
return SteamNativeApi.UnsubscribeItem(publishedFileId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user