SteamCallbacks.cs (127552B)
1 // This file is provided under The MIT License as part of Steamworks.NET. 2 // Copyright (c) 2013-2019 Riley Labrecque 3 // Please see the included LICENSE.txt for additional information. 4 5 // This file is automatically generated. 6 // Changes to this file will be reverted when you update Steamworks.NET 7 8 #if UNITY_ANDROID || UNITY_IOS || UNITY_TIZEN || UNITY_TVOS || UNITY_WEBGL || UNITY_WSA || UNITY_PS4 || UNITY_WII || UNITY_XBOXONE || UNITY_SWITCH 9 #define DISABLESTEAMWORKS 10 #endif 11 12 #if !DISABLESTEAMWORKS 13 14 using System.Runtime.InteropServices; 15 using IntPtr = System.IntPtr; 16 17 namespace Steamworks { 18 // callbacks 19 //--------------------------------------------------------------------------------- 20 // Purpose: Sent when a new app is installed 21 //--------------------------------------------------------------------------------- 22 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 23 [CallbackIdentity(Constants.k_iSteamAppListCallbacks + 1)] 24 public struct SteamAppInstalled_t { 25 public const int k_iCallback = Constants.k_iSteamAppListCallbacks + 1; 26 public AppId_t m_nAppID; // ID of the app that installs 27 } 28 29 //--------------------------------------------------------------------------------- 30 // Purpose: Sent when an app is uninstalled 31 //--------------------------------------------------------------------------------- 32 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 33 [CallbackIdentity(Constants.k_iSteamAppListCallbacks + 2)] 34 public struct SteamAppUninstalled_t { 35 public const int k_iCallback = Constants.k_iSteamAppListCallbacks + 2; 36 public AppId_t m_nAppID; // ID of the app that installs 37 } 38 39 // callbacks 40 //----------------------------------------------------------------------------- 41 // Purpose: posted after the user gains ownership of DLC & that DLC is installed 42 //----------------------------------------------------------------------------- 43 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 44 [CallbackIdentity(Constants.k_iSteamAppsCallbacks + 5)] 45 public struct DlcInstalled_t { 46 public const int k_iCallback = Constants.k_iSteamAppsCallbacks + 5; 47 public AppId_t m_nAppID; // AppID of the DLC 48 } 49 50 //----------------------------------------------------------------------------- 51 // Purpose: response to RegisterActivationCode() 52 //----------------------------------------------------------------------------- 53 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 54 [CallbackIdentity(Constants.k_iSteamAppsCallbacks + 8)] 55 public struct RegisterActivationCodeResponse_t { 56 public const int k_iCallback = Constants.k_iSteamAppsCallbacks + 8; 57 public ERegisterActivationCodeResult m_eResult; 58 public uint m_unPackageRegistered; // package that was registered. Only set on success 59 } 60 61 //--------------------------------------------------------------------------------- 62 // Purpose: posted after the user gains executes a Steam URL with command line or query parameters 63 // such as steam://run/<appid>//-commandline/?param1=value1¶m2=value2¶m3=value3 etc 64 // while the game is already running. The new params can be queried 65 // with GetLaunchQueryParam and GetLaunchCommandLine 66 //--------------------------------------------------------------------------------- 67 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 68 [CallbackIdentity(Constants.k_iSteamAppsCallbacks + 14)] 69 public struct NewUrlLaunchParameters_t { 70 public const int k_iCallback = Constants.k_iSteamAppsCallbacks + 14; 71 } 72 73 //----------------------------------------------------------------------------- 74 // Purpose: response to RequestAppProofOfPurchaseKey/RequestAllProofOfPurchaseKeys 75 // for supporting third-party CD keys, or other proof-of-purchase systems. 76 //----------------------------------------------------------------------------- 77 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 78 [CallbackIdentity(Constants.k_iSteamAppsCallbacks + 21)] 79 public struct AppProofOfPurchaseKeyResponse_t { 80 public const int k_iCallback = Constants.k_iSteamAppsCallbacks + 21; 81 public EResult m_eResult; 82 public uint m_nAppID; 83 public uint m_cchKeyLength; 84 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cubAppProofOfPurchaseKeyMax)] 85 public string m_rgchKey; 86 } 87 88 //----------------------------------------------------------------------------- 89 // Purpose: response to GetFileDetails 90 //----------------------------------------------------------------------------- 91 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 92 [CallbackIdentity(Constants.k_iSteamAppsCallbacks + 23)] 93 public struct FileDetailsResult_t { 94 public const int k_iCallback = Constants.k_iSteamAppsCallbacks + 23; 95 public EResult m_eResult; 96 public ulong m_ulFileSize; // original file size in bytes 97 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)] 98 public byte[] m_FileSHA; // original file SHA1 hash 99 public uint m_unFlags; // 100 } 101 102 // callbacks 103 //----------------------------------------------------------------------------- 104 // Purpose: called when a friends' status changes 105 //----------------------------------------------------------------------------- 106 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 107 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 4)] 108 public struct PersonaStateChange_t { 109 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 4; 110 111 public ulong m_ulSteamID; // steamID of the friend who changed 112 public EPersonaChange m_nChangeFlags; // what's changed 113 } 114 115 //----------------------------------------------------------------------------- 116 // Purpose: posted when game overlay activates or deactivates 117 // the game can use this to be pause or resume single player games 118 //----------------------------------------------------------------------------- 119 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 120 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 31)] 121 public struct GameOverlayActivated_t { 122 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 31; 123 public byte m_bActive; // true if it's just been activated, false otherwise 124 } 125 126 //----------------------------------------------------------------------------- 127 // Purpose: called when the user tries to join a different game server from their friends list 128 // game client should attempt to connect to specified server when this is received 129 //----------------------------------------------------------------------------- 130 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 131 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 32)] 132 public struct GameServerChangeRequested_t { 133 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 32; 134 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)] 135 public string m_rgchServer; // server address ("127.0.0.1:27015", "tf2.valvesoftware.com") 136 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)] 137 public string m_rgchPassword; // server password, if any 138 } 139 140 //----------------------------------------------------------------------------- 141 // Purpose: called when the user tries to join a lobby from their friends list 142 // game client should attempt to connect to specified lobby when this is received 143 //----------------------------------------------------------------------------- 144 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 145 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 33)] 146 public struct GameLobbyJoinRequested_t { 147 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 33; 148 public CSteamID m_steamIDLobby; 149 150 // The friend they did the join via (will be invalid if not directly via a friend) 151 // 152 // On PS3, the friend will be invalid if this was triggered by a PSN invite via the XMB, but 153 // the account type will be console user so you can tell at least that this was from a PSN friend 154 // rather than a Steam friend. 155 public CSteamID m_steamIDFriend; 156 } 157 158 //----------------------------------------------------------------------------- 159 // Purpose: called when an avatar is loaded in from a previous GetLargeFriendAvatar() call 160 // if the image wasn't already available 161 //----------------------------------------------------------------------------- 162 [StructLayout(LayoutKind.Sequential, Pack = 4)] 163 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 34)] 164 public struct AvatarImageLoaded_t { 165 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 34; 166 public CSteamID m_steamID; // steamid the avatar has been loaded for 167 public int m_iImage; // the image index of the now loaded image 168 public int m_iWide; // width of the loaded image 169 public int m_iTall; // height of the loaded image 170 } 171 172 //----------------------------------------------------------------------------- 173 // Purpose: marks the return of a request officer list call 174 //----------------------------------------------------------------------------- 175 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 176 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 35)] 177 public struct ClanOfficerListResponse_t { 178 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 35; 179 public CSteamID m_steamIDClan; 180 public int m_cOfficers; 181 public byte m_bSuccess; 182 } 183 184 //----------------------------------------------------------------------------- 185 // Purpose: callback indicating updated data about friends rich presence information 186 //----------------------------------------------------------------------------- 187 [StructLayout(LayoutKind.Sequential, Pack = 4)] 188 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 36)] 189 public struct FriendRichPresenceUpdate_t { 190 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 36; 191 public CSteamID m_steamIDFriend; // friend who's rich presence has changed 192 public AppId_t m_nAppID; // the appID of the game (should always be the current game) 193 } 194 195 //----------------------------------------------------------------------------- 196 // Purpose: called when the user tries to join a game from their friends list 197 // rich presence will have been set with the "connect" key which is set here 198 //----------------------------------------------------------------------------- 199 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 200 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 37)] 201 public struct GameRichPresenceJoinRequested_t { 202 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 37; 203 public CSteamID m_steamIDFriend; // the friend they did the join via (will be invalid if not directly via a friend) 204 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchMaxRichPresenceValueLength)] 205 public string m_rgchConnect; 206 } 207 208 //----------------------------------------------------------------------------- 209 // Purpose: a chat message has been received for a clan chat the game has joined 210 //----------------------------------------------------------------------------- 211 [StructLayout(LayoutKind.Sequential, Pack = 4)] 212 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 38)] 213 public struct GameConnectedClanChatMsg_t { 214 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 38; 215 public CSteamID m_steamIDClanChat; 216 public CSteamID m_steamIDUser; 217 public int m_iMessageID; 218 } 219 220 //----------------------------------------------------------------------------- 221 // Purpose: a user has joined a clan chat 222 //----------------------------------------------------------------------------- 223 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 224 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 39)] 225 public struct GameConnectedChatJoin_t { 226 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 39; 227 public CSteamID m_steamIDClanChat; 228 public CSteamID m_steamIDUser; 229 } 230 231 //----------------------------------------------------------------------------- 232 // Purpose: a user has left the chat we're in 233 //----------------------------------------------------------------------------- 234 [StructLayout(LayoutKind.Sequential, Pack = 1)] 235 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 40)] 236 public struct GameConnectedChatLeave_t { 237 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 40; 238 public CSteamID m_steamIDClanChat; 239 public CSteamID m_steamIDUser; 240 [MarshalAs(UnmanagedType.I1)] 241 public bool m_bKicked; // true if admin kicked 242 [MarshalAs(UnmanagedType.I1)] 243 public bool m_bDropped; // true if Steam connection dropped 244 } 245 246 //----------------------------------------------------------------------------- 247 // Purpose: a DownloadClanActivityCounts() call has finished 248 //----------------------------------------------------------------------------- 249 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 250 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 41)] 251 public struct DownloadClanActivityCountsResult_t { 252 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 41; 253 [MarshalAs(UnmanagedType.I1)] 254 public bool m_bSuccess; 255 } 256 257 //----------------------------------------------------------------------------- 258 // Purpose: a JoinClanChatRoom() call has finished 259 //----------------------------------------------------------------------------- 260 [StructLayout(LayoutKind.Sequential, Pack = 4)] 261 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 42)] 262 public struct JoinClanChatRoomCompletionResult_t { 263 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 42; 264 public CSteamID m_steamIDClanChat; 265 public EChatRoomEnterResponse m_eChatRoomEnterResponse; 266 } 267 268 //----------------------------------------------------------------------------- 269 // Purpose: a chat message has been received from a user 270 //----------------------------------------------------------------------------- 271 [StructLayout(LayoutKind.Sequential, Pack = 4)] 272 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 43)] 273 public struct GameConnectedFriendChatMsg_t { 274 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 43; 275 public CSteamID m_steamIDUser; 276 public int m_iMessageID; 277 } 278 279 [StructLayout(LayoutKind.Sequential, Pack = 4)] 280 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 44)] 281 public struct FriendsGetFollowerCount_t { 282 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 44; 283 public EResult m_eResult; 284 public CSteamID m_steamID; 285 public int m_nCount; 286 } 287 288 [StructLayout(LayoutKind.Sequential, Pack = 4)] 289 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 45)] 290 public struct FriendsIsFollowing_t { 291 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 45; 292 public EResult m_eResult; 293 public CSteamID m_steamID; 294 [MarshalAs(UnmanagedType.I1)] 295 public bool m_bIsFollowing; 296 } 297 298 [StructLayout(LayoutKind.Sequential, Pack = 4)] 299 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 46)] 300 public struct FriendsEnumerateFollowingList_t { 301 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 46; 302 public EResult m_eResult; 303 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_cEnumerateFollowersMax)] 304 public CSteamID[] m_rgSteamID; 305 public int m_nResultsReturned; 306 public int m_nTotalResultCount; 307 } 308 309 //----------------------------------------------------------------------------- 310 // Purpose: reports the result of an attempt to change the user's persona name 311 //----------------------------------------------------------------------------- 312 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 313 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 47)] 314 public struct SetPersonaNameResponse_t { 315 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 47; 316 317 [MarshalAs(UnmanagedType.I1)] 318 public bool m_bSuccess; // true if name change succeeded completely. 319 [MarshalAs(UnmanagedType.I1)] 320 public bool m_bLocalSuccess; // true if name change was retained locally. (We might not have been able to communicate with Steam) 321 public EResult m_result; // detailed result code 322 } 323 324 //----------------------------------------------------------------------------- 325 // Purpose: Invoked when the status of unread messages changes 326 //----------------------------------------------------------------------------- 327 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 328 [CallbackIdentity(Constants.k_iSteamFriendsCallbacks + 48)] 329 public struct UnreadChatMessagesChanged_t { 330 public const int k_iCallback = Constants.k_iSteamFriendsCallbacks + 48; 331 } 332 333 // callbacks 334 // callback notification - A new message is available for reading from the message queue 335 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 336 [CallbackIdentity(Constants.k_iSteamGameCoordinatorCallbacks + 1)] 337 public struct GCMessageAvailable_t { 338 public const int k_iCallback = Constants.k_iSteamGameCoordinatorCallbacks + 1; 339 public uint m_nMessageSize; 340 } 341 342 // callback notification - A message failed to make it to the GC. It may be down temporarily 343 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 344 [CallbackIdentity(Constants.k_iSteamGameCoordinatorCallbacks + 2)] 345 public struct GCMessageFailed_t { 346 public const int k_iCallback = Constants.k_iSteamGameCoordinatorCallbacks + 2; 347 } 348 349 // won't enforce authentication of users that connect to the server. 350 // Useful when you run a server where the clients may not 351 // be connected to the internet but you want them to play (i.e LANs) 352 // callbacks 353 // client has been approved to connect to this game server 354 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 355 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 1)] 356 public struct GSClientApprove_t { 357 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 1; 358 public CSteamID m_SteamID; // SteamID of approved player 359 public CSteamID m_OwnerSteamID; // SteamID of original owner for game license 360 } 361 362 // client has been denied to connection to this game server 363 [StructLayout(LayoutKind.Sequential, Pack = 4)] 364 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 2)] 365 public struct GSClientDeny_t { 366 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 2; 367 public CSteamID m_SteamID; 368 public EDenyReason m_eDenyReason; 369 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)] 370 public string m_rgchOptionalText; 371 } 372 373 // request the game server should kick the user 374 [StructLayout(LayoutKind.Sequential, Pack = 4)] 375 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 3)] 376 public struct GSClientKick_t { 377 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 3; 378 public CSteamID m_SteamID; 379 public EDenyReason m_eDenyReason; 380 } 381 382 // NOTE: callback values 4 and 5 are skipped because they are used for old deprecated callbacks, 383 // do not reuse them here. 384 // client achievement info 385 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 386 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 6)] 387 public struct GSClientAchievementStatus_t { 388 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 6; 389 public ulong m_SteamID; 390 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)] 391 public string m_pchAchievement; 392 [MarshalAs(UnmanagedType.I1)] 393 public bool m_bUnlocked; 394 } 395 396 // received when the game server requests to be displayed as secure (VAC protected) 397 // m_bSecure is true if the game server should display itself as secure to users, false otherwise 398 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 399 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 15)] 400 public struct GSPolicyResponse_t { 401 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 15; 402 public byte m_bSecure; 403 } 404 405 // GS gameplay stats info 406 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 407 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 7)] 408 public struct GSGameplayStats_t { 409 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 7; 410 public EResult m_eResult; // Result of the call 411 public int m_nRank; // Overall rank of the server (0-based) 412 public uint m_unTotalConnects; // Total number of clients who have ever connected to the server 413 public uint m_unTotalMinutesPlayed; // Total number of minutes ever played on the server 414 } 415 416 // send as a reply to RequestUserGroupStatus() 417 [StructLayout(LayoutKind.Sequential, Pack = 1)] 418 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 8)] 419 public struct GSClientGroupStatus_t { 420 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 8; 421 public CSteamID m_SteamIDUser; 422 public CSteamID m_SteamIDGroup; 423 [MarshalAs(UnmanagedType.I1)] 424 public bool m_bMember; 425 [MarshalAs(UnmanagedType.I1)] 426 public bool m_bOfficer; 427 } 428 429 // Sent as a reply to GetServerReputation() 430 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 431 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 9)] 432 public struct GSReputation_t { 433 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 9; 434 public EResult m_eResult; // Result of the call; 435 public uint m_unReputationScore; // The reputation score for the game server 436 [MarshalAs(UnmanagedType.I1)] 437 public bool m_bBanned; // True if the server is banned from the Steam 438 // master servers 439 440 // The following members are only filled out if m_bBanned is true. They will all 441 // be set to zero otherwise. Master server bans are by IP so it is possible to be 442 // banned even when the score is good high if there is a bad server on another port. 443 // This information can be used to determine which server is bad. 444 445 public uint m_unBannedIP; // The IP of the banned server 446 public ushort m_usBannedPort; // The port of the banned server 447 public ulong m_ulBannedGameID; // The game ID the banned server is serving 448 public uint m_unBanExpires; // Time the ban expires, expressed in the Unix epoch (seconds since 1/1/1970) 449 } 450 451 // Sent as a reply to AssociateWithClan() 452 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 453 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 10)] 454 public struct AssociateWithClanResult_t { 455 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 10; 456 public EResult m_eResult; // Result of the call; 457 } 458 459 // Sent as a reply to ComputeNewPlayerCompatibility() 460 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 461 [CallbackIdentity(Constants.k_iSteamGameServerCallbacks + 11)] 462 public struct ComputeNewPlayerCompatibilityResult_t { 463 public const int k_iCallback = Constants.k_iSteamGameServerCallbacks + 11; 464 public EResult m_eResult; // Result of the call; 465 public int m_cPlayersThatDontLikeCandidate; 466 public int m_cPlayersThatCandidateDoesntLike; 467 public int m_cClanPlayersThatDontLikeCandidate; 468 public CSteamID m_SteamIDCandidate; 469 } 470 471 // callbacks 472 //----------------------------------------------------------------------------- 473 // Purpose: called when the latests stats and achievements have been received 474 // from the server 475 //----------------------------------------------------------------------------- 476 [StructLayout(LayoutKind.Sequential, Pack = 4)] 477 [CallbackIdentity(Constants.k_iSteamGameServerStatsCallbacks)] 478 public struct GSStatsReceived_t { 479 public const int k_iCallback = Constants.k_iSteamGameServerStatsCallbacks; 480 public EResult m_eResult; // Success / error fetching the stats 481 public CSteamID m_steamIDUser; // The user for whom the stats are retrieved for 482 } 483 484 //----------------------------------------------------------------------------- 485 // Purpose: result of a request to store the user stats for a game 486 //----------------------------------------------------------------------------- 487 [StructLayout(LayoutKind.Sequential, Pack = 4)] 488 [CallbackIdentity(Constants.k_iSteamGameServerStatsCallbacks + 1)] 489 public struct GSStatsStored_t { 490 public const int k_iCallback = Constants.k_iSteamGameServerStatsCallbacks + 1; 491 public EResult m_eResult; // success / error 492 public CSteamID m_steamIDUser; // The user for whom the stats were stored 493 } 494 495 //----------------------------------------------------------------------------- 496 // Purpose: Callback indicating that a user's stats have been unloaded. 497 // Call RequestUserStats again to access stats for this user 498 //----------------------------------------------------------------------------- 499 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 500 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 8)] 501 public struct GSStatsUnloaded_t { 502 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 8; 503 public CSteamID m_steamIDUser; // User whose stats have been unloaded 504 } 505 506 // callbacks 507 //----------------------------------------------------------------------------- 508 // Purpose: The browser is ready for use 509 //----------------------------------------------------------------------------- 510 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 511 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 1)] 512 public struct HTML_BrowserReady_t { 513 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 1; 514 public HHTMLBrowser unBrowserHandle; // this browser is now fully created and ready to navigate to pages 515 } 516 517 //----------------------------------------------------------------------------- 518 // Purpose: the browser has a pending paint 519 //----------------------------------------------------------------------------- 520 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 521 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 2)] 522 public struct HTML_NeedsPaint_t { 523 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 2; 524 public HHTMLBrowser unBrowserHandle; // the browser that needs the paint 525 public IntPtr pBGRA; // a pointer to the B8G8R8A8 data for this surface, valid until SteamAPI_RunCallbacks is next called 526 public uint unWide; // the total width of the pBGRA texture 527 public uint unTall; // the total height of the pBGRA texture 528 public uint unUpdateX; // the offset in X for the damage rect for this update 529 public uint unUpdateY; // the offset in Y for the damage rect for this update 530 public uint unUpdateWide; // the width of the damage rect for this update 531 public uint unUpdateTall; // the height of the damage rect for this update 532 public uint unScrollX; // the page scroll the browser was at when this texture was rendered 533 public uint unScrollY; // the page scroll the browser was at when this texture was rendered 534 public float flPageScale; // the page scale factor on this page when rendered 535 public uint unPageSerial; // incremented on each new page load, you can use this to reject draws while navigating to new pages 536 } 537 538 //----------------------------------------------------------------------------- 539 // Purpose: The browser wanted to navigate to a new page 540 // NOTE - you MUST call AllowStartRequest in response to this callback 541 //----------------------------------------------------------------------------- 542 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 543 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 3)] 544 public struct HTML_StartRequest_t { 545 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 3; 546 public HHTMLBrowser unBrowserHandle; // the handle of the surface navigating 547 public string pchURL; // the url they wish to navigate to 548 public string pchTarget; // the html link target type (i.e _blank, _self, _parent, _top ) 549 public string pchPostData; // any posted data for the request 550 [MarshalAs(UnmanagedType.I1)] 551 public bool bIsRedirect; // true if this was a http/html redirect from the last load request 552 } 553 554 //----------------------------------------------------------------------------- 555 // Purpose: The browser has been requested to close due to user interaction (usually from a javascript window.close() call) 556 //----------------------------------------------------------------------------- 557 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 558 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 4)] 559 public struct HTML_CloseBrowser_t { 560 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 4; 561 public HHTMLBrowser unBrowserHandle; // the handle of the surface 562 } 563 564 //----------------------------------------------------------------------------- 565 // Purpose: the browser is navigating to a new url 566 //----------------------------------------------------------------------------- 567 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 568 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 5)] 569 public struct HTML_URLChanged_t { 570 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 5; 571 public HHTMLBrowser unBrowserHandle; // the handle of the surface navigating 572 public string pchURL; // the url they wish to navigate to 573 public string pchPostData; // any posted data for the request 574 [MarshalAs(UnmanagedType.I1)] 575 public bool bIsRedirect; // true if this was a http/html redirect from the last load request 576 public string pchPageTitle; // the title of the page 577 [MarshalAs(UnmanagedType.I1)] 578 public bool bNewNavigation; // true if this was from a fresh tab and not a click on an existing page 579 } 580 581 //----------------------------------------------------------------------------- 582 // Purpose: A page is finished loading 583 //----------------------------------------------------------------------------- 584 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 585 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 6)] 586 public struct HTML_FinishedRequest_t { 587 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 6; 588 public HHTMLBrowser unBrowserHandle; // the handle of the surface 589 public string pchURL; // 590 public string pchPageTitle; // 591 } 592 593 //----------------------------------------------------------------------------- 594 // Purpose: a request to load this url in a new tab 595 //----------------------------------------------------------------------------- 596 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 597 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 7)] 598 public struct HTML_OpenLinkInNewTab_t { 599 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 7; 600 public HHTMLBrowser unBrowserHandle; // the handle of the surface 601 public string pchURL; // 602 } 603 604 //----------------------------------------------------------------------------- 605 // Purpose: the page has a new title now 606 //----------------------------------------------------------------------------- 607 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 608 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 8)] 609 public struct HTML_ChangedTitle_t { 610 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 8; 611 public HHTMLBrowser unBrowserHandle; // the handle of the surface 612 public string pchTitle; // 613 } 614 615 //----------------------------------------------------------------------------- 616 // Purpose: results from a search 617 //----------------------------------------------------------------------------- 618 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 619 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 9)] 620 public struct HTML_SearchResults_t { 621 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 9; 622 public HHTMLBrowser unBrowserHandle; // the handle of the surface 623 public uint unResults; // 624 public uint unCurrentMatch; // 625 } 626 627 //----------------------------------------------------------------------------- 628 // Purpose: page history status changed on the ability to go backwards and forward 629 //----------------------------------------------------------------------------- 630 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 631 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 10)] 632 public struct HTML_CanGoBackAndForward_t { 633 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 10; 634 public HHTMLBrowser unBrowserHandle; // the handle of the surface 635 [MarshalAs(UnmanagedType.I1)] 636 public bool bCanGoBack; // 637 [MarshalAs(UnmanagedType.I1)] 638 public bool bCanGoForward; // 639 } 640 641 //----------------------------------------------------------------------------- 642 // Purpose: details on the visibility and size of the horizontal scrollbar 643 //----------------------------------------------------------------------------- 644 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 645 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 11)] 646 public struct HTML_HorizontalScroll_t { 647 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 11; 648 public HHTMLBrowser unBrowserHandle; // the handle of the surface 649 public uint unScrollMax; // 650 public uint unScrollCurrent; // 651 public float flPageScale; // 652 [MarshalAs(UnmanagedType.I1)] 653 public bool bVisible; // 654 public uint unPageSize; // 655 } 656 657 //----------------------------------------------------------------------------- 658 // Purpose: details on the visibility and size of the vertical scrollbar 659 //----------------------------------------------------------------------------- 660 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 661 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 12)] 662 public struct HTML_VerticalScroll_t { 663 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 12; 664 public HHTMLBrowser unBrowserHandle; // the handle of the surface 665 public uint unScrollMax; // 666 public uint unScrollCurrent; // 667 public float flPageScale; // 668 [MarshalAs(UnmanagedType.I1)] 669 public bool bVisible; // 670 public uint unPageSize; // 671 } 672 673 //----------------------------------------------------------------------------- 674 // Purpose: response to GetLinkAtPosition call 675 //----------------------------------------------------------------------------- 676 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 677 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 13)] 678 public struct HTML_LinkAtPosition_t { 679 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 13; 680 public HHTMLBrowser unBrowserHandle; // the handle of the surface 681 public uint x; // NOTE - Not currently set 682 public uint y; // NOTE - Not currently set 683 public string pchURL; // 684 [MarshalAs(UnmanagedType.I1)] 685 public bool bInput; // 686 [MarshalAs(UnmanagedType.I1)] 687 public bool bLiveLink; // 688 } 689 690 //----------------------------------------------------------------------------- 691 // Purpose: show a Javascript alert dialog, call JSDialogResponse 692 // when the user dismisses this dialog (or right away to ignore it) 693 //----------------------------------------------------------------------------- 694 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 695 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 14)] 696 public struct HTML_JSAlert_t { 697 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 14; 698 public HHTMLBrowser unBrowserHandle; // the handle of the surface 699 public string pchMessage; // 700 } 701 702 //----------------------------------------------------------------------------- 703 // Purpose: show a Javascript confirmation dialog, call JSDialogResponse 704 // when the user dismisses this dialog (or right away to ignore it) 705 //----------------------------------------------------------------------------- 706 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 707 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 15)] 708 public struct HTML_JSConfirm_t { 709 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 15; 710 public HHTMLBrowser unBrowserHandle; // the handle of the surface 711 public string pchMessage; // 712 } 713 714 //----------------------------------------------------------------------------- 715 // Purpose: when received show a file open dialog 716 // then call FileLoadDialogResponse with the file(s) the user selected. 717 //----------------------------------------------------------------------------- 718 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 719 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 16)] 720 public struct HTML_FileOpenDialog_t { 721 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 16; 722 public HHTMLBrowser unBrowserHandle; // the handle of the surface 723 public string pchTitle; // 724 public string pchInitialFile; // 725 } 726 727 //----------------------------------------------------------------------------- 728 // Purpose: a new html window is being created. 729 // 730 // IMPORTANT NOTE: at this time, the API does not allow you to acknowledge or 731 // render the contents of this new window, so the new window is always destroyed 732 // immediately. The URL and other parameters of the new window are passed here 733 // to give your application the opportunity to call CreateBrowser and set up 734 // a new browser in response to the attempted popup, if you wish to do so. 735 //----------------------------------------------------------------------------- 736 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 737 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 21)] 738 public struct HTML_NewWindow_t { 739 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 21; 740 public HHTMLBrowser unBrowserHandle; // the handle of the current surface 741 public string pchURL; // the page to load 742 public uint unX; // the x pos into the page to display the popup 743 public uint unY; // the y pos into the page to display the popup 744 public uint unWide; // the total width of the pBGRA texture 745 public uint unTall; // the total height of the pBGRA texture 746 public HHTMLBrowser unNewWindow_BrowserHandle_IGNORE; 747 } 748 749 //----------------------------------------------------------------------------- 750 // Purpose: change the cursor to display 751 //----------------------------------------------------------------------------- 752 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 753 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 22)] 754 public struct HTML_SetCursor_t { 755 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 22; 756 public HHTMLBrowser unBrowserHandle; // the handle of the surface 757 public uint eMouseCursor; // the EMouseCursor to display 758 } 759 760 //----------------------------------------------------------------------------- 761 // Purpose: informational message from the browser 762 //----------------------------------------------------------------------------- 763 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 764 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 23)] 765 public struct HTML_StatusText_t { 766 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 23; 767 public HHTMLBrowser unBrowserHandle; // the handle of the surface 768 public string pchMsg; // the EMouseCursor to display 769 } 770 771 //----------------------------------------------------------------------------- 772 // Purpose: show a tooltip 773 //----------------------------------------------------------------------------- 774 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 775 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 24)] 776 public struct HTML_ShowToolTip_t { 777 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 24; 778 public HHTMLBrowser unBrowserHandle; // the handle of the surface 779 public string pchMsg; // the EMouseCursor to display 780 } 781 782 //----------------------------------------------------------------------------- 783 // Purpose: update the text of an existing tooltip 784 //----------------------------------------------------------------------------- 785 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 786 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 25)] 787 public struct HTML_UpdateToolTip_t { 788 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 25; 789 public HHTMLBrowser unBrowserHandle; // the handle of the surface 790 public string pchMsg; // the EMouseCursor to display 791 } 792 793 //----------------------------------------------------------------------------- 794 // Purpose: hide the tooltip you are showing 795 //----------------------------------------------------------------------------- 796 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 797 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 26)] 798 public struct HTML_HideToolTip_t { 799 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 26; 800 public HHTMLBrowser unBrowserHandle; // the handle of the surface 801 } 802 803 //----------------------------------------------------------------------------- 804 // Purpose: The browser has restarted due to an internal failure, use this new handle value 805 //----------------------------------------------------------------------------- 806 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 807 [CallbackIdentity(Constants.k_iSteamHTMLSurfaceCallbacks + 27)] 808 public struct HTML_BrowserRestarted_t { 809 public const int k_iCallback = Constants.k_iSteamHTMLSurfaceCallbacks + 27; 810 public HHTMLBrowser unBrowserHandle; // this is the new browser handle after the restart 811 public HHTMLBrowser unOldBrowserHandle; // the handle for the browser before the restart, if your handle was this then switch to using unBrowserHandle for API calls 812 } 813 814 // callbacks 815 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 816 [CallbackIdentity(Constants.k_iClientHTTPCallbacks + 1)] 817 public struct HTTPRequestCompleted_t { 818 public const int k_iCallback = Constants.k_iClientHTTPCallbacks + 1; 819 820 // Handle value for the request that has completed. 821 public HTTPRequestHandle m_hRequest; 822 823 // Context value that the user defined on the request that this callback is associated with, 0 if 824 // no context value was set. 825 public ulong m_ulContextValue; 826 827 // This will be true if we actually got any sort of response from the server (even an error). 828 // It will be false if we failed due to an internal error or client side network failure. 829 [MarshalAs(UnmanagedType.I1)] 830 public bool m_bRequestSuccessful; 831 832 // Will be the HTTP status code value returned by the server, k_EHTTPStatusCode200OK is the normal 833 // OK response, if you get something else you probably need to treat it as a failure. 834 public EHTTPStatusCode m_eStatusCode; 835 836 public uint m_unBodySize; // Same as GetHTTPResponseBodySize() 837 } 838 839 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 840 [CallbackIdentity(Constants.k_iClientHTTPCallbacks + 2)] 841 public struct HTTPRequestHeadersReceived_t { 842 public const int k_iCallback = Constants.k_iClientHTTPCallbacks + 2; 843 844 // Handle value for the request that has received headers. 845 public HTTPRequestHandle m_hRequest; 846 847 // Context value that the user defined on the request that this callback is associated with, 0 if 848 // no context value was set. 849 public ulong m_ulContextValue; 850 } 851 852 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 853 [CallbackIdentity(Constants.k_iClientHTTPCallbacks + 3)] 854 public struct HTTPRequestDataReceived_t { 855 public const int k_iCallback = Constants.k_iClientHTTPCallbacks + 3; 856 857 // Handle value for the request that has received data. 858 public HTTPRequestHandle m_hRequest; 859 860 // Context value that the user defined on the request that this callback is associated with, 0 if 861 // no context value was set. 862 public ulong m_ulContextValue; 863 864 865 // Offset to provide to GetHTTPStreamingResponseBodyData to get this chunk of data 866 public uint m_cOffset; 867 868 // Size to provide to GetHTTPStreamingResponseBodyData to get this chunk of data 869 public uint m_cBytesReceived; 870 } 871 872 // SteamInventoryResultReady_t callbacks are fired whenever asynchronous 873 // results transition from "Pending" to "OK" or an error state. There will 874 // always be exactly one callback per handle. 875 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 876 [CallbackIdentity(Constants.k_iClientInventoryCallbacks + 0)] 877 public struct SteamInventoryResultReady_t { 878 public const int k_iCallback = Constants.k_iClientInventoryCallbacks + 0; 879 public SteamInventoryResult_t m_handle; 880 public EResult m_result; 881 } 882 883 // SteamInventoryFullUpdate_t callbacks are triggered when GetAllItems 884 // successfully returns a result which is newer / fresher than the last 885 // known result. (It will not trigger if the inventory hasn't changed, 886 // or if results from two overlapping calls are reversed in flight and 887 // the earlier result is already known to be stale/out-of-date.) 888 // The normal ResultReady callback will still be triggered immediately 889 // afterwards; this is an additional notification for your convenience. 890 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 891 [CallbackIdentity(Constants.k_iClientInventoryCallbacks + 1)] 892 public struct SteamInventoryFullUpdate_t { 893 public const int k_iCallback = Constants.k_iClientInventoryCallbacks + 1; 894 public SteamInventoryResult_t m_handle; 895 } 896 897 // A SteamInventoryDefinitionUpdate_t callback is triggered whenever 898 // item definitions have been updated, which could be in response to 899 // LoadItemDefinitions() or any other async request which required 900 // a definition update in order to process results from the server. 901 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 902 [CallbackIdentity(Constants.k_iClientInventoryCallbacks + 2)] 903 public struct SteamInventoryDefinitionUpdate_t { 904 public const int k_iCallback = Constants.k_iClientInventoryCallbacks + 2; 905 } 906 907 // Returned 908 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 909 [CallbackIdentity(Constants.k_iClientInventoryCallbacks + 3)] 910 public struct SteamInventoryEligiblePromoItemDefIDs_t { 911 public const int k_iCallback = Constants.k_iClientInventoryCallbacks + 3; 912 public EResult m_result; 913 public CSteamID m_steamID; 914 public int m_numEligiblePromoItemDefs; 915 [MarshalAs(UnmanagedType.I1)] 916 public bool m_bCachedData; // indicates that the data was retrieved from the cache and not the server 917 } 918 919 // Triggered from StartPurchase call 920 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 921 [CallbackIdentity(Constants.k_iClientInventoryCallbacks + 4)] 922 public struct SteamInventoryStartPurchaseResult_t { 923 public const int k_iCallback = Constants.k_iClientInventoryCallbacks + 4; 924 public EResult m_result; 925 public ulong m_ulOrderID; 926 public ulong m_ulTransID; 927 } 928 929 // Triggered from RequestPrices 930 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 931 [CallbackIdentity(Constants.k_iClientInventoryCallbacks + 5)] 932 public struct SteamInventoryRequestPricesResult_t { 933 public const int k_iCallback = Constants.k_iClientInventoryCallbacks + 5; 934 public EResult m_result; 935 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4)] 936 public string m_rgchCurrency; 937 } 938 939 //----------------------------------------------------------------------------- 940 // Callbacks for ISteamMatchmaking (which go through the regular Steam callback registration system) 941 //----------------------------------------------------------------------------- 942 // Purpose: a server was added/removed from the favorites list, you should refresh now 943 //----------------------------------------------------------------------------- 944 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 945 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 2)] 946 public struct FavoritesListChanged_t { 947 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 2; 948 public uint m_nIP; // an IP of 0 means reload the whole list, any other value means just one server 949 public uint m_nQueryPort; 950 public uint m_nConnPort; 951 public uint m_nAppID; 952 public uint m_nFlags; 953 [MarshalAs(UnmanagedType.I1)] 954 public bool m_bAdd; // true if this is adding the entry, otherwise it is a remove 955 public AccountID_t m_unAccountId; 956 } 957 958 //----------------------------------------------------------------------------- 959 // Purpose: Someone has invited you to join a Lobby 960 // normally you don't need to do anything with this, since 961 // the Steam UI will also display a '<user> has invited you to the lobby, join?' dialog 962 // 963 // if the user outside a game chooses to join, your game will be launched with the parameter "+connect_lobby <64-bit lobby id>", 964 // or with the callback GameLobbyJoinRequested_t if they're already in-game 965 //----------------------------------------------------------------------------- 966 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 967 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 3)] 968 public struct LobbyInvite_t { 969 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 3; 970 971 public ulong m_ulSteamIDUser; // Steam ID of the person making the invite 972 public ulong m_ulSteamIDLobby; // Steam ID of the Lobby 973 public ulong m_ulGameID; // GameID of the Lobby 974 } 975 976 //----------------------------------------------------------------------------- 977 // Purpose: Sent on entering a lobby, or on failing to enter 978 // m_EChatRoomEnterResponse will be set to k_EChatRoomEnterResponseSuccess on success, 979 // or a higher value on failure (see enum EChatRoomEnterResponse) 980 //----------------------------------------------------------------------------- 981 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 982 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 4)] 983 public struct LobbyEnter_t { 984 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 4; 985 986 public ulong m_ulSteamIDLobby; // SteamID of the Lobby you have entered 987 public uint m_rgfChatPermissions; // Permissions of the current user 988 [MarshalAs(UnmanagedType.I1)] 989 public bool m_bLocked; // If true, then only invited users may join 990 public uint m_EChatRoomEnterResponse; // EChatRoomEnterResponse 991 } 992 993 //----------------------------------------------------------------------------- 994 // Purpose: The lobby metadata has changed 995 // if m_ulSteamIDMember is the steamID of a lobby member, use GetLobbyMemberData() to access per-user details 996 // if m_ulSteamIDMember == m_ulSteamIDLobby, use GetLobbyData() to access lobby metadata 997 //----------------------------------------------------------------------------- 998 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 999 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 5)] 1000 public struct LobbyDataUpdate_t { 1001 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 5; 1002 1003 public ulong m_ulSteamIDLobby; // steamID of the Lobby 1004 public ulong m_ulSteamIDMember; // steamID of the member whose data changed, or the room itself 1005 public byte m_bSuccess; // true if we lobby data was successfully changed; 1006 // will only be false if RequestLobbyData() was called on a lobby that no longer exists 1007 } 1008 1009 //----------------------------------------------------------------------------- 1010 // Purpose: The lobby chat room state has changed 1011 // this is usually sent when a user has joined or left the lobby 1012 //----------------------------------------------------------------------------- 1013 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1014 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 6)] 1015 public struct LobbyChatUpdate_t { 1016 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 6; 1017 1018 public ulong m_ulSteamIDLobby; // Lobby ID 1019 public ulong m_ulSteamIDUserChanged; // user who's status in the lobby just changed - can be recipient 1020 public ulong m_ulSteamIDMakingChange; // Chat member who made the change (different from SteamIDUserChange if kicking, muting, etc.) 1021 // for example, if one user kicks another from the lobby, this will be set to the id of the user who initiated the kick 1022 public uint m_rgfChatMemberStateChange; // bitfield of EChatMemberStateChange values 1023 } 1024 1025 //----------------------------------------------------------------------------- 1026 // Purpose: A chat message for this lobby has been sent 1027 // use GetLobbyChatEntry( m_iChatID ) to retrieve the contents of this message 1028 //----------------------------------------------------------------------------- 1029 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1030 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 7)] 1031 public struct LobbyChatMsg_t { 1032 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 7; 1033 1034 public ulong m_ulSteamIDLobby; // the lobby id this is in 1035 public ulong m_ulSteamIDUser; // steamID of the user who has sent this message 1036 public byte m_eChatEntryType; // type of message 1037 public uint m_iChatID; // index of the chat entry to lookup 1038 } 1039 1040 //----------------------------------------------------------------------------- 1041 // Purpose: A game created a game for all the members of the lobby to join, 1042 // as triggered by a SetLobbyGameServer() 1043 // it's up to the individual clients to take action on this; the usual 1044 // game behavior is to leave the lobby and connect to the specified game server 1045 //----------------------------------------------------------------------------- 1046 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1047 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 9)] 1048 public struct LobbyGameCreated_t { 1049 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 9; 1050 1051 public ulong m_ulSteamIDLobby; // the lobby we were in 1052 public ulong m_ulSteamIDGameServer; // the new game server that has been created or found for the lobby members 1053 public uint m_unIP; // IP & Port of the game server (if any) 1054 public ushort m_usPort; 1055 } 1056 1057 //----------------------------------------------------------------------------- 1058 // Purpose: Number of matching lobbies found 1059 // iterate the returned lobbies with GetLobbyByIndex(), from values 0 to m_nLobbiesMatching-1 1060 //----------------------------------------------------------------------------- 1061 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1062 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 10)] 1063 public struct LobbyMatchList_t { 1064 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 10; 1065 public uint m_nLobbiesMatching; // Number of lobbies that matched search criteria and we have SteamIDs for 1066 } 1067 1068 //----------------------------------------------------------------------------- 1069 // Purpose: posted if a user is forcefully removed from a lobby 1070 // can occur if a user loses connection to Steam 1071 //----------------------------------------------------------------------------- 1072 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1073 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 12)] 1074 public struct LobbyKicked_t { 1075 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 12; 1076 public ulong m_ulSteamIDLobby; // Lobby 1077 public ulong m_ulSteamIDAdmin; // User who kicked you - possibly the ID of the lobby itself 1078 public byte m_bKickedDueToDisconnect; // true if you were kicked from the lobby due to the user losing connection to Steam (currently always true) 1079 } 1080 1081 //----------------------------------------------------------------------------- 1082 // Purpose: Result of our request to create a Lobby 1083 // m_eResult == k_EResultOK on success 1084 // at this point, the lobby has been joined and is ready for use 1085 // a LobbyEnter_t callback will also be received (since the local user is joining their own lobby) 1086 //----------------------------------------------------------------------------- 1087 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1088 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 13)] 1089 public struct LobbyCreated_t { 1090 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 13; 1091 1092 public EResult m_eResult; // k_EResultOK - the lobby was successfully created 1093 // k_EResultNoConnection - your Steam client doesn't have a connection to the back-end 1094 // k_EResultTimeout - you the message to the Steam servers, but it didn't respond 1095 // k_EResultFail - the server responded, but with an unknown internal error 1096 // k_EResultAccessDenied - your game isn't set to allow lobbies, or your client does haven't rights to play the game 1097 // k_EResultLimitExceeded - your game client has created too many lobbies 1098 1099 public ulong m_ulSteamIDLobby; // chat room, zero if failed 1100 } 1101 1102 //----------------------------------------------------------------------------- 1103 // Purpose: Result of our request to create a Lobby 1104 // m_eResult == k_EResultOK on success 1105 // at this point, the lobby has been joined and is ready for use 1106 // a LobbyEnter_t callback will also be received (since the local user is joining their own lobby) 1107 //----------------------------------------------------------------------------- 1108 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1109 [CallbackIdentity(Constants.k_iSteamMatchmakingCallbacks + 16)] 1110 public struct FavoritesListAccountsUpdated_t { 1111 public const int k_iCallback = Constants.k_iSteamMatchmakingCallbacks + 16; 1112 1113 public EResult m_eResult; 1114 } 1115 1116 //----------------------------------------------------------------------------- 1117 // Callbacks for ISteamGameSearch (which go through the regular Steam callback registration system) 1118 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1119 [CallbackIdentity(Constants.k_iSteamGameSearchCallbacks + 1)] 1120 public struct SearchForGameProgressCallback_t { 1121 public const int k_iCallback = Constants.k_iSteamGameSearchCallbacks + 1; 1122 1123 public ulong m_ullSearchID; // all future callbacks referencing this search will include this Search ID 1124 1125 public EResult m_eResult; // if search has started this result will be k_EResultOK, any other value indicates search has failed to start or has terminated 1126 public CSteamID m_lobbyID; // lobby ID if lobby search, invalid steamID otherwise 1127 public CSteamID m_steamIDEndedSearch; // if search was terminated, steamID that terminated search 1128 1129 public int m_nSecondsRemainingEstimate; 1130 public int m_cPlayersSearching; 1131 } 1132 1133 // notification to all players searching that a game has been found 1134 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1135 [CallbackIdentity(Constants.k_iSteamGameSearchCallbacks + 2)] 1136 public struct SearchForGameResultCallback_t { 1137 public const int k_iCallback = Constants.k_iSteamGameSearchCallbacks + 2; 1138 1139 public ulong m_ullSearchID; 1140 1141 public EResult m_eResult; // if game/host was lost this will be an error value 1142 1143 // if m_bGameFound is true the following are non-zero 1144 public int m_nCountPlayersInGame; 1145 public int m_nCountAcceptedGame; 1146 // if m_steamIDHost is valid the host has started the game 1147 public CSteamID m_steamIDHost; 1148 [MarshalAs(UnmanagedType.I1)] 1149 public bool m_bFinalCallback; 1150 } 1151 1152 //----------------------------------------------------------------------------- 1153 // ISteamGameSearch : Game Host API callbacks 1154 // callback from RequestPlayersForGame when the matchmaking service has started or ended search 1155 // callback will also follow a call from CancelRequestPlayersForGame - m_bSearchInProgress will be false 1156 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1157 [CallbackIdentity(Constants.k_iSteamGameSearchCallbacks + 11)] 1158 public struct RequestPlayersForGameProgressCallback_t { 1159 public const int k_iCallback = Constants.k_iSteamGameSearchCallbacks + 11; 1160 1161 public EResult m_eResult; // m_ullSearchID will be non-zero if this is k_EResultOK 1162 public ulong m_ullSearchID; // all future callbacks referencing this search will include this Search ID 1163 } 1164 1165 // callback from RequestPlayersForGame 1166 // one of these will be sent per player 1167 // followed by additional callbacks when players accept or decline the game 1168 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1169 [CallbackIdentity(Constants.k_iSteamGameSearchCallbacks + 12)] 1170 public struct RequestPlayersForGameResultCallback_t { 1171 public const int k_iCallback = Constants.k_iSteamGameSearchCallbacks + 12; 1172 1173 public EResult m_eResult; // m_ullSearchID will be non-zero if this is k_EResultOK 1174 public ulong m_ullSearchID; 1175 1176 public CSteamID m_SteamIDPlayerFound; // player steamID 1177 public CSteamID m_SteamIDLobby; // if the player is in a lobby, the lobby ID 1178 public PlayerAcceptState_t m_ePlayerAcceptState; 1179 public int m_nPlayerIndex; 1180 public int m_nTotalPlayersFound; // expect this many callbacks at minimum 1181 public int m_nTotalPlayersAcceptedGame; 1182 public int m_nSuggestedTeamIndex; 1183 public ulong m_ullUniqueGameID; 1184 } 1185 1186 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1187 [CallbackIdentity(Constants.k_iSteamGameSearchCallbacks + 13)] 1188 public struct RequestPlayersForGameFinalResultCallback_t { 1189 public const int k_iCallback = Constants.k_iSteamGameSearchCallbacks + 13; 1190 1191 public EResult m_eResult; 1192 public ulong m_ullSearchID; 1193 public ulong m_ullUniqueGameID; 1194 } 1195 1196 // this callback confirms that results were received by the matchmaking service for this player 1197 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1198 [CallbackIdentity(Constants.k_iSteamGameSearchCallbacks + 14)] 1199 public struct SubmitPlayerResultResultCallback_t { 1200 public const int k_iCallback = Constants.k_iSteamGameSearchCallbacks + 14; 1201 1202 public EResult m_eResult; 1203 public ulong ullUniqueGameID; 1204 public CSteamID steamIDPlayer; 1205 } 1206 1207 // this callback confirms that the game is recorded as complete on the matchmaking service 1208 // the next call to RequestPlayersForGame will generate a new unique game ID 1209 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1210 [CallbackIdentity(Constants.k_iSteamGameSearchCallbacks + 15)] 1211 public struct EndGameResultCallback_t { 1212 public const int k_iCallback = Constants.k_iSteamGameSearchCallbacks + 15; 1213 1214 public EResult m_eResult; 1215 public ulong ullUniqueGameID; 1216 } 1217 1218 // Steam has responded to the user request to join a party via the given Beacon ID. 1219 // If successful, the connect string contains game-specific instructions to connect 1220 // to the game with that party. 1221 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1222 [CallbackIdentity(Constants.k_iSteamPartiesCallbacks + 1)] 1223 public struct JoinPartyCallback_t { 1224 public const int k_iCallback = Constants.k_iSteamPartiesCallbacks + 1; 1225 1226 public EResult m_eResult; 1227 public PartyBeaconID_t m_ulBeaconID; 1228 public CSteamID m_SteamIDBeaconOwner; 1229 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] 1230 public string m_rgchConnectString; 1231 } 1232 1233 // Response to CreateBeacon request. If successful, the beacon ID is provided. 1234 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1235 [CallbackIdentity(Constants.k_iSteamPartiesCallbacks + 2)] 1236 public struct CreateBeaconCallback_t { 1237 public const int k_iCallback = Constants.k_iSteamPartiesCallbacks + 2; 1238 1239 public EResult m_eResult; 1240 public PartyBeaconID_t m_ulBeaconID; 1241 } 1242 1243 // Someone has used the beacon to join your party - they are in-flight now 1244 // and we've reserved one of the open slots for them. 1245 // You should confirm when they join your party by calling OnReservationCompleted(). 1246 // Otherwise, Steam may timeout their reservation eventually. 1247 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1248 [CallbackIdentity(Constants.k_iSteamPartiesCallbacks + 3)] 1249 public struct ReservationNotificationCallback_t { 1250 public const int k_iCallback = Constants.k_iSteamPartiesCallbacks + 3; 1251 1252 public PartyBeaconID_t m_ulBeaconID; 1253 public CSteamID m_steamIDJoiner; 1254 } 1255 1256 // Response to ChangeNumOpenSlots call 1257 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1258 [CallbackIdentity(Constants.k_iSteamPartiesCallbacks + 4)] 1259 public struct ChangeNumOpenSlotsCallback_t { 1260 public const int k_iCallback = Constants.k_iSteamPartiesCallbacks + 4; 1261 1262 public EResult m_eResult; 1263 } 1264 1265 // The list of possible Party beacon locations has changed 1266 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1267 [CallbackIdentity(Constants.k_iSteamPartiesCallbacks + 5)] 1268 public struct AvailableBeaconLocationsUpdated_t { 1269 public const int k_iCallback = Constants.k_iSteamPartiesCallbacks + 5; 1270 } 1271 1272 // The list of active beacons may have changed 1273 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1274 [CallbackIdentity(Constants.k_iSteamPartiesCallbacks + 6)] 1275 public struct ActiveBeaconsUpdated_t { 1276 public const int k_iCallback = Constants.k_iSteamPartiesCallbacks + 6; 1277 } 1278 1279 // callbacks 1280 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1281 [CallbackIdentity(Constants.k_iSteamMusicCallbacks + 1)] 1282 public struct PlaybackStatusHasChanged_t { 1283 public const int k_iCallback = Constants.k_iSteamMusicCallbacks + 1; 1284 } 1285 1286 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1287 [CallbackIdentity(Constants.k_iSteamMusicCallbacks + 2)] 1288 public struct VolumeHasChanged_t { 1289 public const int k_iCallback = Constants.k_iSteamMusicCallbacks + 2; 1290 public float m_flNewVolume; 1291 } 1292 1293 // callbacks 1294 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1295 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 1)] 1296 public struct MusicPlayerRemoteWillActivate_t { 1297 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 1; 1298 } 1299 1300 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1301 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 2)] 1302 public struct MusicPlayerRemoteWillDeactivate_t { 1303 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 2; 1304 } 1305 1306 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1307 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 3)] 1308 public struct MusicPlayerRemoteToFront_t { 1309 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 3; 1310 } 1311 1312 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1313 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 4)] 1314 public struct MusicPlayerWillQuit_t { 1315 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 4; 1316 } 1317 1318 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1319 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 5)] 1320 public struct MusicPlayerWantsPlay_t { 1321 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 5; 1322 } 1323 1324 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1325 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 6)] 1326 public struct MusicPlayerWantsPause_t { 1327 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 6; 1328 } 1329 1330 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1331 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 7)] 1332 public struct MusicPlayerWantsPlayPrevious_t { 1333 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 7; 1334 } 1335 1336 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1337 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 8)] 1338 public struct MusicPlayerWantsPlayNext_t { 1339 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 8; 1340 } 1341 1342 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1343 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 9)] 1344 public struct MusicPlayerWantsShuffled_t { 1345 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 9; 1346 [MarshalAs(UnmanagedType.I1)] 1347 public bool m_bShuffled; 1348 } 1349 1350 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1351 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 10)] 1352 public struct MusicPlayerWantsLooped_t { 1353 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 10; 1354 [MarshalAs(UnmanagedType.I1)] 1355 public bool m_bLooped; 1356 } 1357 1358 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1359 [CallbackIdentity(Constants.k_iSteamMusicCallbacks + 11)] 1360 public struct MusicPlayerWantsVolume_t { 1361 public const int k_iCallback = Constants.k_iSteamMusicCallbacks + 11; 1362 public float m_flNewVolume; 1363 } 1364 1365 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1366 [CallbackIdentity(Constants.k_iSteamMusicCallbacks + 12)] 1367 public struct MusicPlayerSelectsQueueEntry_t { 1368 public const int k_iCallback = Constants.k_iSteamMusicCallbacks + 12; 1369 public int nID; 1370 } 1371 1372 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1373 [CallbackIdentity(Constants.k_iSteamMusicCallbacks + 13)] 1374 public struct MusicPlayerSelectsPlaylistEntry_t { 1375 public const int k_iCallback = Constants.k_iSteamMusicCallbacks + 13; 1376 public int nID; 1377 } 1378 1379 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1380 [CallbackIdentity(Constants.k_iSteamMusicRemoteCallbacks + 14)] 1381 public struct MusicPlayerWantsPlayingRepeatStatus_t { 1382 public const int k_iCallback = Constants.k_iSteamMusicRemoteCallbacks + 14; 1383 public int m_nPlayingRepeatStatus; 1384 } 1385 1386 // callbacks 1387 // callback notification - a user wants to talk to us over the P2P channel via the SendP2PPacket() API 1388 // in response, a call to AcceptP2PPacketsFromUser() needs to be made, if you want to talk with them 1389 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1390 [CallbackIdentity(Constants.k_iSteamNetworkingCallbacks + 2)] 1391 public struct P2PSessionRequest_t { 1392 public const int k_iCallback = Constants.k_iSteamNetworkingCallbacks + 2; 1393 public CSteamID m_steamIDRemote; // user who wants to talk to us 1394 } 1395 1396 // callback notification - packets can't get through to the specified user via the SendP2PPacket() API 1397 // all packets queued packets unsent at this point will be dropped 1398 // further attempts to send will retry making the connection (but will be dropped if we fail again) 1399 [StructLayout(LayoutKind.Sequential, Pack = 1)] 1400 [CallbackIdentity(Constants.k_iSteamNetworkingCallbacks + 3)] 1401 public struct P2PSessionConnectFail_t { 1402 public const int k_iCallback = Constants.k_iSteamNetworkingCallbacks + 3; 1403 public CSteamID m_steamIDRemote; // user we were sending packets to 1404 public byte m_eP2PSessionError; // EP2PSessionError indicating why we're having trouble 1405 } 1406 1407 // callback notification - status of a socket has changed 1408 // used as part of the CreateListenSocket() / CreateP2PConnectionSocket() 1409 [StructLayout(LayoutKind.Sequential, Pack = 4)] 1410 [CallbackIdentity(Constants.k_iSteamNetworkingCallbacks + 1)] 1411 public struct SocketStatusCallback_t { 1412 public const int k_iCallback = Constants.k_iSteamNetworkingCallbacks + 1; 1413 public SNetSocket_t m_hSocket; // the socket used to send/receive data to the remote host 1414 public SNetListenSocket_t m_hListenSocket; // this is the server socket that we were listening on; NULL if this was an outgoing connection 1415 public CSteamID m_steamIDRemote; // remote steamID we have connected to, if it has one 1416 public int m_eSNetSocketState; // socket state, ESNetSocketState 1417 } 1418 1419 //----------------------------------------------------------------------------- 1420 // Purpose: Callback for querying UGC 1421 //----------------------------------------------------------------------------- 1422 [CallbackIdentity(Constants.k_ISteamParentalSettingsCallbacks + 1)] 1423 public struct SteamParentalSettingsChanged_t { 1424 public const int k_iCallback = Constants.k_ISteamParentalSettingsCallbacks + 1; 1425 } 1426 1427 // callbacks 1428 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1429 [CallbackIdentity(Constants.k_iSteamRemotePlayCallbacks + 1)] 1430 public struct SteamRemotePlaySessionConnected_t { 1431 public const int k_iCallback = Constants.k_iSteamRemotePlayCallbacks + 1; 1432 public uint m_unSessionID; 1433 } 1434 1435 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1436 [CallbackIdentity(Constants.k_iSteamRemotePlayCallbacks + 2)] 1437 public struct SteamRemotePlaySessionDisconnected_t { 1438 public const int k_iCallback = Constants.k_iSteamRemotePlayCallbacks + 2; 1439 public uint m_unSessionID; 1440 } 1441 1442 // callbacks 1443 //----------------------------------------------------------------------------- 1444 // Purpose: sent when the local file cache is fully synced with the server for an app 1445 // That means that an application can be started and has all latest files 1446 //----------------------------------------------------------------------------- 1447 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1448 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 1)] 1449 public struct RemoteStorageAppSyncedClient_t { 1450 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 1; 1451 public AppId_t m_nAppID; 1452 public EResult m_eResult; 1453 public int m_unNumDownloads; 1454 } 1455 1456 //----------------------------------------------------------------------------- 1457 // Purpose: sent when the server is fully synced with the local file cache for an app 1458 // That means that we can shutdown Steam and our data is stored on the server 1459 //----------------------------------------------------------------------------- 1460 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1461 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 2)] 1462 public struct RemoteStorageAppSyncedServer_t { 1463 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 2; 1464 public AppId_t m_nAppID; 1465 public EResult m_eResult; 1466 public int m_unNumUploads; 1467 } 1468 1469 //----------------------------------------------------------------------------- 1470 // Purpose: Status of up and downloads during a sync session 1471 // 1472 //----------------------------------------------------------------------------- 1473 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1474 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 3)] 1475 public struct RemoteStorageAppSyncProgress_t { 1476 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 3; 1477 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchFilenameMax)] 1478 public string m_rgchCurrentFile; // Current file being transferred 1479 public AppId_t m_nAppID; // App this info relates to 1480 public uint m_uBytesTransferredThisChunk; // Bytes transferred this chunk 1481 public double m_dAppPercentComplete; // Percent complete that this app's transfers are 1482 [MarshalAs(UnmanagedType.I1)] 1483 public bool m_bUploading; // if false, downloading 1484 } 1485 1486 // 1487 // IMPORTANT! k_iClientRemoteStorageCallbacks + 4 is used, see iclientremotestorage.h 1488 // 1489 //----------------------------------------------------------------------------- 1490 // Purpose: Sent after we've determined the list of files that are out of sync 1491 // with the server. 1492 //----------------------------------------------------------------------------- 1493 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1494 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 5)] 1495 public struct RemoteStorageAppSyncStatusCheck_t { 1496 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 5; 1497 public AppId_t m_nAppID; 1498 public EResult m_eResult; 1499 } 1500 1501 //----------------------------------------------------------------------------- 1502 // Purpose: The result of a call to FileShare() 1503 //----------------------------------------------------------------------------- 1504 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1505 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 7)] 1506 public struct RemoteStorageFileShareResult_t { 1507 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 7; 1508 public EResult m_eResult; // The result of the operation 1509 public UGCHandle_t m_hFile; // The handle that can be shared with users and features 1510 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchFilenameMax)] 1511 public string m_rgchFilename; // The name of the file that was shared 1512 } 1513 1514 // k_iClientRemoteStorageCallbacks + 8 is deprecated! Do not reuse 1515 //----------------------------------------------------------------------------- 1516 // Purpose: The result of a call to PublishFile() 1517 //----------------------------------------------------------------------------- 1518 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1519 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 9)] 1520 public struct RemoteStoragePublishFileResult_t { 1521 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 9; 1522 public EResult m_eResult; // The result of the operation. 1523 public PublishedFileId_t m_nPublishedFileId; 1524 [MarshalAs(UnmanagedType.I1)] 1525 public bool m_bUserNeedsToAcceptWorkshopLegalAgreement; 1526 } 1527 1528 //----------------------------------------------------------------------------- 1529 // Purpose: The result of a call to DeletePublishedFile() 1530 //----------------------------------------------------------------------------- 1531 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1532 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 11)] 1533 public struct RemoteStorageDeletePublishedFileResult_t { 1534 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 11; 1535 public EResult m_eResult; // The result of the operation. 1536 public PublishedFileId_t m_nPublishedFileId; 1537 } 1538 1539 //----------------------------------------------------------------------------- 1540 // Purpose: The result of a call to EnumerateUserPublishedFiles() 1541 //----------------------------------------------------------------------------- 1542 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1543 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 12)] 1544 public struct RemoteStorageEnumerateUserPublishedFilesResult_t { 1545 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 12; 1546 public EResult m_eResult; // The result of the operation. 1547 public int m_nResultsReturned; 1548 public int m_nTotalResultCount; 1549 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_unEnumeratePublishedFilesMaxResults)] 1550 public PublishedFileId_t[] m_rgPublishedFileId; 1551 } 1552 1553 //----------------------------------------------------------------------------- 1554 // Purpose: The result of a call to SubscribePublishedFile() 1555 //----------------------------------------------------------------------------- 1556 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1557 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 13)] 1558 public struct RemoteStorageSubscribePublishedFileResult_t { 1559 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 13; 1560 public EResult m_eResult; // The result of the operation. 1561 public PublishedFileId_t m_nPublishedFileId; 1562 } 1563 1564 //----------------------------------------------------------------------------- 1565 // Purpose: The result of a call to EnumerateSubscribePublishedFiles() 1566 //----------------------------------------------------------------------------- 1567 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1568 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 14)] 1569 public struct RemoteStorageEnumerateUserSubscribedFilesResult_t { 1570 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 14; 1571 public EResult m_eResult; // The result of the operation. 1572 public int m_nResultsReturned; 1573 public int m_nTotalResultCount; 1574 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_unEnumeratePublishedFilesMaxResults)] 1575 public PublishedFileId_t[] m_rgPublishedFileId; 1576 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_unEnumeratePublishedFilesMaxResults)] 1577 public uint[] m_rgRTimeSubscribed; 1578 } 1579 1580 //----------------------------------------------------------------------------- 1581 // Purpose: The result of a call to UnsubscribePublishedFile() 1582 //----------------------------------------------------------------------------- 1583 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1584 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 15)] 1585 public struct RemoteStorageUnsubscribePublishedFileResult_t { 1586 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 15; 1587 public EResult m_eResult; // The result of the operation. 1588 public PublishedFileId_t m_nPublishedFileId; 1589 } 1590 1591 //----------------------------------------------------------------------------- 1592 // Purpose: The result of a call to CommitPublishedFileUpdate() 1593 //----------------------------------------------------------------------------- 1594 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1595 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 16)] 1596 public struct RemoteStorageUpdatePublishedFileResult_t { 1597 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 16; 1598 public EResult m_eResult; // The result of the operation. 1599 public PublishedFileId_t m_nPublishedFileId; 1600 [MarshalAs(UnmanagedType.I1)] 1601 public bool m_bUserNeedsToAcceptWorkshopLegalAgreement; 1602 } 1603 1604 //----------------------------------------------------------------------------- 1605 // Purpose: The result of a call to UGCDownload() 1606 //----------------------------------------------------------------------------- 1607 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1608 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 17)] 1609 public struct RemoteStorageDownloadUGCResult_t { 1610 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 17; 1611 public EResult m_eResult; // The result of the operation. 1612 public UGCHandle_t m_hFile; // The handle to the file that was attempted to be downloaded. 1613 public AppId_t m_nAppID; // ID of the app that created this file. 1614 public int m_nSizeInBytes; // The size of the file that was downloaded, in bytes. 1615 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchFilenameMax)] 1616 public string m_pchFileName; // The name of the file that was downloaded. 1617 public ulong m_ulSteamIDOwner; // Steam ID of the user who created this content. 1618 } 1619 1620 //----------------------------------------------------------------------------- 1621 // Purpose: The result of a call to GetPublishedFileDetails() 1622 //----------------------------------------------------------------------------- 1623 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1624 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 18)] 1625 public struct RemoteStorageGetPublishedFileDetailsResult_t { 1626 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 18; 1627 public EResult m_eResult; // The result of the operation. 1628 public PublishedFileId_t m_nPublishedFileId; 1629 public AppId_t m_nCreatorAppID; // ID of the app that created this file. 1630 public AppId_t m_nConsumerAppID; // ID of the app that will consume this file. 1631 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchPublishedDocumentTitleMax)] 1632 public string m_rgchTitle; // title of document 1633 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchPublishedDocumentDescriptionMax)] 1634 public string m_rgchDescription; // description of document 1635 public UGCHandle_t m_hFile; // The handle of the primary file 1636 public UGCHandle_t m_hPreviewFile; // The handle of the preview file 1637 public ulong m_ulSteamIDOwner; // Steam ID of the user who created this content. 1638 public uint m_rtimeCreated; // time when the published file was created 1639 public uint m_rtimeUpdated; // time when the published file was last updated 1640 public ERemoteStoragePublishedFileVisibility m_eVisibility; 1641 [MarshalAs(UnmanagedType.I1)] 1642 public bool m_bBanned; 1643 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchTagListMax)] 1644 public string m_rgchTags; // comma separated list of all tags associated with this file 1645 [MarshalAs(UnmanagedType.I1)] 1646 public bool m_bTagsTruncated; // whether the list of tags was too long to be returned in the provided buffer 1647 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchFilenameMax)] 1648 public string m_pchFileName; // The name of the primary file 1649 public int m_nFileSize; // Size of the primary file 1650 public int m_nPreviewFileSize; // Size of the preview file 1651 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchPublishedFileURLMax)] 1652 public string m_rgchURL; // URL (for a video or a website) 1653 public EWorkshopFileType m_eFileType; // Type of the file 1654 [MarshalAs(UnmanagedType.I1)] 1655 public bool m_bAcceptedForUse; // developer has specifically flagged this item as accepted in the Workshop 1656 } 1657 1658 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1659 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 19)] 1660 public struct RemoteStorageEnumerateWorkshopFilesResult_t { 1661 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 19; 1662 public EResult m_eResult; 1663 public int m_nResultsReturned; 1664 public int m_nTotalResultCount; 1665 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_unEnumeratePublishedFilesMaxResults)] 1666 public PublishedFileId_t[] m_rgPublishedFileId; 1667 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_unEnumeratePublishedFilesMaxResults)] 1668 public float[] m_rgScore; 1669 public AppId_t m_nAppId; 1670 public uint m_unStartIndex; 1671 } 1672 1673 //----------------------------------------------------------------------------- 1674 // Purpose: The result of GetPublishedItemVoteDetails 1675 //----------------------------------------------------------------------------- 1676 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1677 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 20)] 1678 public struct RemoteStorageGetPublishedItemVoteDetailsResult_t { 1679 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 20; 1680 public EResult m_eResult; 1681 public PublishedFileId_t m_unPublishedFileId; 1682 public int m_nVotesFor; 1683 public int m_nVotesAgainst; 1684 public int m_nReports; 1685 public float m_fScore; 1686 } 1687 1688 //----------------------------------------------------------------------------- 1689 // Purpose: User subscribed to a file for the app (from within the app or on the web) 1690 //----------------------------------------------------------------------------- 1691 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1692 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 21)] 1693 public struct RemoteStoragePublishedFileSubscribed_t { 1694 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 21; 1695 public PublishedFileId_t m_nPublishedFileId; // The published file id 1696 public AppId_t m_nAppID; // ID of the app that will consume this file. 1697 } 1698 1699 //----------------------------------------------------------------------------- 1700 // Purpose: User unsubscribed from a file for the app (from within the app or on the web) 1701 //----------------------------------------------------------------------------- 1702 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1703 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 22)] 1704 public struct RemoteStoragePublishedFileUnsubscribed_t { 1705 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 22; 1706 public PublishedFileId_t m_nPublishedFileId; // The published file id 1707 public AppId_t m_nAppID; // ID of the app that will consume this file. 1708 } 1709 1710 //----------------------------------------------------------------------------- 1711 // Purpose: Published file that a user owns was deleted (from within the app or the web) 1712 //----------------------------------------------------------------------------- 1713 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1714 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 23)] 1715 public struct RemoteStoragePublishedFileDeleted_t { 1716 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 23; 1717 public PublishedFileId_t m_nPublishedFileId; // The published file id 1718 public AppId_t m_nAppID; // ID of the app that will consume this file. 1719 } 1720 1721 //----------------------------------------------------------------------------- 1722 // Purpose: The result of a call to UpdateUserPublishedItemVote() 1723 //----------------------------------------------------------------------------- 1724 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1725 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 24)] 1726 public struct RemoteStorageUpdateUserPublishedItemVoteResult_t { 1727 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 24; 1728 public EResult m_eResult; // The result of the operation. 1729 public PublishedFileId_t m_nPublishedFileId; // The published file id 1730 } 1731 1732 //----------------------------------------------------------------------------- 1733 // Purpose: The result of a call to GetUserPublishedItemVoteDetails() 1734 //----------------------------------------------------------------------------- 1735 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1736 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 25)] 1737 public struct RemoteStorageUserVoteDetails_t { 1738 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 25; 1739 public EResult m_eResult; // The result of the operation. 1740 public PublishedFileId_t m_nPublishedFileId; // The published file id 1741 public EWorkshopVote m_eVote; // what the user voted 1742 } 1743 1744 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1745 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 26)] 1746 public struct RemoteStorageEnumerateUserSharedWorkshopFilesResult_t { 1747 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 26; 1748 public EResult m_eResult; // The result of the operation. 1749 public int m_nResultsReturned; 1750 public int m_nTotalResultCount; 1751 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_unEnumeratePublishedFilesMaxResults)] 1752 public PublishedFileId_t[] m_rgPublishedFileId; 1753 } 1754 1755 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1756 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 27)] 1757 public struct RemoteStorageSetUserPublishedFileActionResult_t { 1758 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 27; 1759 public EResult m_eResult; // The result of the operation. 1760 public PublishedFileId_t m_nPublishedFileId; // The published file id 1761 public EWorkshopFileAction m_eAction; // the action that was attempted 1762 } 1763 1764 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1765 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 28)] 1766 public struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t { 1767 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 28; 1768 public EResult m_eResult; // The result of the operation. 1769 public EWorkshopFileAction m_eAction; // the action that was filtered on 1770 public int m_nResultsReturned; 1771 public int m_nTotalResultCount; 1772 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_unEnumeratePublishedFilesMaxResults)] 1773 public PublishedFileId_t[] m_rgPublishedFileId; 1774 [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.k_unEnumeratePublishedFilesMaxResults)] 1775 public uint[] m_rgRTimeUpdated; 1776 } 1777 1778 //----------------------------------------------------------------------------- 1779 // Purpose: Called periodically while a PublishWorkshopFile is in progress 1780 //----------------------------------------------------------------------------- 1781 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1782 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 29)] 1783 public struct RemoteStoragePublishFileProgress_t { 1784 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 29; 1785 public double m_dPercentFile; 1786 [MarshalAs(UnmanagedType.I1)] 1787 public bool m_bPreview; 1788 } 1789 1790 //----------------------------------------------------------------------------- 1791 // Purpose: Called when the content for a published file is updated 1792 //----------------------------------------------------------------------------- 1793 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1794 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 30)] 1795 public struct RemoteStoragePublishedFileUpdated_t { 1796 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 30; 1797 public PublishedFileId_t m_nPublishedFileId; // The published file id 1798 public AppId_t m_nAppID; // ID of the app that will consume this file. 1799 public ulong m_ulUnused; // not used anymore 1800 } 1801 1802 //----------------------------------------------------------------------------- 1803 // Purpose: Called when a FileWriteAsync completes 1804 //----------------------------------------------------------------------------- 1805 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1806 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 31)] 1807 public struct RemoteStorageFileWriteAsyncComplete_t { 1808 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 31; 1809 public EResult m_eResult; // result 1810 } 1811 1812 //----------------------------------------------------------------------------- 1813 // Purpose: Called when a FileReadAsync completes 1814 //----------------------------------------------------------------------------- 1815 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1816 [CallbackIdentity(Constants.k_iClientRemoteStorageCallbacks + 32)] 1817 public struct RemoteStorageFileReadAsyncComplete_t { 1818 public const int k_iCallback = Constants.k_iClientRemoteStorageCallbacks + 32; 1819 public SteamAPICall_t m_hFileReadAsync; // call handle of the async read which was made 1820 public EResult m_eResult; // result 1821 public uint m_nOffset; // offset in the file this read was at 1822 public uint m_cubRead; // amount read - will the <= the amount requested 1823 } 1824 1825 // callbacks 1826 //----------------------------------------------------------------------------- 1827 // Purpose: Screenshot successfully written or otherwise added to the library 1828 // and can now be tagged 1829 //----------------------------------------------------------------------------- 1830 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1831 [CallbackIdentity(Constants.k_iSteamScreenshotsCallbacks + 1)] 1832 public struct ScreenshotReady_t { 1833 public const int k_iCallback = Constants.k_iSteamScreenshotsCallbacks + 1; 1834 public ScreenshotHandle m_hLocal; 1835 public EResult m_eResult; 1836 } 1837 1838 //----------------------------------------------------------------------------- 1839 // Purpose: Screenshot has been requested by the user. Only sent if 1840 // HookScreenshots() has been called, in which case Steam will not take 1841 // the screenshot itself. 1842 //----------------------------------------------------------------------------- 1843 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 1844 [CallbackIdentity(Constants.k_iSteamScreenshotsCallbacks + 2)] 1845 public struct ScreenshotRequested_t { 1846 public const int k_iCallback = Constants.k_iSteamScreenshotsCallbacks + 2; 1847 } 1848 1849 //----------------------------------------------------------------------------- 1850 // Purpose: Callback for querying UGC 1851 //----------------------------------------------------------------------------- 1852 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1853 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 1)] 1854 public struct SteamUGCQueryCompleted_t { 1855 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 1; 1856 public UGCQueryHandle_t m_handle; 1857 public EResult m_eResult; 1858 public uint m_unNumResultsReturned; 1859 public uint m_unTotalMatchingResults; 1860 [MarshalAs(UnmanagedType.I1)] 1861 public bool m_bCachedData; // indicates whether this data was retrieved from the local on-disk cache 1862 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchPublishedFileURLMax)] 1863 public string m_rgchNextCursor; // If a paging cursor was used, then this will be the next cursor to get the next result set. 1864 } 1865 1866 //----------------------------------------------------------------------------- 1867 // Purpose: Callback for requesting details on one piece of UGC 1868 //----------------------------------------------------------------------------- 1869 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1870 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 2)] 1871 public struct SteamUGCRequestUGCDetailsResult_t { 1872 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 2; 1873 public SteamUGCDetails_t m_details; 1874 [MarshalAs(UnmanagedType.I1)] 1875 public bool m_bCachedData; // indicates whether this data was retrieved from the local on-disk cache 1876 } 1877 1878 //----------------------------------------------------------------------------- 1879 // Purpose: result for ISteamUGC::CreateItem() 1880 //----------------------------------------------------------------------------- 1881 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1882 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 3)] 1883 public struct CreateItemResult_t { 1884 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 3; 1885 public EResult m_eResult; 1886 public PublishedFileId_t m_nPublishedFileId; // new item got this UGC PublishFileID 1887 [MarshalAs(UnmanagedType.I1)] 1888 public bool m_bUserNeedsToAcceptWorkshopLegalAgreement; 1889 } 1890 1891 //----------------------------------------------------------------------------- 1892 // Purpose: result for ISteamUGC::SubmitItemUpdate() 1893 //----------------------------------------------------------------------------- 1894 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1895 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 4)] 1896 public struct SubmitItemUpdateResult_t { 1897 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 4; 1898 public EResult m_eResult; 1899 [MarshalAs(UnmanagedType.I1)] 1900 public bool m_bUserNeedsToAcceptWorkshopLegalAgreement; 1901 public PublishedFileId_t m_nPublishedFileId; 1902 } 1903 1904 //----------------------------------------------------------------------------- 1905 // Purpose: a Workshop item has been installed or updated 1906 //----------------------------------------------------------------------------- 1907 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1908 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 5)] 1909 public struct ItemInstalled_t { 1910 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 5; 1911 public AppId_t m_unAppID; 1912 public PublishedFileId_t m_nPublishedFileId; 1913 } 1914 1915 //----------------------------------------------------------------------------- 1916 // Purpose: result of DownloadItem(), existing item files can be accessed again 1917 //----------------------------------------------------------------------------- 1918 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1919 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 6)] 1920 public struct DownloadItemResult_t { 1921 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 6; 1922 public AppId_t m_unAppID; 1923 public PublishedFileId_t m_nPublishedFileId; 1924 public EResult m_eResult; 1925 } 1926 1927 //----------------------------------------------------------------------------- 1928 // Purpose: result of AddItemToFavorites() or RemoveItemFromFavorites() 1929 //----------------------------------------------------------------------------- 1930 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1931 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 7)] 1932 public struct UserFavoriteItemsListChanged_t { 1933 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 7; 1934 public PublishedFileId_t m_nPublishedFileId; 1935 public EResult m_eResult; 1936 [MarshalAs(UnmanagedType.I1)] 1937 public bool m_bWasAddRequest; 1938 } 1939 1940 //----------------------------------------------------------------------------- 1941 // Purpose: The result of a call to SetUserItemVote() 1942 //----------------------------------------------------------------------------- 1943 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1944 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 8)] 1945 public struct SetUserItemVoteResult_t { 1946 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 8; 1947 public PublishedFileId_t m_nPublishedFileId; 1948 public EResult m_eResult; 1949 [MarshalAs(UnmanagedType.I1)] 1950 public bool m_bVoteUp; 1951 } 1952 1953 //----------------------------------------------------------------------------- 1954 // Purpose: The result of a call to GetUserItemVote() 1955 //----------------------------------------------------------------------------- 1956 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1957 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 9)] 1958 public struct GetUserItemVoteResult_t { 1959 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 9; 1960 public PublishedFileId_t m_nPublishedFileId; 1961 public EResult m_eResult; 1962 [MarshalAs(UnmanagedType.I1)] 1963 public bool m_bVotedUp; 1964 [MarshalAs(UnmanagedType.I1)] 1965 public bool m_bVotedDown; 1966 [MarshalAs(UnmanagedType.I1)] 1967 public bool m_bVoteSkipped; 1968 } 1969 1970 //----------------------------------------------------------------------------- 1971 // Purpose: The result of a call to StartPlaytimeTracking() 1972 //----------------------------------------------------------------------------- 1973 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1974 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 10)] 1975 public struct StartPlaytimeTrackingResult_t { 1976 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 10; 1977 public EResult m_eResult; 1978 } 1979 1980 //----------------------------------------------------------------------------- 1981 // Purpose: The result of a call to StopPlaytimeTracking() 1982 //----------------------------------------------------------------------------- 1983 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1984 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 11)] 1985 public struct StopPlaytimeTrackingResult_t { 1986 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 11; 1987 public EResult m_eResult; 1988 } 1989 1990 //----------------------------------------------------------------------------- 1991 // Purpose: The result of a call to AddDependency 1992 //----------------------------------------------------------------------------- 1993 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 1994 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 12)] 1995 public struct AddUGCDependencyResult_t { 1996 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 12; 1997 public EResult m_eResult; 1998 public PublishedFileId_t m_nPublishedFileId; 1999 public PublishedFileId_t m_nChildPublishedFileId; 2000 } 2001 2002 //----------------------------------------------------------------------------- 2003 // Purpose: The result of a call to RemoveDependency 2004 //----------------------------------------------------------------------------- 2005 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2006 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 13)] 2007 public struct RemoveUGCDependencyResult_t { 2008 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 13; 2009 public EResult m_eResult; 2010 public PublishedFileId_t m_nPublishedFileId; 2011 public PublishedFileId_t m_nChildPublishedFileId; 2012 } 2013 2014 //----------------------------------------------------------------------------- 2015 // Purpose: The result of a call to AddAppDependency 2016 //----------------------------------------------------------------------------- 2017 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2018 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 14)] 2019 public struct AddAppDependencyResult_t { 2020 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 14; 2021 public EResult m_eResult; 2022 public PublishedFileId_t m_nPublishedFileId; 2023 public AppId_t m_nAppID; 2024 } 2025 2026 //----------------------------------------------------------------------------- 2027 // Purpose: The result of a call to RemoveAppDependency 2028 //----------------------------------------------------------------------------- 2029 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2030 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 15)] 2031 public struct RemoveAppDependencyResult_t { 2032 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 15; 2033 public EResult m_eResult; 2034 public PublishedFileId_t m_nPublishedFileId; 2035 public AppId_t m_nAppID; 2036 } 2037 2038 //----------------------------------------------------------------------------- 2039 // Purpose: The result of a call to GetAppDependencies. Callback may be called 2040 // multiple times until all app dependencies have been returned. 2041 //----------------------------------------------------------------------------- 2042 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2043 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 16)] 2044 public struct GetAppDependenciesResult_t { 2045 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 16; 2046 public EResult m_eResult; 2047 public PublishedFileId_t m_nPublishedFileId; 2048 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] 2049 public AppId_t[] m_rgAppIDs; 2050 public uint m_nNumAppDependencies; // number returned in this struct 2051 public uint m_nTotalNumAppDependencies; // total found 2052 } 2053 2054 //----------------------------------------------------------------------------- 2055 // Purpose: The result of a call to DeleteItem 2056 //----------------------------------------------------------------------------- 2057 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2058 [CallbackIdentity(Constants.k_iClientUGCCallbacks + 17)] 2059 public struct DeleteItemResult_t { 2060 public const int k_iCallback = Constants.k_iClientUGCCallbacks + 17; 2061 public EResult m_eResult; 2062 public PublishedFileId_t m_nPublishedFileId; 2063 } 2064 2065 // callbacks 2066 //----------------------------------------------------------------------------- 2067 // Purpose: called when a connections to the Steam back-end has been established 2068 // this means the Steam client now has a working connection to the Steam servers 2069 // usually this will have occurred before the game has launched, and should 2070 // only be seen if the user has dropped connection due to a networking issue 2071 // or a Steam server update 2072 //----------------------------------------------------------------------------- 2073 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 2074 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 1)] 2075 public struct SteamServersConnected_t { 2076 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 1; 2077 } 2078 2079 //----------------------------------------------------------------------------- 2080 // Purpose: called when a connection attempt has failed 2081 // this will occur periodically if the Steam client is not connected, 2082 // and has failed in it's retry to establish a connection 2083 //----------------------------------------------------------------------------- 2084 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2085 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 2)] 2086 public struct SteamServerConnectFailure_t { 2087 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 2; 2088 public EResult m_eResult; 2089 [MarshalAs(UnmanagedType.I1)] 2090 public bool m_bStillRetrying; 2091 } 2092 2093 //----------------------------------------------------------------------------- 2094 // Purpose: called if the client has lost connection to the Steam servers 2095 // real-time services will be disabled until a matching SteamServersConnected_t has been posted 2096 //----------------------------------------------------------------------------- 2097 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2098 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 3)] 2099 public struct SteamServersDisconnected_t { 2100 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 3; 2101 public EResult m_eResult; 2102 } 2103 2104 //----------------------------------------------------------------------------- 2105 // Purpose: Sent by the Steam server to the client telling it to disconnect from the specified game server, 2106 // which it may be in the process of or already connected to. 2107 // The game client should immediately disconnect upon receiving this message. 2108 // This can usually occur if the user doesn't have rights to play on the game server. 2109 //----------------------------------------------------------------------------- 2110 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2111 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 13)] 2112 public struct ClientGameServerDeny_t { 2113 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 13; 2114 2115 public uint m_uAppID; 2116 public uint m_unGameServerIP; 2117 public ushort m_usGameServerPort; 2118 public ushort m_bSecure; 2119 public uint m_uReason; 2120 } 2121 2122 //----------------------------------------------------------------------------- 2123 // Purpose: called when the callback system for this client is in an error state (and has flushed pending callbacks) 2124 // When getting this message the client should disconnect from Steam, reset any stored Steam state and reconnect. 2125 // This usually occurs in the rare event the Steam client has some kind of fatal error. 2126 //----------------------------------------------------------------------------- 2127 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2128 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 17)] 2129 public struct IPCFailure_t { 2130 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 17; 2131 public byte m_eFailureType; 2132 } 2133 2134 //----------------------------------------------------------------------------- 2135 // Purpose: Signaled whenever licenses change 2136 //----------------------------------------------------------------------------- 2137 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 2138 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 25)] 2139 public struct LicensesUpdated_t { 2140 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 25; 2141 } 2142 2143 //----------------------------------------------------------------------------- 2144 // callback for BeginAuthSession 2145 //----------------------------------------------------------------------------- 2146 [StructLayout(LayoutKind.Sequential, Pack = 4)] 2147 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 43)] 2148 public struct ValidateAuthTicketResponse_t { 2149 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 43; 2150 public CSteamID m_SteamID; 2151 public EAuthSessionResponse m_eAuthSessionResponse; 2152 public CSteamID m_OwnerSteamID; // different from m_SteamID if borrowed 2153 } 2154 2155 //----------------------------------------------------------------------------- 2156 // Purpose: called when a user has responded to a microtransaction authorization request 2157 //----------------------------------------------------------------------------- 2158 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2159 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 52)] 2160 public struct MicroTxnAuthorizationResponse_t { 2161 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 52; 2162 2163 public uint m_unAppID; // AppID for this microtransaction 2164 public ulong m_ulOrderID; // OrderID provided for the microtransaction 2165 public byte m_bAuthorized; // if user authorized transaction 2166 } 2167 2168 //----------------------------------------------------------------------------- 2169 // Purpose: Result from RequestEncryptedAppTicket 2170 //----------------------------------------------------------------------------- 2171 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2172 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 54)] 2173 public struct EncryptedAppTicketResponse_t { 2174 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 54; 2175 2176 public EResult m_eResult; 2177 } 2178 2179 //----------------------------------------------------------------------------- 2180 // callback for GetAuthSessionTicket 2181 //----------------------------------------------------------------------------- 2182 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2183 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 63)] 2184 public struct GetAuthSessionTicketResponse_t { 2185 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 63; 2186 public HAuthTicket m_hAuthTicket; 2187 public EResult m_eResult; 2188 } 2189 2190 //----------------------------------------------------------------------------- 2191 // Purpose: sent to your game in response to a steam://gamewebcallback/ command 2192 //----------------------------------------------------------------------------- 2193 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2194 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 64)] 2195 public struct GameWebCallback_t { 2196 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 64; 2197 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] 2198 public string m_szURL; 2199 } 2200 2201 //----------------------------------------------------------------------------- 2202 // Purpose: sent to your game in response to ISteamUser::RequestStoreAuthURL 2203 //----------------------------------------------------------------------------- 2204 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2205 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 65)] 2206 public struct StoreAuthURLResponse_t { 2207 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 65; 2208 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)] 2209 public string m_szURL; 2210 } 2211 2212 //----------------------------------------------------------------------------- 2213 // Purpose: sent in response to ISteamUser::GetMarketEligibility 2214 //----------------------------------------------------------------------------- 2215 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2216 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 66)] 2217 public struct MarketEligibilityResponse_t { 2218 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 66; 2219 [MarshalAs(UnmanagedType.I1)] 2220 public bool m_bAllowed; 2221 public EMarketNotAllowedReasonFlags m_eNotAllowedReason; 2222 public RTime32 m_rtAllowedAtTime; 2223 2224 public int m_cdaySteamGuardRequiredDays; // The number of days any user is required to have had Steam Guard before they can use the market 2225 public int m_cdayNewDeviceCooldown; // The number of days after initial device authorization a user must wait before using the market on that device 2226 } 2227 2228 //----------------------------------------------------------------------------- 2229 // Purpose: sent for games with enabled anti indulgence / duration control, for 2230 // enabled users. Lets the game know whether persistent rewards or XP should be 2231 // granted at normal rate, half rate, or zero rate. 2232 // 2233 // This callback is fired asynchronously in response to timers triggering. 2234 // It is also fired in response to calls to GetDurationControl(). 2235 //----------------------------------------------------------------------------- 2236 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2237 [CallbackIdentity(Constants.k_iSteamUserCallbacks + 67)] 2238 public struct DurationControl_t { 2239 public const int k_iCallback = Constants.k_iSteamUserCallbacks + 67; 2240 2241 public EResult m_eResult; // result of call (always k_EResultOK for asynchronous timer-based notifications) 2242 public AppId_t m_appid; // appid generating playtime 2243 2244 [MarshalAs(UnmanagedType.I1)] 2245 public bool m_bApplicable; // is duration control applicable to user + game combination 2246 public int m_csecsLast5h; // playtime in trailing 5 hour window plus current session, in seconds 2247 public EDurationControlProgress m_progress; // recommended progress 2248 public EDurationControlNotification m_notification; // notification to show, if any (always k_EDurationControlNotification_None for API calls) 2249 } 2250 2251 // callbacks 2252 //----------------------------------------------------------------------------- 2253 // Purpose: called when the latests stats and achievements have been received 2254 // from the server 2255 //----------------------------------------------------------------------------- 2256 [StructLayout(LayoutKind.Explicit, Pack = Packsize.value)] 2257 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 1)] 2258 public struct UserStatsReceived_t { 2259 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 1; 2260 [FieldOffset(0)] 2261 public ulong m_nGameID; // Game these stats are for 2262 [FieldOffset(8)] 2263 public EResult m_eResult; // Success / error fetching the stats 2264 [FieldOffset(12)] 2265 public CSteamID m_steamIDUser; // The user for whom the stats are retrieved for 2266 } 2267 2268 //----------------------------------------------------------------------------- 2269 // Purpose: result of a request to store the user stats for a game 2270 //----------------------------------------------------------------------------- 2271 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2272 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 2)] 2273 public struct UserStatsStored_t { 2274 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 2; 2275 public ulong m_nGameID; // Game these stats are for 2276 public EResult m_eResult; // success / error 2277 } 2278 2279 //----------------------------------------------------------------------------- 2280 // Purpose: result of a request to store the achievements for a game, or an 2281 // "indicate progress" call. If both m_nCurProgress and m_nMaxProgress 2282 // are zero, that means the achievement has been fully unlocked. 2283 //----------------------------------------------------------------------------- 2284 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2285 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 3)] 2286 public struct UserAchievementStored_t { 2287 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 3; 2288 2289 public ulong m_nGameID; // Game this is for 2290 [MarshalAs(UnmanagedType.I1)] 2291 public bool m_bGroupAchievement; // if this is a "group" achievement 2292 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchStatNameMax)] 2293 public string m_rgchAchievementName; // name of the achievement 2294 public uint m_nCurProgress; // current progress towards the achievement 2295 public uint m_nMaxProgress; // "out of" this many 2296 } 2297 2298 //----------------------------------------------------------------------------- 2299 // Purpose: call result for finding a leaderboard, returned as a result of FindOrCreateLeaderboard() or FindLeaderboard() 2300 // use CCallResult<> to map this async result to a member function 2301 //----------------------------------------------------------------------------- 2302 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2303 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 4)] 2304 public struct LeaderboardFindResult_t { 2305 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 4; 2306 public SteamLeaderboard_t m_hSteamLeaderboard; // handle to the leaderboard serarched for, 0 if no leaderboard found 2307 public byte m_bLeaderboardFound; // 0 if no leaderboard found 2308 } 2309 2310 //----------------------------------------------------------------------------- 2311 // Purpose: call result indicating scores for a leaderboard have been downloaded and are ready to be retrieved, returned as a result of DownloadLeaderboardEntries() 2312 // use CCallResult<> to map this async result to a member function 2313 //----------------------------------------------------------------------------- 2314 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2315 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 5)] 2316 public struct LeaderboardScoresDownloaded_t { 2317 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 5; 2318 public SteamLeaderboard_t m_hSteamLeaderboard; 2319 public SteamLeaderboardEntries_t m_hSteamLeaderboardEntries; // the handle to pass into GetDownloadedLeaderboardEntries() 2320 public int m_cEntryCount; // the number of entries downloaded 2321 } 2322 2323 //----------------------------------------------------------------------------- 2324 // Purpose: call result indicating scores has been uploaded, returned as a result of UploadLeaderboardScore() 2325 // use CCallResult<> to map this async result to a member function 2326 //----------------------------------------------------------------------------- 2327 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2328 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 6)] 2329 public struct LeaderboardScoreUploaded_t { 2330 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 6; 2331 public byte m_bSuccess; // 1 if the call was successful 2332 public SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was 2333 public int m_nScore; // the score that was attempted to set 2334 public byte m_bScoreChanged; // true if the score in the leaderboard change, false if the existing score was better 2335 public int m_nGlobalRankNew; // the new global rank of the user in this leaderboard 2336 public int m_nGlobalRankPrevious; // the previous global rank of the user in this leaderboard; 0 if the user had no existing entry in the leaderboard 2337 } 2338 2339 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2340 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 7)] 2341 public struct NumberOfCurrentPlayers_t { 2342 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 7; 2343 public byte m_bSuccess; // 1 if the call was successful 2344 public int m_cPlayers; // Number of players currently playing 2345 } 2346 2347 //----------------------------------------------------------------------------- 2348 // Purpose: Callback indicating that a user's stats have been unloaded. 2349 // Call RequestUserStats again to access stats for this user 2350 //----------------------------------------------------------------------------- 2351 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2352 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 8)] 2353 public struct UserStatsUnloaded_t { 2354 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 8; 2355 public CSteamID m_steamIDUser; // User whose stats have been unloaded 2356 } 2357 2358 //----------------------------------------------------------------------------- 2359 // Purpose: Callback indicating that an achievement icon has been fetched 2360 //----------------------------------------------------------------------------- 2361 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2362 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 9)] 2363 public struct UserAchievementIconFetched_t { 2364 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 9; 2365 2366 public CGameID m_nGameID; // Game this is for 2367 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = Constants.k_cchStatNameMax)] 2368 public string m_rgchAchievementName; // name of the achievement 2369 [MarshalAs(UnmanagedType.I1)] 2370 public bool m_bAchieved; // Is the icon for the achieved or not achieved version? 2371 public int m_nIconHandle; // Handle to the image, which can be used in SteamUtils()->GetImageRGBA(), 0 means no image is set for the achievement 2372 } 2373 2374 //----------------------------------------------------------------------------- 2375 // Purpose: Callback indicating that global achievement percentages are fetched 2376 //----------------------------------------------------------------------------- 2377 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2378 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 10)] 2379 public struct GlobalAchievementPercentagesReady_t { 2380 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 10; 2381 2382 public ulong m_nGameID; // Game this is for 2383 public EResult m_eResult; // Result of the operation 2384 } 2385 2386 //----------------------------------------------------------------------------- 2387 // Purpose: call result indicating UGC has been uploaded, returned as a result of SetLeaderboardUGC() 2388 //----------------------------------------------------------------------------- 2389 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2390 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 11)] 2391 public struct LeaderboardUGCSet_t { 2392 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 11; 2393 public EResult m_eResult; // The result of the operation 2394 public SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was 2395 } 2396 2397 //----------------------------------------------------------------------------- 2398 // Purpose: callback indicating global stats have been received. 2399 // Returned as a result of RequestGlobalStats() 2400 //----------------------------------------------------------------------------- 2401 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2402 [CallbackIdentity(Constants.k_iSteamUserStatsCallbacks + 12)] 2403 public struct GlobalStatsReceived_t { 2404 public const int k_iCallback = Constants.k_iSteamUserStatsCallbacks + 12; 2405 public ulong m_nGameID; // Game global stats were requested for 2406 public EResult m_eResult; // The result of the request 2407 } 2408 2409 // callbacks 2410 //----------------------------------------------------------------------------- 2411 // Purpose: The country of the user changed 2412 //----------------------------------------------------------------------------- 2413 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 2414 [CallbackIdentity(Constants.k_iSteamUtilsCallbacks + 1)] 2415 public struct IPCountry_t { 2416 public const int k_iCallback = Constants.k_iSteamUtilsCallbacks + 1; 2417 } 2418 2419 //----------------------------------------------------------------------------- 2420 // Purpose: Fired when running on a laptop and less than 10 minutes of battery is left, fires then every minute 2421 //----------------------------------------------------------------------------- 2422 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2423 [CallbackIdentity(Constants.k_iSteamUtilsCallbacks + 2)] 2424 public struct LowBatteryPower_t { 2425 public const int k_iCallback = Constants.k_iSteamUtilsCallbacks + 2; 2426 public byte m_nMinutesBatteryLeft; 2427 } 2428 2429 //----------------------------------------------------------------------------- 2430 // Purpose: called when a SteamAsyncCall_t has completed (or failed) 2431 //----------------------------------------------------------------------------- 2432 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2433 [CallbackIdentity(Constants.k_iSteamUtilsCallbacks + 3)] 2434 public struct SteamAPICallCompleted_t { 2435 public const int k_iCallback = Constants.k_iSteamUtilsCallbacks + 3; 2436 public SteamAPICall_t m_hAsyncCall; 2437 public int m_iCallback; 2438 public uint m_cubParam; 2439 } 2440 2441 //----------------------------------------------------------------------------- 2442 // called when Steam wants to shutdown 2443 //----------------------------------------------------------------------------- 2444 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value, Size = 1)] 2445 [CallbackIdentity(Constants.k_iSteamUtilsCallbacks + 4)] 2446 public struct SteamShutdown_t { 2447 public const int k_iCallback = Constants.k_iSteamUtilsCallbacks + 4; 2448 } 2449 2450 //----------------------------------------------------------------------------- 2451 // callback for CheckFileSignature 2452 //----------------------------------------------------------------------------- 2453 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2454 [CallbackIdentity(Constants.k_iSteamUtilsCallbacks + 5)] 2455 public struct CheckFileSignature_t { 2456 public const int k_iCallback = Constants.k_iSteamUtilsCallbacks + 5; 2457 public ECheckFileSignature m_eCheckFileSignature; 2458 } 2459 2460 // k_iSteamUtilsCallbacks + 13 is taken 2461 //----------------------------------------------------------------------------- 2462 // Big Picture gamepad text input has been closed 2463 //----------------------------------------------------------------------------- 2464 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2465 [CallbackIdentity(Constants.k_iSteamUtilsCallbacks + 14)] 2466 public struct GamepadTextInputDismissed_t { 2467 public const int k_iCallback = Constants.k_iSteamUtilsCallbacks + 14; 2468 [MarshalAs(UnmanagedType.I1)] 2469 public bool m_bSubmitted; // true if user entered & accepted text (Call ISteamUtils::GetEnteredGamepadTextInput() for text), false if canceled input 2470 public uint m_unSubmittedText; 2471 } 2472 2473 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2474 [CallbackIdentity(Constants.k_iClientVideoCallbacks + 11)] 2475 public struct GetVideoURLResult_t { 2476 public const int k_iCallback = Constants.k_iClientVideoCallbacks + 11; 2477 public EResult m_eResult; 2478 public AppId_t m_unVideoAppID; 2479 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] 2480 public string m_rgchURL; 2481 } 2482 2483 [StructLayout(LayoutKind.Sequential, Pack = Packsize.value)] 2484 [CallbackIdentity(Constants.k_iClientVideoCallbacks + 24)] 2485 public struct GetOPFSettingsResult_t { 2486 public const int k_iCallback = Constants.k_iClientVideoCallbacks + 24; 2487 public EResult m_eResult; 2488 public AppId_t m_unVideoAppID; 2489 } 2490 2491 } 2492 2493 #endif // !DISABLESTEAMWORKS