diff --git a/Facepunch.Steamworks/Generated/SteamEnums.cs b/Facepunch.Steamworks/Generated/SteamEnums.cs index 992a275..8b8e579 100644 --- a/Facepunch.Steamworks/Generated/SteamEnums.cs +++ b/Facepunch.Steamworks/Generated/SteamEnums.cs @@ -9,9 +9,19 @@ namespace Steamworks // // ESteamIPType // + /// + /// Specifies the type of IP. + /// internal enum SteamIPType : int { + /// + /// IPv4 + /// Type4 = 0, + + /// + /// IPv6 + /// Type6 = 1, } @@ -31,6 +41,9 @@ namespace Steamworks // // EResult // + /// + /// Determines the result of a request. + /// public enum Result : int { None = 0, diff --git a/Facepunch.Steamworks/SteamApps.cs b/Facepunch.Steamworks/SteamApps.cs index 2610e02..1e6410e 100644 --- a/Facepunch.Steamworks/SteamApps.cs +++ b/Facepunch.Steamworks/SteamApps.cs @@ -27,41 +27,41 @@ namespace Steamworks } /// - /// posted after the user gains ownership of DLC and that DLC is installed + /// Posted after the user gains ownership of DLC and that DLC is installed. /// public static event Action OnDlcInstalled; /// - /// posted after the user gains executes a Steam URL with command line or query parameters + /// Posted after the user gains executes a Steam URL with command line or query parameters /// such as steam://run/appid//-commandline/?param1=value1(and)param2=value2(and)param3=value3 etc /// while the game is already running. The new params can be queried - /// with GetLaunchQueryParam and GetLaunchCommandLine + /// with GetLaunchQueryParam and GetLaunchCommandLine. /// public static event Action OnNewLaunchParameters; /// - /// Checks if the active user is subscribed to the current App ID + /// Gets whether or not the active user is subscribed to the current App ID. /// public static bool IsSubscribed => Internal.BIsSubscribed(); /// - /// Check if user borrowed this game via Family Sharing, If true, call GetAppOwner() to get the lender SteamID + /// Gets whether or not the user borrowed this game via Family Sharing. If true, call GetAppOwner() to get the lender SteamID. /// public static bool IsSubscribedFromFamilySharing => Internal.BIsSubscribedFromFamilySharing(); /// - /// Checks if the license owned by the user provides low violence depots. + /// Gets whether or not the license owned by the user provides low violence depots. /// Low violence depots are useful for copies sold in countries that have content restrictions /// public static bool IsLowViolence => Internal.BIsLowViolence(); /// - /// Checks whether the current App ID license is for Cyber Cafes. + /// Gets whether or not the current App ID license is for Cyber Cafes. /// public static bool IsCybercafe => Internal.BIsCybercafe(); /// - /// CChecks if the user has a VAC ban on their account + /// Gets whether or not the user has a VAC ban on their account. /// public static bool IsVACBanned => Internal.BIsVACBanned(); @@ -77,19 +77,22 @@ namespace Steamworks public static string[] AvailableLanguages => Internal.GetAvailableGameLanguages().Split( new[] { ',' }, StringSplitOptions.RemoveEmptyEntries ); /// - /// Checks if the active user is subscribed to a specified AppId. + /// Gets whether or not the active user is subscribed to a specified App ID. /// Only use this if you need to check ownership of another game related to yours, a demo for example. /// + /// The App ID of the DLC to check. public static bool IsSubscribedToApp( AppId appid ) => Internal.BIsSubscribedApp( appid.Value ); /// - /// Checks if the user owns a specific DLC and if the DLC is installed + /// Gets whether or not the user owns a specific DLC and if the DLC is installed. /// + /// The App ID of the DLC to check. public static bool IsDlcInstalled( AppId appid ) => Internal.BIsDlcInstalled( appid.Value ); /// - /// Returns the time of the purchase of the app + /// Returns the time of the purchase of the app. /// + /// The App ID to check the purchase time for. public static DateTime PurchaseTime( AppId appid = default ) { if ( appid == 0 ) @@ -99,14 +102,14 @@ namespace Steamworks } /// - /// Checks if the user is subscribed to the current app through a free weekend - /// This function will return false for users who have a retail or other type of license - /// Before using, please ask your Valve technical contact how to package and secure your free weekened + /// Checks if the user is subscribed to the current app through a free weekend. + /// This function will return false for users who have a retail or other type of license. + /// Before using, please ask your Valve technical contact how to package and secure your free weekened. /// public static bool IsSubscribedFromFreeWeekend => Internal.BIsSubscribedFromFreeWeekend(); /// - /// Returns metadata for all available DLC + /// Returns metadata for all available DLC. /// public static IEnumerable DlcInformation() { @@ -128,17 +131,19 @@ namespace Steamworks } /// - /// Install/Uninstall control for optional DLC + /// Install control for optional DLC. /// + /// The App ID of the DLC to install. public static void InstallDlc( AppId appid ) => Internal.InstallDLC( appid.Value ); /// - /// Install/Uninstall control for optional DLC + /// Uninstall control for optional DLC. /// + /// The App ID of the DLC to uninstall. public static void UninstallDlc( AppId appid ) => Internal.UninstallDLC( appid.Value ); /// - /// Returns null if we're not on a beta branch, else the name of the branch + /// Gets the name of the beta branch that is launched, or if the application is not running on a beta branch. /// public static string CurrentBetaName { @@ -152,16 +157,19 @@ namespace Steamworks } /// - /// Allows you to force verify game content on next launch. - /// - /// If you detect the game is out-of-date(for example, by having the client detect a version mismatch with a server), - /// you can call use MarkContentCorrupt to force a verify, show a message to the user, and then quit. + /// Force verify game content on next launch. + /// + /// If you detect the game is out-of-date (for example, by having the client detect a version mismatch with a server), + /// you can call MarkContentCorrupt to force a verify, show a message to the user, and then quit. + /// /// + /// Whether or not to only verify missing files. public static void MarkContentCorrupt( bool missingFilesOnly ) => Internal.MarkContentCorrupt( missingFilesOnly ); /// - /// Gets a list of all installed depots for a given App ID in mount order + /// Gets a list of all installed depots for a given App ID in mount order. /// + /// The App ID. public static IEnumerable InstalledDepots( AppId appid = default ) { if ( appid == 0 ) @@ -177,9 +185,10 @@ namespace Steamworks } /// - /// Gets the install folder for a specific AppID. + /// Gets the install folder for a specific App ID. /// This works even if the application is not installed, based on where the game would be installed with the default Steam library location. /// + /// The App ID. public static string AppInstallDir( AppId appid = default ) { if ( appid == 0 ) @@ -192,26 +201,32 @@ namespace Steamworks } /// - /// The app may not actually be owned by the current user, they may have it left over from a free weekend, etc. + /// Gets whether or not the app is owned by the current user. The app may not actually be owned by the current user; they may have it left over from a free weekend, etc. /// + /// The App ID. public static bool IsAppInstalled( AppId appid ) => Internal.BIsAppInstalled( appid.Value ); /// - /// Gets the Steam ID of the original owner of the current app. If it's different from the current user then it is borrowed.. + /// Gets the Steam ID of the original owner of the current app. If it's different from the current user then it is borrowed. /// public static SteamId AppOwner => Internal.GetAppOwner().Value; /// /// Gets the associated launch parameter if the game is run via steam://run/appid/?param1=value1;param2=value2;param3=value3 etc. - /// Parameter names starting with the character '@' are reserved for internal use and will always return an empty string. - /// Parameter names starting with an underscore '_' are reserved for steam features -- they can be queried by the game, + /// + /// Parameter names starting with the character '@' are reserved for internal use and will always return an empty string. + /// Parameter names starting with an underscore '_' are reserved for steam features -- they can be queried by the game, /// but it is advised that you not param names beginning with an underscore for your own features. + /// /// + /// The name of the parameter. + /// The launch parameter value. public static string GetLaunchParam( string param ) => Internal.GetLaunchQueryParam( param ); /// /// Gets the download progress for optional DLC. /// + /// The App ID to check the progress for. public static DownloadProgress DlcDownloadProgress( AppId appid ) { ulong punBytesDownloaded = 0; @@ -224,16 +239,16 @@ namespace Steamworks } /// - /// Gets the buildid of this app, may change at any time based on backend updates to the game. - /// Defaults to 0 if you're not running a build downloaded from steam. + /// Gets the Build ID of this app, which can change at any time based on backend updates to the game. + /// Defaults to 0 if you're not running a build downloaded from steam. /// public static int BuildId => Internal.GetAppBuildId(); /// /// Asynchronously retrieves metadata details about a specific file in the depot manifest. - /// Currently provides: /// + /// The name of the file. public static async Task GetFileDetailsAsync( string filename ) { var r = await Internal.GetFileDetails( filename ); @@ -253,9 +268,9 @@ namespace Steamworks /// Get command line if game was launched via Steam URL, e.g. steam://run/appid//command line/. /// This method of passing a connect string (used when joining via rich presence, accepting an /// invite, etc) is preferable to passing the connect string on the operating system command - /// line, which is a security risk. In order for rich presence joins to go through this + /// line, which is a security risk. In order for rich presence joins to go through this /// path and not be placed on the OS command line, you must set a value in your app's - /// configuration on Steam. Ask Valve for help with this. + /// configuration on Steam. Ask Valve for help with this. /// public static string CommandLine { @@ -267,8 +282,10 @@ namespace Steamworks } /// - /// check if game is a timed trial with limited playtime + /// Check if game is a timed trial with limited playtime. /// + /// The amount of seconds left on the timed trial. + /// The amount of seconds played on the timed trial. public static bool IsTimedTrial( out int secondsAllowed, out int secondsPlayed ) { uint a = 0; @@ -286,4 +303,4 @@ namespace Steamworks } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamClient.cs b/Facepunch.Steamworks/SteamClient.cs index 73d61cc..d725b67 100644 --- a/Facepunch.Steamworks/SteamClient.cs +++ b/Facepunch.Steamworks/SteamClient.cs @@ -13,7 +13,7 @@ namespace Steamworks /// /// Initialize the steam client. - /// If asyncCallbacks is false you need to call RunCallbacks manually every frame. + /// If is false you need to call manually every frame. /// public static void Init( uint appid, bool asyncCallbacks = true ) { @@ -25,7 +25,7 @@ namespace Steamworks if ( !SteamAPI.Init() ) { - throw new System.Exception( "SteamApi_Init returned false. Steam isn't running, couldn't find Steam, AppId is ureleased, Don't own AppId." ); + throw new System.Exception( "SteamApi_Init returned false. Steam isn't running, couldn't find Steam, App ID is ureleased, Don't own App ID." ); } AppId = appid; @@ -94,6 +94,9 @@ namespace Steamworks /// public static bool IsValid => initialized; + /// + /// Shuts down the steam client. + /// public static void Shutdown() { if ( !IsValid ) return; @@ -119,13 +122,15 @@ namespace Steamworks /// /// Checks if the current user's Steam client is connected to the Steam servers. - /// If it's not then no real-time services provided by the Steamworks API will be enabled. The Steam + /// + /// If it's not, no real-time services provided by the Steamworks API will be enabled. The Steam /// client will automatically be trying to recreate the connection as often as possible. When the /// connection is restored a SteamServersConnected_t callback will be posted. /// You usually don't need to check for this yourself. All of the API calls that rely on this will /// check internally. Forcefully disabling stuff when the player loses access is usually not a /// very good experience for the player and you could be preventing them from accessing APIs that do not /// need a live connection to Steam. + /// /// public static bool IsLoggedOn => SteamUser.Internal.BLoggedOn(); @@ -138,28 +143,30 @@ namespace Steamworks public static SteamId SteamId => SteamUser.Internal.GetSteamID(); /// - /// returns the local players name - guaranteed to not be NULL. - /// this is the same name as on the users community profile page + /// returns the local players name - guaranteed to not be . + /// This is the same name as on the user's community profile page. /// public static string Name => SteamFriends.Internal.GetPersonaName(); /// - /// gets the status of the current user + /// Gets the status of the current user. /// public static FriendState State => SteamFriends.Internal.GetPersonaState(); /// - /// returns the appID of the current process + /// Returns the App ID of the current process. /// public static AppId AppId { get; internal set; } /// - /// Checks if your executable was launched through Steam and relaunches it through Steam if it wasn't - /// this returns true then it starts the Steam client if required and launches your game again through it, + /// Checks if your executable was launched through Steam and relaunches it through Steam if it wasn't. + /// + /// This returns true then it starts the Steam client if required and launches your game again through it, /// and you should quit your process as soon as possible. This effectively runs steam://run/AppId so it /// may not relaunch the exact executable that called it, as it will always relaunch from the version /// installed in your Steam library folder/ /// Note that during development, when not launching via Steam, this might always return true. + /// /// public static bool RestartAppIfNecessary( uint appid ) { diff --git a/Facepunch.Steamworks/SteamFriends.cs b/Facepunch.Steamworks/SteamFriends.cs index 3a8d338..3e31be6 100644 --- a/Facepunch.Steamworks/SteamFriends.cs +++ b/Facepunch.Steamworks/SteamFriends.cs @@ -8,7 +8,7 @@ using Steamworks.Data; namespace Steamworks { /// - /// Undocumented Parental Settings + /// Class for utilizing the Steam Friends API. /// public class SteamFriends : SteamClientClass { @@ -39,54 +39,54 @@ namespace Steamworks } /// - /// Called when chat message has been received from a friend. You'll need to turn on - /// ListenForFriendsMessages to recieve this. (friend, msgtype, message) + /// Invoked when a chat message has been received from a friend. You'll need to enable + /// to recieve this. (friend, msgtype, message) /// public static event Action OnChatMessage; /// - /// Called when a chat message has been received in a Steam group chat that we are in. Associated Functions: JoinClanChatRoom. (friend, msgtype, message) + /// Invoked when a chat message has been received in a Steam group chat that we are in. Associated Functions: JoinClanChatRoom. (friend, msgtype, message) /// public static event Action OnClanChatMessage; /// - /// called when a friends' status changes + /// Invoked when a friends' status changes. /// public static event Action OnPersonaStateChange; /// - /// Called when the user tries to join a game from their friends list - /// rich presence will have been set with the "connect" key which is set here + /// Invoked when the user tries to join a game from their friends list. + /// Rich presence will have been set with the "connect" key which is set here. /// public static event Action OnGameRichPresenceJoinRequested; /// - /// Posted when game overlay activates or deactivates - /// the game can use this to be pause or resume single player games + /// Invoked when game overlay activates or deactivates. + /// The game can use this to be pause or resume single player games. /// public static event Action OnGameOverlayActivated; /// - /// Called when the user tries to join a different game server from their friends list - /// game client should attempt to connect to specified server when this is received + /// Invoked when the user tries to join a different game server from their friends list. + /// Game client should attempt to connect to specified server when this is received. /// public static event Action OnGameServerChangeRequested; /// - /// Called when the user tries to join a lobby from their friends list - /// game client should attempt to connect to specified lobby when this is received + /// Invoked when the user tries to join a lobby from their friends list. + /// Game client should attempt to connect to specified lobby when this is received. /// public static event Action OnGameLobbyJoinRequested; /// - /// Callback indicating updated data about friends rich presence information + /// Invoked when a friend's rich presence data is updated. /// public static event Action OnFriendRichPresenceUpdate; /// - /// Dispatched when an overlay browser instance is navigated to a - /// protocol/scheme registered by RegisterProtocolInOverlayBrowser() + /// Invoked when an overlay browser instance is navigated to a + /// protocol/scheme registered by . /// public static event Action OnOverlayBrowserProtocol; @@ -140,16 +140,28 @@ namespace Steamworks } } + /// + /// Gets an of friends that the current user has. + /// + /// An of friends. public static IEnumerable GetFriends() { return GetFriendsWithFlag(FriendFlags.Immediate); } + /// + /// Gets an of blocked users that the current user has. + /// + /// An of blocked users. public static IEnumerable GetBlocked() { return GetFriendsWithFlag(FriendFlags.Blocked); } + /// + /// Gets an of friend requests that the current user has. + /// + /// An of friend requests. public static IEnumerable GetFriendsRequested() { return GetFriendsWithFlag( FriendFlags.FriendshipRequested ); @@ -195,7 +207,7 @@ namespace Steamworks } /// - /// The dialog to open. Valid options are: + /// Opens a specific overlay window. Valid options are: /// "friends", /// "community", /// "players", @@ -267,18 +279,33 @@ namespace Steamworks await Task.Delay( 500 ); } + /// + /// Returns a small avatar of the user with the given . + /// + /// The of the user to get. + /// A with a value if the image was successfully retrieved. public static async Task GetSmallAvatarAsync( SteamId steamid ) { await CacheUserInformationAsync( steamid, false ); return SteamUtils.GetImage( Internal.GetSmallFriendAvatar( steamid ) ); } + /// + /// Returns a medium avatar of the user with the given . + /// + /// The of the user to get. + /// A with a value if the image was successfully retrieved. public static async Task GetMediumAvatarAsync( SteamId steamid ) { await CacheUserInformationAsync( steamid, false ); return SteamUtils.GetImage( Internal.GetMediumFriendAvatar( steamid ) ); } + /// + /// Returns a large avatar of the user with the given . + /// + /// The of the user to get. + /// A with a value if the image was successfully retrieved. public static async Task GetLargeAvatarAsync( SteamId steamid ) { await CacheUserInformationAsync( steamid, false ); @@ -346,6 +373,11 @@ namespace Steamworks } } + /// + /// Gets whether or not the current user is following the user with the given . + /// + /// The to check. + /// Boolean. public static async Task IsFollowing(SteamId steamID) { var r = await Internal.IsFollowing(steamID); diff --git a/Facepunch.Steamworks/SteamInput.cs b/Facepunch.Steamworks/SteamInput.cs index fbb18e4..17f2137 100644 --- a/Facepunch.Steamworks/SteamInput.cs +++ b/Facepunch.Steamworks/SteamInput.cs @@ -3,6 +3,9 @@ using System.Collections.Generic; namespace Steamworks { + /// + /// Class for utilizing Steam Input. + /// public class SteamInput : SteamClientClass { internal static ISteamInput Internal => Interface as ISteamInput; @@ -16,7 +19,7 @@ namespace Steamworks /// - /// You shouldn't really need to call this because it get called by RunCallbacks on SteamClient + /// You shouldn't really need to call this because it gets called by /// but Valve think it might be a nice idea if you call it right before you get input info - /// just to make sure the info you're getting is 100% up to date. /// @@ -28,7 +31,7 @@ namespace Steamworks static readonly InputHandle_t[] queryArray = new InputHandle_t[STEAM_CONTROLLER_MAX_COUNT]; /// - /// Return a list of connected controllers. + /// Gets a list of connected controllers. /// public static IEnumerable Controllers { diff --git a/Facepunch.Steamworks/SteamInventory.cs b/Facepunch.Steamworks/SteamInventory.cs index 79fa3ac..5d0dfb3 100644 --- a/Facepunch.Steamworks/SteamInventory.cs +++ b/Facepunch.Steamworks/SteamInventory.cs @@ -10,7 +10,7 @@ using Steamworks.Data; namespace Steamworks { /// - /// Undocumented Parental Settings + /// Class for utilizing the Steam Inventory API. /// public class SteamInventory : SteamSharedClass { @@ -65,7 +65,7 @@ namespace Steamworks /// /// Call this if you're going to want to access definition information. You should be able to get /// away with calling this once at the start if your game, assuming your items don't change all the time. - /// This will trigger OnDefinitionsUpdated at which point Definitions should be set. + /// This will trigger at which point Definitions should be set. /// public static void LoadItemDefinitions() { @@ -83,7 +83,7 @@ namespace Steamworks } /// - /// Will call LoadItemDefinitions and wait until Definitions is not null + /// Will call and wait until Definitions is not null /// public static async Task WaitForDefinitions( float timeoutSeconds = 30 ) { @@ -300,7 +300,7 @@ namespace Steamworks /// - /// Grant all promotional items the user is eligible for + /// Grant all promotional items the user is eligible for. /// public static async Task GrantPromoItemsAsync() { @@ -363,4 +363,4 @@ namespace Steamworks } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamMatchmaking.cs b/Facepunch.Steamworks/SteamMatchmaking.cs index 3458fa6..1e8fb10 100644 --- a/Facepunch.Steamworks/SteamMatchmaking.cs +++ b/Facepunch.Steamworks/SteamMatchmaking.cs @@ -8,7 +8,7 @@ using Steamworks.Data; namespace Steamworks { /// - /// Functions for clients to access matchmaking services, favorites, and to operate on game lobbies + /// Methods for clients to access matchmaking services, favorites, and to operate on game lobbies /// public class SteamMatchmaking : SteamClientClass { @@ -83,69 +83,69 @@ namespace Steamworks } /// - /// Someone invited you to a lobby + /// Invoked when the current user is invited to a lobby. /// public static event Action OnLobbyInvite; /// - /// You joined a lobby + /// Invoked when the current user joins a lobby. /// public static event Action OnLobbyEntered; /// - /// You created a lobby + /// Invoked when the current user creates a lobby. /// public static event Action OnLobbyCreated; /// - /// A game server has been associated with the lobby + /// Invoked when a game server has been associated with a lobby. /// public static event Action OnLobbyGameCreated; /// - /// The lobby metadata has changed + /// Invoked when a lobby's metadata is modified. /// public static event Action OnLobbyDataChanged; /// - /// The lobby member metadata has changed + /// Invoked when a member in a lobby's metadata is modified. /// public static event Action OnLobbyMemberDataChanged; /// - /// The lobby member joined + /// Invoked when a member joins a lobby. /// public static event Action OnLobbyMemberJoined; /// - /// The lobby member left the room + /// Invoked when a lobby member leaves the lobby. /// public static event Action OnLobbyMemberLeave; /// - /// The lobby member left the room + /// Invoked when a lobby member leaves the lobby. /// public static event Action OnLobbyMemberDisconnected; /// - /// The lobby member was kicked. The 3rd param is the user that kicked them. + /// Invoked when a lobby member is kicked from a lobby. The 3rd param is the user that kicked them. /// public static event Action OnLobbyMemberKicked; /// - /// The lobby member was banned. The 3rd param is the user that banned them. + /// Invoked when a lobby member is kicked from a lobby. The 3rd param is the user that kicked them. /// public static event Action OnLobbyMemberBanned; /// - /// A chat message was recieved from a member of a lobby + /// Invoked when a chat message is received from a member of the lobby. /// public static event Action OnChatMessage; public static LobbyQuery LobbyList => new LobbyQuery(); /// - /// Creates a new invisible lobby. Call lobby.SetPublic to take it online. + /// Creates a new invisible lobby. Call to take it online. /// public static async Task CreateLobbyAsync( int maxMembers = 100 ) { @@ -156,7 +156,7 @@ namespace Steamworks } /// - /// Attempts to directly join the specified lobby + /// Attempts to directly join the specified lobby. /// public static async Task JoinLobbyAsync( SteamId lobbyId ) { @@ -167,7 +167,7 @@ namespace Steamworks } /// - /// Get a list of servers that are on your favorites list + /// Get a list of servers that are on the current user's favorites list. /// public static IEnumerable GetFavoriteServers() { @@ -191,7 +191,7 @@ namespace Steamworks } /// - /// Get a list of servers that you have added to your play history + /// Get a list of servers that the current user has added to their history. /// public static IEnumerable GetHistoryServers() { @@ -215,4 +215,4 @@ namespace Steamworks } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamMatchmakingServers.cs b/Facepunch.Steamworks/SteamMatchmakingServers.cs index c1af07a..bbbdc5c 100644 --- a/Facepunch.Steamworks/SteamMatchmakingServers.cs +++ b/Facepunch.Steamworks/SteamMatchmakingServers.cs @@ -8,7 +8,7 @@ using Steamworks.Data; namespace Steamworks { /// - /// Functions for clients to access matchmaking services, favorites, and to operate on game lobbies + /// Methods for clients to access matchmaking services, favorites, and to operate on game lobbies /// internal class SteamMatchmakingServers : SteamClientClass { @@ -19,4 +19,4 @@ namespace Steamworks SetInterface( server, new ISteamMatchmakingServers( server ) ); } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamMusic.cs b/Facepunch.Steamworks/SteamMusic.cs index 1ef38f8..7a984a2 100644 --- a/Facepunch.Steamworks/SteamMusic.cs +++ b/Facepunch.Steamworks/SteamMusic.cs @@ -31,22 +31,22 @@ namespace Steamworks } /// - /// Playback status changed + /// Invoked when playback status is changed. /// public static event Action OnPlaybackChanged; /// - /// Volume changed, parameter is new volume + /// Invoked when the volume of the music player is changed. /// public static event Action OnVolumeChanged; /// - /// Checks if Steam Music is enabled + /// Checks if Steam Music is enabled. /// public static bool IsEnabled => Internal.BIsEnabled(); /// - /// true if a song is currently playing, paused, or queued up to play; otherwise false. + /// if a song is currently playing, paused, or queued up to play; otherwise . /// public static bool IsPlaying => Internal.BIsPlaying(); @@ -55,23 +55,28 @@ namespace Steamworks /// public static MusicStatus Status => Internal.GetPlaybackStatus(); - + /// + /// Plays the music player. + /// public static void Play() => Internal.Play(); + /// + /// Pauses the music player. + /// public static void Pause() => Internal.Pause(); /// - /// Have the Steam Music player play the previous song. + /// Forces the music player to play the previous song. /// public static void PlayPrevious() => Internal.PlayPrevious(); /// - /// Have the Steam Music player skip to the next song + /// Forces the music player to skip to the next song. /// public static void PlayNext() => Internal.PlayNext(); /// - /// Gets/Sets the current volume of the Steam Music player + /// Gets and sets the current volume of the Steam Music player /// public static float Volume { @@ -79,4 +84,4 @@ namespace Steamworks set => Internal.SetVolume( value ); } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamNetworking.cs b/Facepunch.Steamworks/SteamNetworking.cs index 05e4c17..b6601ba 100644 --- a/Facepunch.Steamworks/SteamNetworking.cs +++ b/Facepunch.Steamworks/SteamNetworking.cs @@ -8,6 +8,9 @@ using Steamworks.Data; namespace Steamworks { + /// + /// Class for utilizing the Steam Network API. + /// public class SteamNetworking : SteamSharedClass { internal static ISteamNetworking Internal => Interface as ISteamNetworking; @@ -26,20 +29,20 @@ namespace Steamworks } /// - /// This SteamId wants to send you a message. You should respond by calling AcceptP2PSessionWithUser - /// if you want to recieve their messages + /// Invoked when a wants to send the current user a message. You should respond by calling + /// if you want to recieve their messages. /// public static Action OnP2PSessionRequest; /// - /// Called when packets can't get through to the specified user. + /// Invoked when packets can't get through to the specified user. /// All queued packets unsent at this point will be dropped, further attempts /// to send will retry making the connection (but will be dropped if we fail again). /// public static Action OnP2PConnectionFailed; /// - /// This should be called in response to a OnP2PSessionRequest + /// This should be called in response to a . /// public static bool AcceptP2PSessionWithUser( SteamId user ) => Internal.AcceptP2PSessionWithUser( user ); @@ -53,7 +56,7 @@ namespace Steamworks /// /// This should be called when you're done communicating with a user, as this will /// free up all of the resources allocated for the connection under-the-hood. - /// If the remote user tries to send data to you again, a new OnP2PSessionRequest + /// If the remote user tries to send data to you again, a new /// callback will be posted /// public static bool CloseP2PSessionWithUser( SteamId user ) => Internal.CloseP2PSessionWithUser( user ); @@ -77,7 +80,7 @@ namespace Steamworks } /// - /// Reads in a packet that has been sent from another user via SendP2PPacket.. + /// Reads in a packet that has been sent from another user via SendP2PPacket. /// public unsafe static P2Packet? ReadP2PPacket( int channel = 0 ) { @@ -106,7 +109,7 @@ namespace Steamworks } /// - /// Reads in a packet that has been sent from another user via SendP2PPacket.. + /// Reads in a packet that has been sent from another user via SendP2PPacket. /// public unsafe static bool ReadP2PPacket( byte[] buffer, ref uint size, ref SteamId steamid, int channel = 0 ) { @@ -116,7 +119,7 @@ namespace Steamworks } /// - /// Reads in a packet that has been sent from another user via SendP2PPacket.. + /// Reads in a packet that has been sent from another user via SendP2PPacket. /// public unsafe static bool ReadP2PPacket( byte* buffer, uint cbuf, ref uint size, ref SteamId steamid, int channel = 0 ) { diff --git a/Facepunch.Steamworks/SteamNetworkingSockets.cs b/Facepunch.Steamworks/SteamNetworkingSockets.cs index 7e1dd8d..fcd1755 100644 --- a/Facepunch.Steamworks/SteamNetworkingSockets.cs +++ b/Facepunch.Steamworks/SteamNetworkingSockets.cs @@ -114,7 +114,7 @@ namespace Steamworks /// Creates a "server" socket that listens for clients to connect to by calling /// Connect, over ordinary UDP (IPv4 or IPv6) /// - /// To use this derive a class from SocketManager and override as much as you want. + /// To use this derive a class from and override as much as you want. /// /// public static T CreateNormalSocket( NetAddress address ) where T : SocketManager, new() @@ -132,7 +132,7 @@ namespace Steamworks /// Creates a "server" socket that listens for clients to connect to by calling /// Connect, over ordinary UDP (IPv4 or IPv6). /// - /// To use this you should pass a class that inherits ISocketManager. You can use + /// To use this you should pass a class that inherits . You can use /// SocketManager to get connections and send messages, but the ISocketManager class /// will received all the appropriate callbacks. /// @@ -155,7 +155,7 @@ namespace Steamworks } /// - /// Connect to a socket created via CreateListenSocketIP + /// Connect to a socket created via CreateListenSocketIP. /// public static T ConnectNormal( NetAddress address ) where T : ConnectionManager, new() { @@ -167,7 +167,7 @@ namespace Steamworks } /// - /// Connect to a socket created via CreateListenSocketIP + /// Connect to a socket created via CreateListenSocketIP. /// public static ConnectionManager ConnectNormal( NetAddress address, IConnectionManager iface ) { @@ -185,9 +185,9 @@ namespace Steamworks } /// - /// Creates a server that will be relayed via Valve's network (hiding the IP and improving ping) + /// Creates a server that will be relayed via Valve's network (hiding the IP and improving ping). /// - /// To use this derive a class from SocketManager and override as much as you want. + /// To use this derive a class from and override as much as you want. /// /// public static T CreateRelaySocket( int virtualport = 0 ) where T : SocketManager, new() @@ -201,10 +201,10 @@ namespace Steamworks } /// - /// Creates a server that will be relayed via Valve's network (hiding the IP and improving ping) + /// Creates a server that will be relayed via Valve's network (hiding the IP and improving ping). /// - /// To use this you should pass a class that inherits ISocketManager. You can use - /// SocketManager to get connections and send messages, but the ISocketManager class + /// To use this you should pass a class that inherits . You can use + /// to get connections and send messages, but the class /// will received all the appropriate callbacks. /// /// @@ -226,7 +226,7 @@ namespace Steamworks } /// - /// Connect to a relay server + /// Connect to a relay server. /// public static T ConnectRelay( SteamId serverId, int virtualport = 0 ) where T : ConnectionManager, new() { @@ -239,7 +239,7 @@ namespace Steamworks } /// - /// Connect to a relay server + /// Connect to a relay server. /// public static ConnectionManager ConnectRelay( SteamId serverId, int virtualport, IConnectionManager iface ) { @@ -257,4 +257,4 @@ namespace Steamworks return t; } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamNetworkingUtils.cs b/Facepunch.Steamworks/SteamNetworkingUtils.cs index ecd228d..5d80499 100644 --- a/Facepunch.Steamworks/SteamNetworkingUtils.cs +++ b/Facepunch.Steamworks/SteamNetworkingUtils.cs @@ -8,7 +8,7 @@ using Steamworks.Data; namespace Steamworks { /// - /// Undocumented Parental Settings + /// Provides Steam Networking utilities. /// public class SteamNetworkingUtils : SteamSharedClass { @@ -30,7 +30,7 @@ namespace Steamworks /// /// A function to receive debug network information on. This will do nothing - /// unless you set DebugLevel to something other than None. + /// unless you set to something other than . /// /// You should set this to an appropriate level instead of setting it to the highest /// and then filtering it by hand because a lot of energy is used by creating the strings @@ -50,21 +50,24 @@ namespace Steamworks /// relay network. If you do not call this, the initialization will /// be delayed until the first time you use a feature that requires access /// to the relay network, which will delay that first access. - /// + /// /// You can also call this to force a retry if the previous attempt has failed. /// Performing any action that requires access to the relay network will also /// trigger a retry, and so calling this function is never strictly necessary, /// but it can be useful to call it a program launch time, if access to the /// relay network is anticipated. - /// + /// + /// /// Use GetRelayNetworkStatus or listen for SteamRelayNetworkStatus_t /// callbacks to know when initialization has completed. /// Typically initialization completes in a few seconds. - /// + /// + /// /// Note: dedicated servers hosted in known data centers do *not* need /// to call this, since they do not make routing decisions. However, if /// the dedicated server will be using P2P functionality, it will act as /// a "client" and this should be called. + /// /// public static void InitRelayNetworkAccess() { @@ -105,7 +108,7 @@ namespace Steamworks /// /// If you need ping information straight away, wait on this. It will return - /// immediately if you already have up to date ping data + /// immediately if you already have up to date ping data. /// public static async Task WaitForPingDataAsync( float maxAgeInSeconds = 60 * 5 ) { @@ -124,7 +127,7 @@ namespace Steamworks /// - /// [0 - 100] - Randomly discard N pct of packets + /// [0 - 100] - Randomly discard N pct of packets. /// public static float FakeSendPacketLoss { @@ -133,7 +136,7 @@ namespace Steamworks } /// - /// [0 - 100] - Randomly discard N pct of packets + /// [0 - 100] - Randomly discard N pct of packets. /// public static float FakeRecvPacketLoss { @@ -142,7 +145,7 @@ namespace Steamworks } /// - /// Delay all packets by N ms + /// Delay all packets by N ms. /// public static float FakeSendPacketLag { @@ -151,7 +154,7 @@ namespace Steamworks } /// - /// Delay all packets by N ms + /// Delay all packets by N ms. /// public static float FakeRecvPacketLag { @@ -160,7 +163,7 @@ namespace Steamworks } /// - /// Timeout value (in ms) to use when first connecting + /// Timeout value (in ms) to use when first connecting. /// public static int ConnectionTimeout { @@ -169,7 +172,7 @@ namespace Steamworks } /// - /// Timeout value (in ms) to use after connection is established + /// Timeout value (in ms) to use after connection is established. /// public static int Timeout { @@ -180,7 +183,7 @@ namespace Steamworks /// /// Upper limit of buffered pending bytes to be sent. /// If this is reached SendMessage will return LimitExceeded. - /// Default is 524288 bytes (512k) + /// Default is 524288 bytes (512k). /// public static int SendBufferSize { @@ -194,9 +197,10 @@ namespace Steamworks /// we don't know our identity or can't get a cert. On the server, it means that /// we won't automatically reject a connection due to a failure to authenticate. /// (You can examine the incoming connection and decide whether to accept it.) - /// + /// /// This is a dev configuration value, and you should not let users modify it in /// production. + /// /// public static int AllowWithoutAuth { @@ -210,10 +214,11 @@ namespace Steamworks /// 1: Allowed, but prefer encrypted /// 2: Allowed, and preferred /// 3: Required. (Fail the connection if the peer requires encryption.) - /// + /// /// This is a dev configuration value, since its purpose is to disable encryption. /// You should not let users modify it in production. (But note that it requires /// the peer to also modify their value in order for encryption to be disabled.) + /// /// public static int Unencrypted { @@ -222,15 +227,17 @@ namespace Steamworks } /// - /// Get Debug Information via OnDebugOutput event - /// - /// Except when debugging, you should only use NetDebugOutput.Msg - /// or NetDebugOutput.Warning. For best performance, do NOT + /// Get Debug Information via event. + /// + /// Except when debugging, you should only use + /// or . For best performance, do NOT /// request a high detail level and then filter out messages in the callback. - /// + /// + /// /// This incurs all of the expense of formatting the messages, which are then discarded. /// Setting a high priority value (low numeric value) here allows the library to avoid /// doing this work. + /// /// public static NetDebugOutput DebugLevel { @@ -245,12 +252,12 @@ namespace Steamworks } /// - /// So we can remember and provide a Get for DebugLEvel + /// So we can remember and provide a Get for DebugLevel. /// private static NetDebugOutput _debugLevel; /// - /// We need to keep the delegate around until it's not used anymore + /// We need to keep the delegate around until it's not used anymore. /// static NetDebugFunc _debugFunc; diff --git a/Facepunch.Steamworks/SteamParties.cs b/Facepunch.Steamworks/SteamParties.cs index aef57bb..bcccb84 100644 --- a/Facepunch.Steamworks/SteamParties.cs +++ b/Facepunch.Steamworks/SteamParties.cs @@ -30,18 +30,23 @@ namespace Steamworks } /// - /// The list of possible Party beacon locations has changed + /// Invoked when the list of possible Party beacon locations has changed /// public static event Action OnBeaconLocationsUpdated; /// - /// The list of active beacons may have changed + /// Invoked when the list of active beacons may have changed /// public static event Action OnActiveBeaconsUpdated; - + /// + /// Gets the amount of beacons that are active. + /// public static int ActiveBeaconCount => (int) Internal.GetNumActiveBeacons(); + /// + /// Gets an of active beacons. + /// public static IEnumerable ActiveBeacons { get @@ -56,4 +61,4 @@ namespace Steamworks } } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamRemotePlay.cs b/Facepunch.Steamworks/SteamRemotePlay.cs index 48a1945..d612598 100644 --- a/Facepunch.Steamworks/SteamRemotePlay.cs +++ b/Facepunch.Steamworks/SteamRemotePlay.cs @@ -28,30 +28,30 @@ namespace Steamworks } /// - /// Called when a session is connected + /// Invoked when a session is connected. /// public static event Action OnSessionConnected; /// - /// Called when a session becomes disconnected + /// Invoked when a session becomes disconnected. /// public static event Action OnSessionDisconnected; /// - /// Get the number of currently connected Steam Remote Play sessions + /// Gets the number of currently connected Steam Remote Play sessions /// public static int SessionCount => (int) Internal.GetSessionCount(); /// /// Get the currently connected Steam Remote Play session ID at the specified index. - /// IsValid will return false if it's out of bounds + /// IsValid will return if it's out of bounds /// public static RemotePlaySession GetSession( int index ) => (RemotePlaySession) Internal.GetSessionID( index ).Value; /// - /// Invite a friend to Remote Play Together - /// This returns false if the invite can't be sent + /// Invite a friend to Remote Play Together. + /// This returns if the invite can't be sent /// public static bool SendInvite( SteamId steamid ) => Internal.BSendRemotePlayTogetherInvite( steamid ); } diff --git a/Facepunch.Steamworks/SteamRemoteStorage.cs b/Facepunch.Steamworks/SteamRemoteStorage.cs index 4754493..03cadb5 100644 --- a/Facepunch.Steamworks/SteamRemoteStorage.cs +++ b/Facepunch.Steamworks/SteamRemoteStorage.cs @@ -8,7 +8,7 @@ using Steamworks.Data; namespace Steamworks { /// - /// Undocumented Parental Settings + /// Class for utilizing the Steam Remote Storage API. /// public class SteamRemoteStorage : SteamClientClass { @@ -18,12 +18,15 @@ namespace Steamworks { SetInterface( server, new ISteamRemoteStorage( server ) ); } - + /// /// Creates a new file, writes the bytes to the file, and then closes the file. /// If the target file already exists, it is overwritten /// + /// The path of the file. + /// The bytes of data. + /// A boolean, detailing whether or not the operation was successful. public unsafe static bool FileWrite( string filename, byte[] data ) { fixed ( byte* ptr = data ) @@ -35,6 +38,7 @@ namespace Steamworks /// /// Opens a binary file, reads the contents of the file into a byte array, and then closes the file. /// + /// The path of the file. public unsafe static byte[] FileRead( string filename ) { var size = FileSize( filename ); @@ -51,26 +55,35 @@ namespace Steamworks /// /// Checks whether the specified file exists. /// + /// The path of the file. + /// Whether or not the file exists. public static bool FileExists( string filename ) => Internal.FileExists( filename ); /// /// Checks if a specific file is persisted in the steam cloud. /// + /// The path of the file. + /// Boolean. public static bool FilePersisted( string filename ) => Internal.FilePersisted( filename ); /// /// Gets the specified file's last modified date/time. /// + /// The path of the file. + /// A describing when the file was modified last. public static DateTime FileTime( string filename ) => Epoch.ToDateTime( Internal.GetFileTimestamp( filename ) ); /// - /// Gets the specified files size in bytes. 0 if not exists. + /// Returns the specified files size in bytes, or 0 if the file does not exist. /// + /// The path of the file. + /// The size of the file in bytes, or 0 if the file doesn't exist. public static int FileSize( string filename ) => Internal.GetFileSize( filename ); /// /// Deletes the file from remote storage, but leaves it on the local disk and remains accessible from the API. /// + /// A boolean, detailing whether or not the operation was successful. public static bool FileForget( string filename ) => Internal.FileForget( filename ); /// @@ -80,7 +93,7 @@ namespace Steamworks /// - /// Number of bytes total + /// Gets the total number of quota bytes. /// public static ulong QuotaBytes { @@ -93,7 +106,7 @@ namespace Steamworks } /// - /// Number of bytes used + /// Gets the total number of quota bytes that have been used. /// public static ulong QuotaUsedBytes { @@ -106,7 +119,7 @@ namespace Steamworks } /// - /// Number of bytes remaining until your quota is used + /// Number of bytes remaining until the quota is used. /// public static ulong QuotaRemainingBytes { @@ -119,7 +132,7 @@ namespace Steamworks } /// - /// returns true if IsCloudEnabledForAccount AND IsCloudEnabledForApp + /// returns if AND are . /// public static bool IsCloudEnabled => IsCloudEnabledForAccount && IsCloudEnabledForApp; @@ -149,7 +162,7 @@ namespace Steamworks public static int FileCount => Internal.GetFileCount(); /// - /// Get a list of filenames synchronized by Steam Cloud + /// Gets a list of filenames synchronized by Steam Cloud. /// public static IEnumerable Files { @@ -165,4 +178,4 @@ namespace Steamworks } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamScreenshots.cs b/Facepunch.Steamworks/SteamScreenshots.cs index 3db167f..2221077 100644 --- a/Facepunch.Steamworks/SteamScreenshots.cs +++ b/Facepunch.Steamworks/SteamScreenshots.cs @@ -8,7 +8,7 @@ using Steamworks.Data; namespace Steamworks { /// - /// Undocumented Parental Settings + /// Class for utilizing the Steam Screenshots API. /// public class SteamScreenshots : SteamClientClass { @@ -33,19 +33,19 @@ namespace Steamworks } /// - /// A screenshot has been requested by the user from the Steam screenshot hotkey. - /// This will only be called if Hooked is true, in which case Steam + /// Invoked when a screenshot has been requested by the user from the Steam screenshot hotkey. + /// This will only be called if is true, in which case Steam /// will not take the screenshot itself. /// public static event Action OnScreenshotRequested; /// - /// A screenshot successfully written or otherwise added to the library and can now be tagged. + /// Invoked when a screenshot has been successfully written or otherwise added to the library and can now be tagged. /// public static event Action OnScreenshotReady; /// - /// A screenshot attempt failed + /// Invoked when a screenshot attempt failed. /// public static event Action OnScreenshotFailed; @@ -81,15 +81,17 @@ namespace Steamworks /// /// Causes the Steam overlay to take a screenshot. /// If screenshots are being hooked by the game then a - /// ScreenshotRequested callback is sent back to the game instead. + /// callback is sent back to the game instead. /// public static void TriggerScreenshot() => Internal.TriggerScreenshot(); /// /// Toggles whether the overlay handles screenshots when the user presses the screenshot hotkey, or if the game handles them. + /// /// Hooking is disabled by default, and only ever enabled if you do so with this function. - /// If the hooking is enabled, then the ScreenshotRequested_t callback will be sent if the user presses the hotkey or - /// when TriggerScreenshot is called, and then the game is expected to call WriteScreenshot or AddScreenshotToLibrary in response. + /// If the hooking is enabled, then the callback will be sent if the user presses the hotkey or + /// when TriggerScreenshot is called, and then the game is expected to call or in response. + /// /// public static bool Hooked { @@ -97,4 +99,4 @@ namespace Steamworks set => Internal.HookScreenshots( value ); } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamServer.cs b/Facepunch.Steamworks/SteamServer.cs index 20d70c1..27d2ddc 100644 --- a/Facepunch.Steamworks/SteamServer.cs +++ b/Facepunch.Steamworks/SteamServer.cs @@ -32,35 +32,35 @@ namespace Steamworks } /// - /// User has been authed or rejected + /// Invoked when aser has been authed or rejected /// public static event Action OnValidateAuthTicketResponse; /// - /// Called when a connections to the Steam back-end has been established. + /// Invoked when a connection to the Steam back-end has been established. /// This means the server now is logged on and has a working connection to the Steam master server. /// public static event Action OnSteamServersConnected; /// - /// This will occur periodically if the Steam client is not connected, and has failed when retrying to establish a connection (result, stilltrying) + /// This will occur periodically if the Steam client is not connected, and has failed when retrying to establish a connection (result, stilltrying). /// public static event Action OnSteamServerConnectFailure; /// - /// Disconnected from Steam + /// Invoked when the server is disconnected from Steam /// public static event Action OnSteamServersDisconnected; /// - /// Called when authentication status changes, useful for grabbing SteamId once aavailability is current + /// Invoked when authentication status changes, useful for grabbing once availability is current. /// public static event Action OnSteamNetAuthenticationStatus; /// /// Initialize the steam server. - /// If asyncCallbacks is false you need to call RunCallbacks manually every frame. + /// If is you need to call manually every frame. /// public static void Init( AppId appid, SteamServerInit init, bool asyncCallbacks = true ) { @@ -207,7 +207,7 @@ namespace Steamworks private static string _mapname; /// - /// Gets or sets the current ModDir + /// Gets or sets the current ModDir. /// public static string ModDir { @@ -217,7 +217,7 @@ namespace Steamworks private static string _modDir = ""; /// - /// Gets the current product + /// Gets the current product. /// public static string Product { @@ -227,7 +227,7 @@ namespace Steamworks private static string _product = ""; /// - /// Gets or sets the current Product + /// Gets or sets the current Product. /// public static string GameDescription { @@ -237,7 +237,7 @@ namespace Steamworks private static string _gameDescription = ""; /// - /// Gets or sets the current ServerName + /// Gets or sets the current ServerName. /// public static string ServerName { @@ -247,7 +247,7 @@ namespace Steamworks private static string _serverName = ""; /// - /// Set whether the server should report itself as passworded + /// Set whether the server should report itself as passworded. /// public static bool Passworded { @@ -272,6 +272,9 @@ namespace Steamworks } private static string _gametags = ""; + /// + /// Gets the SteamId of the server. + /// public static SteamId SteamId => Internal.GetSteamID(); /// @@ -284,7 +287,7 @@ namespace Steamworks } /// - /// Log onto Steam anonymously. + /// Log off of Steam. /// public static void LogOff() { @@ -293,14 +296,14 @@ namespace Steamworks /// /// Returns true if the server is connected and registered with the Steam master server - /// You should have called LogOnAnonymous etc on startup. + /// You should have called etc on startup. /// public static bool LoggedOn => Internal.BLoggedOn(); /// /// To the best of its ability this tries to get the server's - /// current public ip address. Be aware that this is likely to return - /// null for the first few seconds after initialization. + /// current public IP address. Be aware that this is likely to return + /// for the first few seconds after initialization. /// public static System.Net.IPAddress PublicIp => Internal.GetPublicIP(); @@ -369,7 +372,7 @@ namespace Steamworks } /// - /// Remove all key values + /// Remove all key values. /// public static void ClearKeys() { @@ -449,7 +452,7 @@ namespace Steamworks } /// - /// Does the user own this app (which could be DLC) + /// Does the user own this app (which could be DLC). /// public static UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamid, AppId appid ) { diff --git a/Facepunch.Steamworks/SteamServerStats.cs b/Facepunch.Steamworks/SteamServerStats.cs index 2de7b0f..7432fa7 100644 --- a/Facepunch.Steamworks/SteamServerStats.cs +++ b/Facepunch.Steamworks/SteamServerStats.cs @@ -18,10 +18,12 @@ namespace Steamworks /// - /// Downloads stats for the user - /// If the user has no stats will return fail - /// these stats will only be auto-updated for clients playing on the server + /// Downloads stats for the user. + /// If the user has no stats, this will return . + /// These stats will only be auto-updated for clients playing on the server. /// + /// The SteamId of the user to get stats for. + /// A task describing the progress and result of the download. public static async Task RequestUserStatsAsync( SteamId steamid ) { var r = await Internal.RequestUserStats( steamid ); @@ -33,6 +35,9 @@ namespace Steamworks /// Set the named stat for this user. Setting stats should follow the rules /// you defined in Steamworks. /// + /// The SteamId of the user to set stats for. + /// The name of the stat. + /// The value of the stat. public static bool SetInt( SteamId steamid, string name, int stat ) { return Internal.SetUserStat( steamid, name, stat ); @@ -42,6 +47,9 @@ namespace Steamworks /// Set the named stat for this user. Setting stats should follow the rules /// you defined in Steamworks. /// + /// The SteamId of the user to set stats for. + /// The name of the stat. + /// The value of the stat. public static bool SetFloat( SteamId steamid, string name, float stat ) { return Internal.SetUserStat( steamid, name, stat ); @@ -49,9 +57,12 @@ namespace Steamworks /// /// Get the named stat for this user. If getting the stat failed, will return - /// defaultValue. You should have called Refresh for this userid - which downloads - /// the stats from the backend. If you didn't call it this will always return defaultValue. + /// . You should have called for this SteamID - which downloads + /// the stats from the backend. If you didn't call it this will always return . /// + /// The SteamId of the user to get stats for. + /// The name of the stat. + /// The value to return if the stats cannot be received. public static int GetInt( SteamId steamid, string name, int defaultValue = 0 ) { int data = defaultValue; @@ -67,6 +78,9 @@ namespace Steamworks /// defaultValue. You should have called Refresh for this userid - which downloads /// the stats from the backend. If you didn't call it this will always return defaultValue. /// + /// The SteamId of the user to get stats for. + /// The name of the stat. + /// The value to return if the stats cannot be received. public static float GetFloat( SteamId steamid, string name, float defaultValue = 0 ) { float data = defaultValue; @@ -78,25 +92,29 @@ namespace Steamworks } /// - /// Unlocks the specified achievement for the specified user. Must have called Refresh on a steamid first. - /// Remember to use Commit after use. + /// Unlocks the specified achievement for the specified user. Must have called on a SteamID first. + /// Remember to use after use. /// + /// The SteamId of the user to unlock the achievement for. + /// The ID of the achievement. public static bool SetAchievement( SteamId steamid, string name ) { return Internal.SetUserAchievement( steamid, name ); } /// - /// Resets the unlock status of an achievement for the specified user. Must have called Refresh on a steamid first. - /// Remember to use Commit after use. + /// Resets the unlock status of an achievement for the specified user. Must have called on a SteamID first. + /// Remember to use after use. /// + /// The SteamId of the user to clear the achievement for. + /// The ID of the achievement. public static bool ClearAchievement( SteamId steamid, string name ) { return Internal.ClearUserAchievement( steamid, name ); } /// - /// Return true if available, exists and unlocked + /// Return if available, exists and unlocked /// public static bool GetAchievement( SteamId steamid, string name ) { @@ -110,9 +128,11 @@ namespace Steamworks /// /// Once you've set a stat change on a user you need to commit your changes. - /// You can do that using this function. The callback will let you know if + /// You can do that using this method. The callback will let you know if /// your action succeeded, but most of the time you can fire and forget. /// + /// The SteamId of the user to store stats for. + /// A task describing the progress and result of the commit. public static async Task StoreUserStats( SteamId steamid ) { var r = await Internal.StoreUserStats( steamid ); @@ -120,4 +140,4 @@ namespace Steamworks return r.Value.Result; } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamUgc.cs b/Facepunch.Steamworks/SteamUgc.cs index 02611e1..6f860e8 100644 --- a/Facepunch.Steamworks/SteamUgc.cs +++ b/Facepunch.Steamworks/SteamUgc.cs @@ -32,12 +32,12 @@ namespace Steamworks } /// - /// Posted after Download call + /// Invoked after an item is downloaded. /// public static event Action OnDownloadItemResult; /// - /// Posted when new item is subscribed + /// Invoked when a new item is subscribed. /// public static event Action OnItemSubscribed; public static event Action OnItemUnsubscribed; @@ -50,24 +50,24 @@ namespace Steamworks } /// - /// Start downloading this item. You'll get notified of completion via OnDownloadItemResult. + /// Start downloading this item. You'll get notified of completion via . /// - /// The ID of the file you want to download - /// If true this should go straight to the top of the download list - /// true if nothing went wrong and the download is started + /// The ID of the file to download. + /// If this should go straight to the top of the download list. + /// if nothing went wrong and the download is started. public static bool Download( PublishedFileId fileId, bool highPriority = false ) { return Internal.DownloadItem( fileId, highPriority ); } /// - /// Will attempt to download this item asyncronously - allowing you to instantly react to its installation + /// Will attempt to download this item asyncronously - allowing you to instantly react to its installation. /// - /// The ID of the file you want to download + /// The ID of the file you download. /// An optional callback - /// Allows you to send a message to cancel the download anywhere during the process - /// How often to call the progress function - /// true if downloaded and installed correctly + /// Allows to send a message to cancel the download anywhere during the process. + /// How often to call the progress function. + /// if downloaded and installed properly. public static async Task DownloadAsync( PublishedFileId fileId, Action progress = null, int milisecondsUpdateDelay = 60, CancellationToken ct = default ) { var item = new Steamworks.Ugc.Item( fileId ); @@ -135,7 +135,7 @@ namespace Steamworks } /// - /// Utility function to fetch a single item. Internally this uses Ugc.FileQuery - + /// Utility function to fetch a single item. Internally this uses Ugc.FileQuery - /// which you can use to query multiple items if you need to. /// public static async Task QueryFileAsync( PublishedFileId fileId ) @@ -179,12 +179,12 @@ namespace Steamworks public static void SuspendDownloads() => Internal.SuspendDownloads(true); /// - /// Resumes all workshop downloads + /// Resumes all workshop downloads. /// public static void ResumeDownloads() => Internal.SuspendDownloads(false); /// - /// Show the app's latest Workshop EULA to the user in an overlay window, where they can accept it or not + /// Show the app's latest Workshop EULA to the user in an overlay window, where they can accept it or not. /// public static bool ShowWorkshopEula() { @@ -192,7 +192,7 @@ namespace Steamworks } /// - /// Retrieve information related to the user's acceptance or not of the app's specific Workshop EULA + /// Retrieve information related to the user's acceptance or not of the app's specific Workshop EULA. /// public static async Task GetWorkshopEulaStatus() { diff --git a/Facepunch.Steamworks/SteamUser.cs b/Facepunch.Steamworks/SteamUser.cs index e481d84..230f4f4 100644 --- a/Facepunch.Steamworks/SteamUser.cs +++ b/Facepunch.Steamworks/SteamUser.cs @@ -43,7 +43,7 @@ namespace Steamworks } /// - /// Called when a connections to the Steam back-end has been established. + /// Invoked when a connections to the Steam back-end has been established. /// This means the Steam client now has a working connection to the Steam servers. /// Usually this will have occurred before the game has launched, and should only be seen if the /// user has dropped connection due to a networking issue or a Steam server update. @@ -51,14 +51,14 @@ namespace Steamworks public static event Action OnSteamServersConnected; /// - /// Called when a connection attempt has failed. + /// Invoked when a connection attempt has failed. /// This will occur periodically if the Steam client is not connected, /// and has failed when retrying to establish a connection. /// public static event Action OnSteamServerConnectFailure; /// - /// Called if the client has lost connection to the Steam servers. + /// Invoked when the client has lost connection to the Steam servers. /// Real-time services will be disabled until a matching OnSteamServersConnected has been posted. /// public static event Action OnSteamServersDisconnected; @@ -72,25 +72,25 @@ namespace Steamworks public static event Action OnClientGameServerDeny; /// - /// Called whenever the users licenses (owned packages) changes. + /// Invoked whenever the users licenses (owned packages) changes. /// public static event Action OnLicensesUpdated; /// - /// Called when an auth ticket has been validated. - /// The first parameter is the steamid of this user - /// The second is the Steam ID that owns the game, this will be different from the first - /// if the game is being borrowed via Steam Family Sharing + /// Invoked when an auth ticket has been validated. + /// The first parameter is the of this user + /// The second is the that owns the game, which will be different from the first + /// if the game is being borrowed via Steam Family Sharing. /// public static event Action OnValidateAuthTicketResponse; /// - /// Used internally for GetAuthSessionTicketAsync + /// Used internally for . /// internal static event Action OnGetAuthSessionTicketResponse; /// - /// Called when a user has responded to a microtransaction authorization request. + /// Invoked when a user has responded to a microtransaction authorization request. /// ( appid, orderid, user authorized ) /// public static event Action OnMicroTxnAuthorizationResponse; @@ -110,9 +110,6 @@ namespace Steamworks /// public static event Action OnDurationControl; - - - static bool _recordingVoice; /// @@ -120,7 +117,6 @@ namespace Steamworks /// Once started, use GetAvailableVoice and GetVoice to get the data, and then call StopVoiceRecording /// when the user has released their push-to-talk hotkey or the game session has completed. /// - public static bool VoiceRecord { get => _recordingVoice; @@ -134,7 +130,7 @@ namespace Steamworks /// - /// Returns true if we have voice data waiting to be read + /// Returns true if we have voice data waiting to be read. /// public static bool HasVoiceData { @@ -304,7 +300,7 @@ namespace Steamworks } /// - /// Retrieve a authentication ticket to be sent to the entity who wishes to authenticate you. + /// Retrieve an authentication ticket to be sent to the entity who wishes to authenticate you. /// public static unsafe AuthTicket GetAuthSessionTicket() { @@ -329,7 +325,7 @@ namespace Steamworks /// /// Retrieve a authentication ticket to be sent to the entity who wishes to authenticate you. /// This waits for a positive response from the backend before returning the ticket. This means - /// the ticket is definitely ready to go as soon as it returns. Will return null if the callback + /// the ticket is definitely ready to go as soon as it returns. Will return if the callback /// times out or returns negatively. /// public static async Task GetAuthSessionTicketAsync( double timeoutSeconds = 10.0f ) @@ -510,4 +506,4 @@ namespace Steamworks return new DurationControl { _inner = response.Value }; } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamUserStats.cs b/Facepunch.Steamworks/SteamUserStats.cs index 97bbb31..4a0d8b1 100644 --- a/Facepunch.Steamworks/SteamUserStats.cs +++ b/Facepunch.Steamworks/SteamUserStats.cs @@ -38,25 +38,25 @@ namespace Steamworks /// - /// called when the achivement icon is loaded + /// Invoked when an achivement icon is loaded. /// internal static event Action OnAchievementIconFetched; /// - /// called when the latests stats and achievements have been received - /// from the server + /// Invoked when the latests stats and achievements have been received + /// from the server. /// public static event Action OnUserStatsReceived; /// - /// result of a request to store the user stats for a game + /// Result of a request to store the user stats for a game. /// public static event Action OnUserStatsStored; /// - /// result of a request to store the achievements for a game, or an + /// Result of a request to store the achievements for a game, or an /// "indicate progress" call. If both m_nCurProgress and m_nMaxProgress - /// are zero, that means the achievement has been fully unlocked + /// are zero, that means the achievement has been fully unlocked. /// public static event Action OnAchievementProgress; @@ -67,7 +67,7 @@ namespace Steamworks public static event Action OnUserStatsUnloaded; /// - /// Get the available achievements + /// Get all available achievements. /// public static IEnumerable Achievements { @@ -99,7 +99,7 @@ namespace Steamworks /// /// Tries to get the number of players currently playing this game. - /// Or -1 if failed. + /// Or -1 if failed. /// public static async Task PlayerCountAsync() { @@ -139,11 +139,11 @@ namespace Steamworks /// /// Asynchronously fetches global stats data, which is available for stats marked as /// "aggregated" in the App Admin panel of the Steamworks website. - /// You must have called RequestCurrentStats and it needs to return successfully via + /// You must have called and it needs to return successfully via /// its callback prior to calling this. /// - /// How many days of day-by-day history to retrieve in addition to the overall totals. The limit is 60. - /// OK indicates success, InvalidState means you need to call RequestCurrentStats first, Fail means the remote call failed + /// How many days of day-by-day history to retrieve in addition to the overall totals. The limit is 60. + /// indicates success, means you need to call first, means the remote call failed public static async Task RequestGlobalStatsAsync( int days ) { var result = await SteamUserStats.Internal.RequestGlobalStats( days ); @@ -206,8 +206,7 @@ namespace Steamworks } /// - /// Set a stat value. This will automatically call StoreStats() after a successful call - /// unless you pass false as the last argument. + /// Set a stat value. This will automatically call after a successful call. /// public static bool SetStat( string name, int value ) { @@ -215,8 +214,7 @@ namespace Steamworks } /// - /// Set a stat value. This will automatically call StoreStats() after a successful call - /// unless you pass false as the last argument. + /// Set a stat value. This will automatically call after a successful call. /// public static bool SetStat( string name, float value ) { @@ -224,7 +222,7 @@ namespace Steamworks } /// - /// Get a Int stat value + /// Get an stat value. /// public static int GetStatInt( string name ) { @@ -234,7 +232,7 @@ namespace Steamworks } /// - /// Get a float stat value + /// Get a stat value. /// public static float GetStatFloat( string name ) { @@ -244,7 +242,7 @@ namespace Steamworks } /// - /// Practically wipes the slate clean for this user. If includeAchievements is true, will wipe + /// Practically wipes the slate clean for this user. If is , will also wipe /// any achievements too. /// /// @@ -253,4 +251,4 @@ namespace Steamworks return Internal.ResetAllStats( includeAchievements ); } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/SteamUtils.cs b/Facepunch.Steamworks/SteamUtils.cs index 0e46e6f..71444dc 100644 --- a/Facepunch.Steamworks/SteamUtils.cs +++ b/Facepunch.Steamworks/SteamUtils.cs @@ -36,33 +36,33 @@ namespace Steamworks } /// - /// The country of the user changed + /// Invoked when the country of the user changed. /// public static event Action OnIpCountryChanged; /// - /// Fired when running on a laptop and less than 10 minutes of battery is left, fires then every minute - /// The parameter is the number of minutes left + /// Invoked when running on a laptop and less than 10 minutes of battery is left, fires then every minute. + /// The parameter is the number of minutes left. /// public static event Action OnLowBatteryPower; /// - /// Called when Steam wants to shutdown + /// Invoked when Steam wants to shutdown. /// public static event Action OnSteamShutdown; /// - /// Big Picture gamepad text input has been closed. Parameter is true if text was submitted, false if cancelled etc. + /// Invoked when Big Picture gamepad text input has been closed. Parameter is if text was submitted, if cancelled etc. /// public static event Action OnGamepadTextInputDismissed; /// - /// Returns the number of seconds since the application was active + /// Returns the number of seconds since the application was active. /// public static uint SecondsSinceAppActive => Internal.GetSecondsSinceAppActive(); /// - /// Returns the number of seconds since the user last moved the mouse etc + /// Returns the number of seconds since the user last moved the mouse and/or provided other input. /// public static uint SecondsSinceComputerActive => Internal.GetSecondsSinceComputerActive(); @@ -70,7 +70,7 @@ namespace Steamworks public static Universe ConnectedUniverse => Internal.GetConnectedUniverse(); /// - /// Steam server time. Number of seconds since January 1, 1970, GMT (i.e unix time) + /// Steam server time. Number of seconds since January 1, 1970, GMT (i.e unix time) /// public static DateTime SteamServerTime => Epoch.ToDateTime( Internal.GetServerRealTime() ); @@ -81,9 +81,9 @@ namespace Steamworks public static string IpCountry => Internal.GetIPCountry(); /// - /// returns true if the image exists, and the buffer was successfully filled out - /// results are returned in RGBA format - /// the destination buffer size should be 4 * height * width * sizeof(char) + /// Returns true if the image exists, and the buffer was successfully filled out. + /// Results are returned in RGBA format. + /// The destination buffer size should be 4 * height * width * sizeof(char). /// public static bool GetImageSize( int image, out uint width, out uint height ) { @@ -93,7 +93,7 @@ namespace Steamworks } /// - /// returns the image in RGBA format + /// returns the image in RGBA format. /// public static Data.Image? GetImage( int image ) { @@ -118,12 +118,12 @@ namespace Steamworks } /// - /// Returns true if we're using a battery (ie, a laptop not plugged in) + /// Returns true if we're using a battery (ie, a laptop not plugged in). /// public static bool UsingBatteryPower => Internal.GetCurrentBatteryPower() != 255; /// - /// Returns battery power [0-1] + /// Returns battery power [0-1]. /// public static float CurrentBatteryPower => Math.Min( Internal.GetCurrentBatteryPower() / 100, 1.0f ); @@ -180,7 +180,7 @@ namespace Steamworks } /// - /// Activates the Big Picture text input dialog which only supports gamepad input + /// Activates the Big Picture text input dialog which only supports gamepad input. /// public static bool ShowGamepadTextInput( GamepadTextInputMode inputMode, GamepadTextInputLineMode lineInputMode, string description, int maxChars, string existingText = "" ) { @@ -188,7 +188,7 @@ namespace Steamworks } /// - /// Returns previously entered text + /// Returns previously entered text. /// public static string GetEnteredGamepadText() { @@ -202,18 +202,18 @@ namespace Steamworks } /// - /// returns the language the steam client is running in, you probably want - /// Apps.CurrentGameLanguage instead, this is for very special usage cases + /// Returns the language the steam client is running in. You probably want + /// instead, this is for very special usage cases. /// public static string SteamUILanguage => Internal.GetSteamUILanguage(); /// - /// returns true if Steam itself is running in VR mode + /// Returns if Steam itself is running in VR mode. /// public static bool IsSteamRunningInVR => Internal.IsSteamRunningInVR(); /// - /// Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition + /// Sets the inset of the overlay notification from the corner specified by SetOverlayNotificationPosition. /// public static void SetOverlayNotificationInset( int x, int y ) { @@ -221,24 +221,26 @@ namespace Steamworks } /// - /// returns true if Steam and the Steam Overlay are running in Big Picture mode + /// returns if Steam and the Steam Overlay are running in Big Picture mode /// Games much be launched through the Steam client to enable the Big Picture overlay. During development, - /// a game can be added as a non-steam game to the developers library to test this feature + /// a game can be added as a non-steam game to the developers library to test this feature. /// public static bool IsSteamInBigPictureMode => Internal.IsSteamInBigPictureMode(); /// - /// ask SteamUI to create and render its OpenVR dashboard + /// Ask Steam UI to create and render its OpenVR dashboard. /// public static void StartVRDashboard() => Internal.StartVRDashboard(); /// - /// Set whether the HMD content will be streamed via Steam In-Home Streaming - /// If this is set to true, then the scene in the HMD headset will be streamed, and remote input will not be allowed. - /// If this is set to false, then the application window will be streamed instead, and remote input will be allowed. - /// The default is true unless "VRHeadsetStreaming" "0" is in the extended appinfo for a game. - /// (this is useful for games that have asymmetric multiplayer gameplay) + /// Gets or sets whether the HMD content will be streamed via Steam In-Home Streaming. + /// + /// If this is set to , then the scene in the HMD headset will be streamed, and remote input will not be allowed. + /// If this is set to , then the application window will be streamed instead, and remote input will be allowed. + /// The default is unless "VRHeadsetStreaming" "0" is in the extended app info for a game + /// (this is useful for games that have asymmetric multiplayer gameplay). + /// /// public static bool VrHeadsetStreaming { @@ -258,13 +260,13 @@ namespace Steamworks /// - /// Returns whether this steam client is a Steam China specific client, vs the global client + /// Gets whether this steam client is a Steam China specific client (), or the global client (). /// public static bool IsSteamChinaLauncher => Internal.IsSteamChinaLauncher(); /// /// Initializes text filtering, loading dictionaries for the language the game is running in. - /// Users can customize the text filter behavior in their Steam Account preferences + /// Users can customize the text filter behavior in their Steam Account preferences. /// public static bool InitFilterText() => Internal.InitFilterText( 0 ); @@ -279,13 +281,13 @@ namespace Steamworks } /// - /// returns true if Steam itself is running on the Steam Deck + /// Gets whether or not Steam itself is running on the Steam Deck. /// public static bool IsRunningOnSteamDeck => Internal.IsSteamRunningOnSteamDeck(); /// - /// In game launchers that don't have controller support you can call this to have + /// 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 /// public static void SetGameLauncherMode( bool mode ) => Internal.SetGameLauncherMode( mode ); diff --git a/Facepunch.Steamworks/SteamVideo.cs b/Facepunch.Steamworks/SteamVideo.cs index ac578d3..74150f3 100644 --- a/Facepunch.Steamworks/SteamVideo.cs +++ b/Facepunch.Steamworks/SteamVideo.cs @@ -8,7 +8,7 @@ using Steamworks.Data; namespace Steamworks { /// - /// Undocumented Parental Settings + /// Class for utilizing the Steam Video API. /// public class SteamVideo : SteamClientClass { @@ -25,7 +25,7 @@ namespace Steamworks } /// - /// Return true if currently using Steam's live broadcasting + /// Return if currently using Steam's live broadcasting /// public static bool IsBroadcasting { @@ -37,7 +37,7 @@ namespace Steamworks } /// - /// If we're broadcasting, will return the number of live viewers + /// Returns the number of viewers that are watching the stream, or 0 if is . /// public static int NumViewers { @@ -52,4 +52,4 @@ namespace Steamworks } } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/Achievement.cs b/Facepunch.Steamworks/Structs/Achievement.cs index 04ac438..9cbe45a 100644 --- a/Facepunch.Steamworks/Structs/Achievement.cs +++ b/Facepunch.Steamworks/Structs/Achievement.cs @@ -6,6 +6,9 @@ using System.Threading.Tasks; namespace Steamworks.Data { + /// + /// Represents a Steam Achievement. + /// public struct Achievement { internal string Value; @@ -18,7 +21,7 @@ namespace Steamworks.Data public override string ToString() => Value; /// - /// True if unlocked + /// Gets whether or not the achievement has been unlocked. /// public bool State { @@ -30,15 +33,24 @@ namespace Steamworks.Data } } + /// + /// Gets the identifier of the achievement. This is the "API Name" on Steamworks. + /// public string Identifier => Value; + /// + /// Gets the display name of the achievement. + /// public string Name => SteamUserStats.Internal.GetAchievementDisplayAttribute( Value, "name" ); + /// + /// Gets the description of the achievement. + /// public string Description => SteamUserStats.Internal.GetAchievementDisplayAttribute( Value, "desc" ); /// - /// Should hold the unlock time if State is true + /// If is , this value represents the time that the achievement was unlocked. /// public DateTime? UnlockTime { @@ -56,7 +68,7 @@ namespace Steamworks.Data /// /// Gets the icon of the achievement. This can return a null image even though the image exists if the image - /// hasn't been downloaded by Steam yet. You can use GetIconAsync if you want to wait for the image to be downloaded. + /// hasn't been downloaded by Steam yet. You should use if you want to wait for the image to be downloaded. /// public Image? GetIcon() { @@ -65,8 +77,9 @@ namespace Steamworks.Data /// - /// Gets the icon of the achievement, waits for it to load if we have to + /// Gets the icon of the achievement, yielding until the icon is received or the is reached. /// + /// The timeout in milliseconds before the request will be canceled. Defaults to 5000. public async Task GetIconAsync( int timeout = 5000 ) { var i = SteamUserStats.Internal.GetAchievementIcon( Value ); @@ -107,7 +120,7 @@ namespace Steamworks.Data } /// - /// Returns the fraction (0-1) of users who have unlocked the specified achievement, or -1 if no data available. + /// Gets a decimal (0-1) representing the global amount of users who have unlocked the specified achievement, or -1 if no data available. /// public float GlobalUnlocked { @@ -123,7 +136,7 @@ namespace Steamworks.Data } /// - /// Make this achievement earned + /// Unlock this achievement. /// public bool Trigger( bool apply = true ) { @@ -138,11 +151,11 @@ namespace Steamworks.Data } /// - /// Reset this achievement to not achieved + /// Reset this achievement to be locked. /// public bool Clear() { return SteamUserStats.Internal.ClearAchievement( Value ); } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/AppId.cs b/Facepunch.Steamworks/Structs/AppId.cs index 16e4dcd..eced131 100644 --- a/Facepunch.Steamworks/Structs/AppId.cs +++ b/Facepunch.Steamworks/Structs/AppId.cs @@ -6,6 +6,9 @@ using System.Text; namespace Steamworks { + /// + /// Represents the ID of a Steam application. + /// public struct AppId { public uint Value; @@ -27,4 +30,4 @@ namespace Steamworks return value.Value; } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/DlcInformation.cs b/Facepunch.Steamworks/Structs/DlcInformation.cs index 6d02ff8..2a0654b 100644 --- a/Facepunch.Steamworks/Structs/DlcInformation.cs +++ b/Facepunch.Steamworks/Structs/DlcInformation.cs @@ -6,10 +6,24 @@ using System.Text; namespace Steamworks.Data { + /// + /// Provides information about a DLC. + /// public struct DlcInformation { + /// + /// The of the DLC. + /// public AppId AppId { get; internal set; } + + /// + /// The name of the DLC. + /// public string Name { get; internal set; } + + /// + /// Whether or not the DLC is available. + /// public bool Available { get; internal set; } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/DownloadProgress.cs b/Facepunch.Steamworks/Structs/DownloadProgress.cs index 1f64d45..7a77b33 100644 --- a/Facepunch.Steamworks/Structs/DownloadProgress.cs +++ b/Facepunch.Steamworks/Structs/DownloadProgress.cs @@ -6,10 +6,29 @@ using System.Text; namespace Steamworks.Data { + /// + /// Represents download progress. + /// public struct DownloadProgress { + /// + /// Whether or not the download is currently active. + /// public bool Active; + + /// + /// How many bytes have been downloaded. + /// public ulong BytesDownloaded; + + /// + /// How many bytes in total the download is. + /// public ulong BytesTotal; + + /// + /// Gets the amount of bytes left that need to be downloaded. + /// + public ulong BytesRemaining => BytesTotal - BytesDownloaded; } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/FileDetails.cs b/Facepunch.Steamworks/Structs/FileDetails.cs index 50bd8f7..d4d21f9 100644 --- a/Facepunch.Steamworks/Structs/FileDetails.cs +++ b/Facepunch.Steamworks/Structs/FileDetails.cs @@ -6,10 +6,16 @@ using System.Text; namespace Steamworks.Data { + /// + /// Represents details of a file. + /// public struct FileDetails { + /// + /// The size of the file in bytes. + /// public ulong SizeInBytes; public string Sha1; public uint Flags; } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/Friend.cs b/Facepunch.Steamworks/Structs/Friend.cs index 0561b8d..4b45627 100644 --- a/Facepunch.Steamworks/Structs/Friend.cs +++ b/Facepunch.Steamworks/Structs/Friend.cs @@ -260,4 +260,4 @@ namespace Steamworks } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/Image.cs b/Facepunch.Steamworks/Structs/Image.cs index 57b00cd..8918df6 100644 --- a/Facepunch.Steamworks/Structs/Image.cs +++ b/Facepunch.Steamworks/Structs/Image.cs @@ -7,10 +7,17 @@ namespace Steamworks.Data public uint Height; public byte[] Data; + /// + /// Returns the color of the pixel at the specified position. + /// + /// X-coordinate + /// Y-coordinate + /// The color. + /// If the X and Y or out of bounds. public Color GetPixel( int x, int y ) { - if ( x < 0 || x >= Width ) throw new System.Exception( "x out of bounds" ); - if ( y < 0 || y >= Height ) throw new System.Exception( "y out of bounds" ); + if ( x < 0 || x >= Width ) throw new System.ArgumentException( "x out of bounds" ); + if ( y < 0 || y >= Height ) throw new System.ArgumentException( "y out of bounds" ); Color c = new Color(); @@ -24,14 +31,21 @@ namespace Steamworks.Data return c; } + /// + /// Returns "{Width}x{Height} ({length of }bytes)" + /// + /// public override string ToString() { return $"{Width}x{Height} ({Data.Length}bytes)"; } } + /// + /// Represents a color. + /// public struct Color { public byte r, g, b, a; } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/Lobby.cs b/Facepunch.Steamworks/Structs/Lobby.cs index 4cb40b8..0427c23 100644 --- a/Facepunch.Steamworks/Structs/Lobby.cs +++ b/Facepunch.Steamworks/Structs/Lobby.cs @@ -5,6 +5,9 @@ using System.Threading.Tasks; namespace Steamworks.Data { + /// + /// Represents a Steam lobby. + /// public struct Lobby { public SteamId Id { get; internal set; } @@ -16,8 +19,8 @@ namespace Steamworks.Data } /// - /// Try to join this room. Will return RoomEnter.Success on success, - /// and anything else is a failure + /// Try to join this room. Will return on success, + /// and anything else is a failure. /// public async Task Join() { @@ -37,9 +40,9 @@ namespace Steamworks.Data } /// - /// Invite another user to the lobby - /// will return true if the invite is successfully sent, whether or not the target responds - /// returns false if the local user is not connected to the Steam servers + /// Invite another user to the lobby. + /// Will return if the invite is successfully sent, whether or not the target responds + /// returns if the local user is not connected to the Steam servers /// public bool InviteFriend( SteamId steamid ) { @@ -47,12 +50,12 @@ namespace Steamworks.Data } /// - /// returns the number of users in the specified lobby + /// Gets the number of users in this lobby. /// public int MemberCount => SteamMatchmaking.Internal.GetNumLobbyMembers( Id ); /// - /// Returns current members. Need to be in the lobby to see the users. + /// Returns current members in the lobby. The current user must be in the lobby in order to see the users. /// public IEnumerable Members { @@ -67,7 +70,7 @@ namespace Steamworks.Data /// - /// Get data associated with this lobby + /// Get data associated with this lobby. /// public string GetData( string key ) { @@ -75,7 +78,7 @@ namespace Steamworks.Data } /// - /// Get data associated with this lobby + /// Set data associated with this lobby. /// public bool SetData( string key, string value ) { @@ -86,7 +89,7 @@ namespace Steamworks.Data } /// - /// Removes a metadata key from the lobby + /// Removes a metadata key from the lobby. /// public bool DeleteData( string key ) { @@ -94,7 +97,7 @@ namespace Steamworks.Data } /// - /// Get all data for this lobby + /// Get all data for this lobby. /// public IEnumerable> Data { @@ -113,7 +116,7 @@ namespace Steamworks.Data } /// - /// Gets per-user metadata for someone in this lobby + /// Gets per-user metadata for someone in this lobby. /// public string GetMemberData( Friend member, string key ) { @@ -121,7 +124,7 @@ namespace Steamworks.Data } /// - /// Sets per-user metadata (for the local user implicitly) + /// Sets per-user metadata (for the local user implicitly). /// public void SetMemberData( string key, string value ) { @@ -129,7 +132,7 @@ namespace Steamworks.Data } /// - /// Sends a string to the chat room + /// Sends a string to the chat room. /// public bool SendChatString( string message ) { @@ -139,7 +142,7 @@ namespace Steamworks.Data } /// - /// Sends bytes to the chat room + /// Sends bytes to the chat room. /// public unsafe bool SendChatBytes( byte[] data ) { @@ -150,7 +153,7 @@ namespace Steamworks.Data } /// - /// Sends bytes to the chat room from an unsafe buffer + /// Sends bytes to the chat room from an unsafe buffer. /// public unsafe bool SendChatBytesUnsafe( byte* ptr, int length ) { @@ -158,13 +161,15 @@ namespace Steamworks.Data } /// - /// Refreshes metadata for a lobby you're not necessarily in right now - /// you never do this for lobbies you're a member of, only if your - /// this will send down all the metadata associated with a lobby - /// this is an asynchronous call - /// returns false if the local user is not connected to the Steam servers - /// results will be returned by a LobbyDataUpdate_t callback - /// if the specified lobby doesn't exist, LobbyDataUpdate_t::m_bSuccess will be set to false + /// Refreshes metadata for a lobby you're not necessarily in right now. + /// + /// You never do this for lobbies you're a member of, only if your + /// this will send down all the metadata associated with a lobby. + /// This is an asynchronous call. + /// Returns if the local user is not connected to the Steam servers. + /// Results will be returned by a LobbyDataUpdate_t callback. + /// If the specified lobby doesn't exist, LobbyDataUpdate_t::m_bSuccess will be set to . + /// /// public bool Refresh() { @@ -172,8 +177,8 @@ namespace Steamworks.Data } /// - /// Max members able to join this lobby. Cannot be over 250. - /// Can only be set by the owner + /// Max members able to join this lobby. Cannot be over 250. + /// Can only be set by the owner of the lobby. /// public int MaxMembers { @@ -181,26 +186,42 @@ namespace Steamworks.Data set => SteamMatchmaking.Internal.SetLobbyMemberLimit( Id, value ); } + /// + /// Sets the lobby as public. + /// public bool SetPublic() { return SteamMatchmaking.Internal.SetLobbyType( Id, LobbyType.Public ); } + /// + /// Sets the lobby as private. + /// public bool SetPrivate() { return SteamMatchmaking.Internal.SetLobbyType( Id, LobbyType.Private ); } + /// + /// Sets the lobby as invisible. + /// public bool SetInvisible() { return SteamMatchmaking.Internal.SetLobbyType( Id, LobbyType.Invisible ); } + /// + /// Sets the lobby as friends only. + /// public bool SetFriendsOnly() { return SteamMatchmaking.Internal.SetLobbyType( Id, LobbyType.FriendsOnly ); } + /// + /// Set whether or not the lobby can be joined. + /// + /// Whether or not the lobby can be joined. public bool SetJoinable( bool b ) { return SteamMatchmaking.Internal.SetLobbyJoinable( Id, b ); @@ -242,7 +263,7 @@ namespace Steamworks.Data } /// - /// You must be the lobby owner to set the owner + /// Gets or sets the owner of the lobby. You must be the lobby owner to set the owner /// public Friend Owner { @@ -251,7 +272,7 @@ namespace Steamworks.Data } /// - /// Check if the specified SteamId owns the lobby + /// Check if the specified SteamId owns the lobby. /// public bool IsOwnedBy( SteamId k ) => Owner.Id == k; } diff --git a/Facepunch.Steamworks/Structs/PartyBeacon.cs b/Facepunch.Steamworks/Structs/PartyBeacon.cs index b889042..c235008 100644 --- a/Facepunch.Steamworks/Structs/PartyBeacon.cs +++ b/Facepunch.Steamworks/Structs/PartyBeacon.cs @@ -10,7 +10,7 @@ namespace Steamworks internal PartyBeaconID_t Id; /// - /// Creator of the beacon + /// Gets the owner of the beacon. /// public SteamId Owner { @@ -24,7 +24,7 @@ namespace Steamworks } /// - /// Creator of the beacon + /// Gets metadata related to the beacon. /// public string MetaData { @@ -39,7 +39,7 @@ namespace Steamworks /// /// Will attempt to join the party. If successful will return a connection string. - /// If failed, will return null + /// If failed, will return /// public async Task JoinAsync() { @@ -52,7 +52,7 @@ namespace Steamworks /// /// When a user follows your beacon, Steam will reserve one of the open party slots for them, and send your game a ReservationNotification callback. - /// When that user joins your party, call OnReservationCompleted to notify Steam that the user has joined successfully + /// When that user joins your party, call this method to notify Steam that the user has joined successfully. /// public void OnReservationCompleted( SteamId steamid ) { @@ -70,11 +70,11 @@ namespace Steamworks } /// - /// Turn off the beacon + /// Turn off the beacon. /// public bool Destroy() { return Internal.DestroyBeacon( Id ); } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/Screenshot.cs b/Facepunch.Steamworks/Structs/Screenshot.cs index 2d6e920..623448f 100644 --- a/Facepunch.Steamworks/Structs/Screenshot.cs +++ b/Facepunch.Steamworks/Structs/Screenshot.cs @@ -6,6 +6,9 @@ using System.Text; namespace Steamworks.Data { + /// + /// Represents a screenshot that was taken by a user. + /// public struct Screenshot { internal ScreenshotHandle Value; @@ -19,19 +22,16 @@ namespace Steamworks.Data } /// - /// Tags a user as being visible in the screenshot + /// Sets the location of the screenshot. /// public bool SetLocation( string location ) { return SteamScreenshots.Internal.SetLocation( Value, location ); } - /// - /// Tags a user as being visible in the screenshot - /// public bool TagPublishedFile( PublishedFileId file ) { return SteamScreenshots.Internal.TagPublishedFile( Value, file ); } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/Server.cs b/Facepunch.Steamworks/Structs/Server.cs index 89ea224..95e333a 100644 --- a/Facepunch.Steamworks/Structs/Server.cs +++ b/Facepunch.Steamworks/Structs/Server.cs @@ -142,4 +142,4 @@ namespace Steamworks.Data return Address.GetHashCode() + SteamId.GetHashCode() + ConnectionPort.GetHashCode() + QueryPort.GetHashCode(); } } -} \ No newline at end of file +} diff --git a/Facepunch.Steamworks/Structs/SteamId.cs b/Facepunch.Steamworks/Structs/SteamId.cs index 48c0a0c..9977e5f 100644 --- a/Facepunch.Steamworks/Structs/SteamId.cs +++ b/Facepunch.Steamworks/Structs/SteamId.cs @@ -6,6 +6,9 @@ using System.Text; namespace Steamworks { + /// + /// Represents the ID of a user or steam lobby. + /// public struct SteamId { public ulong Value; @@ -26,4 +29,4 @@ namespace Steamworks public bool IsValid => Value != default; } -} \ No newline at end of file +}