Fix ISteamUserStats linking

* Add Examples for SteamAPI, SteamAppList, SteamApps and SteamController.
* Update SteamHTMLSurface example.
* Update Project file to automatically add & copy resources after successful build.

Blitz/BlitzSteam.bb

@@ -1,368 +0,0 @@
-;	BlitzSteam - Steam wrapper for Blitz
-;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
-;
-;	This program is free software: you can redistribute it and/or modify
-;	it under the terms of the GNU Lesser General Public License as
-;	published by the Free Software Foundation, either version 3 of the 
-;	License, or (at your option) any later version.
-;
-;	This program is distributed in the hope that it will be useful,
-;	but WITHOUT ANY WARRANTY; without even the implied warranty of
-;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;	GNU General Public License for more details.
-;
-;	You should have received a copy of the GNU Lesser General Public License
-;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
-
-; Steam -------------------------------------------------------------------------
-
-; SteamClient -------------------------------------------------------------------
-Const BS_EAccountType_Invalid								= 0
-Const BS_EAccountType_Individual							= 1
-Const BS_EAccountType_Multiseat								= 2
-Const BS_EAccountType_Gameserver							= 3
-Const BS_EAccountType_AnonGamerserver						= 4
-Const BS_EAccountType_Pending								= 5
-Const BS_EAccountType_ContentServer							= 6
-Const BS_EAccountType_Clan									= 7
-Const BS_EAccountType_Chat									= 8
-Const BS_EAccountType_ConsoleUser							= 9
-Const BS_EAccountType_AnonUser								= 10
-
-Const BS_ECallback_SteamAppListCallbacks					= 3900
-Const BS_ECallback_SteamAppsCallbacks						= 1000
-Const BS_ECallback_SteamBillingCallbacks					= 400
-Const BS_ECallback_SteamContentServerCallbacks				= 600
-Const BS_ECallback_SteamControllerCallbacks					= 2800
-Const BS_ECallback_SteamFriendsCallbacks					= 300
-Const BS_ECallback_SteamGameCoordinatorCallbacks			= 1700
-Const BS_ECallback_SteamGameServerCallbacks					= 200
-Const BS_ECallback_SteamGameServerItemsCallbacks			= 1500
-Const BS_ECallback_SteamGameServerStatsCallbacks			= 1800
-Const BS_ECallback_SteamGameStatsCallbacks					= 2000
-Const BS_ECallback_SteamHTMLSurfaceCallbacks				= 4500
-Const BS_ECallback_SteamMatchmakingCallbacks				= 500
-Const BS_ECallback_SteamMusicCallbacks						= 4000
-Const BS_ECallback_SteamMusicRemoteCallbacks				= 4100
-Const BS_ECallback_SteamNetworkingCallbacks					= 1200
-Const BS_ECallback_SteamReservedCallbacks					= 4400
-Const BS_ECallback_SteamScreenshotsCallbacks				= 2300
-Const BS_ECallback_SteamStreamLauncherCallbacks				= 2600
-Const BS_ECallback_SteamStreamClientCallbacks				= 3500
-Const BS_ECallback_SteamUserCallbacks						= 100
-Const BS_ECallback_SteamUserStatsCallbacks					= 1100
-Const BS_ECallback_SteamUtilsCallbacks						= 700
-Const BS_ECallback_Steam2AsyncCallbacks						= 1900
-Const BS_ECallback_ClientAudioCallbacks						= 2400
-Const BS_ECallback_ClientControllerCallbacks				= 2700
-Const BS_ECallback_ClientDepotBuilderCallbacks				= 1400
-Const BS_ECallback_ClientDeviceAuthCallbacks				= 3000
-Const BS_ECallback_ClientFriendsCallbacks					= 800
-Const BS_ECallback_ClientHTTPCallbacks						= 2100
-Const BS_ECallback_ClientInventoryCallbacks					= 4700
-Const BS_ECallback_ClientMusicCallbacks						= 3200
-Const BS_ECallback_ClientNetworkDeviceManagerCallbacks		= 3100
-Const BS_ECallback_ClientParentalSettingsCallbacks			= 2900
-Const BS_ECallback_ClientProductBuilderCallbacks			= 3600
-Const BS_ECallback_ClientRemoteStorageCallbacks				= 1300
-Const BS_ECallback_ClientRemoteClientManagerCallbacks		= 3300
-Const BS_ECallback_ClientRemoteControlManagerCallbacks		= 3800
-Const BS_ECallback_ClientReservedCallbacks					= 4300
-Const BS_ECallback_ClientScreenshotsCallbacks				= 2200
-Const BS_ECallback_ClientShortcutsCallbacks					= 3700
-Const BS_ECallback_ClientUGCCallbacks						= 3400
-Const BS_ECallback_ClientUnifiedMessagesCallbacks			= 2500
-Const BS_ECallback_ClientUserCallbacks						= 900
-Const BS_ECallback_ClientUtilsCallbacks						= 1600
-Const BS_ECallback_ClientVideoCallbacks						= 4600
-Const BS_ECallback_ClientVRCallbacks							= 4200
-
-; SteamAppList ------------------------------------------------------------------
-Const BS_CALLBACK_AppInstalled								= BS_ECallback_SteamAppListCallbacks + 1
-Const BS_CALLBACK_AppUninstalled							= BS_ECallback_SteamAppListCallbacks + 2
-
-
-; SteamApps ---------------------------------------------------------------------
-Const BS_CALLBACK_DLCInstalled								= BS_ECallback_SteamAppsCallbacks + 5
-Const BS_CALLBACK_APPProofOfPurchaseKeyResponse				= BS_ECallback_SteamAppsCallbacks + 13
-Const BS_CALLBACK_NewLaunchQueryParameters					= BS_ECallback_SteamAppsCallbacks + 14
-; The following things are PS3 only:
-;   ERegisterActivationCodeResult
-;   RegisterActivationCodeResponse_t
-
-; SteamController ---------------------------------------------------------------
-Const BS_MASK_RIGHT_TRIGGER									= $00000001
-Const BS_MASK_LEFT_TRIGGER									= $00000002
-Const BS_MASK_RIGHT_BUMPER									= $00000004
-Const BS_MASK_LEFT_BUMPER									= $00000008
-Const BS_MASK_BUTTON_0										= $00000010
-Const BS_MASK_BUTTON_1										= $00000020
-Const BS_MASK_BUTTON_2										= $00000040
-Const BS_MASK_BUTTON_3										= $00000080
-Const BS_MASK_TOUCH_0										= $00000100
-Const BS_MASK_TOUCH_1										= $00000200
-Const BS_MASK_TOUCH_2										= $00000400
-Const BS_MASK_TOUCH_3										= $00000800
-Const BS_MASK_BUTTON_MENU									= $0001000
-Const BS_MASK_BUTTON_STEAM							        = $0002000
-Const BS_MASK_BUTTON_ESCAPE									= $0004000
-Const BS_MASK_BUTTON_BACK_LEFT							    = $0008000
-Const BS_MASK_BUTTON_BACK_RIGHT								= $0010000
-Const BS_MASK_BUTTON_LEFTPAD_CLICKED						= $0020000
-Const BS_MASK_BUTTON_RIGHTPAD_CLICKED						= $0040000
-Const BS_MASK_LEFTPAD_FINGERDOWN							= $0080000
-Const BS_MASK_RIGHTPAD_FINGERDOWN							= $0100000
-Const BS_MASK_JOYSTICK_BUTTON								= $0400000
-Const BS_ESteamControllerPad_Left							= 0
-Const BS_ESteamControllerPad_Right							= 1
-
-Type BS_ControllerState
-	Field unPacketNum%
-	Field ulButtonsL%, ulButtonsR%
-	Field sLeftPadXY ; Left/High = X, Right/Low = Y
-	Field sRightPadXY ; Left/High = X, Right/Low = Y
-End Type
-
-; SteamFriends ------------------------------------------------------------------
-Const BS_EFriendRelationShip_None							= 0
-Const BS_EFriendRelationShip_Blocked						= 1
-Const BS_EFriendRelationShip_RequestRecipient				= 2
-Const BS_EFriendRelationShip_Friend							= 3
-Const BS_EFriendRelationShip_RequestInitiator				= 4
-Const BS_EFriendRelationShip_Ignored						= 5
-Const BS_EFriendRelationShip_IgnoredFriend					= 6
-Const BS_EFriendRelationShip_Suggested						= 7
-
-Const BS_EPersonaState_Offline								= 0
-Const BS_EPersonaState_Online								= 1
-Const BS_EPersonaState_Busy									= 2
-Const BS_EPersonaState_Away									= 3
-Const BS_EPersonaState_Snooze								= 4
-Const BS_EPersonaState_LookingToTrade						= 5
-Const BS_EPersonaState_LookingToPlay						= 6
-
-Const BS_EFriendFlags_None									= $00000000
-Const BS_EFriendFlags_Blocked								= $00000001
-Const BS_EFriendFlags_FriendshipRequested					= $00000002
-Const BS_EFriendFlags_Immediate								= $00000004
-Const BS_EFriendFlags_ClanMember							= $00000008
-Const BS_EFriendFlags_OnGameServer							= $00000010
-Const BS_EFriendFlags_RequestingFriendship					= $00000080
-Const BS_EFriendFlags_RequestingInfo						= $00000100
-Const BS_EFriendFlags_Ignored								= $00000200
-Const BS_EFriendFlags_IgnoredFriend							= $00000400
-Const BS_EFriendFlags_Suggested								= $00000800
-Const BS_EFriendFlags_All									= $0000FFFF
-
-Const BS_cchMaxFriendsGroupName								= 64
-Const BS_cFriendsGroupLimit									= 100
-Const BS_FriendsGroupID_Invalid								= -1
-Const BS_cEnumerateFollowersMax								= 50
-Const BS_cchPersonaNameMax									= 128
-Const BS_cwchPersonaNameMax									= 32
-
-Type BS_FriendGameInfo
-	Field m_gameID%
-	Field m_unGameIP%
-	Field m_usGamePortQueryPort% ; Left/High GamePort, Right/Low QueryPort
-	Field m_steamIDLobby%
-End Type
-
-Const BS_EUserRestrictionNone								= 0
-Const BS_EUserRestrictionUnknown							= 1
-Const BS_EUserRestrictionAnyChat							= 2
-Const BS_EUserRestrictionVoiceChat							= 4
-Const BS_EUserRestrictionGroupChat							= 8
-Const BS_EUserRestrictionRating								= 16
-Const BS_EUserRestrictionGameInvites						= 32
-Const BS_EUserRestrictionTrading							= 64
-
-Type BS_FriendSessionStateInfo
-	Field m_uiOnlineSessionInstances
-	Field m_uiPublishedToFriendsSessionInstance
-End Type
-
-Const BS_cubChatMetadataMax									= 8192
-Const BS_cchMaxRichPresenceKeys								= 20
-Const BS_cchMaxRichPresenceKeyLength						= 64
-Const BS_cchMaxRichPresenceValueLength						= 256
-
-Const BS_EOverlayToStoreFlag_None							= 0
-Const BS_EOverlayToStoreFlag_AddToCart						= 1
-Const BS_EOverlayToStoreFlag_AddToCartAndShow				= 2
-
-Const BS_EPersonaChange_Name								= $0001
-Const BS_EPersonaChange_Status								= $0002
-Const BS_EPersonaChange_ComeOnline							= $0004
-Const BS_EPersonaChange_GoneOffline							= $0008
-Const BS_EPersonaChange_GamePlayed							= $0010
-Const BS_EPersonaChange_GameServer							= $0020
-Const BS_EPersonaChange_Avatar								= $0040
-Const BS_EPersonaChange_JoinedSource						= $0080
-Const BS_EPersonaChange_LeftSource							= $0100
-Const BS_EPersonaChange_RelationshipChanged					= $0200
-Const BS_EPersonaChange_NameFirstSet						= $0400
-Const BS_EPersonaChange_FacebookInfo						= $0800
-Const BS_EPersonaChange_Nickname							= $1000
-Const BS_EPersonaChange_SteamLevel							= $2000
-
-Const BS_CALLBACK_PersonaStateChange						= BS_ECallback_SteamFriendsCallbacks + 4
-Const BS_CALLBACK_GameOverlayActivated						= BS_ECallback_SteamFriendsCallbacks + 31
-Const BS_CALLBACK_GameServerChangeRequested					= BS_ECallback_SteamFriendsCallbacks + 32
-Const BS_CALLBACK_GameLobbyJoinRequested					= BS_ECallback_SteamFriendsCallbacks + 33
-Const BS_CALLBACK_AvatarImageLoaded							= BS_ECallback_SteamFriendsCallbacks + 34
-Const BS_CALLBACK_ClanOfficerListResponse					= BS_ECallback_SteamFriendsCallbacks + 35
-Const BS_CALLBACK_FriendRichPresenceUpdate					= BS_ECallback_SteamFriendsCallbacks + 36
-Const BS_CALLBACK_GameRichPresenceJoinRequested				= BS_ECallback_SteamFriendsCallbacks + 37
-Const BS_CALLBACK_GameConnectedClanChatMsg					= BS_ECallback_SteamFriendsCallbacks + 38
-Const BS_CALLBACK_GameConnectedChatJoin						= BS_ECallback_SteamFriendsCallbacks + 39
-Const BS_CALLBACK_GameConnectedChatLeave					= BS_ECallback_SteamFriendsCallbacks + 40
-Const BS_CALLBACK_DownloadClanActivityCountsResult			= BS_ECallback_SteamFriendsCallbacks + 41
-Const BS_CALLBACK_JoinClanChatRoomCompletionResult			= BS_ECallback_SteamFriendsCallbacks + 42
-Const BS_CALLBACK_GameConnectedFriendChatMsg				= BS_ECallback_SteamFriendsCallbacks + 43
-Const BS_CALLBACK_FriendsGetFollowerCount					= BS_ECallback_SteamFriendsCallbacks + 44
-Const BS_CALLBACK_FriendsIsFollowing						= BS_ECallback_SteamFriendsCallbacks + 45
-Const BS_CALLBACK_FriendsEnumerateFollowingList				= BS_ECallback_SteamFriendsCallbacks + 46
-Const BS_CALLBACK_SetPersonaNameResponse					= BS_ECallback_SteamFriendsCallbacks + 47
-
-; SteamGameServer ---------------------------------------------------------------
-Const BS_EServerMode_Invalid								= 0
-Const BS_EServerMode_NoAuthentication						= 1
-Const BS_EServerMode_Authentication							= 2
-Const BS_EServerMode_AuthenticationAndSecure				= 3
-
-; SteamUser ---------------------------------------------------------------------
-Const BS_EVoiceResult_OK									= 0
-Const BS_EVoiceResult_NotInitialized						= 1
-Const BS_EVoiceResult_NotRecording							= 2
-Const BS_EVoiceResult_NoData								= 3
-Const BS_EVoiceResult_BufferTooSmall						= 4
-Const BS_EVoiceResult_DataCorrupted							= 5
-Const BS_EVoiceResult_Restricted							= 6
-Const BS_EVoiceResult_UnsupportedCodec						= 7
-Const BS_EVoiceResult_ReceiverOutOfDate						= 8
-Const BS_EVoiceResult_ReceiverDidNotAnswer					= 9
-
-Const BS_EBeginAuthSessionResult_OK							= 0	; Ticket is valid for this game and this steamID.
-Const BS_EBeginAuthSessionResult_InvalidTicket				= 1	; Ticket is not valid.
-Const BS_EBeginAuthSessionResult_DuplicateRequest			= 2	; A ticket has already been submitted for this steamID
-Const BS_EBeginAuthSessionResult_InvalidVersion				= 3	; Ticket is from an incompatible interface version
-Const BS_EBeginAuthSessionResult_GameMismatch				= 4	; Ticket is not for this game
-Const BS_EBeginAuthSessionResult_ExpiredTicket				= 5	; Ticket has expired
-
-Const BS_EUserHasLicenseResult_HasLicense					= 0 ; User has a license for specified app
-Const BS_EUserHasLicenseResult_DoesNotHaveLicense			= 1 ; User does not have a license for the specified app
-Const BS_EUserHasLicenseResult_NoAuth						= 2 ; User has not been authenticated
-
-; SteamUserStats ----------------------------------------------------------------
-Const BS_cchStatNameMax										= 128
-Const BS_cchLeaderboardNameMax								= 128
-Const BS_k_cLeaderboardDetailsMax							= 64
-
-Const BS_ELeaderboardDataRequest_Global						= 0
-Const BS_ELeaderboardDataRequest_GlobalAroundUser			= 1
-Const BS_ELeaderboardDataRequest_Friends					= 2
-Const BS_ELeaderboardDataRequest_Users						= 3
-
-Const BS_ELeaderboardSortMethod_None						= 0
-Const BS_ELeaderboardSortMethod_Ascending					= 1 ; top-score is lowest number
-Const BS_ELeaderboardSortMethod_Descending					= 2	; top-score is highest number
-
-Const BS_ELeaderboardDisplayType_None						= 0
-Const BS_ELeaderboardDisplayType_Numeric					= 1 ; simple numerical score
-Const BS_ELeaderboardDisplayType_TimeSeconds				= 2 ; the score represents a time, in seconds
-Const BS_ELeaderboardDisplayType_TimeMilliSeconds			= 3 ; the score represents a time, in milliseconds
-
-Const BS_ELeaderboardUploadScoreMethod_None					= 0
-Const BS_ELeaderboardUploadScoreMethod_KeepBest				= 1 ; Leaderboard will keep user's best score
-Const BS_ELeaderboardUploadScoreMethod_ForceUpdate			= 2 ; Leaderboard will always replace score with specified
-
-Type BS_LeaderboardEntry
-	Field SteamId_High%, SteamId_Low%
-	Field nGlobalRank%
-	Field nScore%
-	Field cDetails%
-	Field hUGC_High%, hUGC_Low%
-End Type
-
-Const BS_CALLBACK_UserStatsReceived							= BS_ECallback_SteamUserStatsCallbacks + 1
-Type BS_UserStatsReceived
-	Field nGameId_High%, nGameId_Low%						; Game these stats are for
-	Field eResult%											; Success / error fetching the stats
-	Field steamIDUser_High%, steamIDUser_Low%				; The user for whom the stats are retrieved for
-End Type
-
-Const BS_CALLBACK_UserStatsStored							= BS_ECallback_SteamUserStatsCallbacks + 2
-Type BS_UserStatsStored
-	Field nGameId_High%, nGameId_Low%						; Game these stats are for
-	Field eResult%											; Success / error 
-End Type
-
-Const BS_CALLBACK_UserAchievementStored						= BS_ECallback_SteamUserStatsCallbacks + 3
-Type BS_UserAchievementStored
-	Field nGameId_High%, nGameId_Low%						; Game this is for
-	Field bGroupAchievement%								; if this is a "group" achievement
-	Field rgchAchievementName[BS_cchStatNameMax]			; name of the achievement
-	Field nCurProgress										; current progress towards the achievement
-	Field nMaxProgress										; "out of" this many
-End Type
-
-Const BS_CALLBACK_LeaderboardFindResult						= BS_ECallback_SteamUserStatsCallbacks + 4
-Type BS_LeaderboardFindResult
-	Field hSteamLeaderboard_High%, hSteamLeaderboard_Low%	;	// handle to the leaderboard serarched for, 0 if no leaderboard found
-	Field bLeaderboardFound%								;				// 0 if no leaderboard found
-End Type
-
-Const BS_CALLBACK_LeaderboardScoresDownloaded				= BS_ECallback_SteamUserStatsCallbacks + 5
-Type BS_LeaderboardScoresDownloaded
-	Field hSteamLeaderboard_High, hSteamLeaderboard_Low		;
-	Field hSteamLeaderboardEntries_High, hSteamLeaderboardEntries_Low; the handle to pass into GetDownloadedLeaderboardEntries()
-	Field cEntryCount										; the number of entries downloaded
-End Type
-
-Const BS_CALLBACK_LeaderboardScoreUploaded					= BS_ECallback_SteamUserStatsCallbacks + 6
-Type BS_LeaderboardScoreUploaded
-	Field bSuccess											; 1 if the call was successful
-	Field hSteamLeaderboard_High, hSteamLeaderboard_Low		; the leaderboard handle that was
-	Field nScore											; the score that was attempted to set
-	Field bScoreChanged										; true if the score in the leaderboard change, false if the existing score was better
-	Field nGlobalRankNew									; the new global rank of the user in this leaderboard
-	Field nGlobalRankPrevious								; the previous global rank of the user in this leaderboard; 0 if the user had no existing entry in the leaderboard
-End Type
-
-Const BS_CALLBACK_NumberOfCurrentPlayers					= BS_ECallback_SteamUserStatsCallbacks + 7
-Type BS_NumberOfCurrentPlayers
-	Field bSuccess											; 1 if the call was successful
-	Field cPlayers											; Number of players currently playing
-End Type
-
-Const BS_CALLBACK_UserStatsUnloaded							= BS_ECallback_SteamUserStatsCallback + 8
-Type BS_UserStatsUnloaded
-	Field steamIDUser_High, steamIDUser_Low					; User whose stats have been unloaded
-End Type
-
-Const BS_CALLBACK_UserAchievementIconFetched				= BS_ECallback_SteamUserStatsCallback + 9
-Type BS_UserAchievementIconFetched
-	Field nGameID_High, nGameID_Low							; Game this is for
-	Field rgchAchievementName[BS_cchStatNameMax]			; name of the achievement
-	Field bAchieved											; Is the icon for the achieved or not achieved version?
-	Field nIconHandle										; Handle to the image, which can be used in SteamUtils()->GetImageRGBA(), 0 means no image is set for the achievement
-End Type
-
-Const BS_CALLBACK_GlobalAchievementPercentagesReady			= BS_ECallback_SteamUserStatsCallback + 10
-Type BS_GlobalAchievementPercentagesReady
-	Field nGameID_High, nGameID_Low							; Game this is for
-	Field eResult											; Result of the operation
-End Type
-
-Const BS_CALLBACK_LeaderboardUGCSet							= BS_ECallback_SteamUserStatsCallback + 11
-Type BS_LeaderboardUGCSet
-	Field eResult											; The result of the operation
-	Field hSteamLeaderboard_High, hSteamLeaderboard_Low		; the leaderboard handle that was
-End Type
-
-Const BS_CALLBACK_GlobalStatsReceived						= BS_ECallback_SteamUserStatsCallback + 12
-Type BS_GlobalStatsReceived
-	Field nGameID_High, nGameId_Low							; Game global stats were requested for
-	Field eResult											; The result of the request
-End Type

Blitz/BlitzSteam.decls

@@ -1,356 +0,0 @@
-;	BlitzSteam - Steam wrapper for Blitz
-;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
-;
-;	This program is free software: you can redistribute it and/or modify
-;	it under the terms of the GNU Lesser General Public License as
-;	published by the Free Software Foundation, either version 3 of the 
-;	License, or (at your option) any later version.
-;
-;	This program is distributed in the hope that it will be useful,
-;	but WITHOUT ANY WARRANTY; without even the implied warranty of
-;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;	GNU General Public License for more details.
-;
-;	You should have received a copy of the GNU Lesser General Public License
-;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
-
-.lib "BlitzSteam.dll"
-; Helpers -----------------------------------------------------------------------
-; -- CSteamID
-BS_CSteamID_New%()
-BS_CSteamID_FromID%(unAccountID%, eUniverse%, eAccountType%)
-BS_CSteamID_FromIDInstance%(unAccountID%, unInstance%, eUniverse%, eAccountType%)
-BS_CSteamID_FromSteamID%(ulSteamID%)
-BS_CSteamID_Copy%(pSteamID%)
-BS_CSteamID_Destroy(pSteamID%)
-BS_CSteamID_Set(pSteamID%, unAccountID%, eUniverse%, eAccountType%)
-BS_CSteamID_InstancedSet(pSteamID%, unAccountID%, unInstance%, eUniverse%, eAccountType%)
-BS_CSteamID_FullSet(pSteamID%, ulIdentifier%, eUniverse%, eAccountType%)
-BS_CSteamID_SetFromUInt64(pSteamID%, ulSteamID%)
-BS_CSteamID_Clear(pSteamID%)
-BS_CSteamID_ConvertToUInt64%(pSteamID%)
-BS_CSteamID_GetStaticAccountKey%(pSteamID%)
-BS_CSteamID_CreateBlankAnonLogon(pSteamID%, eUniverse%)
-BS_CSteamID_CreateBlankAnonUserLogon(pSteamID%, eUniverse%)
-BS_CSteamID_BlankAnonAccount%(pSteamID%)
-BS_CSteamID_GameServerAccount%(pSteamID%)
-BS_CSteamID_PersistentGameServerAccount%(pSteamID%)
-BS_CSteamID_AnonGameServerAccount%(pSteamID%)
-BS_CSteamID_ContentServerAccount%(pSteamID%)
-BS_CSteamID_ClanAccount%(pSteamID%)
-BS_CSteamID_ChatAccount%(pSteamID%)
-BS_CSteamID_IsLobby%(pSteamID%)
-BS_CSteamID_IndividualAccount%(pSteamID%)
-BS_CSteamID_AnonAccount%(pSteamID%)
-BS_CSteamID_AnonUserAccount%(pSteamID%)
-BS_CSteamID_ConsoleUserAccount%(pSteamID%)
-BS_CSteamID_SetAccountID(pSteamID%, unAccountID%)
-BS_CSteamID_SetAccountInstance(pSteamID, unInstance%)
-BS_CSteamID_ClearIndividualInstance(pSteamID%)
-BS_CSteamID_HasNoIndividualInstance%(pSteamID%)
-BS_CSteamID_GetAccountID%(pSteamID%)
-BS_CSteamID_GetAccountInstance%(pSteamID%)
-BS_CSteamID_GetEAccountType%(pSteamID%)
-BS_CSteamID_GetEUniverse%(pSteamID%)
-BS_CSteamID_SetEUniverse(pSteamID%, eUniverse%)
-BS_CSteamID_IsValid%(pSteamID%)
-BS_CSteamID_Compare%(pSteamID%, pSteamIDOther%)
-
-; Steam -------------------------------------------------------------------------
-BS_Init%()
-BS_Shutdown()
-BS_IsSteamRunning%()
-BS_RestartAppIfNecessary%(unOwnAppID%)
-BS_SetMiniDumpComment(pchMsg$)
-BS_WriteMiniDump(uStructuredExceptionCode%, pvExceptionInfo*, uBuildID%)
-BS_WriteMiniDumpEx(uStructuredExceptionCode%, pvExceptionInfo%, uBuildID%) : "BS_WriteMiniDump"
-; -- Interfaces
-BS_AppList%()
-BS_Apps%()
-BS_Client%()
-BS_Controller%()
-BS_Friends%()
-BS_HTTP%()
-BS_HTMLSurface%()
-BS_Inventory%()
-BS_Matchmaking%()
-BS_MatchmakingServers%()
-BS_Music%()
-BS_MusicRemote%()
-BS_Networking%()
-BS_RemoteStorage%()
-BS_Screenshots%()
-BS_UGC%()
-BS_UnifiedMessages%()
-BS_User%()
-BS_UserStats%()
-BS_Utils%()
-BS_Video%()
-; -- Callbacks & Hooks
-BS_RunCallbacks()
-BS_RegisterCallback(pCallback%, iCallback%)
-BS_UnregisterCallback(pCallback%)
-BS_RegisterCallResult(pCallback%, hAPICall_L%, hAPICall_R%)
-BS_UnregisterCallResult(pCallback%, hAPICall_L%, hAPICall_R%)
-
-; SteamAppList ------------------------------------------------------------------
-BS_AppList_GetNumInstalledApps%(lpSteamAppList%)
-BS_AppList_GetInstalledApps%(lpSteamAppList%, pvecAppID*, unMaxIDs%)
-BS_AppList_GetInstalledAppsEx%(lpSteamAppList%, pvecAppID%, unMaxIDs%) : "BS_AppList_GetInstalledApps"
-BS_AppList_GetAppNameEx%(lpSteamAppList%, nAppId%, pchName%, cchNameMax%) : "BS_AppList_GetAppName"
-BS_AppList_GetAppName%(lpSteamAppList%, nAppId%, pchName*, cchNameMax%)
-BS_AppList_GetAppInstallDir%(lpSteamAppList%, nAppId%, pchDirectory*, cchDirectoryMax%)
-BS_AppList_GetAppInstallDirEx%(lpSteamAppList%, nAppId%, pchDirectory%, cchDirectoryMax%) : "BS_AppList_GetAppInstallDir"
-BS_AppList_GetAppBuildId%(lpSteamAppList%, nAppId%)
-
-; SteamApps ---------------------------------------------------------------------
-BS_Apps_IsSubscribed%(lpSteamApps%)
-BS_Apps_IsLowViolence%(lpSteamApps%)
-BS_Apps_IsCybercafe%(lpSteamApps%)
-BS_Apps_IsVACBanned%(lpSteamApps%)
-BS_Apps_GetCurrentGameLanguage$(lpSteamApps%)
-BS_Apps_GetAvailableGameLanguages$(lpSteamApps%)
-BS_Apps_IsSubscribedApp%(lpSteamApps%, appID%)
-BS_Apps_IsDlcInstalled%(lpSteamApps%, appID%)
-BS_Apps_GetEarliestPurchaseUnixTime%(lpSteamApps%, appID%)
-BS_Apps_IsSubscribedFromFreeWeekend%(lpSteamApps%)
-BS_Apps_GetDLCCount%(lpSteamApps%)
-BS_Apps_GetDLCDataByIndex%(lpSteamApps%, iDLC%, pAppId*, pbAvailable*, pchName*, cchNameBufferSize%)
-BS_Apps_GetDLCDataByIndexEx%(lpSteamApps%, iDLC%, pAppId%, pbAvailable%, pchName%, cchNameBufferSize%) : "BS_Apps_GetDLCDataByIndex"
-BS_Apps_InstallDLC(lpSteamApps%, nAppID%)
-BS_Apps_UninstallDLC(lpSteamApps%, nAppID%)
-BS_Apps_RequestAppProofOfPurchaseKey(lpSteamApps%, nAppID%)
-BS_Apps_GetCurrentBetaName%(lpSteamApps%, pchName*, cchNameBufferSize%)
-BS_Apps_GetCurrentBetaNameEx%(lpSteamApps%, pchName%, cchNameBufferSize%) : "BS_Apps_GetCurrentBetaName"
-BS_Apps_MarkContentCorrupt%(lpSteamApps%, bMissingFilesOnly%)
-BS_Apps_GetInstalledDepots%(lpSteamApps%, nAppID%, pvecDepots*, cMaxDepots%)
-BS_Apps_GetInstalledDepotsEx%(lpSteamApps%, nAppID%, pvecDepots%, cMaxDepots%) : "BS_Apps_GetInstalledDepots"
-BS_Apps_GetAppInstallDir%(lpSteamApps%, nAppID%, pchFolder*, cchFolderBufferSize%)
-BS_Apps_GetAppInstallDirEx%(lpSteamApps%, nAppID%, pchFolder%, cchFolderBufferSize%) : "BS_Apps_GetAppInstallDir"
-BS_Apps_IsAppInstalled%(lpSteamApps%, nAppID%)
-BS_Apps_GetAppOwner%(lpSteamApps%)
-BS_Apps_GetLaunchQueryParam$(lpSteamApps%, pchKey$)
-BS_Apps_GetDlcDownloadProgress%(lpSteamApps%, nAppID%, punBytesDownloaded*, punBytesTotal*)
-BS_Apps_GetDlcDownloadProgressEx%(lpSteamApps%, nAppID%, punBytesDownloaded%, punBytesTotal%) : "BS_Apps_GetDlcDownloadProgress"
-BS_Apps_GetAppBuildId%(lpSteamApps%)
-
-; SteamClient -------------------------------------------------------------------
-BS_Client_CreateSteamPipe%(lpSteamClient%)
-BS_Client_ReleaseSteamPipe%(lpSteamClient%, hSteamPipe%)
-BS_Client_ConnectToGlobalUser%(lpSteamClient%, hSteamPipe%)
-BS_Client_SetLocalIPBinding(lpSteamClient, unIP%, usPort%)
-BS_Client_CreateLocalUser%(lpSteamClient%, phSteamPipe%, eAccountType%)
-BS_Client_ReleaseUser(lpSteamClient%, hSteamPipe%, hSteamUser%)
-BS_Client_RunFrame(lpSteamClient%)
-BS_Client_GetIPCCallCount%(lpSteamClient%)
-BS_Client_ShutdownIfAllPipesClosed%(lpSteamClient%)
-; -- Interfaces
-BS_Client_GetSteamAppList%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamApps%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamController%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamFriends%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamGameServer%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamGameServerStats%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamHTMLSurface%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamHTTP%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamInventory%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamMatchmaking%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamMatchmakingServers%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamMusic%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamMusicRemote%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamNetworking%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamRemoteStorage%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamScreenshots%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamUGC%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamUnifiedMessages%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamUser%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamUserStats%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamUtils%(lpSteamClient%, hSteamPipe%, pchVersion$)
-BS_Client_GetSteamVideo%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$)
-; -- Callbacks & Hooks
-BS_Client_SetWarningMessageHook(lpSteamClient%, fpFunction%)
-BS_Client_Set_SteamAPI_CPostAPIResultInProcess(lpSteamClient%, fpFunction%)
-BS_Client_Remove_SteamAPI_CPostAPIResultInProcess(lpSteamClient%, fpFunction%)
-BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess(lpSteamClient%, fpFunction%)
-
-; SteamController ---------------------------------------------------------------
-BS_Controller_Init%(lpSteamController%, pchAbsolutePathToControllerConfigVDF$)
-BS_Controller_Shutdown%(lpSteamController%)
-BS_Controller_RunFrame(lpSteamController%)
-BS_Controller_GetControllerStateEx%(lpSteamController%, unControllerIndex%, pState%) : "BS_Controller_GetControllerState"
-BS_Controller_GetControllerState%(lpSteamController%, unControllerIndex%, pState*)
-BS_Controller_TriggerHapticPulse(lpSteamController%, unControllerIndex%, eTargetPad%, usDurationMicroSec%)
-BS_Controller_SetOverrideMode(lpSteamController%, pchMode$)
-
-; SteamFriends ------------------------------------------------------------------
-BS_Friends_GetPersonaName$(lpSteamFriends%)
-BS_Friends_SetPersonaName%(lpSteamFriends%, pchPersonaName$)
-BS_Friends_GetPersonaState%(lpSteamFriends%)
-BS_Friends_GetFriendCount%(lpSteamFriends%, iFriendFlags%)
-BS_Friends_GetFriendByIndex%(lpSteamFriends%, iFriend%, iFriendFlags%)
-BS_Friends_GetFriendRelationship%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetFriendPersonaState%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetFriendPersonaName$(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetFriendGamePlayed%(lpSteamFriends%, steamIDFriend%, pFriendGameInfo*)
-BS_Friends_GetFriendGamePlayedEx%(lpSteamFriends%, steamIDFriend%, pFriendGameInfo%) : "BS_Friends_GetFriendGamePlayed"
-BS_Friends_GetFriendPersonaNameHistory$(lpSteamFriends%, steamIDFriend%, iPersonaName%)
-BS_Friends_GetFriendSteamLevel%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetPlayerNickname$(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetFriendsGroupCount%(lpSteamFriends%)
-BS_Friends_GetFriendsGroupIDByIndex%(lpSteamFriends%, friendsGroupID%)
-BS_Friends_GetFriendsGroupName$(lpSteamFriends%, friendsGroupID%)
-BS_Friends_GetFriendsGroupMembersCount%(lpSteamFriends%, friendsGroupID%)
-BS_Friends_GetFriendsGroupMembersList(lpSteamFriends%, friendsGroupID%, pOutSteamIDMembers*, nMembersCount%)
-BS_Friends_GetFriendsGroupMembersListEx(lpSteamFriends%, friendsGroupID%, pOutSteamIDMembers%, nMembersCount%) : "BS_Friends_GetFriendsGroupMembersList"
-BS_Friends_HasFriend(lpSteamFriends%, steamIDFriend%, iFriendFlags%)
-BS_Friends_GetClanCount%(lpSteamFriends%)
-BS_Friends_GetClanByIndex%(lpSteamFriends%, iClan%)
-BS_Friends_GetClanName$(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetClanTag$(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetClanActivityCounts%(lpSteamFriends%, steamIDClan%, pnOnline*, pnInGame*, pnChatting*)
-BS_Friends_GetClanActivityCountsEx%(lpSteamFriends%, steamIDClan%, pnOnline%, pnInGame%, pnChatting%) : "BS_Friends_GetClanActivityCounts"
-BS_Friends_DownloadClanActivityCounts%(lpSteamFriends%, steamIDClan%, cClansToRequest%)
-BS_Friends_GetFriendCountFromSource%(lpSteamFriends%, steamIDSource%)
-BS_Friends_GetFriendFromSourceByIndex%(lpSteamFriends%, steamIDSource%, iFriend%)
-BS_Friends_IsUserInSource%(lpSteamFriends%, steamIDUser%, steamIDSource%)
-BS_Friends_SetInGameVoiceSpeaking(lpSteamFriends%, steamIDUser%, bSpeaking%)
-BS_Friends_ActivateGameOverlay(lpSteamFriends%, pchDialog$)
-BS_Friends_ActivateGameOverlayToUser(lpSteamFriends%, pchDialog$, steamID%)
-BS_Friends_ActivateGameOverlayToWebPage(lpSteamFriends%, pchURL$)
-BS_Friends_ActivateGameOverlayToStore(lpSteamFriends%, nAppID%, eFlag%)
-BS_Friends_SetPlayedWith(lpSteamFriends%, steamIDUserPlayedWith%)
-BS_Friends_ActivateGameOverlayInviteDialog(lpSteamFriends%, steamIDLobby%)
-BS_Friends_GetSmallFriendAvatar%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetMediumFriendAvatar%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetLargeFriendAvatar%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_RequestUserInformation%(lpSteamFriends%, steamIDUser%, bRequireNameOnly%)
-BS_Friends_RequestClanOfficerList%(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetClanOwner%(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetClanOfficerCount%(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetClanOfficerByIndex%(lpSteamFriends%, steamIDClan%, iOfficer%)
-BS_Friends_GetUserRestrictions%(lpSteamFriends%)
-BS_Friends_SetRichPresence%(lpSteamFriends%, pchKey$, pchValue$)
-BS_Friends_ClearRichPresence(lpSteamFriends%)
-BS_Friends_GetFriendRichPresence$(lpSteamFriends%, steamIDFriend%, pchKey$)
-BS_Friends_GetFriendRichPresenceKeyCount%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetFriendRichPresenceKeyByIndex$(lpSteamFriends%, steamIDFriend%, iKey%)
-BS_Friends_RequestFriendRichPresence(lpSteamFriends%, steamIDFriend%)
-BS_Friends_InviteUserToGame%(lpSteamFriends%, steamIDFriend%, pchConnectString%)
-BS_Friends_GetCoplayFriendCount%(lpSteamFriends%)
-BS_Friends_GetCoplayFriend%(lpSteamFriends%, iCoplayFriend%)
-BS_Friends_GetFriendCoplayTime%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetFriendCoplayGame%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_JoinClanChatRoom%(lpSteamFriends%, steamIDClan%)
-BS_Friends_LeaveClanChatRoom%(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetClanChatMemberCount%(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetChatMemberByIndex%(lpSteamFriends%, steamIDClan%, iUser%)
-BS_Friends_SendClanChatMessage%(lpSteamFriends%, steamIDClanChat%, pchText$)
-BS_Friends_GetClanChatMessage%(lpSteamFriends%, steamIDClanChat%, iMessage%, prgchText*, cchTextMax%, peChatEntryType*, psteamidChatter*)
-BS_Friends_GetClanChatMessageEx%(lpSteamFriends%, steamIDClanChat%, iMessage%, prgchText%, cchTextMax%, peChatEntryType%, psteamidChatter%) : "BS_Friends_GetClanChatMessage"
-BS_Friends_IsClanChatAdmin%(lpSteamFriends%, steamIDClanChat%, steamIDUser%)
-BS_Friends_IsClanChatWindowOpenInSteam%(lpSteamFriends%, steamIDClanChat%)
-BS_Friends_OpenClanChatWindowInSteam%(lpSteamFriends%, steamIDClanChat%)
-BS_Friends_CloseClanChatWindowInSteam%(lpSteamFriends%, steamIDClanChat%)
-BS_Friends_SetListenForFriendsMessages%(lpSteamFriends%, bInterceptEnabled%)
-BS_Friends_ReplyToFriendMessage%(lpSteamFriends%, steamIDFriend%, pchMsgToSend$)
-BS_Friends_GetFriendMessage%(lpSteamFriends%, steamIDFriend%, iMessageID%, pvData*, cubData%, peChatEntryType*)
-BS_Friends_GetFriendMessageEx%(lpSteamFriends%, steamIDFriend%, iMessageID%, pvData%, cubData%, peChatEntryType%) : "BS_Friends_GetFriendMessage"
-BS_Friends_GetFollowerCount%(lpSteamFriends%, steamID%)
-BS_Friends_IsFollowing%(lpSteamFriends%, steamID%)
-BS_Friends_EnumerateFollowingList%(lpSteamFriends%, unStartIndex%)
-
-; SteamGameServer ---------------------------------------------------------------
-
-
-; SteamUser ---------------------------------------------------------------------
-BS_User_GetHSteamUser%(lpSteamUser%)
-BS_User_IsLoggedOn%(lpSteamUser%)
-BS_User_GetSteamID%(lpSteamUser%)
-BS_User_InitiateGameConnection%(lpSteamUser%, pAuthBlob*, cbMaxAuthBlob%, SteamIDGameServer%, unIPServer%, usPortServer%, bSecure%)
-BS_User_TerminateGameConnection(lpSteamUser%, unIPServer%, usPortServer%)
-BS_User_TrackAppUsageEvent(lpSteamUser%, gameId%, eAppUsageEvent%, pchExtraInfo$)
-BS_User_GetUserDataFolder%(lpSteamUser%, pchBuffer*, cubBuffer%)
-BS_User_StartVoiceRecording(lpSteamUser%)
-BS_User_StopVoiceRecording(lpSteamUser%)
-BS_User_GetAvailableVoice%(lpSteamUser%, pcbCompressed*, pcbUncompressed*, nUncompressedVoiceDesiredSampleRate%)
-BS_User_GetAvailableVoiceEx%(lpSteamUser%, pcbCompressed%, pcbUncompressed%, nUncompressedVoiceDesiredSampleRate%) : "BS_User_GetAvailableVoice"
-BS_User_GetVoice%(lpSteamUser%, bWantCompressed%, pDestBuffer*, cbDestBufferSize%, nBytesWritten*, bWantUncompressed%, pUncompressedDestBuffer*, cbUncompressedDestBufferSize%, nUncompressBytesWritten*, nUncompressedVoiceDesiredSampleRate%)
-BS_User_GetVoiceEx%(lpSteamUser%, bWantCompressed%, pDestBuffer*, cbDestBufferSize%, nBytesWritten%, bWantUncompressed%, pUncompressedDestBuffer*, cbUncompressedDestBufferSize%, nUncompressBytesWritten%, nUncompressedVoiceDesiredSampleRate%) : "BS_User_GetVoice"
-BS_User_DecompressVoice(lpSteamUser%, pCompressed*, cbCompressed%, pDestBuffer*, cbDestBufferSize%, nBytesWritten*, nDesiredSampleRate%)
-BS_User_DecompressVoiceEx(lpSteamUser%, pCompressed*, cbCompressed%, pDestBuffer*, cbDestBufferSize%, nBytesWritten%, nDesiredSampleRate%) : "BS_User_DecompressVoice"
-BS_User_GetVoiceOptimalSampleRate%(lpSteamUser%)
-BS_User_GetAuthSessionTicket%(lpSteamUser%, pTicket*, cbMaxTicket%, pcbTicket*)
-BS_User_GetAuthSessionTicketEx%(lpSteamUser%, pTicket*, cbMaxTicket%, pcbTicket%) : "BS_User_GetAuthSessionTicket"
-BS_User_BeginAuthSession%(lpSteamUser%, pAuthTicket*, cbAuthTicker%, steamID%)
-BS_User_EndAuthSession(lpSteamUser%, steamID%)
-BS_User_CancelAuthTicket(lpSteamUser%, hAuthTicket%)
-BS_User_UserHasLicenseForApp%(lpSteamUser%, steamID%, appID%)
-BS_User_IsBehindNAT%(lpSteamUser%)
-BS_User_AdvertiseGame%(lpSteamUser%, steamIDGameServer%, unIPServer%, usPortServer%)
-BS_User_RequestEncryptedAppTicket%(lpSteamUser%, pDataToInclude*, cbDataToInclude%)
-BS_User_GetEncryptedAppTicket%(lpSteamUser%, pTicket*, cbMaxTicket%, pcbTicket*)
-BS_User_GetEncryptedAppTicketEx%(lpSteamUser%, pTicket*, cbMaxTicket%, pcbTicket%) : "BS_User_GetEncryptedAppTicket"
-BS_User_GetGameBadgeLevel%(lpSteamUser%, nSeries%, bFoil%)
-BS_User_GetPlayerSteamLevel%(lpSteamUser%)
-BS_User_RequestStoreAuthURL%(lpSteamUser%, pchRedirectUrl$)
-
-; SteamUserStats ----------------------------------------------------------------
-BS_UserStats_RequestCurrentStats%(lpSteamUserStats%)
-BS_UserStats_GetStat%(lpSteamUserStats%, pchName$, pData*)
-BS_UserStats_GetStatEx%(lpSteamUserStats%, pchName$, pData%) : "BS_UserStats_GetStat"
-BS_UserStats_GetStatF%(lpSteamUserStats%, pchName$, pData*)
-BS_UserStats_GetStatFEx%(lpSteamUserStats%, pchName$, pData%) : "BS_UserStats_GetStatF"
-BS_UserStats_SetStat%(lpSteamUserStats%, pchName$, pData%)
-BS_UserStats_SetStatF%(lpSteamUserStats%, pchName$, pData#)
-BS_UserStats_UpdateAvgRateStat%(lpSteamUserStats%, pchName$, flCountThisSession#, dSessionLength%)
-BS_UserStats_GetAchievement%(lpSteamUserStats%, pchName$, pbAchieved*)
-BS_UserStats_GetAchievementEx%(lpSteamUserStats%, pchName$, pbAchieved%) : "BS_UserStats_GetAchievement"
-BS_UserStats_SetAchievement%(lpSteamUserStats%, pchName$)
-BS_UserStats_ClearAchievement%(lpSteamUserStats%, pchName$)
-BS_UserStats_GetAchievementAndUnlockTime%(lpSteamUserStats%, pchName$, pbAchieved*, punUnlockTime*)
-BS_UserStats_GetAchievementAndUnlockTimeEx%(lpSteamUserStats%, pchName$, pbAchieved%, punUnlockTime%) : "BS_UserStats_GetAchievementAndUnlockTime"
-BS_UserStats_StoreStats%(lpSteamUserStats%)
-BS_UserStats_GetAchievementIcon%(lpSteamUserStats%, pchName$)
-BS_UserStats_GetAchievementDisplayAttribute$(lpSteamUserStats%, pchName$, pchKey$)
-BS_UserStats_IndicateAchievementProgress%(lpSteamUserStats%, pchName$, nCurProgress%, nMaxProgress%)
-BS_UserStats_GetNumAchievements%(lpSteamUserStats%)
-BS_UserStats_GetAchievementName$(lpSteamUserStats%, iAchievement%)
-BS_UserStats_RequestUserStats%(lpSteamUserStats%, steamIDUser%)
-BS_UserStats_GetUserStat%(lpSteamUserStats%, steamIDUser%, pchName$, pData*)
-BS_UserStats_GetUserStatEx%(lpSteamUserStats%, steamIDUser%, pchName$, pData%) : "BS_UserStats_GetUserStat"
-BS_UserStats_GetUserStatF%(lpSteamUserStats%, steamIDUser%, pchName$, pData*)
-BS_UserStats_GetUserStatFEx%(lpSteamUserStats%, steamIDUser%, pchName$, pData%) : "BS_UserStats_GetUserStatF"
-BS_UserStats_GetUserAchievement%(lpSteamUserStats%, steamIDUser%, pchName$, pbAchieved*)
-BS_UserStats_GetUserAchievementEx%(lpSteamUserStats%, steamIDUser%, pchName$, pbAchieved%) : "BS_UserStats_GetUserAchievement"
-BS_UserStats_GetUserAchievementAndUnlockTime%(lpSteamUserStats%, steamIDUser%, pchName$, pbAchieved*, punUnlockTime*)
-BS_UserStats_GetUserAchievementAndUnlockTimeEx%(lpSteamUserStats%, steamIDUser%, pchName$, pbAchieved%, punUnlockTime%) : "BS_UserStats_GetUserAchievementAndUnlockTime"
-BS_UserStats_ResetAllStats%(lpSteamUserStats%, bAchievementsToo%)
-BS_UserStats_FindOrCreateLeaderboard%(lpSteamUserStats%, pchLeaderboardName$, eLeaderboardSortMethod%, eLeaderboardDisplayType%)
-BS_UserStats_FindLeaderboard%(lpSteamUserStats%, pchLeaderboardName$)
-BS_UserStats_GetLeaderboardName$(lpSteamUserStats%, hSteamLeaderboard%)
-BS_UserStats_GetLeaderboardEntryCount%(lpSteamUserStats%, hSteamLeaderboard%)
-BS_UserStats_GetLeaderboardSortMethod%(lpSteamUserStats%, hSteamLeaderboard%)
-BS_UserStats_GetLeaderboardDisplayType%(lpSteamUserStats%, hSteamLeaderboard%)
-BS_UserStats_DownloadLeaderboardEntries%(lpSteamUserStats%, hSteamLeaderboard%, eLeaderboardDataRequest%, nRangeStart%, nRangeEnd%)
-BS_UserStats_DownloadLeaderboardEntriesForUsers%(lpSteamUserStats%, hSteamLeaderboard%, prgUsers*, cUsers%)
-BS_UserStats_DownloadLeaderboardEntriesForUsersEx%(lpSteamUserStats%, hSteamLeaderboard%, prgUsers%, cUsers%) : "BS_UserStats_DownloadLeaderboardEntriesForUsers"
-BS_UserStats_GetDownloadedLeaderboardEntry%(lpSteamUsers%, hSteamLeaderboardEntries%, index%, pLeaderboardEntry*, pDetails*, cDetailsMax%)
-BS_UserStats_GetDownloadedLeaderboardEntryEx%(lpSteamUsers%, hSteamLeaderboardEntries%, index%, pLeaderboardEntry%, pDetails%, cDetailsMax%)
-BS_UserStats_UploadLeaderboardScore%(lpSteamUserStats%, hSteamLeaderboard%, eLeaderboardUploadScoreMethod%, nScore%, pScoreDetails*, cScoreDetailsCount%)
-BS_UserStats_UploadLeaderboardScoreEx%(lpSteamUserStats%, hSteamLeaderboard%, eLeaderboardUploadScoreMethod%, nScore%, pScoreDetails%, cScoreDetailsCount%) : "BS_UserStats_UploadLeaderboardScore"
-BS_UserStats_AttachLeaderboardUGC%(lpSteamUserStats%, hSteamLeaderboard%, hUGB%)
-BS_UserStats_GetNumberOfCurrentPlayers%(lpSteamUserstats%)
-BS_UserStats_RequestGlobalAchievementPercentages%(lpSteamUserStats%)
-BS_UserStats_GetMostAchievedAchievementInfo%(lpSteamUserStats%, pchName$, unNameBufLen%, pflPercent*, pbAchieved*)
-BS_UserStats_GetMostAchievedAchievementInfoEx%(lpSteamUserStats%, pchName$, unNameBufLen%, pflPercent%, pbAchieved%) : "BS_UserStats_GetMostAchievedAchievementInfo"
-BS_UserStats_GetNextMostAchievedAchievementInfo%(lpSteamUserStats%, iIteratorPrevious%, pchName$, unNameBufLen%, pflPercent*, pbAchieved*)
-BS_UserStats_GetNextMostAchievedAchievementInfoEx%(lpSteamUserStats%, iIteratorPrevious%, pchName$, unNameBufLen%, pflPercent%, pbAchieved%) : "BS_UserStats_GetNextMostAchievedAchievementInfo"
-BS_UserStats_GetAchievementAchievedPercent%(lpSteamUserStats%, pchName$, pflPercent*)
-BS_UserStats_GetAchievementAchievedPercentEx%(lpSteamUserStats%, pchName$, pflPercent%) : "BS_UserStats_GetAchievementAchievedPercent"
-BS_UserStats_RequestGlobalStats%(lpSteamUserStats%, nHistoryDays%)
-BS_UserStats_GetGlobalStatLL%(lpSteamUserStats, pchStatName$, pData%)
-BS_UserStats_GetGlobalStatD%(lpSteamUserStats, pchStatName$, pData%)
-BS_UserStats_GetGlobalStatHistoryLL%(lpSteamUserStats, pchStatName$, pData*, cubData%)
-BS_UserStats_GetGlobalStatHistoryLLEx%(lpSteamUserStats, pchStatName$, pData%, cubData%) : "BS_UserStats_GetGlobalStatHistoryLL"
-BS_UserStats_GetGlobalStatHistoryD%(lpSteamUserStats, pchStatName$, pData*, cubData%)
-BS_UserStats_GetGlobalStatHistoryDEx%(lpSteamUserStats, pchStatName$, pData%, cubData%) : "BS_UserStats_GetGlobalStatHistoryD"

BlitzSteam.cpp

@@ -14,8 +14,9 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
+#include <windows.h>
 uint32_t WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
 	switch (fdwReason) {
 		case DLL_PROCESS_ATTACH:

BlitzSteam.h

@@ -14,20 +14,13 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-// STL Exceptions
+#pragma once
-#include <exception>
+#include "BlitzSteamInternal.h"
-#include <stdexcept>
 
-// Memory Management
+// Our Stuff
-#include <memory>
+#include "Helpers/BlitzPointer.h"
-
+#include "Types/BlitzCallback.h"
-// Platform specific: Windows
+#include "Types/CSteamID.h"
-#include <windows.h>
+#include "Types/Double.h"
-
+#include "Types/Long.h"
-// Macros
+#include "Types/Memory.h"
-#define DLL_EXPORT extern "C" //__declspec(dllexport)
-#define DLL_METHOD extern "C"
-#define DLL_CALL __stdcall
-
-// Steam
-#include "SteamworksSDK/public/steam/steam_api.h"

BlitzSteam.vcxproj

@@ -13,6 +13,7 @@
   <PropertyGroup Label="Globals">
     <ProjectGuid>{805CB1EB-82F0-405E-AC0B-03FBE82CC77D}</ProjectGuid>
     <RootNamespace>BlitzSteam</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -40,38 +41,35 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
     <TargetExt>.dll</TargetExt>
-    <LinkIncremental>true</LinkIncremental>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
     <TargetExt>.dll</TargetExt>
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <SDLCheck>
-      </SDLCheck>
       <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <WholeProgramOptimization>false</WholeProgramOptimization>
       <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
       <BufferSecurityCheck>false</BufferSecurityCheck>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <StructMemberAlignment>4Bytes</StructMemberAlignment>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <CompileAsManaged>false</CompileAsManaged>
       <CompileAsWinRT>false</CompileAsWinRT>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <CreateHotpatchableImage>false</CreateHotpatchableImage>
+      <CreateHotpatchableImage>true</CreateHotpatchableImage>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <OpenMPSupport>false</OpenMPSupport>
       <ForcedIncludeFiles>
       </ForcedIncludeFiles>
@@ -80,38 +78,37 @@
       <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
       <IntrinsicFunctions>false</IntrinsicFunctions>
       <StringPooling>true</StringPooling>
-      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
-      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
       <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
       <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <GenerateDebugInformation>Debug</GenerateDebugInformation>
-      <Version>1.0</Version>
       <AdditionalLibraryDirectories>$(ProjectDir)\SteamworksSDK\redistributable_bin</AdditionalLibraryDirectories>
       <AdditionalDependencies>steam_api.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <LinkTimeCodeGeneration>
       </LinkTimeCodeGeneration>
-      <OptimizeReferences>
+      <OptimizeReferences>false</OptimizeReferences>
-      </OptimizeReferences>
       <LinkStatus>
       </LinkStatus>
       <CreateHotPatchableImage>Enabled</CreateHotPatchableImage>
       <EnableCOMDATFolding>false</EnableCOMDATFolding>
       <FixedBaseAddress>false</FixedBaseAddress>
+      <LargeAddressAware>false</LargeAddressAware>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+      <FullProgramDatabaseFile>true</FullProgramDatabaseFile>
     </Link>
-    <ProjectReference>
+    <ProjectReference />
-      <LinkLibraryDependencies>true</LinkLibraryDependencies>
-    </ProjectReference>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Full</Optimization>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>
-      </SDLCheck>
       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
@@ -122,42 +119,52 @@
       <CompileAsWinRT>false</CompileAsWinRT>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <CreateHotpatchableImage>false</CreateHotpatchableImage>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <OpenMPSupport>false</OpenMPSupport>
       <ForcedIncludeFiles>
       </ForcedIncludeFiles>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
       <MinimalRebuild>false</MinimalRebuild>
       <CallingConvention>Cdecl</CallingConvention>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
       <StringPooling>true</StringPooling>
-      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
-      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
       <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
       <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <GenerateDebugInformation>No</GenerateDebugInformation>
       <EnableCOMDATFolding>false</EnableCOMDATFolding>
-      <OptimizeReferences>
+      <OptimizeReferences>false</OptimizeReferences>
-      </OptimizeReferences>
-      <Version>1.0</Version>
       <AdditionalLibraryDirectories>$(ProjectDir)\SteamworksSDK\redistributable_bin</AdditionalLibraryDirectories>
       <AdditionalDependencies>steam_api.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+      <LinkTimeCodeGeneration>
+      </LinkTimeCodeGeneration>
       <LinkStatus>
       </LinkStatus>
       <CreateHotPatchableImage>Enabled</CreateHotPatchableImage>
       <FixedBaseAddress>false</FixedBaseAddress>
+      <LargeAddressAware>false</LargeAddressAware>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+      <FullProgramDatabaseFile>false</FullProgramDatabaseFile>
     </Link>
-    <ProjectReference>
+    <ProjectReference />
-      <LinkLibraryDependencies>true</LinkLibraryDependencies>
-    </ProjectReference>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="BlitzSteam.cpp" />
-    <ClCompile Include="Helpers\CSteamID.cpp" />
+    <ClCompile Include="Helpers\BlitzPointer.cpp" />
-    <ClCompile Include="Helpers\Callbacks.cpp" />
+    <ClCompile Include="Helpers\Helper.cpp" />
+    <ClCompile Include="Types\BlitzCallback.cpp" />
+    <ClCompile Include="Types\CSteamID.cpp" />
+    <ClCompile Include="Types\Double.cpp" />
+    <ClCompile Include="Types\SteamMatchmakingTypes.cpp" />
+    <ClCompile Include="Types\Long.cpp" />
+    <ClCompile Include="Types\Memory.cpp" />
+    <ClCompile Include="Types\SteamTypes.cpp" />
     <ClCompile Include="Wrapper\Steam.cpp" />
     <ClCompile Include="Wrapper\SteamAppList.cpp" />
     <ClCompile Include="Wrapper\SteamApps.cpp" />
@@ -170,7 +177,7 @@
     <ClCompile Include="Wrapper\SteamHTTP.cpp" />
     <ClCompile Include="Wrapper\SteamInventory.cpp" />
     <ClCompile Include="Wrapper\SteamMatchmaking.cpp" />
-    <ClCompile Include="Wrapper\SteamMatchmakingServer.cpp" />
+    <ClCompile Include="Wrapper\SteamMatchmakingServers.cpp" />
     <ClCompile Include="Wrapper\SteamMusic.cpp" />
     <ClCompile Include="Wrapper\SteamMusicRemote.cpp" />
     <ClCompile Include="Wrapper\SteamNetworking.cpp" />
@@ -184,37 +191,71 @@
     <ClCompile Include="Wrapper\SteamVideo.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="dllmain.h" />
+    <ClInclude Include="BlitzSteam.h" />
+    <ClInclude Include="BlitzSteamInternal.h" />
     <ClInclude Include="Helpers\BlitzPointer.h" />
-    <ClInclude Include="Helpers\Callbacks.h" />
+    <ClInclude Include="Helpers\Helper.h" />
-    <ClInclude Include="Helpers\CSteamID.h" />
+    <ClInclude Include="Types\BlitzCallback.h" />
+    <ClInclude Include="Types\CSteamID.h" />
+    <ClInclude Include="Types\Double.h" />
+    <ClInclude Include="Types\SteamMatchmakingTypes.h" />
+    <ClInclude Include="Types\Long.h" />
+    <ClInclude Include="Types\Memory.h" />
+    <ClInclude Include="Types\SteamTypes.h" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="LICENSE">
+    <None Include="Resources\BlitzSteam.bb" />
-      <Link>LICENSE</Link>
+    <None Include="Resources\BlitzSteam.ipf" />
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    <None Include="Resources\BlitzSteamUtility.bb" />
-    </None>
+    <None Include="Resources\Decls\BlitzSteam.decls" />
-    <None Include="LICENSE.lesser">
+    <None Include="Resources\Decls\BlitzSteam_Callback.decls" />
-      <Link>LICENSE.lesser</Link>
+    <None Include="Resources\Decls\BlitzSteam_CSteamID.decls" />
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    <None Include="Resources\Decls\BlitzSteam_Double.decls" />
-    </None>
+    <None Include="Resources\Decls\BlitzSteam_Long.decls" />
-    <None Include="Blitz\BlitzSteam.bb">
+    <None Include="Resources\Decls\BlitzSteam_Memory.decls" />
-      <Link>BlitzSteam.bb</Link>
+    <None Include="Resources\Decls\BlitzSteam_Steam.decls" />
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    <None Include="Resources\Decls\BlitzSteam_SteamAppList.decls" />
-    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamApps.decls" />
-    <None Include="Blitz\BlitzSteamUtility.bb">
+    <None Include="Resources\Decls\BlitzSteam_SteamClient.decls" />
-      <Link>BlitzSteamUtility.bb</Link>
+    <None Include="Resources\Decls\BlitzSteam_SteamController.decls" />
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    <None Include="Resources\Decls\BlitzSteam_SteamFriends.decls" />
-    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamGameServer.decls" />
-    <None Include="Blitz\BlitzSteam.decls">
+    <None Include="Resources\Decls\BlitzSteam_SteamGameServerStats.decls" />
-      <Link>BlitzSteam.decls</Link>
+    <None Include="Resources\Decls\BlitzSteam_SteamHTMLSurface.decls" />
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    <None Include="Resources\Decls\BlitzSteam_SteamHTTP.decls" />
-    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamInventory.decls" />
-    <None Include="SteamworksSDK\redistributable_bin\steam_api.dll">
+    <None Include="Resources\Decls\BlitzSteam_SteamMatchmaking.decls" />
-      <Link>steam_api.dll</Link>
+    <None Include="Resources\Decls\BlitzSteam_SteamMatchmakingServers.decls" />
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    <None Include="Resources\Decls\BlitzSteam_SteamMatchmakingTypes.decls" />
-    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamMusic.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamMusicRemote.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamNetworking.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamRemoteStorage.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamScreenshots.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamUGC.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamUnifiedMessages.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamUser.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamUserStats.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamUtils.decls" />
+    <None Include="Resources\Decls\BlitzSteam_SteamVideo.decls" />
+    <None Include="Resources\Examples\SteamAPI_Example.bb" />
+    <None Include="Resources\Examples\SteamAppList_Example.bb" />
+    <None Include="Resources\Examples\SteamApps_Example.bb" />
+    <None Include="Resources\Examples\SteamController_Example.bb" />
+    <None Include="Resources\Examples\SteamHTMLSurface_Example.bb" />
+    <None Include="Resources\BlitzSteam.LICENSE" />
+    <None Include="Resources\BlitzSteam.LICENSE.lesser" />
   </ItemGroup>
+  <ItemGroup>
+    <Text Include="Resources\Examples\steam_appid.txt" />
+  </ItemGroup>
+  <Target Name="CopyResources" BeforeTargets="Build">
+    <ItemGroup>
+      <Resources Include="$(ProjectDir)\Resources\**\*.*" />
+      <Resources Include="$(ProjectDir)\SteamworksSDK\redistributable_bin\steam_api.dll" />
+    </ItemGroup>
+    <Copy SourceFiles="@(Resources)" DestinationFiles="@(Resources->'$(TargetDir)%(RecursiveDir)\%(Filename)%(Extension)')" SkipUnchangedFiles="True" UseHardlinksIfPossible="True" />
+  </Target>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

BlitzSteam.vcxproj.filters

@@ -8,24 +8,33 @@
     <Filter Include="Source Files\Wrapper">
       <UniqueIdentifier>{8f00e86e-e1bc-499e-8b2c-da93e9e8f287}</UniqueIdentifier>
     </Filter>
-    <Filter Include="SteamworksSDK">
-      <UniqueIdentifier>{14616756-e67f-4b1c-ac90-776c00a0271d}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Blitz Files">
-      <UniqueIdentifier>{3072c53c-2be5-4712-b853-1bc1438cdc6e}</UniqueIdentifier>
-      <Extensions>bb;decls;ipf</Extensions>
-    </Filter>
     <Filter Include="Source Files\Helpers">
       <UniqueIdentifier>{a6fc08f6-97d9-4a53-a803-34b985d9ae7c}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{a799678b-8efc-42a0-97b2-f3a23da99e17}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Header Files\Helpers">
+      <UniqueIdentifier>{6cebc940-92bb-4a55-a125-ec97956636f2}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Types">
+      <UniqueIdentifier>{f9d810ff-605b-4b00-a607-4b7f1d918286}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Types">
+      <UniqueIdentifier>{812e0ab3-866c-4b15-ae9d-a24d92b05c9a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{65d7146d-e626-44dd-bd9e-525ea8e9252f}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Resource Files\Examples">
+      <UniqueIdentifier>{65e28d96-6d00-47b5-8211-0cf2753aef67}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Resource Files\Decls">
+      <UniqueIdentifier>{59a50312-f52e-475b-9362-7cbb22381620}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="dllmain.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Wrapper\Steam.cpp">
-      <Filter>Source Files\Wrapper</Filter>
-    </ClCompile>
     <ClCompile Include="Wrapper\SteamClient.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
@@ -53,9 +62,6 @@
     <ClCompile Include="Wrapper\SteamMatchmaking.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
-    <ClCompile Include="Wrapper\SteamMatchmakingServer.cpp">
-      <Filter>Source Files\Wrapper</Filter>
-    </ClCompile>
     <ClCompile Include="Wrapper\SteamUserStats.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
@@ -95,41 +101,220 @@
     <ClCompile Include="Wrapper\SteamVideo.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
-    <ClCompile Include="Helpers\CSteamID.cpp">
+    <ClCompile Include="BlitzSteam.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Helpers\Helper.cpp">
       <Filter>Source Files\Helpers</Filter>
     </ClCompile>
-    <ClCompile Include="Helpers\Callbacks.cpp">
+    <ClCompile Include="Wrapper\SteamMatchmakingServers.cpp">
+      <Filter>Source Files\Wrapper</Filter>
+    </ClCompile>
+    <ClCompile Include="Types\Long.cpp">
+      <Filter>Source Files\Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Types\Double.cpp">
+      <Filter>Source Files\Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Types\CSteamID.cpp">
+      <Filter>Source Files\Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Wrapper\Steam.cpp">
+      <Filter>Source Files\Wrapper</Filter>
+    </ClCompile>
+    <ClCompile Include="Types\BlitzCallback.cpp">
+      <Filter>Source Files\Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Types\Memory.cpp">
+      <Filter>Source Files\Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Types\SteamMatchmakingTypes.cpp">
+      <Filter>Source Files\Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Types\SteamTypes.cpp">
+      <Filter>Source Files\Types</Filter>
+    </ClCompile>
+    <ClCompile Include="Helpers\BlitzPointer.cpp">
       <Filter>Source Files\Helpers</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="dllmain.h">
+    <ClInclude Include="BlitzSteam.h">
-      <Filter>Source Files</Filter>
+      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Helpers\Callbacks.h">
-      <Filter>Source Files\Helpers</Filter>
-    </ClInclude>
-    <ClInclude Include="Helpers\CSteamID.h">
-      <Filter>Source Files\Helpers</Filter>
     </ClInclude>
     <ClInclude Include="Helpers\BlitzPointer.h">
-      <Filter>Source Files\Helpers</Filter>
+      <Filter>Header Files\Helpers</Filter>
+    </ClInclude>
+    <ClInclude Include="Helpers\Helper.h">
+      <Filter>Header Files\Helpers</Filter>
+    </ClInclude>
+    <ClInclude Include="Types\Long.h">
+      <Filter>Header Files\Types</Filter>
+    </ClInclude>
+    <ClInclude Include="Types\Double.h">
+      <Filter>Header Files\Types</Filter>
+    </ClInclude>
+    <ClInclude Include="Types\CSteamID.h">
+      <Filter>Header Files\Types</Filter>
+    </ClInclude>
+    <ClInclude Include="Types\BlitzCallback.h">
+      <Filter>Header Files\Types</Filter>
+    </ClInclude>
+    <ClInclude Include="Types\Memory.h">
+      <Filter>Header Files\Types</Filter>
+    </ClInclude>
+    <ClInclude Include="BlitzSteamInternal.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Types\SteamMatchmakingTypes.h">
+      <Filter>Header Files\Types</Filter>
+    </ClInclude>
+    <ClInclude Include="Types\SteamTypes.h">
+      <Filter>Header Files\Types</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <None Include="SteamworksSDK\redistributable_bin\steam_api.dll">
+    <None Include="$(ProjectDir)\Blitz\*.*" />
-      <Filter>SteamworksSDK</Filter>
+    <None Include="$(ProjectDir)\Blitz\*.*" />
+    <None Include="$(ProjectDir)\Blitz\*.*" />
+    <None Include="$(ProjectDir)\Blitz\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="$(ProjectDir)\Blitz\**\*.*" />
+    <None Include="Resources\BlitzSteam.bb">
+      <Filter>Resource Files</Filter>
     </None>
-    <None Include="Blitz\BlitzSteam.bb">
+    <None Include="Resources\BlitzSteamUtility.bb">
-      <Filter>Blitz Files</Filter>
+      <Filter>Resource Files</Filter>
     </None>
-    <None Include="Blitz\BlitzSteam.decls">
+    <None Include="Resources\BlitzSteam.ipf">
-      <Filter>Blitz Files</Filter>
+      <Filter>Resource Files</Filter>
     </None>
-    <None Include="Blitz\BlitzSteamUtility.bb">
+    <None Include="Resources\Examples\SteamAPI_Example.bb">
-      <Filter>Blitz Files</Filter>
+      <Filter>Resource Files\Examples</Filter>
     </None>
-    <None Include="LICENSE" />
+    <None Include="Resources\Examples\SteamAppList_Example.bb">
-    <None Include="LICENSE.lesser" />
+      <Filter>Resource Files\Examples</Filter>
+    </None>
+    <None Include="Resources\Examples\SteamApps_Example.bb">
+      <Filter>Resource Files\Examples</Filter>
+    </None>
+    <None Include="Resources\Examples\SteamController_Example.bb">
+      <Filter>Resource Files\Examples</Filter>
+    </None>
+    <None Include="Resources\Examples\SteamHTMLSurface_Example.bb">
+      <Filter>Resource Files\Examples</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_CSteamID.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_Double.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_Long.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_Memory.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_Steam.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamAppList.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamApps.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamClient.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamController.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamFriends.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamGameServer.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamGameServerStats.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamHTMLSurface.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamHTTP.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamInventory.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamMatchmaking.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamMatchmakingServers.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamMusic.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamMusicRemote.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamNetworking.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamRemoteStorage.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamScreenshots.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamUGC.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamUnifiedMessages.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamUser.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamUserStats.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamUtils.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamVideo.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\BlitzSteam.LICENSE">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="Resources\BlitzSteam.LICENSE.lesser">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_SteamMatchmakingTypes.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+    <None Include="Resources\Decls\BlitzSteam_Callback.decls">
+      <Filter>Resource Files\Decls</Filter>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <Text Include="Resources\Examples\steam_appid.txt">
+      <Filter>Resource Files\Examples</Filter>
+    </Text>
   </ItemGroup>
 </Project>

BlitzSteamInternal.h

@@ -0,0 +1,31 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+
+// Macros
+//#define DLL_FUNCTION(type) extern "C" type __stdcall
+#define DLL(type) extern "C" __declspec(dllexport) type __stdcall
+
+// C/C++ Includes
+#include <math.h>
+#include <stddef.h>
+#include <float.h>
+#include <inttypes.h>
+
+// Steam
+#include "SteamworksSDK/public/steam/steam_api.h"
+#include "SteamworksSDK/public/steam/steam_gameserver.h"

Helpers/BlitzPointer.cpp

@@ -0,0 +1,52 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzPointer.h"
+
+DLL(intptr_t) BS_BlitzPointer_GetReturnAddress() {
+	intptr_t BasePointer, ReturnAddress;
+
+	__asm { //ASM. Do touch if suicidal.
+		mov BasePointer, ebp;		// Store current BasePointer
+	}
+
+	// Blitz uses X86 Call-Near (E8) instructions to call its own functions.
+	// We can simply deduce the Return Address like this because of that.
+	//-- Parent_EBP = *EBP
+	//-- Parent_RP = Parent_EBP + 16
+	ReturnAddress = *(intptr_t*)((*(intptr_t*)BasePointer) + 16);
+
+	return ReturnAddress;
+}
+
+DLL(intptr_t) BS_BlitzPointer_GetFunctionPointer() {
+	intptr_t BasePointer, ReturnAddress, FunctionPointer;
+
+	__asm { //ASM. Do touch if suicidal.
+		mov BasePointer, ebp;		// Store current BasePointer
+	}
+
+	// Blitz uses X86 Call-Near (E8) instructions to call its own functions.
+	// We can simply deduce the Return Address like this because of that.
+	//-- Parent_EBP = *EBP
+	//-- Parent_RP = Parent_EBP + 16
+	ReturnAddress = *(intptr_t*)((*(intptr_t*)BasePointer) + 16);
+
+	// And since it's a Call-Near, the call is offset to the return address.
+	FunctionPointer = ReturnAddress + *(intptr_t*)(ReturnAddress - 4);
+
+	return FunctionPointer;
+}

Helpers/BlitzPointer.h

@@ -14,16 +14,23 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#pragma once
+#include "BlitzSteamInternal.h"
 
-typedef uint32_t(__stdcall *BP_Function0_t)();
+DLL(intptr_t) BS_BlitzPointer_GetReturnAddress();
-typedef uint32_t(__stdcall *BP_Function1_t)(uint32_t);
+DLL(intptr_t) BS_BlitzPointer_GetFunctionPointer();
-typedef uint32_t(__stdcall *BP_Function2_t)(uint32_t, uint32_t);
-typedef uint32_t(__stdcall *BP_Function3_t)(uint32_t, uint32_t, uint32_t);
-typedef uint32_t(__stdcall *BP_Function4_t)(uint32_t, uint32_t, uint32_t, uint32_t);
 
-#define BP_CallFunction0(ptr) ((BP_Function0_t)ptr)()
+// Types of Blitz Functions.
-#define BP_CallFunction1(ptr, p1) ((BP_Function1_t)ptr)(p1)
+typedef int32_t(__stdcall *BP_BlitzFunction0_t)();
-#define BP_CallFunction2(ptr, p1, p2) ((BP_Function2_t)ptr)(p1, p2)
+typedef int32_t(__stdcall *BP_BlitzFunction1_t)(int32_t);
-#define BP_CallFunction3(ptr, p1, p2, p3) ((BP_Function3_t)ptr)(p1, p2, p3)
+typedef int32_t(__stdcall *BP_BlitzFunction2_t)(int32_t, int32_t);
-#define BP_CallFunction4(ptr, p1, p2, p3, p4) ((BP_Function4_t)ptr)(p1, p2, p3, p4)
+typedef int32_t(__stdcall *BP_BlitzFunction3_t)(int32_t, int32_t, int32_t);
+typedef int32_t(__stdcall *BP_BlitzFunction4_t)(int32_t, int32_t, int32_t, int32_t);
+typedef int32_t(__stdcall *BP_BlitzFunction5_t)(int32_t, int32_t, int32_t, int32_t, int32_t);
+
+#define BP_CallFunction0(ptr)						(ptr)()
+#define BP_CallFunction1(ptr, p1)					(ptr)(p1)
+#define BP_CallFunction2(ptr, p1, p2)				(ptr)(p1, p2)
+#define BP_CallFunction3(ptr, p1, p2, p3)			(ptr)(p1, p2, p3)
+#define BP_CallFunction4(ptr, p1, p2, p3, p4)		(ptr)(p1, p2, p3, p4)
+#define BP_CallFunction5(ptr, p1, p2, p3, p4, p5)	(ptr)(p1, p2, p3, p4, p5)

Helpers/CSteamID.cpp

@@ -1,211 +0,0 @@
-//	BlitzSteam - Steam wrapper for Blitz
-//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "dllmain.h"
-
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_New() {
-	return new CSteamID();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_New=_BS_CSteamID_New@0")
-
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromID(uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType) {
-	return new CSteamID(unAccountID, eUniverse, eAccountType);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_FromID=_BS_CSteamID_FromID@12")
-
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromIDInstance(uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType) {
-	return new CSteamID(unAccountID, unInstance, eUniverse, eAccountType);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_FromIDInstance=_BS_CSteamID_FromIDInstance@16")
-
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromSteamID(uint64_t* ulSteamID) {
-	return new CSteamID(*ulSteamID);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_FromSteamID=_BS_CSteamID_FromSteamID@4")
-
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_Copy(CSteamID* pSteamID) {
-	return new CSteamID(*pSteamID);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_Copy=_BS_CSteamID_Copy@4")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_Destroy(CSteamID* pSteamID) {
-	delete pSteamID;
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_Destroy=_BS_CSteamID_Destroy@4")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_Set(CSteamID* pSteamID, uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType) {
-	pSteamID->Set(unAccountID, eUniverse, eAccountType);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_Set=_BS_CSteamID_Set@16")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_InstancedSet(CSteamID* pSteamID, uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType) {
-	pSteamID->InstancedSet(unAccountID, unInstance, eUniverse, eAccountType);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_InstancedSet=_BS_CSteamID_InstancedSet@20")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_FullSet(CSteamID* pSteamID, uint64_t* ulIdentifier, EUniverse eUniverse, EAccountType eAccountType) {
-	pSteamID->FullSet(*ulIdentifier, eUniverse, eAccountType);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_FullSet=_BS_CSteamID_FullSet@16")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID) {
-	pSteamID->SetFromUint64(*ulSteamID);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_SetFromUInt64=_BS_CSteamID_SetFromUInt64@8")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_Clear(CSteamID* pSteamID) {
-	pSteamID->Clear();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_Clear=_BS_CSteamID_Clear@4")
-
-DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID) {
-	uint64_t* val = new uint64_t;
-	*val = pSteamID->ConvertToUint64();
-	return val;
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ConvertToUInt64=_BS_CSteamID_ConvertToUInt64@4")
-
-DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID) {
-	uint64_t* val = new uint64_t;
-	*val = pSteamID->GetStaticAccountKey();
-	return val;
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetStaticAccountKey=_BS_CSteamID_GetStaticAccountKey@4")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse) {
-	pSteamID->CreateBlankAnonLogon(eUniverse);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_CreateBlankAnonLogon=_BS_CSteamID_CreateBlankAnonLogon@8")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse) {
-	pSteamID->CreateBlankAnonUserLogon(eUniverse);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_CreateBlankAnonUserLogon=_BS_CSteamID_CreateBlankAnonUserLogon@8")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID) {
-	return pSteamID->BBlankAnonAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_BlankAnonAccount=_BS_CSteamID_BlankAnonAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GameServerAccount(CSteamID* pSteamID) {
-	return pSteamID->BGameServerAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GameServerAccount=_BS_CSteamID_GameServerAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID) {
-	return pSteamID->BPersistentGameServerAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_PersistentGameServerAccount=_BS_CSteamID_PersistentGameServerAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID) {
-	return pSteamID->BAnonGameServerAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_AnonGameServerAccount=_BS_CSteamID_AnonGameServerAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ContentServerAccount(CSteamID* pSteamID) {
-	return pSteamID->BContentServerAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ContentServerAccount=_BS_CSteamID_ContentServerAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ClanAccount(CSteamID* pSteamID) {
-	return pSteamID->BClanAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ClanAccount=_BS_CSteamID_ClanAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ChatAccount(CSteamID* pSteamID) {
-	return pSteamID->BChatAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ChatAccount=_BS_CSteamID_ChatAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsLobby(CSteamID* pSteamID) {
-	return pSteamID->IsLobby();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_IsLobby=_BS_CSteamID_IsLobby@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IndividualAccount(CSteamID* pSteamID) {
-	return pSteamID->BIndividualAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_IndividualAccount=_BS_CSteamID_IndividualAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonAccount(CSteamID* pSteamID) {
-	return pSteamID->BAnonAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_AnonAccount=_BS_CSteamID_AnonAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonUserAccount(CSteamID* pSteamID) {
-	return pSteamID->BAnonUserAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_AnonUserAccount=_BS_CSteamID_AnonUserAccount@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID) {
-	return pSteamID->BConsoleUserAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ConsoleUserAccount=_BS_CSteamID_ConsoleUserAccount@4")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID) {
-	pSteamID->SetAccountID(unAccountID);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_SetAccountID=_BS_CSteamID_SetAccountID@8")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance) {
-	pSteamID->SetAccountInstance(unInstance);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_SetAccountInstance=_BS_CSteamID_SetAccountInstance@8")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID) {
-	pSteamID->ClearIndividualInstance();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ClearIndividualInstance=_BS_CSteamID_ClearIndividualInstance@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID) {
-	return pSteamID->HasNoIndividualInstance();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_HasNoIndividualInstance=_BS_CSteamID_HasNoIndividualInstance@4")
-
-DLL_EXPORT AccountID_t DLL_CALL BS_CSteamID_GetAccountID(CSteamID* pSteamID) {
-	return pSteamID->GetAccountID();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetAccountID=_BS_CSteamID_GetAccountID@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GetAccountInstance(CSteamID* pSteamID) {
-	return pSteamID->GetUnAccountInstance();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetAccountInstance=_BS_CSteamID_GetAccountInstance@4")
-
-DLL_EXPORT EAccountType DLL_CALL BS_CSteamID_GetEAccountType(CSteamID* pSteamID) {
-	return pSteamID->GetEAccountType();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetEAccountType=_BS_CSteamID_GetEAccountType@4")
-
-DLL_EXPORT EUniverse DLL_CALL BS_CSteamID_GetEUniverse(CSteamID* pSteamID) {
-	return pSteamID->GetEUniverse();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetEUniverse=_BS_CSteamID_GetEUniverse@4")
-
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse) {
-	pSteamID->SetEUniverse(eUniverse);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_SetEUniverse=_BS_CSteamID_SetEUniverse@8")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsValid(CSteamID* pSteamID) {
-	return pSteamID->IsValid();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_IsValid=_BS_CSteamID_IsValid@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther) {
-	return (pSteamID == pSteamIDOther ? 1 : 0) + (pSteamID < pSteamIDOther ? 2 : 0) + (pSteamID > pSteamIDOther ? 4 : 0);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_Compare=_BS_CSteamID_Compare@8")

Helpers/CSteamID.h

@@ -1,56 +0,0 @@
-//	BlitzSteam - Steam wrapper for Blitz
-//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "dllmain.h"
-
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_New();
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromID(uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType);
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromIDInstance(uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType);
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromSteamID(uint64_t* ulSteamID);
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_Copy(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_Destroy(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_Set(CSteamID* pSteamID, uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType);
-DLL_EXPORT void DLL_CALL BS_CSteamID_InstancedSet(CSteamID* pSteamID, uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType);
-DLL_EXPORT void DLL_CALL BS_CSteamID_FullSet(CSteamID* pSteamID, uint64_t* ulIdentifier, EUniverse eUniverse, EAccountType eAccountType);
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_Clear(CSteamID* pSteamID);
-DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID);
-DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GameServerAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ContentServerAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ClanAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ChatAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsLobby(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IndividualAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonUserAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance);
-DLL_EXPORT void DLL_CALL BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID);
-DLL_EXPORT AccountID_t DLL_CALL BS_CSteamID_GetAccountID(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GetAccountInstance(CSteamID* pSteamID);
-DLL_EXPORT EAccountType DLL_CALL BS_CSteamID_GetEAccountType(CSteamID* pSteamID);
-DLL_EXPORT EUniverse DLL_CALL BS_CSteamID_GetEUniverse(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsValid(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther);

Helpers/Callbacks.cpp

@@ -1,62 +0,0 @@
-//	BlitzSteam - Steam wrapper for Blitz
-//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "dllmain.h"
-#include "Helpers/BlitzPointer.h"
-#include <time.h>
-
-// Callbacks
-class BS_Callback : CCallbackBase {
-	public:
-	uint32_t blitzFunctionPointer;
-
-	virtual void Run(void *pvParam) {
-		BP_CallFunction4((uint32_t)blitzFunctionPointer, (uint32_t)pvParam, 0, 0, 0);
-	}
-
-	virtual void Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall) {
-		BP_CallFunction4((uint32_t)blitzFunctionPointer, (uint32_t)pvParam, bIOFailure, (uint32_t)(hSteamAPICall & 0xFFFFFFFF), (uint32_t)(hSteamAPICall >> 32));
-	}
-
-	virtual int GetCallbackSizeBytes() {
-		return sizeof(BS_Callback);
-	}
-};
-
-DLL_EXPORT void* DLL_CALL BS_Helper_CreateCallback(uint32_t fpFunctionPointer) {
-	BS_Callback* lpBSCallback = new BS_Callback();
-	lpBSCallback->blitzFunctionPointer = fpFunctionPointer;
-	return lpBSCallback;
-}
-#pragma comment(linker, "/EXPORT:BS_Helper_CreateCallback=_BS_Helper_CreateCallback@4")
-
-DLL_EXPORT void DLL_CALL BS_Helper_DestroyCallback(uint32_t lpCallback) {
-	BS_Callback* lpBSCallback = (BS_Callback*)lpCallback;
-	if (lpBSCallback != nullptr) {
-		delete lpBSCallback;
-	}
-}
-#pragma comment(linker, "/EXPORT:BS_Helper_DestroyCallback=_BS_Helper_DestroyCallback@4")
-
-DLL_EXPORT const char* DLL_CALL BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat) {
-	char* output = new char[strlen(pchFormat) * 4];
-	time_t t = unTime;
-	struct tm *tm = localtime(&t);
-	strftime(output, sizeof(output), pchFormat, tm);
-	delete tm;
-	return output;
-}
-#pragma comment(linker, "/EXPORT:BS_Helper_FormatUnixTime=_BS_Helper_FormatUnixTime@8")

Helpers/Helper.cpp

@@ -0,0 +1,60 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Helper.h"
+
+DLL(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat) {
+	char* output = new char[strlen(pchFormat) * 4];
+	time_t t = unTime;
+	struct tm *tm = localtime(&t);
+	strftime(output, sizeof(output), pchFormat, tm);
+	delete tm;
+	return output;
+}
+
+DLL(void) BS_Helper_CopyMemoryIntMangle(void* pSource, void* pDest, int32_t iMangling,
+												 uint32_t iSourceW, uint32_t iSourceH, uint32_t iDestW, uint32_t iDestH,
+												 uint32_t iAreaX, uint32_t iAreaY, uint32_t iAreaW, uint32_t iAreaH) {
+	int8_t iMangleByte0 = static_cast<int8_t>((iMangling & 0xFF));
+	int8_t iMangleByte1 = static_cast<int8_t>((iMangling & 0xFF00) >> 8);
+	int8_t iMangleByte2 = static_cast<int8_t>((iMangling & 0xFF0000) >> 16);
+	int8_t iMangleByte3 = static_cast<int8_t>((iMangling & 0xFF000000) >> 24);
+	
+	// Start at beginning
+	for (uint32_t iY = iAreaY; iY < (iAreaY + iAreaH); iY++) {
+		// Only do this once per loop
+		for (uint32_t iX = iAreaX; iX < (iAreaX + iAreaW); iX++) {
+			// Could technically optimize the following into single instructions, but this is fast enough for now.
+			uint32_t* pSourceOff = reinterpret_cast<uint32_t*>(pSource) + ((iSourceW * iY) + iX);
+			uint32_t* pDestOff = reinterpret_cast<uint32_t*>(pDest) + ((iDestW * iY) + iX);
+
+			// Allow Mangling using just a single integer and checking on the fly if it's positive or negative to branch out to the correct shift.
+			*pDestOff =
+				(iMangleByte0 > 0 ?
+					(*pSourceOff & 0xFF) >> iMangleByte0 :
+					(*pSourceOff & 0xFF) << -iMangleByte0)
+				+ (iMangleByte1 > 0 ?
+					(*pSourceOff & 0xFF00) >> iMangleByte1 :
+					(*pSourceOff & 0xFF00) << -iMangleByte1) 
+				+ (iMangleByte2 > 0 ?
+					(*pSourceOff & 0xFF0000) >> iMangleByte2 :
+					(*pSourceOff & 0xFF0000) << -iMangleByte2)
+				+ (iMangleByte3 > 0 ?
+					(*pSourceOff & 0xFF000000) >> iMangleByte3 :
+					(*pSourceOff & 0xFF000000) << -iMangleByte3);
+		}
+	}
+}

Helpers/Helper.h

@@ -0,0 +1,21 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzSteam.h"
+#include <time.h>
+
+DLL(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat);

Readme.md

@@ -0,0 +1,41 @@
+# BlitzSteam - Steam wrapper for Blitz
+
+## Wrapped APIs
+
+* Steam: v1.36
+* SteamAppList: v1.36
+* SteamApps: v1.36
+* SteamClient: v1.36
+* SteamController: v1.36
+* SteamFriends: v1.36
+* SteamGameServer: v1.36
+* SteamGameServerStats: v1.36
+* SteamHTMLSurface: v1.36
+* SteamHTTP: v1.36
+* SteamInventory: v1.36
+* SteamMatchmaking: v1.36
+* SteamMatchmakingServers: v1.36
+* SteamMusic: -
+* SteamMusicRemote: -
+* SteamNetworking: v1.36
+* SteamRemoteStorage: -
+* SteamScreenshots: -
+* SteamUGC: -
+* SteamUnifiedMessages: -
+* SteamUser: v1.36
+* SteamUserStats: v1.36
+* SteamUtils: -
+* SteamVideo: -
+
+# Helping Out
+
+Install the Steamworks SDK to 'SteamworksSDK/' and then it should compile.
+
+# License
+Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.

Resources/BlitzSteam.ipf

@@ -0,0 +1,22 @@
+[IDEal Project file]
+<Settings>
+ Version="1"
+ Expanded="True"
+ Icon=""
+ MainFile="SteamHTMLSurface_Example.bb"
+ Compiler="Blitz3D"
+ CommandLine=""
+</Settings>
+<Folders>
+ AbsPath="\Examples" Expanded="True"
+</Folders>
+<Files>
+ AbsPath="\BlitzSteam.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\BlitzSteamUtility.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\Examples\SteamAPI_Example.bb" PrjFolder="\Examples" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\Examples\SteamAppList_Example.bb" PrjFolder="\Examples" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\Examples\SteamApps_Example.bb" PrjFolder="\Examples" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\Examples\SteamController_Example.bb" PrjFolder="\Examples" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\Examples\SteamHTMLSurface_Example.bb" PrjFolder="\Examples" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\Examples\SteamMatchmakingServers_Example.bb" PrjFolder="\Examples" Line="0" Column="0" Tip="0" Visible="False"
+</Files>

Resources/BlitzSteamUtility.bb

@@ -14,130 +14,61 @@
 ;	You should have received a copy of the GNU Lesser General Public License
 ;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
 
-;----------------------------------------------------------------
+;------------------------------------------------------------------------------
-; -- Constants
+;! Constants
-;----------------------------------------------------------------
+;------------------------------------------------------------------------------
 Const BSU_NAME_LENGTH					= 4096
 Const BSU_INSTALLDIR_LENGTH				= 4096
 Const BSU_APPID_COUNT					= 4096
 Const BSU_INSTALLEDDEPOTS_COUNT			= 4096
 
-;----------------------------------------------------------------
+;------------------------------------------------------------------------------
-; -- Globals
+;! Globals
-;----------------------------------------------------------------
+;------------------------------------------------------------------------------
 Global BSU_Initialized = False
 Global BSU_IsSteamRunning% = False
 ; -- Interfaces
-Global BSU_AppList%, BSU_Apps%, BSU_Client%, BSU_Controller%
+Global BSU_AppList%
-Global BSU_Friends%, BSU_HTTP%, BSU_HTMLSurface%, BSU_Inventory%
+Global BSU_Apps%
-Global BSU_Matchmaking%, BSU_MatchmakingServers%, BSU_Music%
+Global BSU_Client%
-Global BSU_MusicRemote%, BSU_Networking%, BSU_RemoteStorage%
+Global BSU_Controller%
-Global BSU_Screenshots%, BSU_UGC%, BSU_UnifiedMessages%, BSU_User%
+Global BSU_Friends%
-Global BSU_UserStats%, BSU_Utils%, BSU_Video%
+Global BSU_GameServer%
+Global BSU_GameServerStats%
+Global BSU_HTMLSurface%
+Global BSU_HTTP%
+Global BSU_Inventory%
+Global BSU_Matchmaking%
+Global BSU_MatchmakingServers%
+Global BSU_Music%
+Global BSU_MusicRemote%
+Global BSU_Networking%
+Global BSU_RemoteStorage%
+Global BSU_Screenshots%
+Global BSU_UGC%
+Global BSU_UnifiedMessages%
+Global BSU_User%
+Global BSU_UserStats%
+Global BSU_Utils%
+Global BSU_Video%
 
-;----------------------------------------------------------------
+;[Block] API: Steam
-; -- Types
+;------------------------------------------------------------------------------
-;----------------------------------------------------------------
+;! API: Steam
-Type BSU_App
+;------------------------------------------------------------------------------
-	Field AppId%
-	Field Name$
-	Field InstallDir$
-End Type
-
-Type BSU_DLC
-	Field AppId%
-	Field Available%
-	Field Name$
-End Type
-
-Type BSU_Depot
-	Field DepotId%
-End Type
-
-Type BSU_Friend
-	Field SteamID_L, SteamID_R
-	
-	Field Name$
-	Field NickName$
-	
-	Field Index%
-	Field Relationship%
-	Field State%
-	Field SteamLevel%
-End Type
-
-;----------------------------------------------------------------
-; -- Globals
-;----------------------------------------------------------------
-Global BSU_AppCount
-Global BSU_DLCCount
-Global BSU_DepotCount
-Global BSU_FriendCount
-
-;----------------------------------------------------------------
-; -- Functions
-;----------------------------------------------------------------
-; -- Utility
-; Writes a C-String value to a Bank.
-; Returns amount of bytes written.
-Function BSU_PokeCString%(Bank%, Pos%, Value$)
-	If Bank Then
-		Local BankSz = BankSize(Bank)
-		
-		If Pos < 0 Then Pos = 0
-		If Pos >= BankSz Then Pos = BankSz - 1
-		
-		Local ValuePos, ValueLen = Len(Value)
-		For ValuePos = 1 To ValueLen
-			; Don't write over the edge, we still need space for the 0-byte
-			If (Pos + ValuePos) >= (BankSz - 1) Then Exit
-			
-			PokeByte Bank, Pos + ValuePos, Asc(Mid(Value, ValuePos, 1))
-		Next
-		PokeByte Bank, Pos + ValuePos, 0
-		Return ValuePos
-	EndIf
-End Function
-
-; Reads a C-String value from a Bank.
-; Returns read C-String
-Function BSU_PeekCString$(Bank%, Pos%)
-	If Bank Then
-		Local BankSz = BankSize(Bank)
-		
-		If Pos < 0 Then Pos = 0
-		If Pos >= BankSz Then Pos = BankSz - 1
-		
-		Local OutStr$, OutLen = (BankSz - Pos)
-		Local BankPos
-		For BankPos = 0 To OutLen
-			If (Pos + BankPos) >= BankSz Then Exit
-			
-			Local Value = PeekByte(Bank, Pos + BankPos)
-			
-			If Value = 0 Then
-				Exit
-			Else
-				OutStr=OutStr+Chr(Value)
-			EndIf
-		Next
-		Return OutStr
-	EndIf
-End Function
-
-; -- Steam
 Function BSU_Init()
-	BSU_IsSteamRunning = BS_IsSteamRunning()
+	BSU_IsSteamRunning = BS_Steam_IsSteamRunning()
-	If BSU_IsSteamRunning Then
+	If BSU_IsSteamRunning And BS_Steam_Init() Then
-		BS_Init()
 		
 		BSU_AppList				= BS_AppList()
-		BSU_Apps					= BS_Apps()
+		BSU_Apps				= BS_Apps()
 		BSU_Client				= BS_Client()
 		BSU_Controller			= BS_Controller()
 		BSU_Friends				= BS_Friends()
-		BSU_HTTP					= BS_HTTP()
+		BSU_GameServer			= BS_GameServer()
+		BSU_GameServerStats		= BS_GameServerStats()
 		BSU_HTMLSurface			= BS_HTMLSurface()
+		BSU_HTTP				= BS_HTTP()
 		BSU_Inventory			= BS_Inventory()
 		BSU_Matchmaking			= BS_Matchmaking()
 		BSU_MatchmakingServers	= BS_MatchmakingServers()
@@ -148,8 +79,8 @@ Function BSU_Init()
 		BSU_Screenshots			= BS_Screenshots()
 		BSU_UGC					= BS_UGC()
 		BSU_UnifiedMessages		= BS_UnifiedMessages()
-		BSU_User					= BS_User()
+		BSU_User				= BS_User()
-		BSU_UserStats			= BS_UserStats()
+		BSU_UserStats			= BS_ISteamUserStats()
 		BSU_Utils				= BS_Utils()
 		BSU_Video				= BS_Video()
 		
@@ -159,15 +90,18 @@ End Function
 
 Function BSU_Shutdown()
 	If BSU_IsSteamRunning
-		BS_Shutdown()
+		BS_GameServer_Shutdown()
+		BS_Steam_Shutdown()
+		
 		BSU_AppList=0
 		BSU_Apps=0
 		BSU_Client=0
 		BSU_Controller=0
 		BSU_Friends=0
+		BSU_GameServer=0
+		BSU_GameServerStats=0
 		BSU_HTTP=0
 		BSU_HTMLSurface=0
-		BSU_Initialized=0
 		BSU_Matchmaking=0
 		BSU_MatchmakingServers=0
 		BSU_Music=0
@@ -185,8 +119,19 @@ Function BSU_Shutdown()
 		BSU_Initialized = False
 	EndIf
 End Function
+;[End Block]
+
+;[Block] API: AppList
+;------------------------------------------------------------------------------
+;! API: AppList
+;------------------------------------------------------------------------------
+Type BSU_App
+	Field AppId%
+	Field Name$
+	Field InstallDir$
+End Type
+Global BSU_AppCount = 0
 
-; -- SteamAppList
 Function BSU_AppList_GetInstalledApps(BankAppIdsStorage=0, BankAppNameStorage=0, BankAppInstallDirStorage=0)
 	Local BankAppIds, BankAppIdsSz = BSU_APPID_COUNT
 	Local BankAppName, BankAppNameSz = BSU_NAME_LENGTH
@@ -240,11 +185,11 @@ Function BSU_AppList_GetInstalledApps(BankAppIdsStorage=0, BankAppNameStorage=0,
 			
 			; Free temporary storage for name and installdir.
 			If BankAppInstallDirStorage = 0 Then FreeBank BankAppInstallDir
-			If BankAppNameStorage = 0 FreeBank BankAppName
+			If BankAppNameStorage = 0 Then FreeBank BankAppName
 		EndIf
 			
 		; Free temporary storage for AppIds.
-		If BankAppIdsStorage = 0 FreeBank BankAppIds
+		If BankAppIdsStorage = 0 Then FreeBank BankAppIds
 	EndIf
 End Function
 
@@ -303,8 +248,24 @@ Function BSU_AppList_GetInstallDir$(AppID%, BankStorage=0)
 	; Return name read.
 	Return AppInstallDir
 End Function
+;[End Block]
+
+;[Block] API: Apps
+;------------------------------------------------------------------------------
+;! API: Apps
+;------------------------------------------------------------------------------
+Type BSU_DLC
+	Field AppId%
+	Field Available%
+	Field Name$
+End Type
+Global BSU_DLCCount
+
+Type BSU_Depot
+	Field DepotId%
+End Type
+Global BSU_DepotCount
 
-; -- SteamApps
 Function BSU_Apps_GetDLCData(BankAppIdStorage=0, BankAvailableStorage=0, BankNameStorage=0)
 	Local BankAppId%, BankAvailable%
 	Local BankName%, BankNameSz% = BSU_NAME_LENGTH
@@ -516,9 +477,26 @@ Function BSU_Apps_GetDLCDownloadProgress#(nAppID%)
 	EndIf
 	Return Progress
 End Function
+;[End Block]
 
-; -- SteamFriends
+;[Block] API: Apps
-Function BSU_Friends_GetFriends(iFriendFlags=BS_EFriendFlags_All)
+;------------------------------------------------------------------------------
+;! API: Friends
+;------------------------------------------------------------------------------
+Type BSU_Friend
+	Field SteamID_L, SteamID_R
+	
+	Field Name$
+	Field NickName$
+	
+	Field Index%
+	Field Relationship%
+	Field State%
+	Field SteamLevel%
+End Type
+Global BSU_FriendCount
+
+Function BSU_Friends_GetFriends(iFriendFlags = BS_EFriendFlags_All)
 	If BSU_Initialized Then
 		Delete Each BSU_Friend
 		
@@ -551,6 +529,100 @@ Function BSU_Friends_GetFriends(iFriendFlags=BS_EFriendFlags_All)
 	EndIf
 End Function
 
+;[Block] API: GameServer
+;------------------------------------------------------------------------------
+;! API: GameServer
+;------------------------------------------------------------------------------
+Function BSU_GameServer_Init(IPv4%=0, Port%=27015, SteamPort%=27016, QueryPort=27017, ServerMode=BS_EServerMode_AuthenticationAndSecure, Version$="1.0.0.0")
+	If BS_SteamGameServer_Init(IPv4, SteamPort, Port, QueryPort, ServerMode, Version) Then
+		BSU_GameServer = BS_GameServer()
+		BSU_GameServerStats = BS_GameServerStats()
+		BSU_HTTP = BS_GameServerHTTP()
+		BSU_Inventory = BS_GameServerInventory()
+		BSU_Networking = BS_GameServerNetworking()
+		BSU_UGC = BS_GameServerUGC()
+		BSU_Utils = BS_GameServerUtils()
+		
+		BSU_Initialized = True
+	EndIf
+End Function
+
+Function BSU_GameServer_Shutdown()
+	If BSU_Initialized = True
+		BS_SteamGameServer_Shutdown()
+		
+		BSU_GameServer=0
+		BSU_GameServerStats=0
+		BSU_HTTP=0
+		BSU_Inventory=0
+		BSU_Networking=0
+		BSU_UGC=0
+		BSU_Utils=0
+		
+		BSU_Initialized = False
+	EndIf
+End Function
+;[End Block]
+
+;------------------------------------------------------------------------------
+;! API: GameServerStats
+;------------------------------------------------------------------------------
+
+
+
+;[Block] Blitz Stuff
+;----------------------------------------------------------------
+;! Blitz Stuff
+;----------------------------------------------------------------
+; -- Utility
+; Writes a C-String value to a Bank.
+; Returns amount of bytes written.
+Function BSU_PokeCString%(Bank%, Pos%, Value$)
+	If Bank Then
+		Local BankSz = BankSize(Bank)
+		
+		If Pos < 0 Then Pos = 0
+		If Pos >= BankSz Then Pos = BankSz - 1
+		
+		Local ValuePos, ValueLen = Len(Value)
+		For ValuePos = 1 To ValueLen
+			; Don't write over the edge, we still need space for the 0-byte
+			If (Pos + ValuePos) >= (BankSz - 1) Then Exit
+			
+			PokeByte Bank, Pos + ValuePos, Asc(Mid(Value, ValuePos, 1))
+		Next
+		PokeByte Bank, Pos + ValuePos, 0
+		Return ValuePos
+	EndIf
+End Function
+
+; Reads a C-String value from a Bank.
+; Returns read C-String
+Function BSU_PeekCString$(Bank%, Pos%, Len%=-1)
+	If Bank Then
+		Local BankSz = BankSize(Bank)
+		
+		If Pos < 0 Then Pos = 0
+		If Pos >= BankSz Then Pos = BankSz - 1
+		
+		Local OutStr$, OutLen = (BankSz - Pos)
+		Local BankPos
+		For BankPos = 0 To OutLen
+			If (Pos + BankPos) >= BankSz Then Exit
+			
+			Local Value = PeekByte(Bank, Pos + BankPos)
+			
+			If (Value = 0 And Len = -1) Or (Pos > Len) Then
+				Exit
+			Else
+				OutStr=OutStr+Chr(Value)
+			EndIf
+		Next
+		Return OutStr
+	EndIf
+End Function
+;[End Block]
+
 ;~IDEal Editor Parameters:
-;~F#52#67#80#9F#BD#FA#116#133#163#195#1B1#1D0
+;~F#3A#5A#7F#86#C3#DF#100#107#10C#13C#16E#18A#1A9#1C4
 ;~C#Blitz3D

Resources/Decls/BlitzSteam.decls

@@ -0,0 +1,23 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+; Generic ---------------------------------------------------------------------
+BS_Helper_FormatUnixTime$(unixTime%, pchFormat$)								:"_BS_Helper_FormatUnixTime@8"
+BS_Helper_CopyMemoryIntMangle(pSource%, pDest%, iMangling%, iSourceW%, iSourceH%, iDestW%, iDestH%, iAreaX%, iAreaY%, iAreaW%, iAreaH%):"_BS_Helper_CopyMemoryIntMangle@44"
+
+BS_BlitzPointer_GetReturnAddress%()												:"_BS_BlitzPointer_GetReturnAddress@0"
+BS_BlitzPointer_GetFunctionPointer%()											:"_BS_BlitzPointer_GetFunctionPointer@0"

Resources/Decls/BlitzSteam_BlitzCallback.decls

@@ -0,0 +1,33 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+; BlitzCallback ---------------------------------------------------------------
+BS_Callback_New%(pFunction%)													:"_BS_Callback_New@4"
+BS_Callback_Destroy(pThis%)														:"_BS_Callback_Destroy@4"
+BS_Callback_GetCallbackSizeBytes%(pThis%)										:"_BS_Callback_GetCallbackSizeBytes@4"
+BS_Callback_SetCallback(pThis%, iCallback%)										:"_BS_Callback_SetCallback@8"
+BS_Callback_GetCallback%(pThis%)												:"_BS_Callback_GetCallback@4"
+BS_Callback_SetFunction(pThis%, pFunction%)										:"_BS_Callback_SetFunction@8"
+BS_Callback_GetFunction%(pThis%)												:"_BS_Callback_GetFunction@4"
+BS_Callback_SetRegistered(pThis%, bIsRegistered%)								:"_BS_Callback_SetRegistered@8"
+BS_Callback_IsRegistered%(pThis%)												:"_BS_Callback_IsRegistered@4"
+BS_Callback_SetGameServer(pThis%, bIsGameServer%)								:"_BS_Callback_SetGameServer@8"
+BS_Callback_IsGameServer%(pThis%)												:"_BS_Callback_IsGameServer@4"
+BS_Callback_Register(pThis%, iCallback%)										:"_BS_Callback_Register@8"
+BS_Callback_Unregister(pThis%)													:"_BS_Callback_Unregister@4"
+BS_Callback_RegisterResult(pThis%, lSteamAPICall%, iCallback%)					:"_BS_Callback_RegisterResult@12"
+BS_Callback_UnregisterResult(pThis%)											:"_BS_Callback_UnregisterResult@4"

Resources/Decls/BlitzSteam_CSteamID.decls

@@ -0,0 +1,55 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+; CSteamID --------------------------------------------------------------------
+BS_CSteamID_New%()																:"_BS_CSteamID_New@0"
+BS_CSteamID_Copy%(pThis%)														:"_BS_CSteamID_Copy@4"
+BS_CSteamID_Destroy(pThis%)														:"_BS_CSteamID_Destroy@4"
+BS_CSteamID_New_IdUniverseType%(iAccountId%, EUniverse%, EAccountType%)			:"_BS_CSteamID_New_IdUniverseType@12"
+BS_CSteamID_New_IdInstanceUniverseType%(iAccountId%, iInstance%, EUniverse%, EAccountType%):"_BS_CSteamID_New_IdInstanceUniverseType@16"
+BS_CSteamID_FromL%(pOther%)														:"_BS_CSteamID_FromL@4"
+BS_CSteamID_ToL%(pThis%)														:"_BS_CSteamID_ToL@4"
+BS_CSteamID_Set(pThis%, iAccountId%, EUniverse%, EAccountType%)					:"_BS_CSteamID_Set@16"
+BS_CSteamID_InstancedSet(pThis%, iAccountId%, iInstance%, EUniverse%, EAccountType%):"_BS_CSteamID_InstancedSet@20"
+BS_CSteamID_FullSet(pThis%, plIdentifier%, EUniverse%, EAccountType%)			:"_BS_CSteamID_FullSet@16"
+BS_CSteamID_SetFromLong(pthis%, plSteamID%)										:"_BS_CSteamID_SetFromLong@8"
+BS_CSteamID_Clear(pThis%)														:"_BS_CSteamID_Clear@4"
+BS_CSteamID_GetStaticAccountKey%(pThis%)										:"_BS_CSteamID_GetStaticAccountKey@4"
+BS_CSteamID_CreateBlankAnonLogon(pThis%, EUniverse%)							:"_BS_CSteamID_CreateBlankAnonLogon@8"
+BS_CSteamID_CreateBlankAnonUserLogon(pThis%, EUniverse%)						:"_BS_CSteamID_CreateBlankAnonUserLogon@8"
+BS_CSteamID_IsBlankAnonAccount%(pThis%)											:"_BS_CSteamID_IsBlankAnonAccount@4"
+BS_CSteamID_IsGameServerAccount%(pThis%)										:"_BS_CSteamID_IsGameServerAccount@4"
+BS_CSteamID_IsPersistentGameServerAccount%(pThis%)								:"_BS_CSteamID_IsPersistentGameServerAccount@4"
+BS_CSteamID_IsAnonGameServerAccount%(pThis%)									:"_BS_CSteamID_IsAnonGameServerAccount@4"
+BS_CSteamID_IsContentServerAccount%(pThis%)										:"_BS_CSteamID_IsContentServerAccount@4"
+BS_CSteamID_IsClanAccount%(pThis%)												:"_BS_CSteamID_IsClanAccount@4"
+BS_CSteamID_IsChatAccount%(pThis%)												:"_BS_CSteamID_IsChatAccount@4"
+BS_CSteamID_IsLobby%(pThis%)													:"_BS_CSteamID_IsLobby@4"
+BS_CSteamID_IsIndividualAccount%(pThis%)										:"_BS_CSteamID_IsIndividualAccount@4"
+BS_CSteamID_IsAnonAccount%(pThis%)												:"_BS_CSteamID_IsAnonAccount@4"
+BS_CSteamID_IsAnonUserAccount%(pThis%)											:"_BS_CSteamID_IsAnonUserAccount@4"
+BS_CSteamID_IsConsoleUserAccount%(pThis%)										:"_BS_CSteamID_IsConsoleUserAccount@4"
+BS_CSteamID_SetAccountID(pThis%, iAccountId%)									:"_BS_CSteamID_SetAccountID@8"
+BS_CSteamID_GetAccountID%(pThis%)												:"_BS_CSteamID_GetAccountID@4"
+BS_CSteamID_SetAccountInstance(pThis%, iInstance%)								:"_BS_CSteamID_SetAccountInstance@8"
+BS_CSteamID_ClearIndividualInstance(pThis%)										:"_BS_CSteamID_ClearIndividualInstance@4"
+BS_CSteamID_HasNoIndividualInstance%(pThis%)									:"_BS_CSteamID_HasNoIndividualInstance@4"
+BS_CSteamID_GetAccountInstance%(pThis%)											:"_BS_CSteamID_GetAccountInstance@4"
+BS_CSteamID_GetEAccountType%(pThis%)											:"_BS_CSteamID_GetEAccountType@4"
+BS_CSteamID_SetEUniverse%(pThis%, EUniverse%)									:"_BS_CSteamID_SetEUniverse@8"
+BS_CSteamID_GetEUniverse%(pThis%)												:"_BS_CSteamID_GetEUniverse@4"
+BS_CSteamID_Compare%(pThis%, pOther%)											:"_BS_CSteamID_Compare@8"

Resources/Decls/BlitzSteam_Double.decls

@@ -0,0 +1,42 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	aDouble with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+; Double ------------------------------------------------------------------------
+BS_Double_New%()																:"_BS_Double_New@0"
+BS_Double_Copy%(pThis%)															:"_BS_Double_Copy@4"
+BS_Double_Destroy(pThis%)														:"_BS_Double_Destroy@4"
+BS_Double_ToString$(pThis%)														:"_BS_Double_ToString@4"
+BS_Double_FromString%(cString$)													:"_BS_Double_FromString@4"
+BS_Double_FromF%(Float#)														:"_BS_Double_FromF@4"
+BS_Double_ToF#(pThis%)															:"_BS_Double_ToF@4"
+BS_Double_FromI%(iRight%)														:"_BS_Double_FromI@4"
+BS_Double_ToI%(pThis%)															:"_BS_Double_ToI@8"
+BS_Double_FromL(pDouble%)														:"_BS_Double_FromL@4"
+BS_Double_ToL(pThis%)															:"_BS_Double_ToL@4"
+BS_Double_Compare%(pThis%, pOther%)												:"_BS_Double_Compare@8"
+BS_Double_Set%(pThis%, pOther%)													:"_BS_Double_Set@8"
+BS_Double_Add%(pThis%, pOther%)													:"_BS_Double_Add@8"
+BS_Double_Sub%(pThis%, pOther%)													:"_BS_Double_Sub@8"
+BS_Double_Div%(pThis%, pOther%)													:"_BS_Double_Div@8"
+BS_Double_Mul%(pThis%, pOther%)													:"_BS_Double_Mul@8"
+BS_Double_Mod%(pThis%, pOther%)													:"_BS_Double_Mod@8"
+BS_Double_SetF%(pThis%, fOther%)												:"_BS_Double_SetF@8"
+BS_Double_AddF%(pThis%, fOther%)												:"_BS_Double_AddF@8"
+BS_Double_SubF%(pThis%, fOther%)												:"_BS_Double_SubF@8"
+BS_Double_DivF%(pThis%, fOther%)												:"_BS_Double_DivF@8"
+BS_Double_MulF%(pThis%, fOther%)												:"_BS_Double_MulF@8"
+BS_Double_ModF%(pThis%, fOther%)												:"_BS_Double_ModF@8"

Resources/Decls/BlitzSteam_Long.decls

@@ -0,0 +1,52 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+; Long ------------------------------------------------------------------------
+BS_Long_New%()																	:"_BS_Long_New@0"
+BS_Long_Copy%(pThis%)															:"_BS_Long_Copy@4"
+BS_Long_Destroy(pThis%)															:"_BS_Long_Destroy@4"
+BS_Long_ToString$(pThis%)														:"_BS_Long_ToString@4"
+BS_Long_FromString%(cString$)													:"_BS_Long_FromString@4"
+BS_Long_FromI%(iRight%)															:"_BS_Long_FromI@4"
+BS_Long_FromII%(iLeft%, iRight%)												:"_BS_Long_FromII@8"
+BS_Long_ToI%(pThis%, iShift%)													:"_BS_Long_ToI@8"
+BS_Long_ToIH%(pThis%)															:"_BS_Long_ToIH@4"
+BS_Long_ToIL%(pThis%)															:"_BS_Long_ToIL@4"
+BS_Long_FromF%(Float#)															:"_BS_Long_FromF@4"
+BS_Long_ToF#(pThis%)															:"_BS_Long_ToF@4"
+BS_Long_FromD(pDouble%)															:"_BS_Long_FromD@4"
+BS_Long_ToD(pThis%)																:"_BS_Long_ToD@4"
+BS_Long_Compare%(pThis%, pRight%)												:"_BS_Long_Compare@8"
+BS_Long_Set%(pThis%, pOther%)													:"_BS_Long_Set@8"
+BS_Long_Add%(pThis%, pOther%)													:"_BS_Long_Add@8"
+BS_Long_Sub%(pThis%, pOther%)													:"_BS_Long_Sub@8"
+BS_Long_Div%(pThis%, pOther%)													:"_BS_Long_Div@8"
+BS_Long_Mul%(pThis%, pOther%)													:"_BS_Long_Mul@8"
+BS_Long_Mod%(pThis%, pOther%)													:"_BS_Long_Mod@8"
+BS_Long_SetI%(pThis%, iRight%)													:"_BS_Long_SetI@8"
+BS_Long_AddI%(pThis%, iRight%)													:"_BS_Long_AddI@8"
+BS_Long_SubI%(pThis%, iRight%)													:"_BS_Long_SubI@8"
+BS_Long_DivI%(pThis%, iRight%)													:"_BS_Long_DivI@8"
+BS_Long_MulI%(pThis%, iRight%)													:"_BS_Long_MulI@8"
+BS_Long_ModI%(pThis%, iRight%)													:"_BS_Long_ModI@8"
+BS_Long_SetII%(pThis%, iLeft%, iRight%)											:"_BS_Long_SetII@12"
+BS_Long_AddII%(pThis%, iLeft%, iRight%)											:"_BS_Long_AddII@12"
+BS_Long_SubII%(pThis%, iLeft%, iRight%)											:"_BS_Long_SubII@12"
+BS_Long_DivII%(pThis%, iLeft%, iRight%)											:"_BS_Long_DivII@12"
+BS_Long_MulII%(pThis%, iLeft%, iRight%)											:"_BS_Long_MulII@12"
+BS_Long_ModII%(pThis%, iLeft%, iRight%)											:"_BS_Long_ModII@12"
+BS_Long_Shift%(pThis%, iRight%)													:"_BS_Long_Shift@8"

Resources/Decls/BlitzSteam_Memory.decls

@@ -0,0 +1,33 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+; Memory ----------------------------------------------------------------------
+BS_Memory_Alloc%(iSize%)														:"_BS_Memory_Alloc@4"
+BS_Memory_ReAlloc%(pMemory%, iSize%)											:"_BS_Memory_ReAlloc@8"
+BS_Memory_Free(pMemory%)														:"_BS_Memory_Free@4"
+BS_Memory_PokeByte(pMemory%, iOffset%, bValue%)									:"_BS_Memory_PokeByte@12"
+BS_Memory_PeekByte%(pMemory%, iOffset%)											:"_BS_Memory_PeekByte@8"
+BS_Memory_PokeShort(pMemory%, iOffset%, sValue%)								:"_BS_Memory_PokeShort@12"
+BS_Memory_PeekShort%(pMemory%, iOffset%)										:"_BS_Memory_PeekShort@8"
+BS_Memory_PokeInt(pMemory%, iOffset%, iValue%)									:"_BS_Memory_PokeInt@12"
+BS_Memory_PeekInt%(pMemory%, iOffset%)											:"_BS_Memory_PeekInt@8"
+BS_Memory_PokeFloat(pMemory%, iOffset%, fValue#)								:"_BS_Memory_PokeFloat@12"
+BS_Memory_PeekFloat#(pMemory%, iOffset%)										:"_BS_Memory_PeekFloat@8"
+BS_Memory_PokeLong(pMemory%, iOffset%, lValue%)									:"_BS_Memory_PokeLong@12"
+BS_Memory_PeekLong%(pMemory%, iOffset%)											:"_BS_Memory_PeekLong@8"
+BS_Memory_PokeDouble(pMemory%, iOffset%, dValue%)								:"_BS_Memory_PokeDouble@12"
+BS_Memory_PeekDouble%(pMemory%, iOffset%)										:"_BS_Memory_PeekDouble@8"

Resources/Decls/BlitzSteam_Steam.decls

@@ -0,0 +1,28 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Steam -----------------------------------------------------------------------
+BS_SteamAPI_Init%()																:"_BS_SteamAPI_Init@0"
+BS_SteamAPI_Shutdown()															:"_BS_SteamAPI_Shutdown@0"
+BS_SteamAPI_IsSteamRunning%()													:"_BS_SteamAPI_IsSteamRunning@0"
+BS_SteamAPI_RestartAppIfNecessary%(iAppId%)										:"_BS_SteamAPI_RestartAppIfNecessary@4"
+BS_SteamAPI_SetMiniDumpComment(cComment$)										:"_BS_SteamAPI_SetMiniDumpComment@4"
+BS_SteamAPI_WriteMiniDump(iExceptionCode%, pExceptionInfo*, iBuildId%)			:"_BS_SteamAPI_WriteMiniDump@12"
+BS_SteamAPI_WriteMiniDumpEx(iExceptionCode%, pExceptionInfo%, iBuildId%)		:"_BS_SteamAPI_WriteMiniDump@12"
+BS_SteamAPI_ReleaseCurrentThreadMemory%()										:"_BS_SteamAPI_ReleaseCurrentThreadMemory@0"
+BS_SteamAPI_RunCallbacks()														:"_BS_SteamAPI_RunCallbacks@0"

Resources/Decls/BlitzSteam_SteamAppList.decls

@@ -0,0 +1,28 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; AppList ---------------------------------------------------------------------
+BS_SteamAppList%()																:"_BS_SteamAppList@0"
+BS_ISteamAppList_GetNumInstalledApps%(pThis%)									:"_BS_ISteamAppList_GetNumInstalledApps@4"
+BS_ISteamAppList_GetInstalledApps%(pThis%, pAppIdBuffer*, iMaxIDs%)				:"_BS_ISteamAppList_GetInstalledApps@12"
+BS_ISteamAppList_GetInstalledAppsEx%(pThis%, pAppIdBuffer%, iMaxIDs%)			:"_BS_ISteamAppList_GetInstalledApps@12"
+BS_ISteamAppList_GetAppName%(pThis%, iAppId%, pNameBuffer*, iNameMax%)			:"_BS_ISteamAppList_GetAppName@12"
+BS_ISteamAppList_GetAppNameEx%(pThis%, iAppId%, pNameBuffer%, iNameMax%)		:"_BS_ISteamAppList_GetAppName@12"
+BS_ISteamAppList_GetAppInstallDir%(pThis%, iAppId%, pPathBuffer*, iPathMax%)	:"_BS_ISteamAppList_GetAppInstallDir@16"
+BS_ISteamAppList_GetAppInstallDirEx%(pThis%, iAppId%, pPathBuffer%, iPathMax%)	:"_BS_ISteamAppList_GetAppInstallDir@16"
+BS_ISteamAppList_GetAppBuildId%(pThis%, iAppId%)								:"_BS_ISteamAppList_GetAppBuildId@8"

Resources/Decls/BlitzSteam_SteamApps.decls

@@ -0,0 +1,49 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Apps ------------------------------------------------------------------------
+BS_SteamApps%()																	:"_BS_SteamApps@0"
+BS_ISteamApps_IsSubscribed%(pThis%)												:"_BS_ISteamApps_IsSubscribed@4"
+BS_ISteamApps_IsLowViolence%(pThis%)											:"_BS_ISteamApps_IsLowViolence@4"
+BS_ISteamApps_IsCybercafe%(pThis%)												:"_BS_ISteamApps_IsCybercafe@4"
+BS_ISteamApps_IsVACBanned%(pThis%)												:"_BS_ISteamApps_IsVACBanned@4"
+BS_ISteamApps_GetCurrentGameLanguage$(pThis%)									:"_BS_ISteamApps_GetCurrentGameLanguage@4"
+BS_ISteamApps_GetAvailableGameLanguages$(pThis%)								:"_BS_ISteamApps_GetAvailableGameLanguages@4"
+BS_ISteamApps_IsSubscribedApp%(pThis%, iAppId%)									:"_BS_ISteamApps_IsSubscribedApp@8"
+BS_ISteamApps_IsDlcInstalled%(pThis%, iAppId%)									:"_BS_ISteamApps_IsDlcInstalled@8"
+BS_ISteamApps_GetEarliestPurchaseUnixTime%(pThis%, iAppId%)						:"_BS_ISteamApps_GetEarliestPurchaseUnixTime@8"
+BS_ISteamApps_IsSubscribedFromFreeWeekend%(pThis%)								:"_BS_ISteamApps_IsSubscribedFromFreeWeekend@4"
+BS_ISteamApps_GetDLCCount%(pThis%)												:"_BS_ISteamApps_GetDLCCount@4"
+BS_ISteamApps_GetDLCDataByIndex%(pThis%, iDLC%, pAppId*, pAvailable*, pName*, iNameSize%):"_BS_ISteamApps_GetDLCDataByIndex@24"
+BS_ISteamApps_GetDLCDataByIndexEx%(pThis%, iDLC%, pAppId%, pAvailable%, pName%, iNameSize%):"_BS_ISteamApps_GetDLCDataByIndex@24"
+BS_ISteamApps_InstallDLC(pThis%, iAppId%)										:"_BS_ISteamApps_InstallDLC@8"
+BS_ISteamApps_UninstallDLC(pThis%, iAppId%)										:"_BS_ISteamApps_UninstallDLC@8"
+BS_ISteamApps_RequestAppProofOfPurchaseKey(pThis%, iAppId%)						:"_BS_ISteamApps_RequestAppProofOfPurchaseKey@8"
+BS_ISteamApps_GetCurrentBetaName%(pThis%, pName*, iNameSize%)					:"_BS_ISteamApps_GetCurrentBetaName@12"
+BS_ISteamApps_GetCurrentBetaNameEx%(pThis%, pName%, iNameSize%)					:"_BS_ISteamApps_GetCurrentBetaName@12"
+BS_ISteamApps_MarkContentCorrupt%(pThis%, bMissingFilesOnly%)					:"_BS_ISteamApps_MarkContentCorrupt@8"
+BS_ISteamApps_GetInstalledDepots%(pThis%, iAppId%, pDepots*, iMaxDepots%)		:"_BS_ISteamApps_GetInstalledDepots@16"
+BS_ISteamApps_GetInstalledDepotsEx%(pThis%, iAppId%, pDepots%, iMaxDepots%)		:"_BS_ISteamApps_GetInstalledDepots@16"
+BS_ISteamApps_GetAppInstallDir%(pThis%, iAppId%, pPathBuffer*, iPathBufferSize%):"_BS_ISteamApps_GetAppInstallDir@16"
+BS_ISteamApps_GetAppInstallDirEx%(pThis%, iAppId%, pPathBuffer%, iPathBufferSize%):"_BS_ISteamApps_GetAppInstallDir@16"
+BS_ISteamApps_IsAppInstalled%(pThis%, iAppId%)									:"_BS_ISteamApps_IsAppInstalled@8"
+BS_ISteamApps_GetAppOwner%(pThis%)												:"_BS_ISteamApps_GetAppOwner@4"
+BS_ISteamApps_GetLaunchQueryParam$(pThis%, cKey$)								:"_BS_ISteamApps_GetLaunchQueryParam@8"
+BS_ISteamApps_GetDlcDownloadProgress%(pThis%, iAppId%, llDownloaded*, llTotal*)	:"_BS_ISteamApps_GetDlcDownloadProgress@16"
+BS_ISteamApps_GetDlcDownloadProgressEx%(pThis%, iAppId%, llDownloaded%, llTotal%):"_BS_ISteamApps_GetDlcDownloadProgress@16"
+BS_ISteamApps_GetAppBuildId%(pThis%)											:"_BS_ISteamApps_GetAppBuildId@4"

Resources/Decls/BlitzSteam_SteamClient.decls

@@ -0,0 +1,51 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Client ----------------------------------------------------------------------
+BS_SteamClient%()																:"_BS_SteamClient@0"
+BS_ISteamClient_CreateSteamPipe%(pThis%)										:"_BS_ISteamClient_CreateSteamPipe@4"
+BS_ISteamClient_ReleaseSteamPipe%(pThis%, hPipe%)								:"_BS_ISteamClient_ReleaseSteamPipe@8"
+BS_ISteamClient_ConnectToGlobalUser%(pThis%, hPipe%)							:"_BS_ISteamClient_ConnectToGlobalUser@8"
+BS_ISteamClient_SetLocalIPBinding(pThis, unIP%, usPort%)						:"_BS_ISteamClient_SetLocalIPBinding@12"
+BS_ISteamClient_CreateLocalUser%(pThis%, pSteamPipe%, EAccountType%)			:"_BS_ISteamClient_CreateLocalUser@12"
+BS_ISteamClient_ReleaseUser(pThis%, hPipe%, hUser%)								:"_BS_ISteamClient_ReleaseUser@12"
+BS_ISteamClient_GetIPCCallCount%(pThis%)										:"_BS_ISteamClient_GetIPCCallCount@4"
+BS_ISteamClient_ShutdownIfAllPipesClosed%(pThis%)								:"_BS_ISteamClient_ShutdownIfAllPipesClosed@4"
+BS_ISteamClient_GetSteamAppList%(pThis%, hUser%, hPipe%, cVersion$)				:"_BS_ISteamClient_GetSteamAppList@16"
+BS_ISteamClient_GetSteamApps%(pThis%, hUser%, hPipe%, cVersion$)				:"_BS_ISteamClient_GetSteamApps@16"
+BS_ISteamClient_GetSteamController%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamController@16"
+BS_ISteamClient_GetSteamFriends%(pThis%, hUser%, hPipe%, cVersion$)				:"_BS_ISteamClient_GetSteamFriends@16"
+BS_ISteamClient_GetSteamGameServer%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamGameServer@16"
+BS_ISteamClient_GetSteamGameServerStats%(pThis%, hUser%, hPipe%, cVersion$)		:"_BS_ISteamClient_GetSteamGameServerStats@16"
+BS_ISteamClient_GetSteamHTMLSurface%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamHTMLSurface@16"
+BS_ISteamClient_GetSteamHTTP%(pThis%, hUser%, hPipe%, cVersion$)				:"_BS_ISteamClient_GetSteamHTTP@16"
+BS_ISteamClient_GetSteamInventory%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamInventory@16"
+BS_ISteamClient_GetSteamMatchmaking%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamMatchmaking@16"
+BS_ISteamClient_GetSteamMatchmakingServers%(pThis%, hUser%, hPipe%, cVersion$)	:"_BS_ISteamClient_GetSteamMatchmakingServers@16"
+BS_ISteamClient_GetSteamMusic%(pThis%, hUser%, hPipe%, cVersion$)				:"_BS_ISteamClient_GetSteamMusic@16"
+BS_ISteamClient_GetSteamMusicRemote%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamMusicRemote@16"
+BS_ISteamClient_GetSteamNetworking%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamNetworking@16"
+BS_ISteamClient_GetSteamRemoteStorage%(pThis%, hUser%, hPipe%, cVersion$)		:"_BS_ISteamClient_GetSteamRemoteStorage@16"
+BS_ISteamClient_GetSteamScreenshots%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamScreenshots@16"
+BS_ISteamClient_GetSteamUGC%(pThis%, hUser%, hPipe%, cVersion$)					:"_BS_ISteamClient_GetSteamUGC@16"
+BS_ISteamClient_GetSteamUnifiedMessages%(pThis%, hUser%, hPipe%, cVersion$)		:"_BS_ISteamClient_GetSteamUnifiedMessages@16"
+BS_ISteamClient_GetSteamUser%(pThis%, hUser%, hPipe%, cVersion$)				:"_BS_ISteamClient_GetSteamUser@16"
+BS_ISteamClient_GetSteamUserStats%(pThis%, hUser%, hPipe%, cVersion$)			:"_BS_ISteamClient_GetSteamUserStats@16"
+BS_ISteamClient_GetSteamUtils%(pThis%, hPipe%, cVersion$)						:"_BS_ISteamClient_GetSteamUtils@12"
+BS_ISteamClient_GetSteamVideo%(pThis%, hUser%, hPipe%, cVersion$)				:"_BS_ISteamClient_GetSteamVideo@16"
+BS_ISteamClient_SetWarningMessageHook(pThis%, pFunction%)						:"_BS_ISteamClient_SetWarningMessageHook@8"

Resources/Decls/BlitzSteam_SteamController.decls

@@ -0,0 +1,48 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Controller ------------------------------------------------------------------
+BS_SteamController%()														:"_BS_SteamController@0"
+BS_SteamController_Init%(pThis%, cControlConfigVDF$)						:"_BS_ISteamController_Init@8"
+BS_ISteamController_Shutdown%(pThis%)										:"_BS_ISteamController_Shutdown@4"
+BS_ISteamController_RunFrame(pThis%)										:"_BS_ISteamController_RunFrame@4"
+BS_ISteamController_GetConnectedControllers%(pThis%, pHandles*)				:"_BS_ISteamController_GetConnectedControllers@8"
+BS_ISteamController_GetConnectedControllersEx%(pThis%, pHandles%)			:"_BS_ISteamController_GetConnectedControllers@8"
+BS_ISteamController_GetConnectedControllersSimple%(pThis%)					:"_BS_ISteamController_GetConnectedControllersSimple@4"
+BS_ISteamController_GetConnectedControllersSimple_Index%(iIndex%)			:"_BS_ISteamController_GetConnectedControllersSimple@4"
+BS_ISteamController_ShowBindingPanel%(pThis%, pController%)					:"_BS_ISteamController_ShowBindingPanel@8"
+BS_ISteamController_GetActionSetHandle%(pThis%, cSetName$)					:"_BS_ISteamController_GetActionSetHandle@8"
+;! Returns: ControllerActionSetHandle_t*. Clean Up!
+BS_ISteamController_ActivateActionSet(pThis%, pController%, pActionSet%)	:"_BS_ISteamController_ActivateActionSet@12"
+BS_ISteamController_GetCurrentActionSet%(pThis%, pController%)				:"_BS_ISteamController_GetCurrentActionSet@8"
+;! Returns: ControllerActionSetHandle_t*. Clean Up!
+BS_ISteamController_GetDigitalActionHandle%(pThis%, cName$)					:"_BS_ISteamController_GetDigitalActionHandle@8"
+;! Returns: ControllerDigitalActionHandle_t*. Clean Up!
+BS_ISteamController_GetDigitalActionData%(pThis%, pController%, pDigital%)	:"_BS_ISteamController_GetDigitalActionData@12"
+;! Returns: ControllerDigitalActionData_t*. Clean Up!
+BS_ISteamController_GetDigitalActionOrigins%(pThis%, pController%, pActionSet%, pDigital%, pEControllerActionOrigin*):"_BS_ISteamController_GetDigitalActionOrigins@20"
+BS_ISteamController_GetDigitalActionOriginsEx%(pThis%, pController%, pActionSet%, pDigital%, pEControllerActionOrigin%):"_BS_ISteamController_GetDigitalActionOrigins@20"
+BS_ISteamController_GetAnalogActionHandle%(pThis%, cName$)					:"_BS_ISteamController_GetAnalogActionHandle@8"
+;! Returns: ControllerAnalogActionHandle_t*. Clean Up!
+BS_ISteamController_GetAnalogActionData%(pThis%, pController%, pAnalog%)	:"_BS_ISteamController_GetAnalogActionData@12"
+;! Returns: ControllerAnalogActionData_t*. Clean Up!
+BS_ISteamController_GetAnalogActionOrigins%(pThis%, pController%, pActionSet%, pAnalog%, pEControllerActionOrigin*):"_BS_ISteamController_GetAnalogActionOrigins@20"
+BS_ISteamController_GetAnalogActionOriginsEx%(pThis%, pController%, pActionSet%, pAnalog%, pEControllerActionOrigin*):"_BS_ISteamController_GetAnalogActionOrigins@20"
+BS_ISteamController_StopAnalogActionMomentum(pThis%, pController%, pAnalog%):"_BS_ISteamController_StopAnalogActionMomentum@12"
+BS_ISteamController_TriggerHapticPulse(pThis%, pController%, ESteamControllerPad%, iDuration%):"_BS_ISteamController_TriggerHapticPulse@16"
+BS_ISteamController_TriggerRepeatedHapticPulse(pThis%, pController%, ESteamControllerPad%, iDuration%, iOffDuration%, iRepeats%, iFlags%):"_BS_ISteamController_TriggerRepeatedHapticPulse@28"

Resources/Decls/BlitzSteam_SteamFriends.decls

@@ -0,0 +1,104 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Friends ---------------------------------------------------------------------
+BS_SteamFriends%()																:"_BS_SteamFriends@0"
+BS_ISteamFriends_GetPersonaName$(pThis%)										:"_BS_ISteamFriends_GetPersonaName@4"
+BS_ISteamFriends_SetPersonaName%(pThis%, cPersonaName$)							:"_BS_ISteamFriends_SetPersonaName@8"
+;! Returns: SteamAPICall_t*. Clean Up!
+BS_ISteamFriends_GetPersonaState%(pThis%)										:"_BS_ISteamFriends_GetPersonaState@4"
+BS_ISteamFriends_GetFriendCount%(pThis%, EFriendFlags%)							:"_BS_ISteamFriends_GetFriendCount@8"
+BS_ISteamFriends_GetFriendByIndex%(pThis%, iFriend%, EFriendFlags%)				:"_BS_ISteamFriends_GetFriendByIndex@12"
+;! Returns: CSteamID*. Clean Up!
+BS_ISteamFriends_GetFriendRelationship%(pThis%, pllFriend%)						:"_BS_ISteamFriends_GetFriendRelationship@8"
+BS_ISteamFriends_GetFriendPersonaState%(pThis%, pllFriend%)						:"_BS_ISteamFriends_GetFriendPersonaState@8"
+BS_ISteamFriends_GetFriendPersonaName$(pThis%, pllFriend%)						:"_BS_ISteamFriends_GetFriendPersonaName@8"
+BS_ISteamFriends_GetFriendGamePlayed%(pThis%, pllFriend%, pFriendGameInfo*)		:"_BS_ISteamFriends_GetFriendGamePlayed@12"
+BS_ISteamFriends_GetFriendGamePlayedEx%(pThis%, pllFriend%, pFriendGameInfo%)	:"_BS_ISteamFriends_GetFriendGamePlayed@12"
+BS_ISteamFriends_GetFriendPersonaNameHistory$(pThis%, pllFriend%, iDepth%)		:"_BS_ISteamFriends_GetFriendPersonaNameHistory@12"
+BS_ISteamFriends_GetFriendSteamLevel%(pThis%, pllFriend%)						:"_BS_ISteamFriends_GetFriendSteamLevel@8"
+BS_ISteamFriends_GetPlayerNickname$(pThis%, pllFriend%)							:"_BS_ISteamFriends_GetPlayerNickname@8"
+BS_ISteamFriends_GetFriendsGroupCount%(pThis%)									:"_BS_ISteamFriends_GetFriendsGroupCount@4"
+BS_ISteamFriends_GetFriendsGroupIDByIndex%(pThis%, iIndex%)						:"_BS_ISteamFriends_GetFriendsGroupIDByIndex@8"
+BS_ISteamFriends_GetFriendsGroupName$(pThis%, iGroupID%)						:"_BS_ISteamFriends_GetFriendsGroupName@8"
+BS_ISteamFriends_GetFriendsGroupMembersCount%(pThis%, iGroupID%)				:"_BS_ISteamFriends_GetFriendsGroupMembersCount@8"
+BS_ISteamFriends_GetFriendsGroupMembersList(pThis%, iGroupID%, pllMembers*, nMembersCount%):"_BS_ISteamFriends_GetFriendsGroupMembersList@16"
+BS_ISteamFriends_GetFriendsGroupMembersListEx(pThis%, iGroupID%, pllMembers%, nMembersCount%):"_BS_ISteamFriends_GetFriendsGroupMembersList@16"
+BS_ISteamFriends_HasFriend(pThis%, pllFriend%, EFriendFlags%)					:"_BS_ISteamFriends_HasFriend@12"
+BS_ISteamFriends_GetClanCount%(pThis%)											:"_BS_ISteamFriends_GetClanCount@4"
+BS_ISteamFriends_GetClanByIndex%(pThis%, iClan%)								:"_BS_ISteamFriends_GetClanByIndex@8"
+BS_ISteamFriends_GetClanName$(pThis%, llClanID%)								:"_BS_ISteamFriends_GetClanName@8"
+BS_ISteamFriends_GetClanTag$(pThis%, llClanID%)									:"_BS_ISteamFriends_GetClanTag@8"
+BS_ISteamFriends_GetClanActivityCounts%(pThis%, llClanID%, pnOnline*, pnInGame*, pnChatting*):"_BS_ISteamFriends_GetClanActivityCounts@20"
+BS_ISteamFriends_GetClanActivityCountsEx%(pThis%, llClanID%, pnOnline%, pnInGame%, pnChatting%):"_BS_ISteamFriends_GetClanActivityCounts@20"
+BS_ISteamFriends_DownloadClanActivityCounts%(pThis%, llClanID%, cClansToRequest%):"_BS_ISteamFriends_DownloadClanActivityCounts@12"
+BS_ISteamFriends_GetFriendCountFromSource%(pThis%, llSourceID%)					:"_BS_ISteamFriends_GetFriendCountFromSource@8"
+BS_ISteamFriends_GetFriendFromSourceByIndex%(pThis%, llSourceID%, iFriend%)		:"_BS_ISteamFriends_GetFriendFromSourceByIndex@12"
+BS_ISteamFriends_IsUserInSource%(pThis%, llSteamID%, llSourceID%)				:"_BS_ISteamFriends_IsUserInSource@12"
+BS_ISteamFriends_SetInGameVoiceSpeaking(pThis%, llSteamID%, bSpeaking%)			:"_BS_ISteamFriends_SetInGameVoiceSpeaking@12"
+BS_ISteamFriends_ActivateGameOverlay(pThis%, cDialog$)							:"_BS_ISteamFriends_ActivateGameOverlay@8"
+BS_ISteamFriends_ActivateGameOverlayToUser(pThis%, cDialog$, llSteamID%)		:"_BS_ISteamFriends_ActivateGameOverlayToUser@12"
+BS_ISteamFriends_ActivateGameOverlayToWebPage(pThis%, cURL$)					:"_BS_ISteamFriends_ActivateGameOverlayToWebPage@8"
+BS_ISteamFriends_ActivateGameOverlayToStore(pThis%, nAppID%, EOverlayToStoreFlag%):"_BS_ISteamFriends_ActivateGameOverlayToStore@12"
+BS_ISteamFriends_SetPlayedWith(pThis%, llSteamID%)								:"_BS_ISteamFriends_SetPlayedWith@8"
+BS_ISteamFriends_ActivateGameOverlayInviteDialog(pThis%, llLobbyID%)			:"_BS_ISteamFriends_ActivateGameOverlayInviteDialog@8"
+BS_ISteamFriends_GetSmallFriendAvatar%(pThis%, llSteamID%)						:"_BS_ISteamFriends_GetSmallFriendAvatar@8"
+BS_ISteamFriends_GetMediumFriendAvatar%(pThis%, llSteamID%)						:"_BS_ISteamFriends_GetMediumFriendAvatar@8"
+BS_ISteamFriends_GetLargeFriendAvatar%(pThis%, llSteamID%)						:"_BS_ISteamFriends_GetLargeFriendAvatar@8"
+BS_ISteamFriends_RequestUserInformation%(pThis%, llSteamID%, bNameOnly%)		:"_BS_ISteamFriends_RequestUserInformation@12"
+BS_ISteamFriends_RequestClanOfficerList%(pThis%, llClanID%)						:"_BS_ISteamFriends_RequestClanOfficerList@8"
+BS_ISteamFriends_GetClanOwner%(pThis%, llClanID%)								:"_BS_ISteamFriends_GetClanOwner@8"
+BS_ISteamFriends_GetClanOfficerCount%(pThis%, llClanID%)						:"_BS_ISteamFriends_GetClanOfficerCount@8"
+BS_ISteamFriends_GetClanOfficerByIndex%(pThis%, llClanID%, iOfficer%)			:"_BS_ISteamFriends_GetClanOfficerByIndex@12"
+;! Returns: CSteamID*. Clean Up!
+BS_ISteamFriends_GetUserRestrictions%(pThis%)									:"_BS_ISteamFriends_GetUserRestrictions@4"
+BS_ISteamFriends_SetRichPresence%(pThis%, cKey$, cValue$)						:"_BS_ISteamFriends_SetRichPresence@12"
+BS_ISteamFriends_ClearRichPresence(pThis%)										:"_BS_ISteamFriends_ClearRichPresence@4"
+BS_ISteamFriends_GetFriendRichPresence$(pThis%, llSteamID%, cKey$)				:"_BS_ISteamFriends_GetFriendRichPresence@12"
+BS_ISteamFriends_GetFriendRichPresenceKeyCount%(pThis%, llSteamID%)				:"_BS_ISteamFriends_GetFriendRichPresenceKeyCount@8"
+BS_ISteamFriends_GetFriendRichPresenceKeyByIndex$(pThis%, llSteamID%, iKey%)	:"_BS_ISteamFriends_GetFriendRichPresenceKeyByIndex@12"
+BS_ISteamFriends_RequestFriendRichPresence(pThis%, llSteamID%)					:"_BS_ISteamFriends_RequestFriendRichPresence@8"
+BS_ISteamFriends_InviteUserToGame%(pThis%, llSteamID%, cConnectString%)			:"_BS_ISteamFriends_InviteUserToGame@12"
+BS_ISteamFriends_GetCoplayFriendCount%(pThis%)									:"_BS_ISteamFriends_GetCoplayFriendCount@4"
+BS_ISteamFriends_GetCoplayFriend%(pThis%, iCoplayFriend%)						:"_BS_ISteamFriends_GetCoplayFriend@8"
+;! Returns: CSteamID*. Clean Up!
+BS_ISteamFriends_GetFriendCoplayTime%(pThis%, llSteamID%)						:"_BS_ISteamFriends_GetFriendCoplayTime@8"
+BS_ISteamFriends_GetFriendCoplayGame%(pThis%, llSteamID%)						:"_BS_ISteamFriends_GetFriendCoplayGame@8"
+BS_ISteamFriends_JoinClanChatRoom%(pThis%, llClanID%)							:"_BS_ISteamFriends_JoinClanChatRoom@8"
+;! Returns: SteamAPICall_t*. Clean Up!
+BS_ISteamFriends_LeaveClanChatRoom%(pThis%, llClanID%)							:"_BS_ISteamFriends_LeaveClanChatRoom@8"
+BS_ISteamFriends_GetClanChatMemberCount%(pThis%, llClanID%)						:"_BS_ISteamFriends_GetClanChatMemberCount@8"
+BS_ISteamFriends_GetChatMemberByIndex%(pThis%, llClanID%, iUser%)				:"_BS_ISteamFriends_GetChatMemberByIndex@12"
+;! Returns: CSteamID*. Clean Up!
+BS_ISteamFriends_SendClanChatMessage%(pThis%, llClanChatID%, cMessage$)			:"_BS_ISteamFriends_SendClanChatMessage@12"
+BS_ISteamFriends_GetClanChatMessage%(pThis%, llClanChatID%, iMessage%, pMessage*, iMessageSize%, pEChatEntryType*, pSteamID*):"_BS_ISteamFriends_GetClanChatMessage@28"
+BS_ISteamFriends_GetClanChatMessageEx%(pThis%, llClanChatID%, iMessage%, pMessage%, iMessageSize%, peChatEntryType%, pSteamID%):"_BS_ISteamFriends_GetClanChatMessage@28"
+BS_ISteamFriends_IsClanChatAdmin%(pThis%, llClanChatID%, llSteamID%)			:"_BS_ISteamFriends_IsClanChatAdmin@12"
+BS_ISteamFriends_IsClanChatWindowOpenInSteam%(pThis%, llClanChatID%)			:"_BS_ISteamFriends_IsClanChatWindowOpenInSteam@8"
+BS_ISteamFriends_OpenClanChatWindowInSteam%(pThis%, llClanChatID%)				:"_BS_ISteamFriends_OpenClanChatWindowInSteam@8"
+BS_ISteamFriends_CloseClanChatWindowInSteam%(pThis%, llClanChatID%)				:"_BS_ISteamFriends_CloseClanChatWindowInSteam@8"
+BS_ISteamFriends_SetListenForFriendsMessages%(pThis%, bInterceptEnabled%)		:"_BS_ISteamFriends_SetListenForFriendsMessages@8"
+BS_ISteamFriends_ReplyToFriendMessage%(pThis%, llSteamID%, cMessage$)			:"_BS_ISteamFriends_ReplyToFriendMessage@12"
+BS_ISteamFriends_GetFriendMessage%(pThis%, llSteamID%, iMessageID%, pData*, iDataSize%, pEChatEntryType*):"_BS_ISteamFriends_GetFriendMessage@24"
+BS_ISteamFriends_GetFriendMessageEx%(pThis%, llSteamID%, iMessageID%, pData%, iDataSize%, pEChatEntryType%):"_BS_ISteamFriends_GetFriendMessage@24"
+BS_ISteamFriends_GetFollowerCount%(pThis%, llSteamID%)							:"_BS_ISteamFriends_GetFollowerCount@8"
+;! Returns: SteamAPICall_t*. Clean Up!
+BS_ISteamFriends_IsFollowing%(pThis%, llSteamID%)								:"_BS_ISteamFriends_IsFollowing@8"
+;! Returns: SteamAPICall_t*. Clean Up!
+BS_ISteamFriends_EnumerateFollowingList%(pThis%, iStartIndex%)					:"_BS_ISteamFriends_EnumerateFollowingList@8"
+;! Returns: SteamAPICall_t*. Clean Up!

Resources/Decls/BlitzSteam_SteamGameServer.decls

@@ -0,0 +1,77 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; GameServer ------------------------------------------------------------------
+BS_SteamGameServer_Init%(iIP%, sSteamPort%, sGamePort%, sQueryPort%, EServerMode%, cVersion$):"_BS_SteamGameServer_Init@24"
+BS_SteamGameServer_Shutdown()													:"_BS_SteamGameServer_Shutdown@0"
+BS_SteamGameServer_RunCallbacks()												:"_BS_SteamGameServer_RunCallbacks@0"
+BS_SteamGameServer_GetHSteamPipe%()												:"_BS_SteamGameServer_GetHSteamPipe@0"
+BS_SteamGameServer_IsSecure%()													:"_BS_SteamGameServer_IsSecure@0"
+BS_SteamGameServer_GetSteamID%()												:"_BS_SteamGameServer_GetSteamID@0"
+;! Function above returns a CSteamID*, clean it up afterwards!
+BS_SteamGameServer%()															:"_BS_SteamGameServer@0"
+BS_ISteamGameServer_InitGameServer%(pThis%, iIP%, sGamePort%, sQueryPort%, iFlags%, iAppId%, cVersion$):"_BS_ISteamGameServer_InitGameServer@24"
+BS_ISteamGameServer_SetProduct(pThis%, cProduct$)								:"_BS_ISteamGameServer_SetProduct@8"
+BS_ISteamGameServer_SetGameDescription(pThis%, cDescription$)					:"_BS_ISteamGameServer_SetGameDescription@8"
+BS_ISteamGameServer_SetModDir(pThis%, cDirectory$)								:"_BS_ISteamGameServer_SetModDir@8"
+BS_ISteamGameServer_SetDedicatedServer(pThis%, bDedicated%)						:"_BS_ISteamGameServer_SetDedicatedServer@8"
+BS_ISteamGameServer_LogOn(pThis%, cToken$)										:"_BS_ISteamGameServer_LogOn@8"
+BS_ISteamGameServer_LogOnAnonymous(pThis%)										:"_BS_ISteamGameServer_LogOnAnonymous@4"
+BS_ISteamGameServer_LogOff(pThis%)												:"_BS_ISteamGameServer_LogOff@4"
+BS_ISteamGameServer_IsLoggedOn%(pThis%)											:"_BS_ISteamGameServer_IsLoggedOn@4"
+BS_ISteamGameServer_IsSecure%(pThis%)											:"_BS_ISteamGameServer_IsSecure@4"
+BS_ISteamGameServer_GetSteamID%(pThis%)											:"_BS_ISteamGameServer_GetSteamID@4"
+BS_ISteamGameServer_WasRestartRequested%(pThis%)								:"_BS_ISteamGameServer_WasRestartRequested@4"
+BS_ISteamGameServer_SetMaxPlayerCount(pThis%, iMaxPlayers%)						:"_BS_ISteamGameServer_SetMaxPlayerCount@8"
+BS_ISteamGameServer_SetBotPlayerCount(pThis%, iBotPlayers%)						:"_BS_ISteamGameServer_SetBotPlayerCount@8"
+BS_ISteamGameServer_SetServerName(pThis%, cName$)								:"_BS_ISteamGameServer_SetServerName@8"
+BS_ISteamGameServer_SetMapName(pThis%, cName$)									:"_BS_ISteamGameServer_SetMapName@8"
+BS_ISteamGameServer_SetPasswordProtected(pThis%, bPassworded%)					:"_BS_ISteamGameServer_SetPasswordProtected@8"
+BS_ISteamGameServer_SetSpectatorPort(pThis%, sPort%)							:"_BS_ISteamGameServer_SetSpectatorPort@8"
+BS_ISteamGameServer_SetSpectatorServerName(pThis%, cName$)						:"_BS_ISteamGameServer_SetSpectatorServerName@8"
+BS_ISteamGameServer_ClearAllKeyValues(pThis%)									:"_BS_ISteamGameServer_ClearAllKeyValues@4"
+BS_ISteamGameServer_SetKeyValue(pThis%, cKey$, cValue$)							:"_BS_ISteamGameServer_SetKeyValue@12"
+BS_ISteamGameServer_SetGameTags(pThis%, cTags$)									:"_BS_ISteamGameServer_SetGameTags@8"
+BS_ISteamGameServer_SetGameData(pThis%, cData$)									:"_BS_ISteamGameServer_SetGameData@8"
+BS_ISteamGameServer_SetRegion(pThis%, cRegion$)									:"_BS_ISteamGameServer_SetRegion@8"
+BS_ISteamGameServer_SendUserConnectAndAuthenticate%(pThis%, iIP%, pAuthBlob*, iAuthBlobSize%, lSteamId%):"_BS_ISteamGameServer_SendUserConnectAndAuthenticate@20"
+BS_ISteamGameServer_SendUserConnectAndAuthenticateEx%(pThis%, iIP%, pAuthBlob%, iAuthBlobSize%, lSteamId%):"_BS_ISteamGameServer_SendUserConnectAndAuthenticate@20"
+BS_ISteamGameServer_CreateUnauthenticatedUserConnection%(pThis%)				:"_BS_ISteamGameServer_CreateUnauthenticatedUserConnection@4"
+;! Function above returns a CSteamID*, clean it up afterwards!
+BS_ISteamGameServer_SendUserDisconnect(pThis%, lSteamId%)						:"_BS_ISteamGameServer_SendUserDisconnect@8"
+BS_ISteamGameServer_UpdateUserData%(pThis%, lSteamId%, cName$, iScore%):"_BS_ISteamGameServer_UpdateUserData@16"
+BS_ISteamGameServer_GetAuthSessionTicket%(pThis%, pTicket*, iTicketSize%, piTicketSize*):"_BS_ISteamGameServer_GetAuthSessionTicket@16"
+BS_ISteamGameServer_GetAuthSessionTicketEx%(pThis%, pTicket%, iTicketSize%, piTicketSize%):"_BS_ISteamGameServer_GetAuthSessionTicket@16"
+BS_ISteamGameServer_BeginAuthSession%(pThis%, pTicket*, iTicketSize%, lSteamId%):"_BS_ISteamGameServer_BeginAuthSession@16"
+BS_ISteamGameServer_BeginAuthSessionEx%(pThis%, pTicket%, iTicketSize%, lSteamId%):"_BS_ISteamGameServer_BeginAuthSession@16"
+BS_ISteamGameServer_EndAuthSession(pThis%, lSteamId%)							:"_BS_ISteamGameServer_EndAuthSession@8"
+BS_ISteamGameServer_CancelAuthTicket(pThis%, iAuthTicket%)						:"_BS_ISteamGameServer_CancelAuthTicket@8"
+BS_ISteamGameServer_UserHasLicenseForApp%(pThis%, lSteamId%, iAppId%)			:"_BS_ISteamGameServer_UserHasLicenseForApp@12"
+BS_ISteamGameServer_RequestUserGroupStatus%(pThis%, lSteamId%, pSteamIdGroup%)	:"_BS_ISteamGameServer_RequestUserGroupStatus@12"
+BS_ISteamGameServer_GetPublicIP%(pThis%)										:"_BS_ISteamGameServer_GetPublicIP@4"
+BS_ISteamGameServer_HandleIncomingPacket%(pThis%, pBuffer*, iBufferSize%, iIP%, sPort%):"_BS_ISteamGameServer_HandleIncomingPacket@20"
+BS_ISteamGameServer_HandleIncomingPacketEx%(pThis%, pBuffer%, iBufferSize%, iIP%, sPort%):"_BS_ISteamGameServer_HandleIncomingPacket@20"
+BS_ISteamGameServer_GetNextOutgoingPacket%(pThis%, pBuffer*, iBufferSize%, piIP*, psPort*):"_BS_ISteamGameServer_GetNextOutgoingPacket@20"
+BS_ISteamGameServer_GetNextOutgoingPacketEx%(pThis%, pBuffer%, iBufferSize%, piIP%, psPort%):"_BS_ISteamGameServer_GetNextOutgoingPacket@20"
+BS_ISteamGameServer_EnableHeartbeats(pThis%, bActive%)							:"_BS_ISteamGameServer_EnableHeartbeats@8"
+BS_ISteamGameServer_SetHeartbeatInterval(pThis%, iInterval%)					:"_BS_ISteamGameServer_SetHeartbeatInterval@8"
+BS_ISteamGameServer_ForceHeartbeat(pThis%)										:"_BS_ISteamGameServer_ForceHeartbeat@4"
+BS_ISteamGameServer_AssociateWithClan%(pThis%, pSteamIDClan%)					:"_BS_ISteamGameServer_AssociateWithClan@8"
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
+BS_ISteamGameServer_ComputeNewPlayerCompatibility%(pThis%, pSteamIDNewPlayer%)	:"_BS_ISteamGameServer_ComputeNewPlayerCompatibility@8"
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!

Resources/Decls/BlitzSteam_SteamGameServerStats.decls

@@ -0,0 +1,36 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; GameServerStats -------------------------------------------------------------
+BS_SteamGameServerStats%()														:"_BS_SteamGameServerStats@0"
+BS_ISteamGameServerStats_RequestUserStats%(pThis%, lSteamId%)					:"_BS_ISteamGameServerStats_RequestUserStats@8"
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
+BS_ISteamGameServerStats_StoreUserStats%(pThis%, lSteamId%)						:"_BS_ISteamGameServerStats_StoreUserStats@8"
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
+BS_ISteamGameServerStats_GetUserStat%(pThis%, lSteamId%, cName$, pData*)		:"_BS_ISteamGameServerStats_GetUserStat@16"
+BS_ISteamGameServerStats_GetUserStatEx%(pThis%, lSteamId%, cName$, pData%)		:"_BS_ISteamGameServerStats_GetUserStat@16"
+BS_ISteamGameServerStats_GetUserStatF%(pThis%, lSteamId%, cName$, pData*)		:"_BS_ISteamGameServerStats_GetUserStatF@16"
+BS_ISteamGameServerStats_GetUserStatFEx%(pThis%, lSteamId%, cName$, pData%)		:"_BS_ISteamGameServerStats_GetUserStatF@16"
+BS_ISteamGameServerStats_GetUserAchievement%(pThis%, lSteamId%, cName$, pbAchieved*):"_BS_ISteamGameServerStats_GetUserAchievement@16"
+BS_ISteamGameServerStats_GetUserAchievementEx%(pThis%, lSteamId%, cName$, pbAchieved%):"_BS_ISteamGameServerStats_GetUserAchievement@16"
+BS_ISteamGameServerStats_SetUserStat%(pThis%, lSteamId%, cName%, iData%)		:"_BS_ISteamGameServerStats_SetUserStat@16"
+BS_ISteamGameServerStats_SetUserStatF%(pThis%, lSteamId%, cName%, fData#)		:"_BS_ISteamGameServerStats_SetUserStatF@16"
+BS_ISteamGameServerStats_UpdateUserAvgRateStat%(pThis%, lSteamId%, cName$, fCountThisSession#, dSessionLength%):"_BS_ISteamGameServerStats_UpdateUserAvgRateStat@20"
+;! Function above takes a Double* as last parameter.
+BS_ISteamGameServerStats_SetUserAchievement%(pThis%, lSteamId%, cName$)			:"_BS_ISteamGameServerStats_SetUserAchievement@12"
+BS_ISteamGameServerStats_ClearUserAchievement%(pThis%, lSteamId%, cName$)		:"_BS_ISteamGameServerStats_ClearUserAchievement@12"

Resources/Decls/BlitzSteam_SteamHTMLSurface.decls

@@ -0,0 +1,56 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; HTMLSurface -----------------------------------------------------------------
+BS_SteamHTMLSurface%()															:"_BS_SteamHTMLSurface@0"
+BS_ISteamHTMLSurface_Init%(pThis%)												:"_BS_ISteamHTMLSurface_Init@4"
+BS_ISteamHTMLSurface_Shutdown%(pThis%)											:"_BS_ISteamHTMLSurface_Shutdown@4"
+BS_ISteamHTMLSurface_CreateBrowser%(pThis%, cUserAgent$, cUserCSS$)				:"_BS_ISteamHTMLSurface_CreateBrowser@12"
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
+BS_ISteamHTMLSurface_RemoveBrowser(pThis%, iHandle%)							:"_BS_ISteamHTMLSurface_RemoveBrowser@8"
+BS_ISteamHTMLSurface_LoadURL(pThis%, iHandle%, cURL$, cPostData$)				:"_BS_ISteamHTMLSurface_LoadURL@16"
+BS_ISteamHTMLSurface_SetSize(pThis%, iHandle%, iWidth%, iHeight%)				:"_BS_ISteamHTMLSurface_SetSize@16"
+BS_ISteamHTMLSurface_StopLoad(pThis%, iHandle%)									:"_BS_ISteamHTMLSurface_StopLoad@8"
+BS_ISteamHTMLSurface_Reload(pThis%, iHandle%)									:"_BS_ISteamHTMLSurface_Reload@8"
+BS_ISteamHTMLSurface_GoBack(pThis%, iHandle%)									:"_BS_ISteamHTMLSurface_GoBack@8"
+BS_ISteamHTMLSurface_GoForward(pThis%, iHandle%)								:"_BS_ISteamHTMLSurface_GoForward@8"
+BS_ISteamHTMLSurface_AddHeader(pThis%, iHandle%, cKey$, cValue$)				:"_BS_ISteamHTMLSurface_AddHeader@16"
+BS_ISteamHTMLSurface_ExecuteJavascript(pThis%, iHandle%, cScript$)				:"_BS_ISteamHTMLSurface_ExecuteJavascript@12"
+BS_ISteamHTMLSurface_MouseUp(pThis%, iHandle%, EMouseButton%)					:"_BS_ISteamHTMLSurface_MouseUp@12"
+BS_ISteamHTMLSurface_MouseDown(pThis%, iHandle%, EMouseButton%)					:"_BS_ISteamHTMLSurface_MouseDown@12"
+BS_ISteamHTMLSurface_MouseDoubleClick(pThis%, iHandle%, EMouseButton%)			:"_BS_ISteamHTMLSurface_MouseDoubleClick@12"
+BS_ISteamHTMLSurface_MouseMove(pThis%, iHandle%, X%, Y%)						:"_BS_ISteamHTMLSurface_MouseMove@16"
+BS_ISteamHTMLSurface_MouseWheel(pThis%, iHandle%, iDelta%)						:"_BS_ISteamHTMLSurface_MouseWheel@12"
+BS_ISteamHTMLSurface_KeyDown(pThis%, iHandle%, iKeyCode%, EHTMLKeyModifiers%)	:"_BS_ISteamHTMLSurface_KeyDown@16"
+BS_ISteamHTMLSurface_KeyUp(pThis%, iHandle%, iKeyCode%, EHTMLKeyModifiers%)		:"_BS_ISteamHTMLSurface_KeyUp@16"
+BS_ISteamHTMLSurface_KeyChar(pThis%, iHandle%, iUnicodeChar%, EHTMLKeyModifiers%):"_BS_ISteamHTMLSurface_KeyChar@16"
+BS_ISteamHTMLSurface_SetHorizontalScroll(pThis%, iHandle%, iAbsolutePixelScroll%):"_BS_ISteamHTMLSurface_SetHorizontalScroll@16"
+BS_ISteamHTMLSurface_SetVerticalScroll(pThis%, iHandle%, iAbsolutePixelScroll%)	:"_BS_ISteamHTMLSurface_SetVerticalScroll@16"
+BS_ISteamHTMLSurface_SetKeyFocus(pThis%, iHandle%, bHasKeyFocus%)				:"_BS_ISteamHTMLSurface_SetKeyFocus@12"
+BS_ISteamHTMLSurface_ViewSource(pThis%, iHandle%)								:"_BS_ISteamHTMLSurface_ViewSource@8"
+BS_ISteamHTMLSurface_CopyToClipboard(pThis%, iHandle%)							:"_BS_ISteamHTMLSurface_CopyToClipboard@8"
+BS_ISteamHTMLSurface_PasteFromClipboard(pThis%, iHandle%)						:"_BS_ISteamHTMLSurface_PasteFromClipboard@8"
+BS_ISteamHTMLSurface_Find(pThis%, iHandle%, cSearch$, bCurrentlyInFind%, bReverse%):"_BS_ISteamHTMLSurface_Find@20"
+BS_ISteamHTMLSurface_StopFind(pThis%, iHandle%)									:"_BS_ISteamHTMLSurface_StopFind@8"
+BS_ISteamHTMLSurface_GetLinkAtPosition(pThis%, iHandle%, X%, Y%)				:"_BS_ISteamHTMLSurface_GetLinkAtPosition@16"
+BS_ISteamHTMLSurface_SetCookie(pThis%, iHandle%, cHostName$, cKey$, cValue$, cPath$, nExpires%, bSecure%, bHTTPOnly%):"_BS_ISteamHTMLSurface_SetCookie@36"
+BS_ISteamHTMLSurface_SetPageScaleFactor(pThis%, iHandle%, fZoom#, iX%, iY%)		:"_BS_ISteamHTMLSurface_SetPageScaleFactor@20"
+BS_ISteamHTMLSurface_SetBackgroundMode(pThis%, iHandle%, bBackgroundMode%)		:"_BS_ISteamHTMLSurface_SetBackgroundMode@12"
+BS_ISteamHTMLSurface_AllowStartRequest(pThis%, iHandle%, bAllowed%)				:"_BS_ISteamHTMLSurface_AllowStartRequest@12"
+BS_ISteamHTMLSurface_JSDialogResponse(pThis%, iHandle%, bResult%)				:"_BS_ISteamHTMLSurface_JSDialogResponse@12"
+BS_ISteamHTMLSurface_FileLoadDialogResponse(pThis%, iHandle%, pcSelectedFiles%)	:"_BS_ISteamHTMLSurface_FileLoadDialogResponse@12"

Resources/Decls/BlitzSteam_SteamHTTP.decls

@@ -0,0 +1,54 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; HTTP ------------------------------------------------------------------------
+BS_SteamHTTP%()																	:"_BS_SteamHTTP@0"
+BS_SteamGameServerHTTP%()														:"_BS_SteamGameServerHTTP@0"
+BS_ISteamHTTP_CreateHTTPRequest%(pThis%, EHTTPRequestMethod%, cAbsoluteUrl$)	:"_BS_ISteamHTTP_CreateHTTPRequest@12"
+BS_ISteamHTTP_SetHTTPRequestContextValue%(pThis%, iRequest%, lContextValue%)	:"_BS_ISteamHTTP_SetHTTPRequestContextValue@12"
+BS_ISteamHTTP_SetHTTPNetworkActivityTimeout%(pThis%, iRequest%, iSeconds%)		:"_BS_ISteamHTTP_SetHTTPNetworkActivityTimeout@12"
+BS_ISteamHTTP_SetHTTPRequestHeaderValue%(pThis%, iRequest%, cName$, cValue$)	:"_BS_ISteamHTTP_SetHTTPRequestHeaderValue@16"
+BS_ISteamHTTP_SetHTTPRequestGetOrPostParameter%(pThis%, iRequest%, cName$, cValue$):"_BS_ISteamHTTP_SetHTTPRequestGetOrPostParameter@16"
+BS_ISteamHTTP_SendHTTPRequest%(pThis%, iRequest, lCallHandle%)					:"_BS_ISteamHTTP_SendHTTPRequest@12"
+BS_ISteamHTTP_SendHTTPRequestAndStreamResponse%(pThis%, iRequest%, lCallHandle%):"_BS_ISteamHTTP_SendHTTPRequestAndStreamResponse@12"
+BS_ISteamHTTP_DeferHTTPRequest%(pThis%, iRequest%)								:"_BS_ISteamHTTP_DeferHTTPRequest@8"
+BS_ISteamHTTP_PrioritizeHTTPRequest%(pThis%, iRequest%)							:"_BS_ISteamHTTP_PrioritizeHTTPRequest@8"
+BS_ISteamHTTP_GetHTTPResponseHeaderSize%(pThis%, iRequest%, cName$, piSize*)	:"_BS_ISteamHTTP_GetHTTPResponseHeaderSize@16"
+BS_ISteamHTTP_GetHTTPResponseHeaderSizeEx%(pThis%, iRequest%, cName$, piSize%)	:"_BS_ISteamHTTP_GetHTTPResponseHeaderSize@16"
+BS_ISteamHTTP_GetHTTPResponseHeaderValue%(pThis%, iRequest%, cName$, pBuffer*, iSize%):"_BS_ISteamHTTP_GetHTTPResponseHeaderValue@20"
+BS_ISteamHTTP_GetHTTPResponseHeaderValueEx%(pThis%, iRequest%, cName$, pBuffer%, iSize%):"_BS_ISteamHTTP_GetHTTPResponseHeaderValue@20"
+BS_ISteamHTTP_GetHTTPResponseBodySize%(pThis%, iRequest%, piSize*)				:"_BS_ISteamHTTP_GetHTTPResponseBodySize@12"
+BS_ISteamHTTP_GetHTTPResponseBodySizeEx%(pThis%, iRequest%, piSize%)			:"_BS_ISteamHTTP_GetHTTPResponseBodySize@12"
+BS_ISteamHTTP_GetHTTPResponseBodyData%(pThis%, iRequest%, pBuffer*, nSize%)		:"_BS_ISteamHTTP_GetHTTPResponseBodyData@16"
+BS_ISteamHTTP_GetHTTPResponseBodyDataEx%(pThis%, iRequest%, pBuffer%, nSize%)	:"_BS_ISteamHTTP_GetHTTPResponseBodyData@16"
+BS_ISteamHTTP_GetHTTPStreamingResponseBodyData%(pThis%, iRequest%, iOffset%, pBuffer*, nSize%):"_BS_ISteamHTTP_GetHTTPStreamingResponseBodyData@20"
+BS_ISteamHTTP_GetHTTPStreamingResponseBodyDataEx%(pThis%, iRequest%, iOffset%, pBuffer%, nSize%):"_BS_ISteamHTTP_GetHTTPStreamingResponseBodyData@20"
+BS_ISteamHTTP_ReleaseHTTPRequest%(pThis%, iRequest%)							:"_BS_ISteamHTTP_ReleaseHTTPRequest@8"
+BS_ISteamHTTP_GetHTTPDownloadProgressPct%(pThis%, iRequest%, pfPercent*)		:"_BS_ISteamHTTP_GetHTTPDownloadProgressPct@12"
+BS_ISteamHTTP_GetHTTPDownloadProgressPctEx%(pThis%, iRequest%, pfPercent%)		:"_BS_ISteamHTTP_GetHTTPDownloadProgressPct@12"
+BS_ISteamHTTP_SetHTTPRequestRawPostBody%(pThis%, iRequest%, cType$, pBody*, nSize%):"_BS_ISteamHTTP_SetHTTPRequestRawPostBody@16"
+BS_ISteamHTTP_SetHTTPRequestRawPostBodyEx%(pThis%, iRequest%, cType$, pBody*, nSize%):"_BS_ISteamHTTP_SetHTTPRequestRawPostBody@16"
+BS_ISteamHTTP_CreateCookieContainer%(pThis%, bAllowResponsesToModify%)			:"_BS_ISteamHTTP_CreateCookieContainer@8"
+BS_ISteamHTTP_ReleaseCookieContainer%(pThis%, iCookieContainer%)				:"_BS_ISteamHTTP_ReleaseCookieContainer@8"
+BS_ISteamHTTP_SetCookie%(pthis%, iCookieContainer%, cHost$, cUrl$, cCookie$)	:"_BS_ISteamHTTP_SetCookie@20"
+BS_ISteamHTTP_SetHTTPRequestCookieContainer%(pThis%, iRequest%, iCookieContainer%):"_BS_ISteamHTTP_SetHTTPRequestCookieContainer@12"
+BS_ISteamHTTP_SetHTTPRequestUserAgentInfo%(pThis%, iRequest%, cUserAgent$)		:"_BS_ISteamHTTP_SetHTTPRequestUserAgentInfo@12"
+BS_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate%(pThis%, iRequest%, bRequire%):"_BS_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate@12"
+BS_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS%(pThis%, iRequest%, iMilliseconds%):"_BS_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS@12"
+BS_ISteamHTTP_GetHTTPRequestWasTimedOut%(pThis%, iRequest%, pbWasTimedOut*)		:"_BS_ISteamHTTP_GetHTTPRequestWasTimedOut@12"
+BS_ISteamHTTP_GetHTTPRequestWasTimedOutEx%(pThis%, iRequest%, pbWasTimedOut%)	:"_BS_ISteamHTTP_GetHTTPRequestWasTimedOut@12"

Resources/Decls/BlitzSteam_SteamInventory.decls

@@ -0,0 +1,59 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Inventory -------------------------------------------------------------------
+BS_SteamInventory%()															:"_BS_SteamInventory@0"
+BS_SteamGameServerInventory%()													:"_BS_SteamGameServerInventory@0"
+BS_ISteamInventory_GetResultStatus%(pThis%, iResultHandle%)						:"_BS_ISteamInventory_GetResultStatus@8"
+BS_ISteamInventory_GetResultItems%(pThis%, iResultHandle%, pItemsArray*, piItemsArraySize*):"_BS_ISteamInventory_GetResultItems@16"
+BS_ISteamInventory_GetResultItemsEx%(pThis%, iResultHandle%, pItemsArray%, piItemsArraySize%):"_BS_ISteamInventory_GetResultItems@16"
+BS_ISteamInventory_GetResultTimestamp%(pThis%, iResultHandle%)					:"_BS_ISteamInventory_GetResultTimestamp@8"
+BS_ISteamInventory_CheckResultSteamID%(pThis%, iResultHandle%, lSteamIdExpected%):"_BS_ISteamInventory_GetResultTimestamp@12"
+BS_ISteamInventory_DestroyResult(pThis%, iResultHandle%)						:"_BS_ISteamInventory_DestroyResult@8"
+BS_ISteamInventory_GetAllItems%(pThis%, piResultHandle*)						:"_BS_ISteamInventory_GetAllItems@8"
+BS_ISteamInventory_GetAllItemsEx%(pThis%, piResultHandle%)						:"_BS_ISteamInventory_GetAllItems@8"
+BS_ISteamInventory_GetItemsByID%(pThis%, piResultHandle*, plInstanceIds*, iInstanceIdCount%):"_BS_ISteamInventory_GetItemsByID@16"
+BS_ISteamInventory_GetItemsByIDEx%(pThis%, piResultHandle%, plInstanceIds%, iInstanceIdCount%):"_BS_ISteamInventory_GetItemsByID@16"
+BS_ISteamInventory_SerializeResult%(pThis%, iResultHandle%, pOutBuffer*, piOutBufferSize*):"_BS_ISteamInventory_SerializeResult@16"
+BS_ISteamInventory_SerializeResultEx%(pThis%, iResultHandle%, pOutBuffer%, piOutBufferSize%):"_BS_ISteamInventory_SerializeResult@16"
+BS_ISteamInventory_DeserializeResult%(pThis%, piResultHandle*, pBuffer*, iBufferSize%, bReservedMustBeFalse):"_BS_ISteamInventory_DeserializeResult@20"
+BS_ISteamInventory_DeserializeResultEx%(pThis%, piResultHandle%, pBuffer%, iBufferSize%, bReservedMustBeFalse):"_BS_ISteamInventory_DeserializeResult@20"
+BS_ISteamInventory_GenerateItems%(pThis%, piResultHandle*, piIdArray*, piQuantityArray*, iArrayLength%):"_BS_ISteamInventory_GenerateItems@20"
+BS_ISteamInventory_GenerateItemsEx%(pThis%, piResultHandle%, piIdArray%, piQuantityArray%, iArrayLength%):"_BS_ISteamInventory_GenerateItems@20"
+BS_ISteamInventory_GrantPromoItems%(pThis%, piResultHandle*)					:"_BS_ISteamInventory_GrantPromoItems@8"
+BS_ISteamInventory_GrantPromoItemsEx%(pThis%, piResultHandle%)					:"_BS_ISteamInventory_GrantPromoItems@8"
+BS_ISteamInventory_AddPromoItem%(pThis%, piResultHandle*, iId%)					:"_BS_ISteamInventory_AddPromoItem@12"
+BS_ISteamInventory_AddPromoItemEx%(pThis%, piResultHandle%, iId%)				:"_BS_ISteamInventory_AddPromoItem@12"
+BS_ISteamInventory_AddPromoItems%(pThis%, piResultHandle*, piIdsArray*, iArrayLength%):"_BS_ISteamInventory_AddPromoItems@16"
+BS_ISteamInventory_AddPromoItemsEx%(pThis%, piResultHandle%, piIdsArray%, iArrayLength%):"_BS_ISteamInventory_AddPromoItems@16"
+BS_ISteamInventory_ConsumeItem%(pThis%, piResultHandle*, iId%, iQuantity%)		:"_BS_ISteamInventory_ConsumeItem@16"
+BS_ISteamInventory_ConsumeItemEx%(pThis%, piResultHandle%, iId%, iQuantity%)	:"_BS_ISteamInventory_ConsumeItem@16"
+BS_ISteamInventory_ExchangeItems%(pThis%, piResultHandle*, piGenerateArray*, piGenerateQuantityArray*, iArrayGenerateLength%, piDestroyArray*, piDestroyQuantityArray*, iArrayDestroyLength%):"_BS_ISteamInventory_ExchangeItems@32"
+BS_ISteamInventory_ExchangeItemsEx%(pThis%, piResultHandle%, piGenerateArray%, piGenerateQuantityArray%, iArrayGenerateLength%, piDestroyArray%, piDestroyQuantityArray%, iArrayDestroyLength%):"_BS_ISteamInventory_ExchangeItems@32"
+BS_ISteamInventory_TransferItemQuantity%(pThis%, piResultHandle*, iSourceId%, iQuantity%, iDestId%):"_BS_ISteamInventory_TransferItemQuantity@20"
+BS_ISteamInventory_TransferItemQuantityEx%(pThis%, piResultHandle%, iSourceId%, iQuantity%, iDestId%):"_BS_ISteamInventory_TransferItemQuantity@20"
+BS_ISteamInventory_SendItemDropHeartbeat%(pThis%)								:"_BS_ISteamInventory_SendItemDropHeartbeat@4"
+BS_ISteamInventory_TriggerItemDrop%(pThis%, piResultHandle*, iDropListId%)		:"_BS_ISteamInventory_TriggerItemDrop@12"
+BS_ISteamInventory_TriggerItemDropEx%(pThis%, piResultHandle%, iDropListId%)	:"_BS_ISteamInventory_TriggerItemDrop@12"
+BS_ISteamInventory_TradeItems%(pThis%, piResultHandle*, lSteamIdPartner%, piArrayGive*, piArrayGiveQuantity*, iArrayGiveLength%, piArrayGet*, piArrayGetQuantity*, iArrayGetLength%):"_BS_ISteamInventory_TradeItems@36"
+BS_ISteamInventory_TradeItemsEx%(pThis%, piResultHandle%, lSteamIdPartner%, piArrayGive%, piArrayGiveQuantity%, iArrayGiveLength%, piArrayGet%, piArrayGetQuantity%, iArrayGetLength%):"_BS_ISteamInventory_TradeItems@36"
+BS_ISteamInventory_LoadItemDefinitions%(pThis%)									:"_BS_ISteamInventory_LoadItemDefinitions@4"
+BS_ISteamInventory_GetItemDefinitionIDs%(pThis%, piArrayId*, piArrayIdSize*)	:"_BS_ISteamInventory_GetItemDefinitionIDs@12"
+BS_ISteamInventory_GetItemDefinitionIDsEx%(pThis%, piArrayId%, piArrayIdSize%)	:"_BS_ISteamInventory_GetItemDefinitionIDs@12"
+BS_ISteamInventory_GetItemDefinitionProperty%(pThis%, iId%, cName$, pcValueBuffer*, piValueBufferSize*):"_BS_ISteamInventory_GetItemDefinitionProperty@20"
+BS_ISteamInventory_GetItemDefinitionPropertyEx%(pThis%, iId%, cName$, pcValueBuffer%, piValueBufferSize%):"_BS_ISteamInventory_GetItemDefinitionProperty@20"

Resources/Decls/BlitzSteam_SteamMatchmaking.decls

@@ -0,0 +1,21 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Matchmaking -----------------------------------------------------------------
+BS_SteamMatchmaking%()															:"_BS_SteamMatchmaking@0"
+; Todo

Resources/Decls/BlitzSteam_SteamMatchmakingServers.decls

@@ -0,0 +1,42 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; MatchmakingServers ----------------------------------------------------------
+BS_SteamMatchmakingServers%()													:"_BS_SteamMatchmakingServers@0"
+BS_ISteamMatchmakingServers_RequestInternetServerList%(pThis%, iApp%, ppchFilters*, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestInternetServerList@20"
+BS_ISteamMatchmakingServers_RequestInternetServerListEx%(pThis%, iApp%, ppchFilters%, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestInternetServerList@20"
+BS_ISteamMatchmakingServers_RequestLANServerList%(pThis%, iApp%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestLANServerList@12"
+BS_ISteamMatchmakingServers_RequestFriendsServerList%(pThis%, iApp%, ppchFilters*, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestFriendsServerList@20"
+BS_ISteamMatchmakingServers_RequestFriendsServerListEx%(pThis%, iApp%, ppchFilters%, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestFriendsServerList@20"
+BS_ISteamMatchmakingServers_RequestFavoritesServerList%(pThis%, iApp%, ppchFilters*, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestFavoritesServerList@20"
+BS_ISteamMatchmakingServers_RequestFavoritesServerListEx%(pThis%, iApp%, ppchFilters%, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestFavoritesServerList@20"
+BS_ISteamMatchmakingServers_RequestHistoryServerList%(pThis%, iApp%, ppchFilters*, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestHistoryServerList@20"
+BS_ISteamMatchmakingServers_RequestHistoryServerListEx%(pThis%, iApp%, ppchFilters%, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestHistoryServerList@20"
+BS_ISteamMatchmakingServers_RequestSpectatorServerList%(pThis%, iApp%, ppchFilters*, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestSpectatorServerList@20"
+BS_ISteamMatchmakingServers_RequestSpectatorServerListEx%(pThis%, iApp%, ppchFilters%, nFilters%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_RequestSpectatorServerList@20"
+BS_ISteamMatchmakingServers_ReleaseRequest%(pThis%, hServerListRequest%)		:"_BS_ISteamMatchmakingServers_ReleaseRequest@8"
+BS_ISteamMatchmakingServers_GetServerDetails%(pThis%, hRequest%, iServer%)		:"_BS_ISteamMatchmakingServers_GetServerDetails@12"
+BS_ISteamMatchmakingServers_CancelQuery%(pThis%, hRequest%)						:"_BS_ISteamMatchmakingServers_CancelQuery@8"
+BS_ISteamMatchmakingServers_RefreshQuery%(pThis%, hRequest%)					:"_BS_ISteamMatchmakingServers_RefreshQuery@8"
+BS_ISteamMatchmakingServers_IsRefreshing%(pThis%, hRequest%)					:"_BS_ISteamMatchmakingServers_IsRefreshing@8"
+BS_ISteamMatchmakingServers_GetServerCount%(pThis%, hRequest%)					:"_BS_ISteamMatchmakingServers_GetServerCount@8"
+BS_ISteamMatchmakingServers_RefreshServer%(pThis%, hRequest%)					:"_BS_ISteamMatchmakingServers_RefreshServer@8"
+BS_ISteamMatchmakingServers_PingServer%(pThis%, unIP%, usPort%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_PingServer@16"
+BS_ISteamMatchmakingServers_PlayerDetails%(pThis%, unIP%, usPort%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_PlayerDetails@16"
+BS_ISteamMatchmakingServers_ServerRules%(pThis%, unIP%, usPort%, pRequestServersResponse%):"_BS_ISteamMatchmakingServers_ServerRules@16"
+BS_ISteamMatchmakingServers_CancelServerQuery%(pThis%, hServerQuery)			:"_BS_ISteamMatchmakingServers_CancelServerQuery@8"

Resources/Decls/BlitzSteam_SteamMatchmakingTypes.decls

@@ -0,0 +1,78 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; ISteamMatchmakingServerListResponse -----------------------------------------
+BS_ISteamMatchmakingServerListResponse_New%(Data%, pServerResponded%, pServerFailedToRespond%, pRefreshComplete%):"_BS_ISteamMatchmakingServerListResponse_New@16"
+BS_ISteamMatchmakingServerListResponse_Destroy%(pThis%):"_BS_ISteamMatchmakingServerListResponse_Destroy@4"
+;- Callback pServerResponded: Function(Data%, hRequest%, iServer%)
+;- Callback pServerFailedToRespond: Function(Data%, hRequest%, iServer%)
+;- Callback pRefreshComplete: Function(Data%)
+
+; ISteamMatchmakingPingResponse -----------------------------------------------
+BS_ISteamMatchmakingPingResponse_New%(Data%, pServerResponded%, pServerFailedToRespond%):"_BS_ISteamMatchmakingPingResponse_New@12"
+BS_ISteamMatchmakingPingResponse_Destroy%(pThis%):"_BS_ISteamMatchmakingPingResponse_Destroy@4"
+;- Callback pServerResponded: Function(Data%, TGameServerItem%)
+;- Callback pServerFailedToRespond: Function(Data%)
+
+; ISteamMatchmakingPlayersResponse --------------------------------------------
+BS_ISteamMatchmakingPlayersResponse_New%(Data%, pAddPlayerToList%, pPlayersFailedToRespond%, pPlayersRefreshComplete%):"_BS_ISteamMatchmakingPlayersResponse_New@16"
+BS_ISteamMatchmakingPlayersResponse_Destroy%(pThis%):"_BS_ISteamMatchmakingPlayersResponse_Destroy@4"
+;- Callback pAddPlayerToList: Function(Data%, pchName%, nScore%, flTimePlayer#)
+;- Callback pPlayersFailedToRespond: Function(Data%)
+;- Callback pPlayersRefreshComplete: Function(Data%)
+
+; ISteamMatchmakingRulesResponse ----------------------------------------------
+BS_ISteamMatchmakingRulesResponse_New%(Data%, pRulesResponded%, pRulesFailedToRespond%, pRulesRefreshComplete%):"_BS_ISteamMatchmakingRulesResponse_New@16"
+BS_ISteamMatchmakingRulesResponse_Destroy%(pThis%):"_BS_ISteamMatchmakingPlayersResponse_Destroy@4"
+;- Callback pRulesResponded: Function(Data%, pchRule%, pchValue%)
+;- Callback pRulesFailedToRespond: Function(Data%)
+;- Callback pRulesRefreshComplete: Function(Data%)
+
+; TGameServerItem -------------------------------------------------------------
+BS_TGameServerItem_GetName$(pThis%)												:"_BS_TGameServerItem_GetName@4"
+BS_TGameServerItem_SetName(pThis%, cName$)										:"_BS_TGameServerItem_SetName@8"
+BS_TGameServerItem_NetAdr%(pThis%)												:"_BS_TGameServerItem_NetAdr@4"
+BS_TGameServerItem_Ping%(pThis%)												:"_BS_TGameServerItem_Ping@4"
+BS_TGameServerItem_HadSuccessfulResponse%(pThis%)								:"_BS_TGameServerItem_HadSuccessfulResponse@4"
+BS_TGameServerItem_DoNotRefresh%(pThis%)										:"_BS_TGameServerItem_DoNotRefresh@4"
+BS_TGameServerItem_GameDir$(pThis%)												:"_BS_TGameServerItem_GameDir@4"
+BS_TGameServerItem_Map$(pThis%)													:"_BS_TGameServerItem_Map@4"
+BS_TGameServerItem_GameDescription$(pThis%)										:"_BS_TGameServerItem_GameDescription@4"
+BS_TGameServerItem_AppId%(pThis%)												:"_BS_TGameServerItem_AppId@4"
+BS_TGameServerItem_Players%(pThis%)												:"_BS_TGameServerItem_Players@4"
+BS_TGameServerItem_MaxPlayers%(pThis%)											:"_BS_TGameServerItem_MaxPlayers@4"
+BS_TGameServerItem_BotPlayers%(pThis%)											:"_BS_TGameServerItem_BotPlayers@4"
+BS_TGameServerItem_Password%(pThis%)											:"_BS_TGameServerItem_Password@4"
+BS_TGameServerItem_Secure%(pThis%)												:"_BS_TGameServerItem_Secure@4"
+BS_TGameServerItem_TimeLastPlayed%(pThis%)										:"_BS_TGameServerItem_TimeLastPlayed@4"
+BS_TGameServerItem_ServerVersion%(pThis%)										:"_BS_TGameServerItem_ServerVersion@4"
+BS_TGameServerItem_GameTags$(pThis%)											:"_BS_TGameServerItem_GameTags@4"
+BS_TGameServerItem_SteamID%(pThis%)												:"_BS_TGameServerItem_SteamID@4"
+
+; TServerNetAdr ---------------------------------------------------------------
+BS_TServerNetAdr_Set(pThis%, pThat%)											:"_BS_TServerNetAdr_Set@8"
+BS_TServerNetAdr_Init(pThis%, iIP%, iQueryPort%, iConnectionPort%)				:"_BS_TServerNetAdr_Init@16"
+BS_TServerNetAdr_GetQueryPort%(pThis%)											:"_BS_TServerNetAdr_GetQueryPort@4"
+BS_TServerNetAdr_SetQueryPort(pThis%, iPort%)									:"_BS_TServerNetAdr_SetQueryPort@8"
+BS_TServerNetAdr_GetConnectionPort%(pThis%)										:"_BS_TServerNetAdr_GetConnectionPort@4"
+BS_TServerNetAdr_SetConnectionPort(pThis%, iPort%)								:"_BS_TServerNetAdr_SetConnectionPort@8"
+BS_TServerNetAdr_GetIP%(pThis%)													:"_BS_TServerNetAdr_GetIP@4"
+BS_TServerNetAdr_SetIP(pThis%, iIP%)											:"_BS_TServerNetAdr_SetIP@8"
+BS_TServerNetAdr_GetConnectionAddressString$(pThis%)							:"_BS_TServerNetAdr_GetConnectionAddressString@4"
+BS_TServerNetAdr_GetQueryAddressString$(pThis%)									:"_BS_TServerNetAdr_GetQueryAddressString@4"
+BS_TServerNetAdr_Compare%(pThis%, pThat%)										:"_BS_TServerNetAdr_Compare@8"

Resources/Decls/BlitzSteam_SteamMusic.decls

@@ -0,0 +1,21 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Music -----------------------------------------------------------------------
+BS_SteamMusic%()																:"_BS_SteamMusic@0"
+; Todo

Resources/Decls/BlitzSteam_SteamMusicRemote.decls

@@ -0,0 +1,21 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; MusicRemote -----------------------------------------------------------------
+BS_SteamMusicRemote%()															:"_BS_SteamMusicRemote@0"
+; Todo

Resources/Decls/BlitzSteam_SteamNetworking.decls

@@ -0,0 +1,32 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Networking ------------------------------------------------------------------
+BS_SteamNetworking%()															:"_BS_SteamNetworking@0"
+BS_SteamGameServerNetworking%()													:"_BS_SteamGameServerNetworking@0"
+BS_ISteamNetworking_SendP2PPacket%(pThis%, lRemoteSteamId%, pData*, iDataSize%, EP2PSendType%, iChannel%):"_BS_ISteamNetworking_SendP2PPacket@24"
+BS_ISteamNetworking_SendP2PPacketEx%(pThis%, lRemoteSteamId%, pData%, iDataSize%, EP2PSendType%, iChannel%):"_BS_ISteamNetworking_SendP2PPacket@24"
+BS_ISteamNetworking_IsP2PPacketAvailable%(pThis%, piSize*, iChannel%)			:"_BS_ISteamNetworking_IsP2PPacketAvailable@12"
+BS_ISteamNetworking_IsP2PPacketAvailableEx%(pThis%, piSize%, iChannel%)			:"_BS_ISteamNetworking_IsP2PPacketAvailable@12"
+BS_ISteamNetworking_ReadP2PPacket%(pThis%, pBuffer*, iBufferSize%, piMessageSize*, plRemoteSteamId*, iChannel%):"_BS_ISteamNetworking_ReadP2PPacket@24"
+BS_ISteamNetworking_ReadP2PPacketEx%(pThis%, pBuffer%, iBufferSize%, piMessageSize%, plRemoteSteamId%, iChannel%):"_BS_ISteamNetworking_ReadP2PPacket@24"
+BS_ISteamNetworking_AcceptP2PSessionWithUser%(pThis%, lRemoteSteamId%)			:"_BS_ISteamNetworking_AcceptP2PSessionWithUser@8"
+BS_ISteamNetworking_CloseP2PSessionWithUser%(pThis%, lRemoteSteamId%)			:"_BS_ISteamNetworking_CloseP2PSessionWithUser@8"
+BS_ISteamNetworking_CloseP2PChannelWithUser%(pThis%, lRemoteSteamId%, iChannel%):"_BS_ISteamNetworking_CloseP2PChannelWithUser@12"
+BS_ISteamNetworking_GetP2PSessionState%(pThis%, lRemoteSteamId%, pConnectionState*):"_BS_ISteamNetworking_GetP2PSessionState@12"
+BS_ISteamNetworking_AllowP2PPacketRelay%(pThis%, bAllow%)						:"_BS_ISteamNetworking_AllowP2PPacketRelay@8"

Resources/Decls/BlitzSteam_SteamRemoteStorage.decls

@@ -0,0 +1,21 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; RemoteStorage ---------------------------------------------------------------
+BS_SteamRemoteStorage%()														:"_BS_SteamRemoteStorage@0"
+; Todo

Resources/Decls/BlitzSteam_SteamScreenshots.decls

@@ -0,0 +1,21 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Screenshots -----------------------------------------------------------------
+BS_SteamScreenshots%()															:"_BS_SteamScreenshots@0"
+; Todo

Resources/Decls/BlitzSteam_SteamUGC.decls

@@ -0,0 +1,22 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; UGC -------------------------------------------------------------------------
+BS_SteamUGC%()																	:"_BS_SteamUGC@0"
+BS_SteamGameServerUGC%()														:"_BS_SteamGameServerUGC@0"
+; Todo

Resources/Decls/BlitzSteam_SteamUnifiedMessages.decls

@@ -0,0 +1,20 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; UnifiedMessages -------------------------------------------------------------
+BS_SteamUnifiedMessages%()														:"_BS_SteamUnifiedMessages@0"

Resources/Decls/BlitzSteam_SteamUser.decls

@@ -0,0 +1,49 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; User ------------------------------------------------------------------------
+BS_SteamUser%()																	:"_BS_SteamUser@0"
+BS_ISteamUser_GetHSteamUser%(pThis%)											:"_BS_ISteamUser_GetHSteamUser@4"
+BS_ISteamUser_IsLoggedOn%(pThis%)												:"_BS_ISteamUser_IsLoggedOn@4"
+BS_ISteamUser_GetSteamID%(pThis%)												:"_BS_ISteamUser_GetSteamID@4"
+BS_ISteamUser_InitiateGameConnection%(pThis%, pAuthBlob*, iAuthBlobSize%, lSteamId%, iIp%, sPort%, bSecure%):"_BS_ISteamUser_InitiateGameConnection@28"
+BS_ISteamUser_InitiateGameConnectionEx%(pThis%, pAuthBlob%, iAuthBlobSize%, lSteamId%, iIp%, sPort%, bSecure%):"_BS_ISteamUser_InitiateGameConnection@28"
+BS_ISteamUser_TerminateGameConnection(pThis%, iIp%, sPort%)						:"_BS_ISteamUser_TerminateGameConnection@12"
+BS_ISteamUser_TrackAppUsageEvent(pThis%, iAppId%, EAppUsageEvent%, cExtraInfo$)	:"_BS_ISteamUser_TrackAppUsageEvent@16"
+BS_ISteamUser_GetUserDataFolder%(pThis%, pBuffer*, iBufferSize%)				:"_BS_ISteamUser_GetUserDataFolder@12"
+BS_ISteamUser_StartVoiceRecording(pThis%)										:"_BS_ISteamUser_StartVoiceRecording@4"
+BS_ISteamUser_StopVoiceRecording(pThis%)										:"_BS_ISteamUser_StopVoiceRecording@4"
+BS_ISteamUser_GetAvailableVoice%(pThis%, pCompressed*, pUncompressed*, nDesiredSampleRate%):"_BS_ISteamUser_GetAvailableVoice@16"
+BS_ISteamUser_GetAvailableVoiceEx%(pThis%, pCompressed%, pUncompressed%, nDesiredSampleRate%):"_BS_ISteamUser_GetAvailableVoice@16"
+BS_ISteamUser_GetVoice%(pThis%, bCompressed%, pCompressed*, iCompressedSize%, piCompressedBytesWritten*, bUncompressed%, pUncompressed*, iUncompressedSize%, piUncompressedBytesWritten*, iSampleRate%):"_BS_ISteamUser_GetVoice@36"
+BS_ISteamUser_GetVoiceEx%(pThisEx%, bCompressed%, pCompressed%, iCompressedSize%, piCompressedBytesWritten%, bUncompressed%, pUncompressed%, iUncompressedSize%, piUncompressedBytesWritten%, iSampleRate%):"_BS_ISteamUser_GetVoice@36"
+BS_ISteamUser_DecompressVoice(pThis%, pCompressed*, iCompressedSize%, pUncompressed*, iUncompressedSize%, iUncompressedBytesWritten*, iSampleRate%):"_BS_ISteamUser_DecompressVoice@28"
+BS_ISteamUser_DecompressVoiceEx(pThis%, pCompressed*, iCompressedSize%, pUncompressed%, iUncompressedSize%, iUncompressedBytesWritten%, iSampleRate%):"_BS_ISteamUser_DecompressVoice@28"
+BS_ISteamUser_GetVoiceOptimalSampleRate%(pThis%)								:"_BS_ISteamUser_GetVoiceOptimalSampleRate@4"
+BS_ISteamUser_GetAuthSessionTicket%(pThis%, pTicket*, iTicketSize%, piTicketSize*):"_BS_ISteamUser_GetAuthSessionTicket@16"
+BS_ISteamUser_BeginAuthSession%(pThis%, pAuthTicket*, iAuthTicketSize%, lSteamId%):"_BS_ISteamUser_BeginAuthSession@16"
+BS_ISteamUser_EndAuthSession(pThis%, lSteamId%)									:"_BS_ISteamUser_EndAuthSession@8"
+BS_ISteamUser_CancelAuthTicket(pThis%, hAuthTicket%)							:"_BS_ISteamUser_CancelAuthTicket@8"
+BS_ISteamUser_UserHasLicenseForApp%(pThis%, lSteamId%, iAppId%)					:"_BS_ISteamUser_UserHasLicenseForApp@12"
+BS_ISteamUser_IsBehindNAT%(pThis%)												:"_BS_ISteamUser_IsBehindNAT@4"
+BS_ISteamUser_AdvertiseGame%(pThis%, lSteamId%, iIp%, sPort%)					:"_BS_ISteamUser_AdvertiseGame@16"
+BS_ISteamUser_RequestEncryptedAppTicket%(pThis%, pData*, iDataSize%)			:"_BS_ISteamUser_RequestEncryptedAppTicket@12"
+BS_ISteamUser_GetEncryptedAppTicket%(pThis%, pTicket*, iTicketSize%, piTicketSize*):"_BS_ISteamUser_GetEncryptedAppTicket@16"
+BS_ISteamUser_GetGameBadgeLevel%(pThis%, iSeries%, bFoil%)						:"_BS_ISteamUser_GetGameBadgeLevel@12"
+BS_ISteamUser_GetPlayerSteamLevel%(pThis%)										:"_BS_ISteamUser_GetPlayerSteamLevel@4"
+BS_ISteamUser_RequestStoreAuthURL%(pThis%, cRedirectUrl$)						:"_BS_ISteamUser_RequestStoreAuthURL@8"

Resources/Decls/BlitzSteam_SteamUserStats.decls

@@ -0,0 +1,77 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; UserStats -------------------------------------------------------------------
+BS_SteamUserStats%()																			:"_BS_ISteamUserStats@0"
+BS_ISteamUserStats_RequestCurrentStats%(pThis%)													:"_BS_ISteamUserStats_RequestCurrentStats@4"
+BS_ISteamUserStats_GetStat%(pThis%, cName$, pData*)												:"_BS_ISteamUserStats_GetStat@12"
+BS_ISteamUserStats_GetStatEx%(pThis%, cName$, pData%)											:"_BS_ISteamUserStats_GetStat@12"
+BS_ISteamUserStats_GetStatF%(pThis%, cName$, pData*)											:"_BS_ISteamUserStats_GetStatF@12"
+BS_ISteamUserStats_GetStatFEx%(pThis%, cName$, pData%)											:"_BS_ISteamUserStats_GetStatF@12"
+BS_ISteamUserStats_SetStat%(pThis%, cName$, pData%)												:"_BS_ISteamUserStats_SetStat@12"
+BS_ISteamUserStats_SetStatF%(pThis%, cName$, pData#)											:"_BS_ISteamUserStats_SetStatF@12"
+BS_ISteamUserStats_UpdateAvgRateStat%(pThis%, cName$, fCountThisSession#, dSessionLength%)		:"_BS_ISteamUserStats_UpdateAvgRateStat@16"
+BS_ISteamUserStats_GetAchievement%(pThis%, cName$, pbAchieved*)									:"_BS_ISteamUserStats_GetAchievement@12"
+BS_ISteamUserStats_GetAchievementEx%(pThis%, cName$, pbAchieved%)								:"_BS_ISteamUserStats_GetAchievement@12"
+BS_ISteamUserStats_SetAchievement%(pThis%, cName$)												:"_BS_ISteamUserStats_SetAchievement@8"
+BS_ISteamUserStats_ClearAchievement%(pThis%, cName$)											:"_BS_ISteamUserStats_ClearAchievement@8"
+BS_ISteamUserStats_GetAchievementAndUnlockTime%(pThis%, cName$, pbAchieved*, piUnlockTime*)		:"_BS_ISteamUserStats_GetAchievementAndUnlockTime@16"
+BS_ISteamUserStats_GetAchievementAndUnlockTimeEx%(pThis%, cName$, pbAchieved%, piUnlockTime%)	:"_BS_ISteamUserStats_GetAchievementAndUnlockTime@16"
+BS_ISteamUserStats_StoreStats%(pThis%)															:"_BS_ISteamUserStats_StoreStats@4"
+BS_ISteamUserStats_GetAchievementIcon%(pThis%, cName$)											:"_BS_ISteamUserStats_GetAchievementIcon@8"
+BS_ISteamUserStats_GetAchievementDisplayAttribute$(pThis%, cName$, cKey$)						:"_BS_ISteamUserStats_GetAchievementDisplayAttribute@12"
+BS_ISteamUserStats_IndicateAchievementProgress%(pThis%, cName$, iProgress%, iMaxProgress%)		:"_BS_ISteamUserStats_IndicateAchievementProgress@16"
+BS_ISteamUserStats_GetNumAchievements%(pThis%)													:"_BS_ISteamUserStats_GetNumAchievements@4"
+BS_ISteamUserStats_GetAchievementName$(pThis%, iAchievement%)									:"_BS_ISteamUserStats_GetAchievementName@8"
+BS_ISteamUserStats_RequestUserStats%(pThis%, lSteamId%)											:"_BS_ISteamUserStats_RequestUserStats@8"
+BS_ISteamUserStats_GetUserStat%(pThis%, lSteamId%, cName$, pData*)								:"_BS_ISteamUserStats_GetUserStat@16"
+BS_ISteamUserStats_GetUserStatEx%(pThis%, lSteamId%, cName$, pData%)							:"_BS_ISteamUserStats_GetUserStat@16"
+BS_ISteamUserStats_GetUserStatF%(pThis%, lSteamId%, cName$, pData*)								:"_BS_ISteamUserStats_GetUserStatF@16"
+BS_ISteamUserStats_GetUserStatFEx%(pThis%, lSteamId%, cName$, pData%)							:"_BS_ISteamUserStats_GetUserStatF@16"
+BS_ISteamUserStats_GetUserAchievement%(pThis%, lSteamId%, cName$, pbAchieved*)					:"_BS_ISteamUserStats_GetUserAchievement@16"
+BS_ISteamUserStats_GetUserAchievementEx%(pThis%, lSteamId%, cName$, pbAchieved%)				:"_BS_ISteamUserStats_GetUserAchievement@16"
+BS_ISteamUserStats_GetUserAchievementAndUnlockTime%(pThis%, lSteamId%, cName$, pbAchieved*, piUnlockTime*)												:"_BS_ISteamUserStats_GetUserAchievementAndUnlockTime@20"
+BS_ISteamUserStats_GetUserAchievementAndUnlockTimeEx%(pThis%, lSteamId%, cName$, pbAchieved%, piUnlockTime%)											:"_BS_ISteamUserStats_GetUserAchievementAndUnlockTime@20"
+BS_ISteamUserStats_ResetAllStats%(pThis%, bAchievementsToo%)									:"_BS_ISteamUserStats_ResetAllStats@8"
+BS_ISteamUserStats_FindOrCreateLeaderboard%(pThis%, cLeaderboardName$, eLeaderboardSortMethod%, eLeaderboardDisplayType%)								:"_BS_ISteamUserStats_FindOrCreateLeaderboard@16"
+BS_ISteamUserStats_FindLeaderboard%(pThis%, cLeaderboardName$)									:"_BS_ISteamUserStats_FindLeaderboard@8"
+BS_ISteamUserStats_GetLeaderboardName$(pThis%, hSteamLeaderboard%)								:"_BS_ISteamUserStats_GetLeaderboardName@8"
+BS_ISteamUserStats_GetLeaderboardEntryCount%(pThis%, hSteamLeaderboard%)						:"_BS_ISteamUserStats_GetLeaderboardEntryCount@8"
+BS_ISteamUserStats_GetLeaderboardSortMethod%(pThis%, hSteamLeaderboard%)						:"_BS_ISteamUserStats_GetLeaderboardSortMethod@8"
+BS_ISteamUserStats_GetLeaderboardDisplayType%(pThis%, hSteamLeaderboard%)						:"_BS_ISteamUserStats_GetLeaderboardDisplayType@8"
+BS_ISteamUserStats_DownloadLeaderboardEntries%(pThis%, hSteamLeaderboard%, eLeaderboardDataRequest%, iRangeStart%, iRangeEnd%)							:"_BS_ISteamUserStats_DownloadLeaderboardEntries@20"
+BS_ISteamUserStats_DownloadLeaderboardEntriesForUsers%(pThis%, hSteamLeaderboard%, plUsers*, iUserCount%)												:"_BS_ISteamUserStats_DownloadLeaderboardEntriesForUsers@16"
+BS_ISteamUserStats_DownloadLeaderboardEntriesForUsersEx%(pThis%, hSteamLeaderboard%, plUsers%, iUserCount%)												:"_BS_ISteamUserStats_DownloadLeaderboardEntriesForUsers@16"
+BS_ISteamUserStats_GetDownloadedLeaderboardEntry%(lpSteamUsers%, hSteamLeaderboardEntries%, iIndex%, pLeaderboardEntry*, pDetails*, iDetailsMax%)		:"_BS_ISteamUserStats_GetDownloadedLeaderboardEntry@24"
+BS_ISteamUserStats_GetDownloadedLeaderboardEntryEx%(lpSteamUsers%, hSteamLeaderboardEntries%, iIndex%, pLeaderboardEntry%, pDetails%, iDetailsMax%)		:"_BS_ISteamUserStats_GetDownloadedLeaderboardEntry@24"
+BS_ISteamUserStats_UploadLeaderboardScore%(pThis%, hSteamLeaderboard%, eLeaderboardUploadScoreMethod%, iScore%, pScoreDetails*, iScoreDetailsCount%)	:"_BS_ISteamUserStats_UploadLeaderboardScore@24"
+BS_ISteamUserStats_UploadLeaderboardScoreEx%(pThis%, hSteamLeaderboard%, eLeaderboardUploadScoreMethod%, iScore%, pScoreDetails%, iScoreDetailsCount%)	:"_BS_ISteamUserStats_UploadLeaderboardScore@24"
+BS_ISteamUserStats_AttachLeaderboardUGC%(pThis%, hSteamLeaderboard%, hUGC%)						:"_BS_ISteamUserStats_AttachLeaderboardUGC@12"
+BS_ISteamUserStats_GetNumberOfCurrentPlayers%(pThis%)											:"_BS_ISteamUserStats_GetNumberOfCurrentPlayers@4"
+BS_ISteamUserStats_RequestGlobalAchievementPercentages%(pThis%)									:"_BS_ISteamUserStats_RequestGlobalAchievementPercentages@4"
+BS_ISteamUserStats_GetMostAchievedAchievementInfo%(pThis%, cName$, iNameLength%, pfPercent*, pbAchieved*)												:"_BS_ISteamUserStats_GetMostAchievedAchievementInfo@20"
+BS_ISteamUserStats_GetMostAchievedAchievementInfoEx%(pThis%, cName$, iNameLength%, pfPercent%, pbAchieved%)												:"_BS_ISteamUserStats_GetMostAchievedAchievementInfo@20"
+BS_ISteamUserStats_GetNextMostAchievedAchievementInfo%(pThis%, iIteratorPrevious%, cName$, iNameLength%, pfPercent*, pbAchieved*)						:"_BS_ISteamUserStats_GetNextMostAchievedAchievementInfo@24"
+BS_ISteamUserStats_GetNextMostAchievedAchievementInfoEx%(pThis%, iIteratorPrevious%, cName$, iNameLength%, pfPercent%, pbAchieved%)						:"_BS_ISteamUserStats_GetNextMostAchievedAchievementInfo@24"
+BS_ISteamUserStats_GetAchievementAchievedPercent%(pThis%, cName$, pfPercent*)					:"_BS_ISteamUserStats_GetAchievementAchievedPercent@12"
+BS_ISteamUserStats_GetAchievementAchievedPercentEx%(pThis%, cName$, pfPercent%)					:"_BS_ISteamUserStats_GetAchievementAchievedPercent@12"
+BS_ISteamUserStats_RequestGlobalStats%(pThis%, iHistoryDays%)									:"_BS_ISteamUserStats_RequestGlobalStats@8"
+BS_ISteamUserStats_GetGlobalStatL%(pThis, cStatName$, plData%)									:"_BS_ISteamUserStats_GetGlobalStatL@12"
+BS_ISteamUserStats_GetGlobalStatD%(pThis, cStatName$, pdData%)									:"_BS_ISteamUserStats_GetGlobalStatD@12"
+BS_ISteamUserStats_GetGlobalStatHistoryL%(pThis, cStatName$, plDataArray%, iDataSize%)			:"_BS_ISteamUserStats_GetGlobalStatHistoryL@16"
+BS_ISteamUserStats_GetGlobalStatHistoryD%(pThis, cStatName$, pdDataArray%, iDataSize%)			:"_BS_ISteamUserStats_GetGlobalStatHistoryD@16"

Resources/Decls/BlitzSteam_SteamUtils.decls

@@ -0,0 +1,21 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Utils -----------------------------------------------------------------------
+BS_SteamUtils%()																:"_BS_SteamUtils@0"
+BS_SteamGameServerUtils%()														:"_BS_SteamGameServerUtils@0"

Resources/Decls/BlitzSteam_SteamVideo.decls

@@ -0,0 +1,20 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzSteam.dll"
+
+; Utils -----------------------------------------------------------------------
+BS_SteamVideo%()																:"_BS_SteamVideo@0"

Resources/Examples/SteamAPI_Example.bb

@@ -0,0 +1,66 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Include "../BlitzSteam.bb"
+
+; Initialize Steam before your next call to Graphics.
+If BS_SteamAPI_Init() = False Then
+	RuntimeError "Steam: Failed to initialize!"
+EndIf
+
+Const FPS = 30
+Const FPS_MULT# = 1.0 / FPS
+
+; Demo Scene
+Graphics3D 1024, 768, 32, 2
+SetBuffer BackBuffer()
+
+Local demoTimer = CreateTimer(FPS)
+
+Local demoRoot = CreatePivot()
+
+Local demoCameraRoot = CreatePivot(demoRoot)
+Local demoCamera = CreateCamera(demoCameraRoot)
+MoveEntity demoCamera, 0, 0, -10
+
+Local demoCube = CreateCube(demoRoot)
+
+Local EndGame = False
+Repeat
+	Cls
+	
+	;! Update
+	; End on Escape
+	EndGame = KeyHit(1)
+	
+	TurnEntity demoCube, 1 * FPS_MULT, 3 * FPS_MULT, 2.332 * FPS_MULT
+	
+	;! Render 3D
+	RenderWorld
+	
+	;! Render 2D
+	Text 0, 0, "Escape to Quit"
+	
+	;! Update Window
+	Flip 0
+	WaitTimer(demoTimer)
+Until EndGame = True
+
+; Shut down Steam as the last action of your program.
+BS_SteamAPI_Shutdown()
+End
+;~IDEal Editor Parameters:
+;~C#Blitz3D

Resources/Examples/SteamAppList_Example.bb

@@ -0,0 +1,128 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Include "../BlitzSteam.bb"
+
+; Initialize Steam before your next call to Graphics.
+If BS_SteamAPI_Init() = False Then
+	RuntimeError "Steam: Failed to initialize!"
+EndIf
+
+Const FPS = 30
+Const FPS_MULT# = 1.0 / FPS
+
+; Demo Scene
+Graphics3D 1024, 768, 32, 2
+SetBuffer BackBuffer()
+
+Local demoTimer = CreateTimer(FPS)
+
+Local demoRoot = CreatePivot()
+
+Local demoCameraRoot = CreatePivot(demoRoot)
+Local demoCamera = CreateCamera(demoCameraRoot)
+MoveEntity demoCamera, 0, 0, -10
+
+Local demoCube = CreateCube(demoRoot)
+
+; SteamAppList stuff
+Type SteamAppList
+	Field AppId%
+	Field Name$
+	Field InstallDir$
+	Field BuildId%
+End Type
+Global SteamAppList_Count%
+
+Function SteamAppList_Fill()
+	SteamAppList_Count = BS_ISteamAppList_GetNumInstalledApps(BS_SteamAppList())
+	
+	Local Buffer = CreateBank(4 * SteamAppList_Count)
+	Local AppNameBuffer = CreateBank(1024)
+	Local PathBuffer = CreateBank(260)
+	
+	Local AppIdCount = BS_ISteamAppList_GetInstalledApps(BS_SteamAppList(), Buffer, SteamAppList_Count)
+	Delete Each SteamAppList
+	For Index = 0 To AppIdCount - 1
+		Local AppId = PeekInt(Buffer, Index*4)
+		
+		Local SAL.SteamAppList = New SteamAppList
+		SAL\AppId = AppId
+		Local AppNameLen = BS_ISteamAppList_GetAppName(BS_SteamAppList(), AppId, AppNameBuffer, 1024)
+		SAL\Name = PeekCString(AppNameBuffer, 0, AppNameLen)
+		Local PathLen = BS_ISteamAppList_GetAppInstallDir(BS_SteamAppList(), AppId, PathBuffer, 260)
+		SAL\InstallDir = PeekCString(PathBuffer, 0, PathLen)
+		SAL\BuildId = BS_ISteamAppList_GetAppBuildId(BS_SteamAppList(), AppId)
+	Next
+	
+	FreeBank AppNameBuffer
+	FreeBank PathBuffer
+	FreeBank Buffer
+End Function
+
+Function PeekCString$(Bank, Offset=0, Length=-1)
+	Local Out$ = "", Pos = Offset
+	While Abs(Length) > 0
+		Length = Length - 1
+		
+		Local by = PeekByte(Bank, Pos)
+		If by = 0 Then
+			Length = 0
+		Else
+			Out = Out + Chr(by)
+		EndIf
+		
+		Pos = Pos + 1
+	Wend
+	Return Out
+End Function
+
+SteamAppList_Fill()
+
+; Main Loop
+Local EndGame = False
+Repeat
+	Cls
+	
+	;! Update
+	; End on Escape
+	EndGame = KeyHit(1)
+	
+	TurnEntity demoCube, 1 * FPS_MULT, 3 * FPS_MULT, 2.332 * FPS_MULT
+	
+	;! Render 3D
+	RenderWorld
+	
+	;! Render 2D
+	Text 0, 0, "Escape to Quit"
+	
+	Text 0,15, "Installed Apps: " + SteamAppList_Count
+	Local SAL.SteamAppList, Index = 0
+	For SAL.SteamAppList = Each SteamAppList
+		Index = Index + 1
+		Text 0, 30 + Index* 15, RSet(SAL\AppId, 6) + "/" + RSet(SAL\BuildId, 8) + ": " + SAL\Name + " (Installed: '" + SAL\InstallDir + "')"
+	Next
+	
+	;! Update Window
+	Flip 0
+	WaitTimer(demoTimer)
+Until EndGame = True
+
+; Shut down Steam as the last action of your program.
+BS_SteamAPI_Shutdown()
+End
+;~IDEal Editor Parameters:
+;~C#Blitz3D

Resources/Examples/SteamApps_Example.bb

@@ -0,0 +1,179 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Include "../BlitzSteam.bb"
+
+; Initialize Steam before your next call to Graphics.
+If BS_SteamAPI_Init() = False Then
+	RuntimeError "Steam: Failed to initialize!"
+EndIf
+
+Const FPS = 30
+Const FPS_MULT# = 1.0 / FPS
+
+; Demo Scene
+Graphics3D 1024, 768, 32, 2
+SetBuffer BackBuffer()
+
+Local demoTimer = CreateTimer(FPS)
+Local demoRoot = CreatePivot()
+Local demoCameraRoot = CreatePivot(demoRoot)
+Local demoCamera = CreateCamera(demoCameraRoot)
+MoveEntity demoCamera, 0, 0, -10
+Local demoCube = CreateCube(demoRoot)
+
+; SteamApps Stuff
+Type SteamAppsDLC
+	Field Id%
+	Field Available%
+	Field Name$
+End Type
+Global SteamAppsDLC_Count
+
+Function SteamAppsDLC_Fill()
+	Local IdBuffer = CreateBank(4)
+	Local AvailableBuffer = CreateBank(4)
+	Local NameBuffer = CreateBank(1024)
+	
+	SteamAppsDLC_Count = BS_ISteamApps_GetDLCCount(BS_SteamApps())
+	Delete Each SteamAppsDLC
+	For Index = 0 To SteamAppsDLC_Count - 1
+		If BS_ISteamApps_GetDLCDataByIndex(BS_SteamApps(), Index, IdBuffer, AvailableBuffer, NameBuffer, 1024)
+			Local SAD.SteamAppsDLC = New SteamAppsDLC
+			SAD\Id = PeekInt(IdBuffer, 0)
+			SAD\Available = PeekInt(AvailableBuffer, 0)
+			SAD\Name = PeekCString(NameBuffer, 0, 1024)
+		Else
+			SteamAppsDLC_Count = SteamAppsDLC_Count - 1
+		EndIf
+	Next
+	
+	FreeBank NameBuffer
+	FreeBank AvailableBuffer
+	FreeBank IdBuffer
+End Function
+
+Type SteamAppsDepots
+	Field DepotId
+End Type
+Global SteamAppsDepots_Count
+
+Function SteamAppsDepots_Fill()
+	Local DepotsBuffer
+	; Exercise: Do this one yourself with the above Type. It's not that hard.
+End Function
+
+Function PeekCString$(Bank, Offset=0, Length=-1)
+	Local Out$ = "", Pos = Offset
+	While Abs(Length) > 0
+		Length = Length - 1
+		
+		Local by = PeekByte(Bank, Pos)
+		If by = 0 Then
+			Length = 0
+		Else
+			Out = Out + Chr(by)
+		EndIf
+		
+		Pos = Pos + 1
+	Wend
+	Return Out
+End Function
+
+Local BetaBuffer = CreateBank(1024)
+BS_ISteamApps_GetCurrentBetaName(BS_SteamApps(), BetaBuffer, 1024)
+Local Beta$ = PeekCString(BetaBuffer, 0, 1024)
+FreeBank BetaBuffer
+
+Local AppInstallDir$, AppInstallDirBuffer = CreateBank(260)
+BS_ISteamApps_GetAppInstallDir(BS_SteamApps(), 480, AppInstallDirBuffer, 260)
+AppInstallDir = PeekCString(AppInstallDirBuffer, 0, 260)
+FreeBank AppInstallDirBuffer
+
+Local llOwner = BS_ISteamApps_GetAppOwner(BS_SteamApps())
+Local OwnerId$ = "[U:" + BS_CSteamID_GetAccountInstance(llOwner) + ":" + BS_CSteamID_GetAccountID(llOwner) + "] STEAM_" + (BS_CSteamID_GetEAccountType(llOwner) - 1) + ":" + (BS_CSteamID_GetEUniverse(llOwner) - 1) + ":" + (BS_CSteamID_GetAccountID(llOwner) / 2)
+BS_CSteamID_Destroy llOwner
+
+; Main Loop
+Local EndGame = False
+Repeat
+	Cls
+	
+	;! Update
+	; End on Escape
+	EndGame = KeyHit(1)
+	
+	TurnEntity demoCube, 1 * FPS_MULT, 3 * FPS_MULT, 2.332 * FPS_MULT
+	
+	;! Render 3D
+	RenderWorld
+	
+	;! Render 2D
+	Text 0, 0, "Escape to Quit"
+	
+	Text 0, 30, "Is Subscribed? " + BS_ISteamApps_IsSubscribed(BS_SteamApps())
+	Text 0, 45, "Is Low Violence? " + BS_ISteamApps_IsLowViolence(BS_SteamApps())
+	Text 0, 60, "Is Cybercafe? " + BS_ISteamApps_IsCybercafe(BS_SteamApps())
+	Text 0, 75, "Is VAC Banned? " + BS_ISteamApps_IsVACBanned(BS_SteamApps())
+	Text 0, 90, "Current Game Language: " + BS_ISteamApps_GetCurrentGameLanguage(BS_SteamApps())
+	Text 0,105, "Available Game Languages: " + BS_ISteamApps_GetAvailableGameLanguages(BS_SteamApps())
+	Text 0,120, "Is Subscribed App (480)? " + BS_ISteamApps_IsSubscribedApp(BS_SteamApps(), 480)
+	Text 0,135, "Is DLC (323180) Installed? " + BS_ISteamApps_IsDlcInstalled(BS_SteamApps(), 323180) ; Portal 2 Soundtrack DLC
+	Text 0,150, "Earliest Purchase Unix Time (480): " + BS_ISteamApps_GetEarliestPurchaseUnixTime(BS_SteamApps(), 480)
+	Text 0,165, "Is Subscribed from Free Weekend? " + BS_ISteamApps_IsSubscribedFromFreeWeekend(BS_SteamApps())
+	Text 0,180, "DLC Count: " + BS_ISteamApps_GetDLCCount(BS_SteamApps())
+	Text 0,195, "Current Beta Name: " + Beta
+	Text 0,210, "App Install Dir: " + AppInstallDir$
+	Text 0,225, "Is App Installed (480): " + BS_ISteamApps_IsAppInstalled(BS_SteamApps(), 480)
+	Text 0,240, "App Owner Id: " + OwnerId
+	Text 0,255, "App Built Id: " + BS_ISteamApps_GetAppBuildId(BS_SteamApps())
+	
+	; BS_ISteamApps_GetLanchQueryParam$(BS_SteamApps(), pchKey$)
+	;	// Returns the associated launch param if the game is run via steam://run/<appid>//?param1=value1;param2=value2;param3=value3 etc.
+	;	// Parameter names starting with the character '@' are reserved for internal use and will always return and empty string.
+	;	// Parameter names starting with an underscore '_' are reserved for steam features -- they can be queried by the game,
+	;	// but it is advised that you not param names beginning with an underscore for your own features.
+	
+	; BS_ISteamApps_MarkContentCorrupt signals steam that game files are corrupt or missing. Forces a validation after quit and before next start.
+	
+	; How To Use: BS_ISteamApps_RequestProofOfPurchaseKey(BS_SteamApps(), nAppId)
+	;	// Request cd-key for yourself or owned DLC. If you are interested in this
+	;	// data then make sure you provide us with a list of valid keys to be distributed
+	;	// to users when they purchase the game, before the game ships.
+	;	// You'll receive an AppProofOfPurchaseKeyResponse_t callback when
+	;	// the key is available (which may be immediately).
+	; Example (Spacewar) does not have CD-Keys.
+	
+	Text 512, 0, "DLCs: " + SteamAppsDLC_Count
+	Local Index = 0, SAD.SteamAppsDLC
+	For SAD = Each SteamAppsDLC
+		Text 512, 15 + Index * 15, SAD\Id + "(" + SAD\Available + "): " + SAD\Name
+		; You could install DLCs from the app itself, BS_ISteamApps_InstallDLC, BS_ISteamApps_UninstallDLC
+		; BS_ISteamApps_GetDlcDownloadProgress allows you to check the progress, BlitzUtility's LongLong stuff is useful here.
+		
+		Index = Index + 1
+	Next
+	
+	;! Update Window
+	Flip 0
+	WaitTimer(demoTimer)
+Until EndGame = True
+
+; Shut down Steam as the last action of your program.
+BS_SteamAPI_Shutdown()
+End
+;~IDEal Editor Parameters:
+;~C#Blitz3D

Resources/Examples/SteamController_Example.bb

@@ -0,0 +1,68 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Include "../BlitzSteam.bb"
+
+;! Example is incomplete, I do not own a Steam Controller.
+
+; Initialize Steam before your next call to Graphics.
+If BS_SteamAPI_Init() = False Then
+	RuntimeError "Steam: Failed to initialize!"
+EndIf
+
+Const FPS = 30
+Const FPS_MULT# = 1.0 / FPS
+
+; Demo Scene
+Graphics3D 1024, 768, 32, 2
+SetBuffer BackBuffer()
+
+Local demoTimer = CreateTimer(FPS)
+
+Local demoRoot = CreatePivot()
+
+Local demoCameraRoot = CreatePivot(demoRoot)
+Local demoCamera = CreateCamera(demoCameraRoot)
+MoveEntity demoCamera, 0, 0, -10
+
+Local demoCube = CreateCube(demoRoot)
+
+Local EndGame = False
+Repeat
+	Cls
+	
+	;! Update
+	; End on Escape
+	EndGame = KeyHit(1)
+	
+	TurnEntity demoCube, 1 * FPS_MULT, 3 * FPS_MULT, 2.332 * FPS_MULT
+	
+	;! Render 3D
+	RenderWorld
+	
+	;! Render 2D
+	Text 0, 0, "Escape to Quit"
+	
+	;! Update Window
+	Flip 0
+	WaitTimer(demoTimer)
+Until EndGame = True
+
+; Shut down Steam as the last action of your program.
+BS_SteamAPI_Shutdown()
+End
+;~IDEal Editor Parameters:
+;~C#Blitz3D

Resources/Examples/SteamHTMLSurface_Example.bb

@@ -0,0 +1,396 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Include "../BlitzSteam.bb"
+;----------------------------------------------------------------
+;! Steam Stuff
+;----------------------------------------------------------------
+
+; SteamClient: WarningMessageHook
+Global Steam_WarningMessageHook_Callback = 0
+Function Steam_WarningMessageHook(bIsWarning%, pchMessageBuffer%)
+	If Steam_WarningMessageHook_Callback = 0 Then
+		Steam_WarningMessageHook_Callback = BP_GetFunctionPointer()
+		Return
+	EndIf
+	
+	; Read Message from buffer
+	Local msg$ = ""
+	If bIsWarning = 1 Then
+		msg = "[Warning]"
+	Else
+		msg = "[Info]"
+	EndIf
+	msg = msg + PeekMemoryStringC(pchMessageBuffer)
+	
+	DebugLog "[Steam]" + msg$
+End Function:Steam_WarningMessageHook(0, 0)
+Function PeekMemoryStringC(Memory%, Length%=-1)
+	Local Ptr = Memory
+	Local iChar = 0, tiChar = 0
+	Local sOut$ = ""
+	
+	Repeat
+		tiChar = PeekMemoryByte(Ptr)
+		
+		; Advance memory, decrease Length
+		Ptr = Ptr + 1
+		Length = Length - 1
+		
+		If (tiChar = 0) Then
+			Length = 0
+		Else
+			sOut = sOut + Chr(tiChar)
+		EndIf
+	Until Length = 0
+	
+	Return sOut
+End Function
+
+;----------------------------------------------------------------
+;! SteamBrowser (Image & Texture Drawing)
+;----------------------------------------------------------------
+Global SteamBrowser_Callback_BrowserReady_p = 0, SteamBrowser_Callback_BrowserReady_c = 0
+Global SteamBrowser_Callback_NeedsPaint_p = 0, SteamBrowser_Callback_NeedsPaint_c = 0
+Global SteamBrowser_Callback_StartRequest_p = 0, SteamBrowser_Callback_StartRequest_c = 0
+
+Type SteamBrowser
+	Field Id%, lSteamAPICall%
+	Field Size%[1] ;Width, Height
+	Field URL$
+	
+	; CEF Stuff
+	Field UpdateRegion[3] ;X,Y,W,H
+	Field Serial%, Scale#, ScrollX%, ScrollY%
+	
+	; Image Based
+	Field hImage%
+	
+	; Texture Based
+	Field hTexture%
+End Type
+
+Function SteamBrowser_Create.SteamBrowser(Width%, Height%, URL$="http://google.com/", UserAgent$="SteamBrowser", UserCSS$="")
+	; Create our Object
+	Local SB.SteamBrowser = New SteamBrowser
+	SB\Id = 0 ; Initialize to 0 until the Browser is ready.
+	SB\Size[0] = Width
+	SB\Size[1] = Height
+	SB\URL = URL
+	SB\lSteamAPICall = BS_ISteamHTMLSurface_CreateBrowser(BS_SteamHTMLSurface(), UserAgent, UserCSS)
+	
+	; We need to register our callbacks, or nothing will work.
+	BS_Callback_RegisterResult SteamBrowser_Callback_BrowserReady_c, SB\lSteamAPICall, BS_SteamHTMLSurface_BrowserReady ; Listen to the result of the last SteamAPICall.
+	BS_Callback_Register SteamBrowser_Callback_NeedsPaint_c, BS_SteamHTMLSurface_NeedsPaint
+	BS_Callback_Register SteamBrowser_Callback_StartRequest_c, BS_SteamHTMLSurface_StartRequest
+	
+	; Image Based
+	SB\hImage = CreateImage(SB\Size[0], SB\Size[1])
+	; Texture Based
+	SB\hTexture = CreateTexture(SB\Size[0], SB\Size[1], 1+2)
+	
+	Return SB
+End Function
+
+Function SteamBrowser_Destroy(SB.SteamBrowser)
+	; Texture Based
+	FreeTexture SB\hTexture
+	; Image Based
+	FreeImage SB\hImage
+	
+	BS_ISteamHTMLSurface_RemoveBrowser BS_SteamHTMLSurface(), SB\Id
+	Delete SB
+End Function
+
+Function SteamBrowser_Find.SteamBrowser(iId%, lSteamAPICall%)
+	Local SB.SteamBrowser = Null
+	; Find by Id
+	If iId <> 0
+		For SB.SteamBrowser = Each SteamBrowser
+			If (SB\Id = iId) Then
+				Return SB
+			EndIf
+		Next
+	EndIf
+	; Find by SteamAPICall
+	If lSteamAPICall <> 0
+		For SB.SteamBrowser = Each SteamBrowser
+			If (SB\lSteamAPICall <> 0) And (BS_Long_Compare(lSteamAPICall, SB\lSteamAPICall) = 0) Then
+				Return SB
+			EndIf
+		Next
+	EndIf
+	Return Null
+End Function
+
+Function SteamBrowser_SetSize(SB.SteamBrowser, Width%, Height%)
+	SB\Size[0] = Width
+	SB\Size[1] = Height
+	
+	; Update Browser Size
+	BS_ISteamHTMLSurface_SetSize BS_SteamHTMLSurface(), SB\Id, Width, Height
+	
+	; Image Based
+	FreeImage(SB\hImage)
+	SB\hImage = CreateImage(Width, Height)
+	; Texture Based
+	FreeTexture(SB\hTexture)
+	SB\hTexture = CreateTexture(Width, Height, 1+2)
+End Function
+
+Function SteamBrowser_LoadUrl(SB.SteamBrowser, URL$, PostData$="")
+	BS_ISteamHTMLSurface_LoadURL BS_SteamHTMLSurface(), SB\Id, URL, PostData
+End Function
+
+Function SteamBrowser_IsReady(SB.SteamBrowser)
+	Return (SB\Id <> 0)
+End Function
+
+Function SteamBrowser_GetImageHandle(SB.SteamBrowser)
+	Return SB\hImage
+End Function
+
+Function SteamBrowser_GetTextureHandle(SB.SteamBrowser)
+	Return SB\hTexture
+End Function
+
+Function SteamBrowser_Callback_BrowserReady(pvParam%, bIOFailure, lSteamAPICall)
+	If (SteamBrowser_Callback_BrowserReady_p = 0) Then
+		SteamBrowser_Callback_BrowserReady_p = BP_GetFunctionPointer()
+		SteamBrowser_Callback_BrowserReady_c = BS_Callback_New(SteamBrowser_Callback_BrowserReady_p)
+		Return 
+	EndIf
+	
+	; Search for a valid SteamBrowser object.
+	Local SB.SteamBrowser = SteamBrowser_Find(0, lSteamAPICall)
+	SB\Id = BS_Memory_PeekInt(pvParam, 0)
+	SteamBrowser_SetSize(SB, SB\Size[0], SB\Size[1])
+	SteamBrowser_LoadUrl(SB, SB\URL)
+	
+	; Destroy our SteamAPICall pointer and clear the value.
+	BS_Long_Destroy(SB\lSteamAPICall):SB\lSteamAPICall = 0
+End Function:SteamBrowser_Callback_BrowserReady(0, 0, 0)
+
+Function SteamBrowser_Callback_NeedsPaint(pvParam%, p2, p3)
+	If (SteamBrowser_Callback_NeedsPaint_p = 0) Then
+		SteamBrowser_Callback_NeedsPaint_p = BP_GetFunctionPointer()
+		SteamBrowser_Callback_NeedsPaint_c = BS_Callback_New(SteamBrowser_Callback_NeedsPaint_p)
+		Return 
+	EndIf
+	
+	; Search for a valid SteamBrowser object.
+	Local SB.SteamBrowser = SteamBrowser_Find(BS_Memory_PeekInt(pvParam, 0), 0)
+	
+	; Parse Data from pvParam
+	Local pBuffer, pW, pH, pUpdateX, pUpdateY, pUpdateW, pUpdateH, pScrollX, pScrollY, pScale#, pSerial
+	pBuffer				= BS_Memory_PeekInt(pvParam, 4)
+	pW					= BS_Memory_PeekInt(pvParam, 8)
+	pH					= BS_Memory_PeekInt(pvParam, 12)
+	pUpdateX			= BS_Memory_PeekInt(pvParam, 16)
+	pUpdateY			= BS_Memory_PeekInt(pvParam, 20)
+	pUpdateW			= BS_Memory_PeekInt(pvParam, 24)
+	pUpdateH			= BS_Memory_PeekInt(pvParam, 28)
+	pScrollX			= BS_Memory_PeekInt(pvParam, 32)
+	pScrollY			= BS_Memory_PeekInt(pvParam, 36)
+	pScale				= BS_Memory_PeekFloat(pvParam, 40)
+	pSerial				= BS_Memory_PeekInt(pvParam, 44)
+	
+	; Assign to Object
+	SB\UpdateRegion[0] = pUpdateX
+	SB\UpdateRegion[1] = pUpdateY
+	SB\UpdateRegion[2] = pUpdateW
+	SB\UpdateRegion[3] = pUpdateH
+	SB\Scale = pScale
+	SB\ScrollX = pScrollX
+	SB\ScrollY = pScrollY
+	SB\Serial = pSerial
+	
+	; Fix up Buffer Size (Always next bigger 16*n, for whatever reason (SIBLY WHAT DID YOU DO!?))
+	Local nW = (16 * Ceil(pW / 16.0))
+	;DebugLog ImageWidth(SB\hImage) + ":" + ImageHeight(SB\hImage)
+	
+	; Image Based
+	Local hImageBuffer = ImageBuffer(SB\hImage)
+	LockBuffer hImageBuffer
+	BS_Helper_CopyMemoryIntMangle pBuffer, BS_Memory_PeekInt(hImageBuffer, 72), 0, pW, pH, nW, SB\Size[1], pUpdateX, pUpdateY, pUpdateW, pUpdateH
+	UnlockBuffer hImageBuffer
+	
+	; Texture Based (Identical)
+	Local hTextureBuffer = ImageBuffer(SB\hImage)
+	LockBuffer hTextureBuffer
+	BS_Helper_CopyMemoryIntMangle pBuffer, BS_Memory_PeekInt(hTextureBuffer, 72), 0, pW, pH, nW, SB\Size[1], pUpdateX, pUpdateY, pUpdateW, pUpdateH
+	UnlockBuffer hTextureBuffer
+	
+	
+	; pvParam Structure
+	;CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the browser that needs the paint
+	;CALLBACK_MEMBER(1, const char *, pBGRA ) // a pointer to the B8G8R8A8 data for this surface, valid until SteamAPI_RunCallbacks is next called
+	;CALLBACK_MEMBER(2, uint32, unWide) // the total width of the pBGRA texture
+	;CALLBACK_MEMBER(3, uint32, unTall) // the total height of the pBGRA texture
+	;CALLBACK_MEMBER(4, uint32, unUpdateX) // the offset in X for the damage rect for this update
+	;CALLBACK_MEMBER(5, uint32, unUpdateY) // the offset in Y for the damage rect for this update
+	;CALLBACK_MEMBER(6, uint32, unUpdateWide) // the width of the damage rect for this update
+	;CALLBACK_MEMBER(7, uint32, unUpdateTall) // the height of the damage rect for this update
+	;CALLBACK_MEMBER(8, uint32, unScrollX) // the page scroll the browser was at when this texture was rendered
+	;CALLBACK_MEMBER(9, uint32, unScrollY) // the page scroll the browser was at when this texture was rendered
+	;CALLBACK_MEMBER(10, float, flPageScale) // the page scale factor on this page when rendered
+	;CALLBACK_MEMBER(11, uint32, unPageSerial) // incremented on each new page load, you can use this to reject draws while navigating to new pages
+End Function:SteamBrowser_Callback_NeedsPaint(0, 0, 0)
+
+Function SteamBrowser_Callback_StartRequest(pvParam%, p2, p3)
+	If (SteamBrowser_Callback_StartRequest_p = 0) Then
+		SteamBrowser_Callback_StartRequest_p = BP_GetFunctionPointer()
+		SteamBrowser_Callback_StartRequest_c = BS_Callback_New(SteamBrowser_Callback_StartRequest_p)
+		Return 
+	EndIf
+	
+	; Search for a valid SteamBrowser object.
+	Local SB.SteamBrowser = SteamBrowser_Find(BS_Memory_PeekInt(pvParam, 0), 0)
+	
+	; Default to allow all requests. (Why not? For an Example, this is good enough.)
+	; Could implement a simple filter using a second type, but why don't you experiment a bit?
+	BS_ISteamHTMLSurface_AllowStartRequest BS_SteamHTMLSurface(), SB\Id, True
+End Function:SteamBrowser_Callback_StartRequest(0, 0, 0)
+
+
+
+
+;----------------------------------------------------------------
+;! Example Code
+;----------------------------------------------------------------
+If BS_SteamAPI_Init() = 0 Then RuntimeError "Steam failed to initialize."
+
+; Steam: Hooks, Callbacks, CallResults
+BS_ISteamClient_SetWarningMessageHook BS_SteamClient(), Steam_WarningMessageHook_Callback
+
+; Steam: HTMLSurface API
+If BS_SteamHTMLSurface() = 0 Then RuntimeError "Steam: HTMLSurface API is not available."
+If BS_ISteamHTMLSurface_Init(BS_SteamHTMLSurface()) = 0 Then RuntimeError "Steam: HTMLSurface API did not want to be initialized?!"
+;BS_ISteamHTMLSurface_SetSize BS_SteamHTMLSurface(), 0, GraphicsWidth(), GraphicsHeight()
+
+Const FPS = 60
+Const FPS_MULT# = 1.0 / FPS
+
+; Demo Scene
+Graphics3D 1024, 768, 32, 2
+SetBuffer BackBuffer()
+
+Local demoTimer = CreateTimer(FPS)
+Local demoRoot = CreatePivot()
+Local demoCameraRoot = CreatePivot(demoRoot)
+Local demoCamera = CreateCamera(demoCameraRoot)
+MoveEntity demoCamera, 0, 0, -10
+Local demoCube = CreateCube(demoRoot)
+
+; Create a Browser
+Local myBrowser.SteamBrowser = SteamBrowser_Create(GraphicsWidth(), GraphicsHeight(), "http://store.steampowered.com/app/368720/")
+
+Local Mouse[3], MouseButton[3], Key[255]
+While Not KeyHit(1)
+	Cls
+	
+	; Only allow input when the browser is up to date.
+	;If (myBrowser\iLastDraw > myBrowser\iLastRequest) Then
+	If True
+		; Mouse Input
+		If Mouse[0] <> MouseX() Or Mouse[1] <> MouseY() Then
+			Mouse[0] = MouseX()
+			Mouse[1] = MouseY()
+			BS_ISteamHTMLSurface_MouseMove BS_SteamHTMLSurface(), myBrowser\Id, MouseX(), MouseY()
+		EndIf
+		If Mouse[2] <> MouseZ() Then
+			Mouse[2] = MouseZ()
+			BS_ISteamHTMLSurface_MouseWheel BS_SteamHTMLSurface(), myBrowser\Id, MouseZSpeed()*30
+		EndIf
+		
+		Local Button
+		For Button = 1 To 3
+			Local ButtonDown = MouseDown(Button)
+			If MouseButton[Button] <> ButtonDown Then
+				MouseButton[Button] = MouseDown(Button)
+				
+				If ButtonDown
+					BS_ISteamHTMLSurface_MouseDown BS_SteamHTMLSurface(), myBrowser\Id, Button - 1
+				Else
+					BS_ISteamHTMLSurface_MouseUp BS_SteamHTMLSurface(), myBrowser\Id, Button - 1
+				EndIf
+			EndIf
+		Next
+		
+		; Keyboard
+		Local Modifier = BS_EHTMLKeyModifiers_None
+		If KeyDown(42) Or KeyDown(54) Then Modifier = Modifier Or BS_EHTMLKeyModifiers_ShiftDown
+		If KeyDown(29) Or KeyDown(157) Or KeyDown(184) Then Modifier = Modifier Or BS_EHTMLKeyModifiers_CtrlDown
+		If KeyDown(56) Or KeyDown(184) Then Modifier = Modifier Or BS_EHTMLKeyModifiers_AltDown
+		
+		Local VK
+		For VK = 0 To 255
+			Local SC = InputEx_User32_MapVirtualKeyEx(VK, 0, 0)
+			
+			Local KeyDownN = KeyDown(SC)
+			If Key[VK] <> KeyDownN Then
+				Key[VK] = KeyDownN
+				
+				If KeyDownN = 1 Then
+					BS_ISteamHTMLSurface_KeyDown BS_SteamHTMLSurface(), myBrowser\Id, VK, Modifier
+				Else 
+					BS_ISteamHTMLSurface_KeyUp BS_SteamHTMLSurface(), myBrowser\Id, VK, Modifier
+				EndIf
+			EndIf
+		Next
+		Local GetKeyC = GetKey()
+		If GetKeyC
+			BS_ISteamHTMLSurface_KeyChar BS_SteamHTMLSurface(), myBrowser\Id, GetKeyC, Modifier
+		EndIf
+		
+	EndIf
+		
+	; Steam: Run any Callbacks
+	; Q: Why before RenderWorld/Flip?
+	; A: If we did any changes, having them available before Rendering helps responsiveness.
+	;    A one-frame Delay is noticeable, even to people claiming the eye only sees 30 fps.
+	;    Please read a Biology book if you are one of those, it doesn't work like that.
+	BS_SteamAPI_RunCallbacks()
+	
+	RenderWorld
+	
+	;If (myBrowser\iLastDraw > myBrowser\iLastRequest) Then
+	If Not KeyDown(57)
+		DrawBlock SteamBrowser_GetImageHandle(myBrowser), 0, 0, 0
+		Color 255, 0, 0
+		Rect myBrowser\UpdateRegion[0],myBrowser\UpdateRegion[1],myBrowser\UpdateRegion[2],myBrowser\UpdateRegion[3], 0
+	Else
+		EntityTexture demoCube, SteamBrowser_GetTextureHandle(myBrowser)
+	EndIf
+	;EndIf
+	
+	Flip
+	WaitTimer demoTimer
+Wend
+
+; Destroy existing Browser
+SteamBrowser_Destroy(myBrowser):myBrowser = Null
+
+; Steam: HTMLSurface API
+BS_ISteamHTMLSurface_Shutdown(BS_SteamHTMLSurface())
+BS_SteamAPI_Shutdown()
+
+EndGraphics
+End
+
+;~IDEal Editor Parameters:
+;~F#17#28
+;~C#Blitz3D

Resources/Examples/SteamMatchmakingServers_Example.bb

@@ -0,0 +1,90 @@
+;	BlitzSteam - Steam wrapper for Blitz
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Include "../BlitzSteam.bb"
+
+;----------------------------------------------------------------
+;! Configuration
+;----------------------------------------------------------------
+Const APPID = 480 ; Test App / SpaceWar
+
+Const FRAMERATE = 60
+Const RESOLUTION_X = 1024
+Const RESOLUTION_Y = 768
+Const RESOLUTION_Z = 32
+Const RESOLUTION_MODE = 2
+
+;----------------------------------------------------------------
+;! Init Code
+;----------------------------------------------------------------
+Global Timer = CreateTimer(FRAMERATE)
+
+Global ServerListResponse_ServerResponded_p%:ServerListResponse_ServerResponded(0, 0, 0)
+Global ServerListResponse_RefreshComplete_p%:ServerListResponse_RefreshComplete(0, 0, 0)
+
+Graphics3D RESOLUTION_X, RESOLUTION_Y, RESOLUTION_Z, RESOLUTION_MODE
+SetBuffer BackBuffer()
+
+If Not BS_SteamAPI_Init() Then RuntimeError "Failed to initialize Steam!"
+
+;----------------------------------------------------------------
+;! Main Code
+;----------------------------------------------------------------
+Local Bank =CreateBank(1)
+Local pRequestServersResponse = BS_ISteamMatchmakingServerListResponse_New(0, ServerListResponse_ServerResponded_p, 0, ServerListResponse_RefreshComplete_p)
+Local hRequest = BS_ISteamMatchmakingServers_RequestInternetServerList(BS_SteamMatchmakingServers(), 480, Bank, 0, pRequestServersResponse)
+
+While Not KeyHit(1)
+	WaitTimer Timer
+	BS_SteamAPI_RunCallbacks()
+Wend
+
+BS_ISteamMatchmakingServers_ReleaseRequest(BS_SteamMatchmakingServers(), hRequest)
+BS_SteamAPI_Shutdown()
+
+;----------------------------------------------------------------
+;! Functions
+;----------------------------------------------------------------
+Function ServerListResponse_ServerResponded(pData%, hRequest%, iServer%)
+	If (Not ServerListResponse_ServerResponded_p)
+		ServerListResponse_ServerResponded_p = BP_GetFunctionPointer()
+		Return
+	EndIf
+	Print iServer
+	Return
+End Function
+
+Function ServerListResponse_RefreshComplete(pData%, hRequest%, eMatchMakingServerResponse%)
+	If (Not ServerListResponse_RefreshComplete_p)
+		ServerListResponse_RefreshComplete_p = BP_GetFunctionPointer()
+		Return
+	EndIf
+	
+	Select eMatchMakingServerResponse
+		Case BS_EMatchMakingServerResponse_ServerResponded
+			Print "Got Servers"
+		Case BS_EMatchMakingServerResponse_ServerFailedToRespond
+			Print "Server did not respond"
+		Case BS_EMatchMakingServerResponse_NoServersListedOnMasterServer
+			Print "No Servers listed for this game."
+		Default
+			Print "Unknown"
+	End Select
+	Return
+End Function
+
+;~IDEal Editor Parameters:
+;~C#Blitz3D

Resources/Examples/steam_appid.txt

@@ -0,0 +1 @@
+480

Types/BlitzCallback.cpp

@@ -0,0 +1,266 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzCallback.h"
+
+void BlitzCallback::Initialize() {
+#define BlitzCallback_DefineSize(T) BlitzCallback::Sizes.emplace(T::k_iCallback, sizeof(T));
+	// Do nothing if it was already done.
+	if (BlitzCallback::Sizes.size() > 0)
+		return;
+
+	// Default to the size of the class itself if no callback id is given.
+	BlitzCallback::Sizes.emplace(0, sizeof(BlitzCallback));
+
+	// SteamAPI
+	// SteamAppList
+	BlitzCallback_DefineSize(SteamAppInstalled_t);
+	BlitzCallback_DefineSize(SteamAppUninstalled_t);
+	// SteamApps
+	BlitzCallback_DefineSize(DlcInstalled_t);
+	BlitzCallback_DefineSize(RegisterActivationCodeResponse_t);
+	BlitzCallback_DefineSize(AppProofOfPurchaseKeyResponse_t);
+	BlitzCallback_DefineSize(NewLaunchQueryParameters_t);
+	// SteamController
+	// SteamFriends
+	BlitzCallback_DefineSize(PersonaStateChange_t);
+	BlitzCallback_DefineSize(GameOverlayActivated_t);
+	BlitzCallback_DefineSize(GameServerChangeRequested_t);
+	BlitzCallback_DefineSize(GameLobbyJoinRequested_t);
+	BlitzCallback_DefineSize(AvatarImageLoaded_t);
+	BlitzCallback_DefineSize(ClanOfficerListResponse_t);
+	BlitzCallback_DefineSize(FriendRichPresenceUpdate_t);
+	BlitzCallback_DefineSize(GameRichPresenceJoinRequested_t);
+	BlitzCallback_DefineSize(GameConnectedClanChatMsg_t);
+	BlitzCallback_DefineSize(GameConnectedChatJoin_t);
+	BlitzCallback_DefineSize(GameConnectedChatLeave_t);
+	BlitzCallback_DefineSize(DownloadClanActivityCountsResult_t);
+	BlitzCallback_DefineSize(JoinClanChatRoomCompletionResult_t);
+	BlitzCallback_DefineSize(GameConnectedFriendChatMsg_t);
+	BlitzCallback_DefineSize(FriendsGetFollowerCount_t);
+	BlitzCallback_DefineSize(FriendsIsFollowing_t);
+	BlitzCallback_DefineSize(FriendsEnumerateFollowingList_t);
+	BlitzCallback_DefineSize(SetPersonaNameResponse_t);
+	// SteamGameServer
+	BlitzCallback_DefineSize(GSClientApprove_t);
+	BlitzCallback_DefineSize(GSClientDeny_t);
+	BlitzCallback_DefineSize(GSClientKick_t);
+	BlitzCallback_DefineSize(GSClientAchievementStatus_t);
+	BlitzCallback_DefineSize(GSPolicyResponse_t);
+	BlitzCallback_DefineSize(GSGameplayStats_t);
+	BlitzCallback_DefineSize(GSClientGroupStatus_t);
+	BlitzCallback_DefineSize(GSReputation_t);
+	BlitzCallback_DefineSize(AssociateWithClanResult_t);
+	BlitzCallback_DefineSize(ComputeNewPlayerCompatibilityResult_t);
+	// SteamGameServerStats
+	BlitzCallback_DefineSize(GSStatsReceived_t);
+	BlitzCallback_DefineSize(GSStatsStored_t);
+	BlitzCallback_DefineSize(GSStatsUnloaded_t);
+	// SteamHTMLSurface
+	BlitzCallback_DefineSize(HTML_BrowserReady_t);
+	// SteamHTTP
+	BlitzCallback_DefineSize(HTTPRequestCompleted_t);
+	BlitzCallback_DefineSize(HTTPRequestHeadersReceived_t);
+	BlitzCallback_DefineSize(HTTPRequestDataReceived_t);
+	// SteamInventory
+	BlitzCallback_DefineSize(SteamInventoryResultReady_t);
+	BlitzCallback_DefineSize(SteamInventoryFullUpdate_t);
+	BlitzCallback_DefineSize(SteamInventoryDefinitionUpdate_t);
+	// SteamMatchmaking
+	// SteamMatchmakingServers
+	// SteamMusic
+	// SteamMusicRemote
+	// SteamNetworking
+	BlitzCallback_DefineSize(P2PSessionRequest_t);
+	BlitzCallback_DefineSize(P2PSessionConnectFail_t);
+	BlitzCallback_DefineSize(SocketStatusCallback_t);
+}
+
+std::map<int32_t, size_t> BlitzCallback::Sizes;
+
+BlitzCallback::BlitzCallback(BP_BlitzFunction3_t pFunctionPointer) {
+	BlitzCallback::Initialize();
+
+	// Initialize all values to 0.
+	this->m_iCallback = 0;
+	this->m_nCallbackFlags = 0;
+	this->m_hSteamAPICall = 0;
+
+	// Set function pointer.
+	this->m_pFunctionPointer = pFunctionPointer;
+}
+
+BlitzCallback::~BlitzCallback() {
+	// Unregister if we are still registered.
+	this->UnregisterResult();
+	this->Unregister();
+
+	// Reset all variables to 0.
+	this->m_iCallback = 0;
+	this->m_nCallbackFlags = 0;
+	this->m_hSteamAPICall = 0;
+	this->m_pFunctionPointer = 0;
+}
+
+void BlitzCallback::Run(void *pvParam) {
+	if (m_hSteamAPICall != 0)
+		m_hSteamAPICall = 0; // Caller unregisters for us.
+
+	BP_CallFunction3(m_pFunctionPointer, reinterpret_cast<int32_t>(pvParam), 0, 0);
+}
+
+void BlitzCallback::Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall) {
+	if (m_hSteamAPICall != 0)
+		m_hSteamAPICall = 0; // Caller unregisters for us.
+
+	BP_CallFunction3(m_pFunctionPointer, reinterpret_cast<int32_t>(pvParam), (bIOFailure ? 0 : 1), reinterpret_cast<int32_t>(&hSteamAPICall));
+}
+
+int BlitzCallback::GetCallbackSizeBytes() {
+	return (BlitzCallback::Sizes.find(this->m_iCallback)->second);
+}
+
+void BlitzCallback::SetCallback(int32_t iCallback) {
+	this->m_iCallback = iCallback;
+}
+
+int32_t BlitzCallback::GetCallback() {
+	return this->m_iCallback;
+}
+
+void BlitzCallback::SetFunction(BP_BlitzFunction3_t pFunction) {
+	this->m_pFunctionPointer = pFunction;
+}
+
+BP_BlitzFunction3_t BlitzCallback::GetFunction() {
+	return this->m_pFunctionPointer;
+}
+
+bool BlitzCallback::IsRegistered() {
+	return (this->m_nCallbackFlags & this->k_ECallbackFlagsRegistered) != 0;
+}
+
+void BlitzCallback::SetRegistered(bool bIsRegistered) {
+	this->m_nCallbackFlags &= ~k_ECallbackFlagsRegistered;
+	if (bIsRegistered)
+		this->m_nCallbackFlags |= k_ECallbackFlagsRegistered;
+}
+
+bool BlitzCallback::IsGameServer() {
+	return (this->m_nCallbackFlags & this->k_ECallbackFlagsGameServer) != 0;
+}
+
+void BlitzCallback::SetGameServer(bool bIsGameServer) {
+	this->m_nCallbackFlags &= ~k_ECallbackFlagsGameServer;
+	if (bIsGameServer)
+		this->m_nCallbackFlags |= k_ECallbackFlagsGameServer;
+}
+
+void BlitzCallback::Register(uint32_t iCallback) {
+	if (this->IsRegistered())
+		this->Unregister();
+
+	SteamAPI_RegisterCallback(this, iCallback);
+	this->m_iCallback = iCallback;
+}
+
+void BlitzCallback::Unregister() {
+	if (this->IsRegistered()) {
+		SteamAPI_UnregisterCallback(this);
+		this->m_iCallback = 0;
+	}
+}
+
+void BlitzCallback::RegisterResult(SteamAPICall_t hSteamAPICall, uint32_t iCallback) {
+	if (this->m_hSteamAPICall != 0)
+		this->UnregisterResult();
+
+	this->m_hSteamAPICall = hSteamAPICall;
+	this->m_iCallback = iCallback;
+
+	SteamAPI_RegisterCallResult(this, hSteamAPICall);
+}
+
+void BlitzCallback::UnregisterResult() {
+	if (this->m_hSteamAPICall != 0) {
+		SteamAPI_UnregisterCallResult(this, this->m_hSteamAPICall);
+		this->m_hSteamAPICall = 0;
+		this->m_iCallback = 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// C-Callables
+//-----------------------------------------------------------------------------
+DLL(BlitzCallback*) BS_Callback_New(BP_BlitzFunction3_t pFunctionPointer) {
+	return new BlitzCallback(pFunctionPointer);
+}
+
+DLL(void) BS_Callback_Destroy(BlitzCallback* pCallback) {
+	delete pCallback;
+}
+
+DLL(int32_t) BS_Callback_GetCallbackSizeBytes(BlitzCallback* pCallback) {
+	return pCallback->GetCallbackSizeBytes();
+}
+
+DLL(void) BS_Callback_SetCallback(BlitzCallback* pCallback, int32_t iCallback) {
+	pCallback->SetCallback(iCallback);
+}
+
+DLL(int32_t) BS_Callback_GetCallback(BlitzCallback* pCallback) {
+	return pCallback->GetCallback();
+}
+
+DLL(void) BS_Callback_SetFunction(BlitzCallback* pCallback, BP_BlitzFunction3_t pFunction) {
+	pCallback->SetFunction(pFunction);
+}
+
+DLL(BP_BlitzFunction3_t) BS_Callback_GetFunction(BlitzCallback* pCallback) {
+	return pCallback->GetFunction();
+}
+
+DLL(int32_t) BS_Callback_IsRegistered(BlitzCallback* pCallback) {
+	return pCallback->IsRegistered();
+}
+
+DLL(void) BS_Callback_SetRegistered(BlitzCallback* pCallback, int32_t bIsRegistered) {
+	pCallback->SetRegistered(!!bIsRegistered);
+}
+
+DLL(int32_t) BS_Callback_IsGameServer(BlitzCallback* pCallback) {
+	return pCallback->IsGameServer();
+}
+
+DLL(void) BS_Callback_SetGameServer(BlitzCallback* pCallback, int32_t bIsGameServer) {
+	pCallback->SetGameServer(!!bIsGameServer);
+}
+
+DLL(void) BS_Callback_Register(BlitzCallback* pCallback, uint32_t iCallback) {
+	pCallback->Register(iCallback);
+}
+
+DLL(void) BS_Callback_Unregister(BlitzCallback* pCallback) {
+	pCallback->Unregister();
+}
+
+DLL(void) BS_Callback_RegisterResult(BlitzCallback* pCallback, SteamAPICall_t* pSteamAPICall, uint32_t iCallback) {
+	pCallback->RegisterResult(*pSteamAPICall, iCallback);
+}
+
+DLL(void) BS_Callback_UnregisterResult(BlitzCallback* pCallback) {
+	pCallback->UnregisterResult();
+}

Types/BlitzCallback.h

@@ -0,0 +1,96 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include "BlitzSteamInternal.h"
+#include "../Helpers/BlitzPointer.h"
+
+#include <list>
+#include <vector>
+#include <map>
+
+class BlitzCallback : public CCallbackBase {
+	// Static Parts
+	public:
+	/// Initializes the CallbackSizes list for future use.
+	static void Initialize();
+	static std::map<int32_t, size_t> Sizes;
+
+	// Class Parts
+	public:
+	// Constructor
+	BlitzCallback(BP_BlitzFunction3_t pFunctionPointer);
+	// Destructor
+	~BlitzCallback();
+
+	// Run
+	virtual void Run(void *pvParam);
+	virtual void Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall);
+
+	// Callback Size
+	virtual int GetCallbackSizeBytes();
+
+	// Accessors
+	void SetCallback(int32_t iCallback);
+	int32_t GetCallback();
+
+	void SetFunction(BP_BlitzFunction3_t pFunction);
+	BP_BlitzFunction3_t GetFunction();
+	
+	bool IsRegistered();
+	void SetRegistered(bool bIsRegistered);
+
+	bool IsGameServer();
+	void SetGameServer(bool bIsGameServer);
+
+	// Registration in Steam
+	/// Register as Callback
+	void Register(uint32_t iCallback);
+	void Unregister();
+
+	/// Register as CallResult
+	void RegisterResult(SteamAPICall_t hSteamAPICall, uint32_t iCallback);
+	void UnregisterResult();
+
+	private:
+	/// Function to Call
+	BP_BlitzFunction3_t m_pFunctionPointer;
+
+	/// Assigned SteamAPICall
+	SteamAPICall_t m_hSteamAPICall;
+};
+
+//-----------------------------------------------------------------------------
+// C-Callables
+//-----------------------------------------------------------------------------
+DLL(BlitzCallback*) BS_Callback_New(BP_BlitzFunction3_t pFunctionPointer);
+DLL(void) BS_Callback_Destroy(BlitzCallback* pCallback);
+
+DLL(int32_t) BS_Callback_GetCallbackSizeBytes(BlitzCallback* pCallback);
+DLL(void) BS_Callback_SetCallback(BlitzCallback* pCallback, int32_t iCallback);
+DLL(int32_t) BS_Callback_GetCallback(BlitzCallback* pCallback);
+DLL(void) BS_Callback_SetFunction(BlitzCallback* pCallback, BP_BlitzFunction3_t pFunction);
+DLL(BP_BlitzFunction3_t) BS_Callback_GetFunction(BlitzCallback* pCallback);
+DLL(void) BS_Callback_SetRegistered(BlitzCallback* pCallback, int32_t bIsRegistered);
+DLL(int32_t) BS_Callback_IsRegistered(BlitzCallback* pCallback);
+DLL(void) BS_Callback_SetGameServer(BlitzCallback* pCallback, int32_t bIsGameServer);
+DLL(int32_t) BS_Callback_IsGameServer(BlitzCallback* pCallback);
+
+DLL(void) BS_Callback_Register(BlitzCallback* pCallback, uint32_t iCallback);
+DLL(void) BS_Callback_Unregister(BlitzCallback* pCallback);
+DLL(void) BS_Callback_RegisterResult(BlitzCallback* pCallback, SteamAPICall_t* pSteamAPICall, uint32_t iCallback);
+DLL(void) BS_Callback_UnregisterResult(BlitzCallback* pCallback);

Types/CSteamID.cpp

@@ -0,0 +1,172 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "CSteamID.h"
+
+DLL(CSteamID*) BS_CSteamID_New() {
+	return new CSteamID();
+}
+
+DLL(CSteamID*) BS_CSteamID_Copy(CSteamID* pOther) {
+	return new CSteamID(*pOther);
+}
+
+DLL(void) BS_CSteamID_Destroy(CSteamID* pThis) {
+	delete pThis;
+}
+
+DLL(CSteamID*) BS_CSteamID_New_IdUniverseType(AccountID_t iAccountId, EUniverse eUniverse, EAccountType eAccountType) {
+	return new CSteamID(iAccountId, eUniverse, eAccountType);
+}
+
+DLL(CSteamID*) BS_CSteamID_New_IdInstanceUniverseType(AccountID_t iAccountId, uint32_t iInstance, EUniverse eUniverse, EAccountType eAccountType) {
+	return new CSteamID(iAccountId, iInstance, eUniverse, eAccountType);
+}
+
+DLL(CSteamID*) BS_CSteamID_FromL(int64_t* pOther) {
+	return new CSteamID((uint64_t)*pOther);
+}
+
+DLL(int64_t*) BS_CSteamID_ToL(CSteamID* pThis) {
+	return new int64_t(pThis->ConvertToUint64());
+}
+
+DLL(void) BS_CSteamID_Set(CSteamID* pThis, AccountID_t iAccountID, EUniverse eUniverse, EAccountType eAccountType) {
+	pThis->Set(iAccountID, eUniverse, eAccountType);
+}
+
+DLL(void) BS_CSteamID_InstancedSet(CSteamID* pThis, AccountID_t iAccountId, uint32_t iInstance, EUniverse eUniverse, EAccountType eAccountType) {
+	pThis->InstancedSet(iAccountId, iInstance, eUniverse, eAccountType);
+}
+
+DLL(void) BS_CSteamID_FullSet(CSteamID* pThis, int64_t* plIdentifier, EUniverse eUniverse, EAccountType eAccountType) {
+	pThis->FullSet(*plIdentifier, eUniverse, eAccountType);
+}
+
+DLL(void) BS_CSteamID_SetFromLong(CSteamID* pThis, int64_t* plSteamID) {
+	pThis->SetFromUint64(*plSteamID);
+}
+
+DLL(void) BS_CSteamID_Clear(CSteamID* pThis) {
+	pThis->Clear();
+}
+
+DLL(int64_t*) BS_CSteamID_GetStaticAccountKey(CSteamID* pThis) {
+	return new int64_t(pThis->GetStaticAccountKey());
+}
+
+DLL(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pThis, EUniverse eUniverse) {
+	pThis->CreateBlankAnonLogon(eUniverse);
+}
+
+DLL(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pThis, EUniverse eUniverse) {
+	pThis->CreateBlankAnonUserLogon(eUniverse);
+}
+
+DLL(int32_t) BS_CSteamID_IsBlankAnonAccount(CSteamID* pThis) {
+	return pThis->BBlankAnonAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsGameServerAccount(CSteamID* pThis) {
+	return pThis->BGameServerAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsPersistentGameServerAccount(CSteamID* pThis) {
+	return pThis->BPersistentGameServerAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsAnonGameServerAccount(CSteamID* pThis) {
+	return pThis->BAnonGameServerAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsContentServerAccount(CSteamID* pThis) {
+	return pThis->BContentServerAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsClanAccount(CSteamID* pThis) {
+	return pThis->BClanAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsChatAccount(CSteamID* pThis) {
+	return pThis->BChatAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsLobby(CSteamID* pThis) {
+	return pThis->IsLobby();
+}
+
+DLL(int32_t) BS_CSteamID_IsIndividualAccount(CSteamID* pThis) {
+	return pThis->BIndividualAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsAnonAccount(CSteamID* pThis) {
+	return pThis->BAnonAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsAnonUserAccount(CSteamID* pThis) {
+	return pThis->BAnonUserAccount();
+}
+
+DLL(int32_t) BS_CSteamID_IsConsoleUserAccount(CSteamID* pThis) {
+	return pThis->BConsoleUserAccount();
+}
+
+DLL(void) BS_CSteamID_SetAccountID(CSteamID* pThis, AccountID_t iAccountId) {
+	pThis->SetAccountID(iAccountId);
+}
+
+DLL(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pThis) {
+	return pThis->GetAccountID();
+}
+
+DLL(void) BS_CSteamID_SetAccountInstance(CSteamID* pThis, uint32_t iInstance) {
+	pThis->SetAccountInstance(iInstance);
+}
+
+DLL(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pThis) {
+	pThis->ClearIndividualInstance();
+}
+
+DLL(int32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pThis) {
+	return pThis->HasNoIndividualInstance();
+}
+
+DLL(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pThis) {
+	return pThis->GetUnAccountInstance();
+}
+
+DLL(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pThis) {
+	return pThis->GetEAccountType();
+}
+
+DLL(void) BS_CSteamID_SetEUniverse(CSteamID* pThis, EUniverse eUniverse) {
+	pThis->SetEUniverse(eUniverse);
+}
+
+DLL(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pThis) {
+	return pThis->GetEUniverse();
+}
+
+DLL(int32_t) BS_CSteamID_Compare(CSteamID* pThis, CSteamID* pOther) {
+	if ((pThis == nullptr) || (pOther == nullptr))
+		return -1;
+
+	return /* It can either be Equal (0) or Smaller or Greater. Easy to check. */
+		   /* Greater */
+		(*pThis > *pOther ? 1 : 0) +
+		/* Smaller */
+		(*pThis < *pOther ? -1 : 0);
+}

Types/CSteamID.h

@@ -0,0 +1,179 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzSteamInternal.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+DLL(CSteamID*) BS_CSteamID_New();
+DLL(CSteamID*) BS_CSteamID_Copy(CSteamID* pOther);
+DLL(void) BS_CSteamID_Destroy(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+// Input  : unAccountID -	32-bit account ID
+//			eUniverse -		Universe this account belongs to
+//			eAccountType -	Type of account
+//-----------------------------------------------------------------------------
+DLL(CSteamID*) BS_CSteamID_New_IdUniverseType(AccountID_t iAccountId, EUniverse eUniverse, EAccountType eAccountType);
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+// Input  : unAccountID -	32-bit account ID
+//			unAccountInstance - instance 
+//			eUniverse -		Universe this account belongs to
+//			eAccountType -	Type of account
+//-----------------------------------------------------------------------------
+DLL(CSteamID*) BS_CSteamID_New_IdInstanceUniverseType(AccountID_t iAccountId, uint32_t iInstance, EUniverse eUniverse, EAccountType eAccountType);
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+// Input  : ulSteamID -		64-bit representation of a Steam ID
+// Note:	Will not accept a uint32 or int32 as input, as that is a probable mistake.
+//			See the stubbed out overloads in the private: section for more info.
+//-----------------------------------------------------------------------------
+DLL(CSteamID*) BS_CSteamID_FromL(int64_t* pOther);
+DLL(int64_t*) BS_CSteamID_ToL(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets parameters for steam ID
+// Input  : unAccountID -	32-bit account ID
+//			eUniverse -		Universe this account belongs to
+//			eAccountType -	Type of account
+//-----------------------------------------------------------------------------
+DLL(void) BS_CSteamID_Set(CSteamID* pThis, AccountID_t iAccountID, EUniverse eUniverse, EAccountType eAccountType);
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets parameters for steam ID
+// Input  : unAccountID -	32-bit account ID
+//			eUniverse -		Universe this account belongs to
+//			eAccountType -	Type of account
+//-----------------------------------------------------------------------------
+DLL(void) BS_CSteamID_InstancedSet(CSteamID* pThis, AccountID_t iAccountId, uint32_t iInstance, EUniverse eUniverse, EAccountType eAccountType);
+
+//-----------------------------------------------------------------------------
+// Purpose: Initializes a steam ID from its 52 bit parts and universe/type
+// Input  : ulIdentifier - 52 bits of goodness
+//-----------------------------------------------------------------------------
+DLL(void) BS_CSteamID_FullSet(CSteamID* pThis, int64_t* plIdentifier, EUniverse eUniverse, EAccountType eAccountType);
+
+//-----------------------------------------------------------------------------
+// Purpose: Initializes a steam ID from its 64-bit representation
+// Input  : ulSteamID -		64-bit representation of a Steam ID
+//-----------------------------------------------------------------------------
+DLL(void) BS_CSteamID_SetFromLong(CSteamID* pThis, int64_t* plSteamID);
+
+//-----------------------------------------------------------------------------
+// Purpose: Clear all fields, leaving an invalid ID.
+//-----------------------------------------------------------------------------
+DLL(void) BS_CSteamID_Clear(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Converts the static parts of a steam ID to a 64-bit representation.
+//			For multiseat accounts, all instances of that account will have the
+//			same static account key, so they can be grouped together by the static
+//			account key.
+// Output : 64-bit static account key
+//-----------------------------------------------------------------------------
+DLL(int64_t*) BS_CSteamID_GetStaticAccountKey(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: create an anonymous game server login to be filled in by the AM
+//-----------------------------------------------------------------------------
+DLL(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pThis, EUniverse eUniverse);
+
+//-----------------------------------------------------------------------------
+// Purpose: create an anonymous game server login to be filled in by the AM
+//-----------------------------------------------------------------------------
+DLL(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pThis, EUniverse eUniverse);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an anonymous game server login that will be filled in?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsBlankAnonAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a game server account id?  (Either persistent or anonymous)
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsGameServerAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a persistent (not anonymous) game server account id?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsPersistentGameServerAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an anonymous game server account id?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsAnonGameServerAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a content server account id?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsContentServerAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a clan account id?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsClanAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a chat account id?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsChatAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a Lobby?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsLobby(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an individual user account id?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsIndividualAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an anonymous account?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsAnonAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an anonymous user account? ( used to create an account or reset a password )
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsAnonUserAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a faked up Steam ID for a PSN friend account?
+//-----------------------------------------------------------------------------
+DLL(int32_t) BS_CSteamID_IsConsoleUserAccount(CSteamID* pThis);
+
+// simple accessors
+DLL(void) BS_CSteamID_SetAccountID(CSteamID* pThis, AccountID_t iAccountId);
+DLL(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pThis);
+
+DLL(void) BS_CSteamID_SetAccountInstance(CSteamID* pThis, uint32_t iInstance);
+DLL(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pThis);
+DLL(int32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pThis);
+DLL(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pThis);
+
+DLL(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pThis);
+
+DLL(void) BS_CSteamID_SetEUniverse(CSteamID* pThis, EUniverse eUniverse);
+DLL(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pThis);
+
+DLL(int32_t) BS_CSteamID_Compare(CSteamID* pThis, CSteamID* pOther);

Types/Double.cpp

@@ -0,0 +1,125 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Long.h"
+
+DLL(double_t*) BS_Double_New() {
+	return new double_t;
+}
+DLL(double_t*) BS_Double_Copy(double_t* pOther) {
+	return new double_t(*pOther);
+}
+DLL(void) BS_Double_Destroy(double_t* pThis) {
+	delete pThis;
+}
+
+char* BS_Double_Buffer = new char[32];
+DLL(const char*) BS_Double_ToString(double_t* pThis) {
+	std::stringstream myStream;
+	myStream << (*pThis);
+
+	const char* myBuffer = myStream.str().c_str();
+	strcpy_s(BS_Double_Buffer, 32, myBuffer);
+	return BS_Double_Buffer;
+}
+DLL(double_t*) BS_Double_FromString(const char* pString) {
+	double_t* pThis = new double_t;
+	std::stringstream myStream = std::stringstream(pString);
+	myStream >> *pThis;
+	return pThis;
+}
+
+DLL(double_t*) BS_Double_FromF(float_t fOther) {
+	return new double_t(fOther);
+}
+DLL(float_t) BS_Double_ToF(double_t* pThis) {
+	return (float_t)*pThis;
+}
+
+DLL(double_t*) BS_Double_FromI(int32_t iOther) {
+	return new double_t(iOther);
+}
+DLL(int32_t) BS_Double_ToI(double_t* pThis) {
+	return (int32_t)*pThis;
+}
+
+DLL(double_t*) BS_Double_FromL(int64_t* pOther) {
+	return new double_t((double_t)*pOther);
+}
+DLL(int64_t*) BS_Double_ToL(double_t* pThis) {
+	return new int64_t((int64_t)*pThis);
+}
+
+DLL(int32_t) BS_Double_Compare(double_t* pThis, double_t* pOther) {
+	if ((pThis == nullptr) || (pOther == nullptr))
+		return -1;
+
+	return /* It can either be Equal (0) or Smaller or Greater. Easy to check. */
+		   /* Greater */
+		(*pThis > *pOther ? 1 : 0) +
+		/* Smaller */
+		(*pThis < *pOther ? -1 : 0);
+}
+
+DLL(double_t*) BS_Double_Set(double_t* pThis, double_t* pOther) {
+	*pThis = *pOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_Add(double_t* pThis, double_t* pOther) {
+	*pThis += *pOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_Sub(double_t* pThis, double_t* pOther) {
+	*pThis -= *pOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_Div(double_t* pThis, double_t* pOther) {
+	*pThis /= *pOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_Mul(double_t* pThis, double_t* pOther) {
+	*pThis *= *pOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_Mod(double_t* pThis, double_t* pOther) {
+	*pThis = fmod(*pThis, *pOther);
+	return pThis;
+}
+
+DLL(double_t*) BS_Double_SetF(double_t* pThis, float_t fOther) {
+	*pThis = fOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_AddF(double_t* pThis, float_t fOther) {
+	*pThis += fOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_SubF(double_t* pThis, float_t fOther) {
+	*pThis -= fOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_DivF(double_t* pThis, float_t fOther) {
+	*pThis /= fOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_MulF(double_t* pThis, float_t fOther) {
+	*pThis *= fOther;
+	return pThis;
+}
+DLL(double_t*) BS_Double_ModF(double_t* pThis, float_t fOther) {
+	*pThis = fmod(*pThis, fOther);
+	return pThis;
+}

Types/Double.h

@@ -0,0 +1,51 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzSteamInternal.h"
+#include <sstream>
+
+DLL(double_t*) BS_Double_New();
+DLL(double_t*) BS_Double_Copy(double_t* pRight);
+DLL(void) BS_Double_Destroy(double_t* pThis);
+
+DLL(const char*) BS_Double_ToString(double_t* pThis);
+DLL(double_t*) BS_Double_FromString(const char* pString);
+
+DLL(double_t*) BS_Double_FromF(float_t fOther);
+DLL(float_t) BS_Double_ToF(double_t* pThis);
+
+DLL(double_t*) BS_Double_FromI(int32_t iOther);
+DLL(int32_t) BS_Double_ToI(double_t* pThis);
+
+DLL(double_t*) BS_Double_FromL(int64_t* pOther);
+DLL(int64_t*) BS_Double_ToL(double_t* pThis);
+
+DLL(int32_t) BS_Double_Compare(double_t* pThis, double_t* pOther);
+
+DLL(double_t*) BS_Double_Set(double_t* pThis, double_t* pOther);
+DLL(double_t*) BS_Double_Add(double_t* pThis, double_t* pOther);
+DLL(double_t*) BS_Double_Sub(double_t* pThis, double_t* pOther);
+DLL(double_t*) BS_Double_Div(double_t* pThis, double_t* pOther);
+DLL(double_t*) BS_Double_Mul(double_t* pThis, double_t* pOther);
+DLL(double_t*) BS_Double_Mod(double_t* pThis, double_t* pOther);
+
+DLL(double_t*) BS_Double_SetF(double_t* pThis, float_t fOther);
+DLL(double_t*) BS_Double_AddF(double_t* pThis, float_t fOther);
+DLL(double_t*) BS_Double_SubF(double_t* pThis, float_t fOther);
+DLL(double_t*) BS_Double_DivF(double_t* pThis, float_t fOther);
+DLL(double_t*) BS_Double_MulF(double_t* pThis, float_t fOther);
+DLL(double_t*) BS_Double_ModF(double_t* pThis, float_t fOther);

Types/Long.cpp

@@ -0,0 +1,170 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Long.h"
+
+DLL(int64_t*) BS_Long_New() {
+	return new int64_t;
+}
+DLL(int64_t*) BS_Long_Copy(int64_t* pOther) {
+	return new int64_t(*pOther);
+}
+DLL(void) BS_Long_Destroy(int64_t* pThis) {
+	delete pThis;
+}
+
+char* BS_Long_Buffer = new char[32];
+DLL(const char*) BS_Long_ToString(int64_t* pThis) {
+	std::stringstream myStream;
+	myStream << (*pThis);
+
+	const char* myBuffer = myStream.str().c_str();
+	strcpy_s(BS_Long_Buffer, 32, myBuffer);
+	return BS_Long_Buffer;
+}
+DLL(int64_t*) BS_Long_FromString(const char* pString) {
+	int64_t* pThis = new int64_t;
+	std::stringstream myStream = std::stringstream(pString);
+	myStream >> *pThis;
+	return pThis;
+}
+
+DLL(int64_t*) BS_Long_FromI(int32_t iRight) {
+	return new int64_t(iRight);
+}
+DLL(int64_t*) BS_Long_FromII(int32_t iLeft, int32_t iRight) {
+	return new int64_t(((int64_t)(iLeft) << 32) + iRight);
+}
+DLL(int32_t) BS_Long_ToI(int64_t* pThis, int32_t iShift) {
+	if (iShift >= 0)
+		return (int32_t)(*pThis >> iShift);
+	else
+		return (int32_t)(*pThis << -iShift);
+}
+DLL(int32_t) BS_Long_ToIH(int64_t* pThis) {
+	return (int32_t)(*pThis >> 32);
+}
+DLL(int32_t) BS_Long_ToIL(int64_t* pThis) {
+	return (int32_t)*pThis;
+}
+
+DLL(int64_t*) BS_Long_FromF(float_t fOther) {
+	return new int64_t((int64_t)fOther);
+}
+DLL(float_t) BS_Long_ToF(int64_t* pThis) {
+	return (float_t)*pThis;
+}
+
+DLL(int64_t*) BS_Long_FromD(double_t* pOther) {
+	return new int64_t((int64_t)*pOther);
+}
+DLL(double_t*) BS_Long_ToD(int64_t* pThis) {
+	return new double_t((double_t)*pThis);
+}
+
+DLL(int32_t) BS_Long_Compare(int64_t* pThis, int64_t* pOther) {
+	if ((pThis == nullptr) || (pOther == nullptr))
+		return -1;
+
+	return /* It can either be Equal (0) or Smaller or Greater. Easy to check. */
+		/* Greater */
+		(*pThis > *pOther ? 1 : 0) +
+		/* Smaller */
+		(*pThis < *pOther ? -1 : 0);
+}
+
+DLL(int64_t*) BS_Long_Set(int64_t* pThis, int64_t* pOther) {
+	*pThis = *pOther;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_Add(int64_t* pThis, int64_t* pOther) {
+	*pThis += *pOther;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_Sub(int64_t* pThis, int64_t* pOther) {
+	*pThis -= *pOther;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_Div(int64_t* pThis, int64_t* pOther) {
+	*pThis /= *pOther;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_Mul(int64_t* pThis, int64_t* pOther) {
+	*pThis *= *pOther;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_Mod(int64_t* pThis, int64_t* pOther) {
+	*pThis %= *pOther;
+	return pThis;
+}
+
+DLL(int64_t*) BS_Long_SetI(int64_t* pThis, int32_t iRight) {
+	*pThis = iRight;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_AddI(int64_t* pThis, int32_t iRight) {
+	*pThis += iRight;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_SubI(int64_t* pThis, int32_t iRight) {
+	*pThis -= iRight;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_DivI(int64_t* pThis, int32_t iRight) {
+	*pThis /= iRight;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_MulI(int64_t* pThis, int32_t iRight) {
+	*pThis *= iRight;
+	return pThis;
+}
+DLL(int64_t*) BS_Long_ModI(int64_t* pThis, int32_t iRight) {
+	*pThis %= iRight;
+	return pThis;
+}
+
+DLL(int64_t*) BS_Long_SetII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis = (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL(int64_t*) BS_Long_AddII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis += (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL(int64_t*) BS_Long_SubII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis -= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL(int64_t*) BS_Long_DivII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis /= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL(int64_t*) BS_Long_MulII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis *= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL(int64_t*) BS_Long_ModII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis %= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+
+DLL(int64_t*) BS_Long_Shift(int64_t* pThis, int32_t iRight) {
+	if (iRight >= 0)
+		*pThis >>= iRight;
+	else
+		*pThis <<= -iRight;
+	return pThis;
+}

Types/Long.h

@@ -0,0 +1,63 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzSteamInternal.h"
+#include <sstream>
+
+DLL(int64_t*) BS_Long_New();
+DLL(int64_t*) BS_Long_Copy(int64_t* pRight);
+DLL(void) BS_Long_Destroy(int64_t* pThis);
+
+DLL(const char*) BS_Long_ToString(int64_t* pThis);
+DLL(int64_t*) BS_Long_FromString(const char* pString);
+
+DLL(int64_t*) BS_Long_FromI(int32_t iRight);
+DLL(int64_t*) BS_Long_FromII(int32_t iLeft, int32_t iRight);
+DLL(int32_t) BS_Long_ToI(int64_t* pThis, int32_t iShift);
+DLL(int32_t) BS_Long_ToIH(int64_t* pThis);
+DLL(int32_t) BS_Long_ToIL(int64_t* pThis);
+
+DLL(int64_t*) BS_Long_FromF(float_t fOther);
+DLL(float_t) BS_Long_ToF(int64_t* pThis);
+
+DLL(int64_t*) BS_Long_FromD(double_t* pOther);
+DLL(double_t*) BS_Long_ToD(int64_t* pThis);
+
+DLL(int32_t) BS_Long_Compare(int64_t* pThis, int64_t* pOther);
+
+DLL(int64_t*) BS_Long_Set(int64_t* pThis, int64_t* pOther);
+DLL(int64_t*) BS_Long_Add(int64_t* pThis, int64_t* pOther);
+DLL(int64_t*) BS_Long_Sub(int64_t* pThis, int64_t* pOther);
+DLL(int64_t*) BS_Long_Div(int64_t* pThis, int64_t* pOther);
+DLL(int64_t*) BS_Long_Mul(int64_t* pThis, int64_t* pOther);
+DLL(int64_t*) BS_Long_Mod(int64_t* pThis, int64_t* pOther);
+
+DLL(int64_t*) BS_Long_SetI(int64_t* pThis, int32_t iRight);
+DLL(int64_t*) BS_Long_AddI(int64_t* pThis, int32_t iRight);
+DLL(int64_t*) BS_Long_SubI(int64_t* pThis, int32_t iRight);
+DLL(int64_t*) BS_Long_DivI(int64_t* pThis, int32_t iRight);
+DLL(int64_t*) BS_Long_MulI(int64_t* pThis, int32_t iRight);
+DLL(int64_t*) BS_Long_ModI(int64_t* pThis, int32_t iRight);
+
+DLL(int64_t*) BS_Long_SetII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL(int64_t*) BS_Long_AddII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL(int64_t*) BS_Long_SubII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL(int64_t*) BS_Long_DivII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL(int64_t*) BS_Long_MulII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL(int64_t*) BS_Long_ModII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+
+DLL(int64_t*) BS_Long_Shift(int64_t* pThis, int32_t iShift);

Types/Memory.cpp

@@ -0,0 +1,77 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Memory.h"
+
+DLL(void*) BS_Memory_Alloc(uint32_t iSize) {
+	return malloc(iSize);
+}
+
+DLL(void*) BS_Memory_ReAlloc(void* pMemory, uint32_t iNewSize) {
+	return realloc(pMemory, iNewSize);
+}
+
+DLL(void) BS_Memory_Free(void* pMemory) {
+	free(pMemory);
+}
+
+DLL(void) BS_Memory_PokeByte(void* pMemory, uint32_t offset, int8_t value) {
+	*((reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
+}
+
+DLL(int32_t) BS_Memory_PeekByte(void* pMemory, uint32_t offset) {
+	return *(reinterpret_cast<uint8_t*>(pMemory) + offset);
+}
+
+DLL(void) BS_Memory_PokeShort(void* pMemory, uint32_t offset, int16_t value) {
+	*(reinterpret_cast<int16_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
+}
+
+DLL(int32_t) BS_Memory_PeekShort(void* pMemory, uint32_t offset) {
+	return *(int16_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
+}
+
+DLL(void) BS_Memory_PokeInt(void* pMemory, uint32_t offset, int32_t value) {
+	*(reinterpret_cast<uint32_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
+}
+
+DLL(int32_t) BS_Memory_PeekInt(void* pMemory, uint32_t offset) {
+	return *(int32_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
+}
+
+DLL(void) BS_Memory_PokeFloat(void* pMemory, uint32_t offset, float_t value) {
+	*(reinterpret_cast<float_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
+}
+
+DLL(float_t) BS_Memory_PeekFloat(void* pMemory, uint32_t offset) {
+	return *(float_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
+}
+
+DLL(void) BS_Memory_PokeLong(void* pMemory, uint32_t offset, int64_t* value) {
+	*(reinterpret_cast<int64_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = *value;
+}
+
+DLL(int64_t*) BS_Memory_PeekLong(void* pMemory, uint32_t offset) {
+	return new int64_t(*(reinterpret_cast<int64_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)));
+}
+
+DLL(void) BS_Memory_PokeDouble(void* pMemory, uint32_t offset, double_t* value) {
+	*(reinterpret_cast<double_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = *value;
+}
+
+DLL(double_t*) BS_Memory_PeekDouble(void* pMemory, uint32_t offset) {
+	return new double_t(*(reinterpret_cast<double_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)));
+}

Types/Memory.h

@@ -0,0 +1,42 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzSteamInternal.h"
+#include <stdlib.h>
+
+
+DLL(void*) BS_Memory_Alloc(uint32_t iSize);
+DLL(void*) BS_Memory_ReAlloc(void* pMemory, uint32_t iNewSize);
+DLL(void) BS_Memory_Free(void* pMemory);
+
+DLL(void) BS_Memory_PokeByte(void* pMemory, uint32_t offset, int8_t value);
+DLL(int32_t) BS_Memory_PeekByte(void* pMemory, uint32_t offset);
+
+DLL(void) BS_Memory_PokeShort(void* pMemory, uint32_t offset, int16_t value);
+DLL(int32_t) BS_Memory_PeekShort(void* pMemory, uint32_t offset);
+
+DLL(void) BS_Memory_PokeInt(void* pMemory, uint32_t offset, int32_t value);
+DLL(int32_t) BS_Memory_PeekInt(void* pMemory, uint32_t offset);
+
+DLL(void) BS_Memory_PokeFloat(void* pMemory, uint32_t offset, float_t value);
+DLL(float_t) BS_Memory_PeekFloat(void* pMemory, uint32_t offset);
+
+DLL(void) BS_Memory_PokeLong(void* pMemory, uint32_t offset, int64_t* value);
+DLL(int64_t*) BS_Memory_PeekLong(void* pMemory, uint32_t offset);
+
+DLL(void) BS_Memory_PokeDouble(void* pMemory, uint32_t offset, double_t* value);
+DLL(double_t*) BS_Memory_PeekDouble(void* pMemory, uint32_t offset);

Types/SteamMatchmakingTypes.cpp

@@ -0,0 +1,271 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "SteamMatchmakingTypes.h"
+
+//////////////////////////////////////////////////////////////////////////
+BlitzISteamMatchmakingServerListResponse::BlitzISteamMatchmakingServerListResponse(void* pData, BP_BlitzFunction3_t pServerResponded,
+	BP_BlitzFunction3_t pServerFailedToRespond, BP_BlitzFunction3_t pRefreshComplete)
+	: m_pData(pData), m_pServerResponded(pServerResponded), m_pServerFailedToRespond(pServerFailedToRespond), m_pRefreshComplete(pRefreshComplete) {}
+
+void BlitzISteamMatchmakingServerListResponse::ServerResponded(HServerListRequest hRequest, int iServer) {
+	if (this->m_pServerResponded != nullptr)
+		BP_CallFunction3(m_pServerResponded, reinterpret_cast<int32_t>(m_pData), reinterpret_cast<int32_t>(hRequest), iServer);
+}
+
+void BlitzISteamMatchmakingServerListResponse::ServerFailedToRespond(HServerListRequest hRequest, int iServer) {
+	if (this->m_pServerFailedToRespond != nullptr)
+		BP_CallFunction3(m_pServerFailedToRespond, reinterpret_cast<int32_t>(m_pData), reinterpret_cast<int32_t>(hRequest), iServer);
+}
+
+void BlitzISteamMatchmakingServerListResponse::RefreshComplete(HServerListRequest hRequest, EMatchMakingServerResponse response) {
+	if (this->m_pRefreshComplete != nullptr)
+		BP_CallFunction3(m_pRefreshComplete, reinterpret_cast<int32_t>(m_pData), reinterpret_cast<int32_t>(hRequest), static_cast<int32_t>(response));
+}
+
+DLL(BlitzISteamMatchmakingServerListResponse*) BS_ISteamMatchmakingServerListResponse_New(void* pData, BP_BlitzFunction3_t pServerResponded, BP_BlitzFunction3_t pServerFailedToRespond, BP_BlitzFunction3_t pRefreshComplete) {
+	return new BlitzISteamMatchmakingServerListResponse(pData, pServerResponded, pServerFailedToRespond, pRefreshComplete);
+}
+
+DLL(void) BS_ISteamMatchmakingServerListResponse_Destroy(BlitzISteamMatchmakingServerListResponse* pThis) {
+	delete pThis;
+}
+
+//////////////////////////////////////////////////////////////////////////
+BlitzISteamMatchmakingPingResponse::BlitzISteamMatchmakingPingResponse(void* pData, BP_BlitzFunction2_t pServerResponded, BP_BlitzFunction1_t pServerFailedToRespond)
+	: m_pData(pData), m_pServerResponded(pServerResponded), m_pServerFailedToRespond(pServerFailedToRespond) {}
+
+void BlitzISteamMatchmakingPingResponse::ServerResponded(gameserveritem_t &server) {
+	if (this->m_pServerResponded != nullptr)
+		BP_CallFunction2(m_pServerResponded, reinterpret_cast<int32_t>(m_pData), reinterpret_cast<int32_t>(&server));
+}
+
+void BlitzISteamMatchmakingPingResponse::ServerFailedToRespond() {
+	if (this->m_pServerFailedToRespond != nullptr)
+		BP_CallFunction1(m_pServerFailedToRespond, reinterpret_cast<int32_t>(m_pData));
+}
+
+DLL(BlitzISteamMatchmakingPingResponse*) BS_ISteamMatchmakingPingResponse_New(void* pData, BP_BlitzFunction2_t pServerResponded, BP_BlitzFunction1_t pServerFailedToRespond) {
+	return new BlitzISteamMatchmakingPingResponse(pData, pServerResponded, pServerFailedToRespond);
+}
+
+DLL(void) BS_ISteamMatchmakingPingResponse_Destroy(BlitzISteamMatchmakingPingResponse* pThis) {
+	delete pThis;
+}
+
+//////////////////////////////////////////////////////////////////////////
+BlitzISteamMatchmakingPlayersResponse::BlitzISteamMatchmakingPlayersResponse(void* pData, BP_BlitzFunction4_t pAddPlayerToList, BP_BlitzFunction1_t pPlayersFailedToRespond, BP_BlitzFunction1_t pPlayersRefreshComplete)
+	: m_pData(pData), m_pAddPlayerToList(pAddPlayerToList), m_pPlayersFailedToRespond(pPlayersFailedToRespond), m_pPlayersRefreshComplete(pPlayersRefreshComplete) {}
+
+void BlitzISteamMatchmakingPlayersResponse::AddPlayerToList(const char *pchName, int nScore, float flTimePlayed) {
+	if (m_pAddPlayerToList != nullptr)
+		BP_CallFunction4(m_pAddPlayerToList, reinterpret_cast<int32_t>(m_pData), reinterpret_cast<int32_t>(pchName), nScore, *reinterpret_cast<int32_t*>(&flTimePlayed));
+}
+
+void BlitzISteamMatchmakingPlayersResponse::PlayersFailedToRespond() {
+	if (m_pPlayersFailedToRespond != nullptr)
+		BP_CallFunction1(m_pPlayersFailedToRespond, reinterpret_cast<int32_t>(m_pData));
+}
+
+void BlitzISteamMatchmakingPlayersResponse::PlayersRefreshComplete() {
+	if (m_pPlayersRefreshComplete != nullptr)
+		BP_CallFunction1(m_pPlayersRefreshComplete, reinterpret_cast<int32_t>(m_pData));
+}
+
+DLL(BlitzISteamMatchmakingPlayersResponse*) BS_ISteamMatchmakingPlayersResponse_New(void* pData, BP_BlitzFunction4_t pAddPlayerToList, BP_BlitzFunction1_t pPlayersFailedToRespond, BP_BlitzFunction1_t pPlayersRefreshComplete) {
+	return new BlitzISteamMatchmakingPlayersResponse(pData, pAddPlayerToList, pPlayersFailedToRespond, pPlayersRefreshComplete);
+}
+
+DLL(void) BS_ISteamMatchmakingPlayersResponse_Destroy(BlitzISteamMatchmakingPlayersResponse* pThis) {
+	delete pThis;
+}
+
+//////////////////////////////////////////////////////////////////////////
+BlitzISteamMatchmakingRulesResponse::BlitzISteamMatchmakingRulesResponse(void* pData, BP_BlitzFunction3_t pRulesResponded, BP_BlitzFunction1_t pRulesFailedToRespond, BP_BlitzFunction1_t pRulesRefreshComplete)
+	: m_pData(pData), m_pRulesResponded(pRulesResponded), m_pRulesFailedToRespond(pRulesFailedToRespond), m_pRulesRefreshComplete(pRulesRefreshComplete) {}
+
+void BlitzISteamMatchmakingRulesResponse::RulesResponded(const char *pchRule, const char *pchValue) {
+	if (this->m_pRulesResponded != nullptr)
+		BP_CallFunction3(m_pRulesResponded, reinterpret_cast<int32_t>(m_pData), reinterpret_cast<int32_t>(pchRule), reinterpret_cast<int32_t>(pchValue));
+}
+
+void BlitzISteamMatchmakingRulesResponse::RulesFailedToRespond() {
+	if (this->m_pRulesFailedToRespond != nullptr)
+		BP_CallFunction1(m_pRulesFailedToRespond, reinterpret_cast<int32_t>(m_pData));
+}
+
+void BlitzISteamMatchmakingRulesResponse::RulesRefreshComplete() {
+	if (this->m_pRulesRefreshComplete != nullptr)
+		BP_CallFunction1(m_pRulesRefreshComplete, reinterpret_cast<int32_t>(m_pData));
+}
+
+DLL(BlitzISteamMatchmakingRulesResponse*) BS_ISteamMatchmakingRulesResponse_New(void* pData, BP_BlitzFunction3_t pRulesResponded, BP_BlitzFunction1_t pRulesFailedToRespond, BP_BlitzFunction1_t pRulesRefreshComplete) {
+	return new BlitzISteamMatchmakingRulesResponse(pData, pRulesResponded, pRulesFailedToRespond, pRulesRefreshComplete);
+}
+
+DLL(void) BS_ISteamMatchmakingRulesResponse_Destroy(BlitzISteamMatchmakingRulesResponse* pThis) {
+	delete pThis;
+}
+
+//////////////////////////////////////////////////////////////////////////
+char* BS_TGameServerItem_CharBuffer = new char[128];
+
+DLL(const char*) BS_TGameServerItem_GetName(gameserveritem_t* pThis) {
+	strcpy(BS_TGameServerItem_CharBuffer, pThis->GetName());
+	return BS_TGameServerItem_CharBuffer;
+}
+
+DLL(void) BS_TGameServerItem_SetName(gameserveritem_t* pThis, const char* cName) {
+	pThis->SetName(cName);
+}
+
+///< IP/Query Port/Connection Port for this server
+DLL(servernetadr_t*) BS_TGameServerItem_NetAdr(gameserveritem_t* pThis) {
+	return &(pThis->m_NetAdr);
+}
+
+///< current ping time in milliseconds
+DLL(int) BS_TGameServerItem_Ping(gameserveritem_t* pThis) {
+	return pThis->m_nPing;
+}
+
+///< server has responded successfully in the past
+DLL(bool) BS_TGameServerItem_HadSuccessfulResponse(gameserveritem_t* pThis) {
+	return pThis->m_bHadSuccessfulResponse;
+}
+
+///< server is marked as not responding and should no longer be refreshed
+DLL(bool) BS_TGameServerItem_DoNotRefresh(gameserveritem_t* pThis) {
+	return pThis->m_bDoNotRefresh;
+}
+
+///< current game directory
+DLL(const char*) BS_TGameServerItem_GameDir(gameserveritem_t* pThis) {
+	strcpy(BS_TGameServerItem_CharBuffer, pThis->m_szGameDir);
+	return BS_TGameServerItem_CharBuffer;
+}
+
+///< current map
+DLL(const char*) BS_TGameServerItem_Map(gameserveritem_t* pThis) {
+	strcpy(BS_TGameServerItem_CharBuffer, pThis->m_szMap);
+	return BS_TGameServerItem_CharBuffer;
+}
+
+///< game description
+DLL(const char*) BS_TGameServerItem_GameDescription(gameserveritem_t* pThis) {
+	strcpy(BS_TGameServerItem_CharBuffer, pThis->m_szGameDescription);
+	return BS_TGameServerItem_CharBuffer;
+}
+
+///< Steam App ID of this server
+DLL(uint32_t) BS_TGameServerItem_AppId(gameserveritem_t* pThis) {
+	return pThis->m_nAppID;
+}
+
+///< total number of players currently on the server.  INCLUDES BOTS!!
+DLL(uint32_t) BS_TGameServerItem_Players(gameserveritem_t* pThis) {
+	return pThis->m_nPlayers;
+}
+
+///< Maximum players that can join this server
+DLL(uint32_t) BS_TGameServerItem_MaxPlayers(gameserveritem_t* pThis) {
+	return pThis->m_nMaxPlayers;
+}
+
+///< Number of bots (i.e simulated players) on this server
+DLL(uint32_t) BS_TGameServerItem_BotPlayers(gameserveritem_t* pThis) {
+	return pThis->m_nBotPlayers;
+}
+
+///< true if this server needs a password to join
+DLL(bool) BS_TGameServerItem_Password(gameserveritem_t* pThis) {
+	return pThis->m_bPassword;
+}
+
+///< Is this server protected by VAC
+DLL(bool) BS_TGameServerItem_Secure(gameserveritem_t* pThis) {
+	return pThis->m_bSecure;
+}
+
+///< time (in unix time) when this server was last played on (for favorite/history servers)
+DLL(uint32_t) BS_TGameServerItem_TimeLastPlayed(gameserveritem_t* pThis) {
+	return pThis->m_ulTimeLastPlayed;
+}
+
+///< server version as reported to Steam
+DLL(uint32_t) BS_TGameServerItem_ServerVersion(gameserveritem_t* pThis) {
+	return pThis->m_nServerVersion;
+}
+
+/// the tags this server exposes
+DLL(const char*) BS_TGameServerItem_GameTags(gameserveritem_t* pThis) {
+	strcpy(BS_TGameServerItem_CharBuffer, pThis->m_szGameTags);
+	return BS_TGameServerItem_CharBuffer;
+}
+
+/// steamID of the game server - invalid if it's doesn't have one (old server, or not connected to Steam)
+DLL(CSteamID*) BS_TGameServerItem_SteamID(gameserveritem_t* pThis) {
+	return &(pThis->m_steamID);
+}
+
+//////////////////////////////////////////////////////////////////////////
+char* BS_TServerNetAdr_CharBuffer = new char[128];
+
+DLL(void) BS_TServerNetAdr_Set(servernetadr_t* pThis, servernetadr_t* pThat) {
+	*pThis = *pThat;
+}
+
+DLL(void) BS_TServerNetAdr_Init(servernetadr_t* pThis, uint32_t iIP, uint16_t iQueryPort, uint16_t iConnectionPort) {
+	pThis->Init(iIP, iQueryPort, iConnectionPort);
+}
+
+DLL(uint16_t) BS_TServerNetAdr_GetQueryPort(servernetadr_t* pThis) {
+	return pThis->GetQueryPort();
+}
+
+DLL(void) BS_TServerNetAdr_SetQueryPort(servernetadr_t* pThis, uint16_t iPort) {
+	pThis->SetQueryPort(iPort);
+}
+
+DLL(uint16_t) BS_TServerNetAdr_GetConnectionPort(servernetadr_t* pThis) {
+	return pThis->GetConnectionPort();
+}
+
+DLL(void) BS_TServerNetAdr_SetConnectionPort(servernetadr_t* pThis, uint16_t iPort) {
+	pThis->SetConnectionPort(iPort);
+}
+
+DLL(uint32_t) BS_TServerNetAdr_GetIP(servernetadr_t* pThis) {
+	return pThis->GetIP();
+}
+
+DLL(void) BS_TServerNetAdr_SetIP(servernetadr_t* pThis, uint32_t iIP) {
+	pThis->SetIP(iIP);
+}
+
+DLL(const char*) BS_TServerNetAdr_GetConnectionAddressString(servernetadr_t* pThis) {
+	strcpy(BS_TServerNetAdr_CharBuffer, pThis->GetConnectionAddressString());
+	return BS_TServerNetAdr_CharBuffer;
+}
+
+DLL(const char*) BS_TServerNetAdr_GetQueryAddressString(servernetadr_t* pThis) {
+	strcpy(BS_TServerNetAdr_CharBuffer, pThis->GetQueryAddressString());
+	return BS_TServerNetAdr_CharBuffer;
+}
+
+DLL(uint32_t) BS_TServerNetAdr_Compare(servernetadr_t* pThis, servernetadr_t* pThat) {
+	return (pThis < pThat ? -1 : (pThis > pThat ? 1 : 0));
+}

Types/SteamMatchmakingTypes.h

@@ -0,0 +1,137 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzSteamInternal.h"
+#include "../Helpers/BlitzPointer.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after a server list refresh
+// or an individual server update.
+//
+// Since you get these callbacks after requesting full list refreshes you will
+// usually implement this interface inside an object like CServerBrowser.  If that
+// object is getting destructed you should use ISteamMatchMakingServers()->CancelQuery()
+// to cancel any in-progress queries so you don't get a callback into the destructed
+// object and crash.
+//-----------------------------------------------------------------------------
+class BlitzISteamMatchmakingServerListResponse : public ISteamMatchmakingServerListResponse {
+private:
+	void* m_pData;
+
+	BP_BlitzFunction3_t m_pServerResponded;
+	BP_BlitzFunction3_t m_pServerFailedToRespond;
+	BP_BlitzFunction3_t m_pRefreshComplete;
+public:
+	BlitzISteamMatchmakingServerListResponse(void* pData, BP_BlitzFunction3_t pServerResponded, BP_BlitzFunction3_t pServerFailedToRespond, BP_BlitzFunction3_t pRefreshComplete);
+
+	// Server has responded ok with updated data
+	virtual void ServerResponded(HServerListRequest hRequest, int iServer) override;
+	// Server has failed to respond
+	virtual void ServerFailedToRespond(HServerListRequest hRequest, int iServer) override;
+	// A list refresh you had initiated is now 100% completed
+	virtual void RefreshComplete(HServerListRequest hRequest, EMatchMakingServerResponse response) override;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after pinging an individual server 
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->PingServer() call below.  If you are 
+// destructing an object that implements this interface then you should call 
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress.  Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class BlitzISteamMatchmakingPingResponse : public ISteamMatchmakingPingResponse {
+private:
+	void* m_pData;
+
+	BP_BlitzFunction2_t m_pServerResponded;
+	BP_BlitzFunction1_t m_pServerFailedToRespond;
+public:
+	BlitzISteamMatchmakingPingResponse(void* pData, BP_BlitzFunction2_t pServerResponded, BP_BlitzFunction1_t pServerFailedToRespond);
+
+	// Server has responded successfully and has updated data
+	virtual void ServerResponded(gameserveritem_t &server) override;
+	// Server failed to respond to the ping request
+	virtual void ServerFailedToRespond() override;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after requesting details on
+// who is playing on a particular server.
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->PlayerDetails() call below.  If you are 
+// destructing an object that implements this interface then you should call 
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress.  Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class BlitzISteamMatchmakingPlayersResponse : public ISteamMatchmakingPlayersResponse {
+private:
+	void* m_pData;
+
+	BP_BlitzFunction4_t m_pAddPlayerToList;
+	BP_BlitzFunction1_t m_pPlayersFailedToRespond;
+	BP_BlitzFunction1_t m_pPlayersRefreshComplete;
+
+public:
+	BlitzISteamMatchmakingPlayersResponse(void* pData, BP_BlitzFunction4_t pAddPlayerToList, BP_BlitzFunction1_t pPlayersFailedToRespond, BP_BlitzFunction1_t pPlayersRefreshComplete);
+
+	// Got data on a new player on the server -- you'll get this callback once per player
+	// on the server which you have requested player data on.
+	virtual void AddPlayerToList(const char *pchName, int nScore, float flTimePlayed) override;
+	// The server failed to respond to the request for player details
+	virtual void PlayersFailedToRespond() override;
+	// The server has finished responding to the player details request 
+	// (ie, you won't get anymore AddPlayerToList callbacks)
+	virtual void PlayersRefreshComplete() override;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after requesting rules
+// details on a particular server.
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->ServerRules() call below.  If you are 
+// destructing an object that implements this interface then you should call 
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress.  Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class BlitzISteamMatchmakingRulesResponse : public ISteamMatchmakingRulesResponse {
+private:
+	void* m_pData;
+
+	BP_BlitzFunction3_t m_pRulesResponded;
+	BP_BlitzFunction1_t m_pRulesFailedToRespond, m_pRulesRefreshComplete;
+
+public:
+	BlitzISteamMatchmakingRulesResponse(void* pData, BP_BlitzFunction3_t pRulesResponded, BP_BlitzFunction1_t pRulesFailedToRespond, BP_BlitzFunction1_t pRulesRefreshComplete);
+
+	// Got data on a rule on the server -- you'll get one of these per rule defined on
+	// the server you are querying
+	virtual void RulesResponded(const char *pchRule, const char *pchValue) override;
+
+	// The server failed to respond to the request for rule details
+	virtual void RulesFailedToRespond() override;
+
+	// The server has finished responding to the rule details request 
+	// (ie, you won't get anymore RulesResponded callbacks)
+	virtual void RulesRefreshComplete() override;
+};

Types/SteamTypes.cpp

@@ -0,0 +1,17 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "SteamTypes.h"

Types/SteamTypes.h

@@ -0,0 +1,19 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzSteamInternal.h"
+

Wrapper/Steam.cpp

@@ -14,166 +14,86 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
-DLL_EXPORT uint32_t DLL_CALL BS_Init() {
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+//	Steam API setup & shutdown
+//
+//	These functions manage loading, initializing and shutdown of the steamclient.dll
+//
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+DLL(int32_t) BS_SteamAPI_Init() {
 	return SteamAPI_Init();
 }
-#pragma comment(linker, "/EXPORT:BS_Init=_BS_Init@0")
 
-DLL_EXPORT void DLL_CALL BS_Shutdown() {
+DLL(void) BS_SteamAPI_Shutdown() {
 	SteamAPI_Shutdown();
 }
-#pragma comment(linker, "/EXPORT:BS_Shutdown=_BS_Shutdown@0")
 
-DLL_EXPORT uint32_t DLL_CALL BS_IsSteamRunning() {
+// checks if a local Steam client is running 
+DLL(int32_t) BS_SteamAPI_IsSteamRunning() {
 	return SteamAPI_IsSteamRunning();
 }
-#pragma comment(linker, "/EXPORT:BS_IsSteamRunning=_BS_IsSteamRunning@0")
 
-DLL_EXPORT uint32_t DLL_CALL BS_RestartAppIfNecessary(uint32 unOwnAppID) {
+// Detects if your executable was launched through the Steam client, and restarts your game through 
+// the client if necessary. The Steam client will be started if it is not running.
+//
+// Returns: true if your executable was NOT launched through the Steam client. This function will
+//          then start your application through the client. Your current process should exit.
+//
+//          false if your executable was started through the Steam client or a steam_appid.txt file
+//          is present in your game's directory (for development). Your current process should continue.
+//
+// NOTE: This function should be used only if you are using CEG or not using Steam's DRM. Once applied
+//       to your executable, Steam's DRM will handle restarting through Steam if necessary.
+DLL(int32_t) BS_SteamAPI_RestartAppIfNecessary(uint32_t unOwnAppID) {
 	return SteamAPI_RestartAppIfNecessary(unOwnAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_RestartAppIfNecessary=_BS_RestartAppIfNecessary@4")
 
-DLL_EXPORT void DLL_CALL BS_SetMiniDumpComment(const char* pchMsg) {
+// crash dump recording functions
-	SteamAPI_SetMiniDumpComment(pchMsg);
+DLL(void) BS_SteamAPI_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32_t uBuildID) {
-}
-#pragma comment(linker, "/EXPORT:BS_SetMiniDumpComment=_BS_SetMiniDumpComment@4")
-
-DLL_EXPORT void DLL_CALL BS_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID) {
 	SteamAPI_WriteMiniDump(uStructuredExceptionCode, pvExceptionInfo, uBuildID);
 }
-#pragma comment(linker, "/EXPORT:BS_WriteMiniDump=_BS_WriteMiniDump@12")
 
-// Interface Pointers, configured by SteamAPI_Init().
+DLL(void) BS_SteamAPI_SetMiniDumpComment(const char* pchMsg) {
-DLL_EXPORT ISteamClient* DLL_CALL BS_Client() {
+	SteamAPI_SetMiniDumpComment(pchMsg);
-	return SteamClient();
 }
-#pragma comment(linker, "/EXPORT:BS_Client=_BS_Client@0")
 
-DLL_EXPORT ISteamUser* DLL_CALL BS_User() {
+// Most Steam API functions allocate some amount of thread-local memory for
-	return SteamUser();
+// parameter storage. The SteamAPI_ReleaseCurrentThreadMemory() function
+// will free all API-related memory associated with the calling thread.
+// This memory is also released automatically by SteamAPI_RunCallbacks(), so
+// a single-threaded program does not need to explicitly call this function.
+DLL(void) BS_SteamAPI_ReleaseCurrentThreadMemory() {
+	return SteamAPI_ReleaseCurrentThreadMemory();
 }
-#pragma comment(linker, "/EXPORT:BS_User=_BS_User@0")
 
-DLL_EXPORT ISteamFriends* DLL_CALL BS_Friends() {
+// -- Callbacks
-	return SteamFriends();
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
-}
+//	steam callback and call-result helpers
-#pragma comment(linker, "/EXPORT:BS_Friends=_BS_Friends@0")
+//
+//	The following macros and classes are used to register your application for
+//	callbacks and call-results, which are delivered in a predictable manner.
+//
+//	STEAM_CALLBACK macros are meant for use inside of a C++ class definition.
+//	They map a Steam notification callback directly to a class member function
+//	which is automatically prototyped as "void func( callback_type *pParam )".
+//
+//	CCallResult is used with specific Steam APIs that return "result handles".
+//	The handle can be passed to a CCallResult object's Set function, along with
+//	an object pointer and member-function pointer. The member function will
+//	be executed once the results of the Steam API call are available.
+//
+//	CCallback and CCallbackManual classes can be used instead of STEAM_CALLBACK
+//	macros if you require finer control over registration and unregistration.
+//
+//	Callbacks and call-results are queued automatically and are only
+//	delivered/executed when your application calls SteamAPI_RunCallbacks().
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
 
-DLL_EXPORT ISteamUtils* DLL_CALL BS_Utils() {
+// SteamAPI_RunCallbacks is safe to call from multiple threads simultaneously,
-	return SteamUtils();
+// but if you choose to do this, callback code may be executed on any thread.
-}
+DLL(void) BS_SteamAPI_RunCallbacks() {
-#pragma comment(linker, "/EXPORT:BS_Utils=_BS_Utils@0")
-
-DLL_EXPORT ISteamMatchmaking* DLL_CALL BS_Matchmaking() {
-	return SteamMatchmaking();
-}
-#pragma comment(linker, "/EXPORT:BS_Matchmaking=_BS_Matchmaking@0")
-
-DLL_EXPORT ISteamUserStats* DLL_CALL BS_UserStats() {
-	return SteamUserStats();
-}
-#pragma comment(linker, "/EXPORT:BS_UserStats=_BS_UserStats@0")
-
-DLL_EXPORT ISteamApps* DLL_CALL BS_Apps() {
-	return SteamApps();
-}
-#pragma comment(linker, "/EXPORT:BS_Apps=_BS_Apps@0")
-
-DLL_EXPORT ISteamNetworking* DLL_CALL BS_Networking() {
-	return SteamNetworking();
-}
-#pragma comment(linker, "/EXPORT:BS_Networking=_BS_Networking@0")
-
-DLL_EXPORT ISteamMatchmakingServers* DLL_CALL BS_MatchmakingServers() {
-	return SteamMatchmakingServers();
-}
-#pragma comment(linker, "/EXPORT:BS_MatchmakingServers=_BS_MatchmakingServers@0")
-
-DLL_EXPORT ISteamRemoteStorage* DLL_CALL BS_RemoteStorage() {
-	return SteamRemoteStorage();
-}
-#pragma comment(linker, "/EXPORT:BS_RemoteStorage=_BS_RemoteStorage@0")
-
-DLL_EXPORT ISteamScreenshots* DLL_CALL BS_Screenshots() {
-	return SteamScreenshots();
-}
-#pragma comment(linker, "/EXPORT:BS_Screenshots=_BS_Screenshots@0")
-
-DLL_EXPORT ISteamHTTP* DLL_CALL BS_HTTP() {
-	return SteamHTTP();
-}
-#pragma comment(linker, "/EXPORT:BS_HTTP=_BS_HTTP@0")
-
-DLL_EXPORT ISteamUnifiedMessages* DLL_CALL BS_UnifiedMessages() {
-	return SteamUnifiedMessages();
-}
-#pragma comment(linker, "/EXPORT:BS_UnifiedMessages=_BS_UnifiedMessages@0")
-
-DLL_EXPORT ISteamController* DLL_CALL BS_Controller() {
-	return SteamController();
-}
-#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0")
-
-DLL_EXPORT ISteamUGC* DLL_CALL BS_UGC() {
-	return SteamUGC();
-}
-#pragma comment(linker, "/EXPORT:BS_UGC=_BS_UGC@0")
-
-DLL_EXPORT ISteamAppList* DLL_CALL BS_AppList() {
-	return SteamAppList();
-}
-#pragma comment(linker, "/EXPORT:BS_AppList=_BS_AppList@0")
-
-DLL_EXPORT ISteamMusic* DLL_CALL BS_Music() {
-	return SteamMusic();
-}
-#pragma comment(linker, "/EXPORT:BS_Music=_BS_Music@0")
-
-DLL_EXPORT ISteamMusicRemote* DLL_CALL BS_MusicRemote() {
-	return SteamMusicRemote();
-}
-#pragma comment(linker, "/EXPORT:BS_MusicRemote=_BS_MusicRemote@0")
-
-DLL_EXPORT ISteamHTMLSurface* DLL_CALL BS_HTMLSurface() {
-	return SteamHTMLSurface();
-}
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0")
-
-DLL_EXPORT ISteamInventory* DLL_CALL BS_Inventory() {
-	return SteamInventory();
-}
-#pragma comment(linker, "/EXPORT:BS_Inventory=_BS_Inventory@0")
-
-DLL_EXPORT ISteamVideo* DLL_CALL BS_Video() {
-	return SteamVideo();
-}
-#pragma comment(linker, "/EXPORT:BS_Video=_BS_Video@0")
-
-// Callbacks & Hooks
-DLL_EXPORT void DLL_CALL BS_RunCallbacks() {
 	SteamAPI_RunCallbacks();
 }
-#pragma comment(linker, "/EXPORT:BS_RunCallbacks=_BS_RunCallbacks@0")
-
-DLL_EXPORT void DLL_CALL BS_RegisterCallback(class CCallbackBase *pCallback, int iCallback) {
-	SteamAPI_RegisterCallback(pCallback, iCallback);
-}
-#pragma comment(linker, "/EXPORT:BS_RegisterCallback=_BS_RegisterCallback@8")
-
-DLL_EXPORT void DLL_CALL BS_UnregisterCallback(class CCallbackBase *pCallback) {
-	SteamAPI_UnregisterCallback(pCallback);
-}
-#pragma comment(linker, "/EXPORT:BS_UnregisterCallback=_BS_UnregisterCallback@4")
-
-DLL_EXPORT void DLL_CALL BS_RegisterCallResult(class CCallbackBase *pCallback, uint32_t hAPICall_L, uint32_t hAPICall_R) {
-	SteamAPI_RegisterCallResult(pCallback, ((uint64_t)hAPICall_L << 32) + (uint64_t)hAPICall_R);
-}
-#pragma comment(linker, "/EXPORT:BS_RegisterCallResult=_BS_RegisterCallResult@12")
-
-DLL_EXPORT void DLL_CALL BS_UnregisterCallResult(class CCallbackBase *pCallback, uint32_t hAPICall_L, uint32_t hAPICall_R) {
-	SteamAPI_UnregisterCallResult(pCallback, ((uint64_t)hAPICall_L << 32) + (uint64_t)hAPICall_R);
-}
-#pragma comment(linker, "/EXPORT:BS_UnregisterCallResult=_BS_UnregisterCallResult@12")

Wrapper/SteamAppList.cpp

@@ -14,29 +14,37 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) {
+//-----------------------------------------------------------------------------
+// Purpose: This is a restricted interface that can only be used by previously approved apps,
+//	contact your Steam Account Manager if you believe you need access to this API.
+//	This interface lets you detect installed apps for the local Steam client, useful for debugging tools
+//	to offer lists of apps to debug via Steam.
+//-----------------------------------------------------------------------------
+DLL(ISteamAppList*) BS_SteamAppList() {
+	return SteamAppList();
+}
+
+DLL(int32_t) BS_ISteamAppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) {
 	return lpSteamAppList->GetNumInstalledApps();
 }
-#pragma comment(linker, "/EXPORT:BS_AppList_GetNumInstalledApps=_BS_AppList_GetNumInstalledApps@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32 unMaxAppIDs) {
+DLL(int32_t) BS_ISteamAppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32_t unMaxAppIDs) {
 	return lpSteamAppList->GetInstalledApps(pvecAppID, unMaxAppIDs);
 }
-#pragma comment(linker, "/EXPORT:BS_AppList_GetInstalledApps=_BS_AppList_GetInstalledApps@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppName(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchName, uint32_t cchNameMax) {
+// returns -1 if no name was found
-	return lpSteamAppList->GetAppName(nAppID, pchName, cchNameMax);
+DLL(int32_t) BS_ISteamAppList_GetAppName(ISteamAppList* lpSteamAppList, AppId_t nAppID, const char* pchName, uint32_t cchNameMax) {
+	return lpSteamAppList->GetAppName(nAppID, (char*)pchName, cchNameMax);
 }
-#pragma comment(linker, "/EXPORT:BS_AppList_GetAppName=_BS_AppList_GetAppName@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectory, uint32_t cchDirectoryMax) {
+// returns -1 if no dir was found
-	return lpSteamAppList->GetAppInstallDir(nAppID, pchDirectory, cchDirectoryMax);
+DLL(int32_t) BS_ISteamAppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectoryBuffer, uint32_t cchDirectoryMax) {
+	return lpSteamAppList->GetAppInstallDir(nAppID, pchDirectoryBuffer, cchDirectoryMax);
 }
-#pragma comment(linker, "/EXPORT:BS_AppList_GetAppInstallDir=_BS_AppList_GetAppInstallDir@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppBuildId(ISteamAppList* lpSteamAppList, AppId_t nAppID) {
+// return the buildid of this app, may change at any time based on backend updates to the game
+DLL(int32_t) BS_ISteamAppList_GetAppBuildId(ISteamAppList* lpSteamAppList, AppId_t nAppID) {
 	return lpSteamAppList->GetAppBuildId(nAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_AppList_GetAppBuildId=_BS_AppList_GetAppBuildId@8")

Wrapper/SteamApps.cpp

@@ -14,126 +14,133 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
-#include "Helpers/CSteamID.h"
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribed(ISteamApps* lpSteamApps) {
+//-----------------------------------------------------------------------------
+// Purpose: interface to app data
+//-----------------------------------------------------------------------------
+DLL(ISteamApps*) BS_SteamApps() {
+	return SteamApps();
+}
+
+DLL(int32_t) BS_ISteamApps_IsSubscribed(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsSubscribed();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribed=_BS_Apps_IsSubscribed@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsLowViolence(ISteamApps* lpSteamApps) {
+DLL(int32_t) BS_ISteamApps_IsLowViolence(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsLowViolence();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsLowViolence=_BS_Apps_IsLowViolence@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsCybercafe(ISteamApps* lpSteamApps) {
+DLL(int32_t) BS_ISteamApps_IsCybercafe(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsCybercafe();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsCybercafe=_BS_Apps_IsCybercafe@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsVACBanned(ISteamApps* lpSteamApps) {
+DLL(int32_t) BS_ISteamApps_IsVACBanned(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsVACBanned();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsVACBanned=_BS_Apps_IsVACBanned@4")
 
-DLL_EXPORT const char* DLL_CALL BS_Apps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) {
+DLL(const char*) BS_ISteamApps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetCurrentGameLanguage();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentGameLanguage=_BS_Apps_GetCurrentGameLanguage@4")
 
-DLL_EXPORT const char* DLL_CALL BS_Apps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) {
+DLL(const char*) BS_ISteamApps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetAvailableGameLanguages();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAvailableGameLanguages=_BS_Apps_GetAvailableGameLanguages@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribedApp(ISteamApps* lpSteamApps, AppId_t appID) {
+// only use this member if you need to check ownership of another game related to yours, a demo for example
+DLL(int32_t) BS_ISteamApps_IsSubscribedApp(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsSubscribedApp(appID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedApp=_BS_Apps_IsSubscribedApp@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsDlcInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
+// Takes AppID of DLC and checks if the user owns the DLC & if the DLC is installed
+DLL(int32_t) BS_ISteamApps_IsDlcInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsDlcInstalled(appID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsDlcInstalled=_BS_Apps_IsDlcInstalled@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) {
+// returns the Unix time of the purchase of the app
+DLL(int32_t) BS_ISteamApps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->GetEarliestPurchaseUnixTime(appID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetEarliestPurchaseUnixTime=_BS_Apps_GetEarliestPurchaseUnixTime@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) {
+// Checks if the user is subscribed to the current app through a free weekend
+// This function will return false for users who have a retail or other type of license
+// Before using, please ask your Valve technical contact how to package and secure your free weekened
+DLL(int32_t) BS_ISteamApps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsSubscribedFromFreeWeekend();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedFromFreeWeekend=_BS_Apps_IsSubscribedFromFreeWeekend@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDLCCount(ISteamApps* lpSteamApps) {
+// Returns the number of DLC pieces for the running app
+DLL(int32_t) BS_ISteamApps_GetDLCCount(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetDLCCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetDLCCount=_BS_Apps_GetDLCCount@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDLCDataByIndex(ISteamApps* lpSteamApps, uint32_t iDLC, AppId_t *pAppId, bool* pbAvailable, char *pchName, uint32_t cchNameBufferSize) {
+// Returns metadata for DLC by index, of range [0, GetDLCCount()]
-	return lpSteamApps->BGetDLCDataByIndex(iDLC, pAppId, (bool*)pbAvailable, pchName, cchNameBufferSize);
+DLL(int32_t) BS_ISteamApps_GetDLCDataByIndex(ISteamApps* lpSteamApps, uint32_t iDLC, AppId_t *pAppIdBuffer, bool* pbAvailableBuffer, char *pchNameBuffer, uint32_t cchNameBufferSize) {
+	return lpSteamApps->BGetDLCDataByIndex(iDLC, pAppIdBuffer, (bool*)pbAvailableBuffer, pchNameBuffer, cchNameBufferSize);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetDLCDataByIndex=_BS_Apps_GetDLCDataByIndex@24")
 
-DLL_EXPORT void DLL_CALL BS_Apps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
+// Install/Uninstall control for optional DLC
+DLL(void) BS_ISteamApps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
 	lpSteamApps->InstallDLC(nAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_InstallDLC=_BS_Apps_InstallDLC@8")
 
-DLL_EXPORT void DLL_CALL BS_Apps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
+DLL(void) BS_ISteamApps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
 	lpSteamApps->UninstallDLC(nAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_UninstallDLC=_BS_Apps_UninstallDLC@8")
 
-DLL_EXPORT void DLL_CALL BS_Apps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) {
+// Request cd-key for yourself or owned DLC. If you are interested in this
+// data then make sure you provide us with a list of valid keys to be distributed
+// to users when they purchase the game, before the game ships.
+// You'll receive an AppProofOfPurchaseKeyResponse_t callback when
+// the key is available (which may be immediately).
+DLL(void) BS_ISteamApps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) {
 	lpSteamApps->RequestAppProofOfPurchaseKey(nAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_RequestAppProofOfPurchaseKey=_BS_Apps_RequestAppProofOfPurchaseKey@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetCurrentBetaName(ISteamApps* lpSteamApps, char *pchName, int cchNameBufferSize) {
+// returns current beta branch name, 'public' is the default branch
-	return lpSteamApps->GetCurrentBetaName(pchName, cchNameBufferSize);
+DLL(int32_t) BS_ISteamApps_GetCurrentBetaName(ISteamApps* lpSteamApps, char* pchNameBuffer, int cchNameBufferSize) {
+	return lpSteamApps->GetCurrentBetaName(pchNameBuffer, cchNameBufferSize);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentBetaName=_BS_Apps_GetCurrentBetaName@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) {
+// signal Steam that game files seems corrupt or missing
+DLL(int32_t) BS_ISteamApps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) {
 	return lpSteamApps->MarkContentCorrupt(bMissingFilesOnly != 0);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_MarkContentCorrupt=_BS_Apps_MarkContentCorrupt@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetInstalledDepots(ISteamApps* lpSteamApps, AppId_t nAppID, DepotId_t *pvecDepots, uint32_t cMaxDepots) {
+// return installed depots in mount order
-	return lpSteamApps->GetInstalledDepots(nAppID, pvecDepots, cMaxDepots);
+DLL(int32_t) BS_ISteamApps_GetInstalledDepots(ISteamApps* lpSteamApps, AppId_t nAppID, DepotId_t *pDepotsBuffer, uint32_t cMaxDepots) {
+	return lpSteamApps->GetInstalledDepots(nAppID, pDepotsBuffer, cMaxDepots);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetInstalledDepots=_BS_Apps_GetInstalledDepots@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize) {
+// returns current app install folder for AppID, returns folder name length
-	return lpSteamApps->GetAppInstallDir(appID, pchFolder, cchFolderBufferSize);
+DLL(int32_t) BS_ISteamApps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolderBuffer, uint32_t cchFolderBufferSize) {
+	return lpSteamApps->GetAppInstallDir(appID, pchFolderBuffer, cchFolderBufferSize);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAppInstallDir=_BS_Apps_GetAppInstallDir@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
+// returns true if that app is installed (not necessarily owned)
+DLL(int32_t) BS_ISteamApps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsAppInstalled(appID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsAppInstalled=_BS_Apps_IsAppInstalled@8")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_Apps_GetAppOwner(ISteamApps* lpSteamApps) {
+// returns the SteamID of the original owner. If different from current user, it's borrowed
-	CSteamID* steamID = new CSteamID(lpSteamApps->GetAppOwner());
+DLL(CSteamID*) BS_ISteamApps_GetAppOwner(ISteamApps* lpSteamApps) {
-	return BS_CSteamID_Copy(steamID);
+	return new CSteamID(lpSteamApps->GetAppOwner());
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAppOwner=_BS_Apps_GetAppOwner@4")
 
-DLL_EXPORT const char* DLL_CALL BS_Apps_GetLaunchQueryParam(ISteamApps* lpSteamApps, const char *pchKey) {
+// Returns the associated launch param if the game is run via steam://run/<appid>//?param1=value1;param2=value2;param3=value3 etc.
+// Parameter names starting with the character '@' are reserved for internal use and will always return and empty string.
+// Parameter names starting with an underscore '_' are reserved for steam features -- they can be queried by the game,
+// but it is advised that you not param names beginning with an underscore for your own features.
+DLL(const char*) BS_ISteamApps_GetLaunchQueryParam(ISteamApps* lpSteamApps, const char *pchKey) {
 	return lpSteamApps->GetLaunchQueryParam(pchKey);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetLaunchQueryParam=_BS_Apps_GetLaunchQueryParam@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDlcDownloadProgress(ISteamApps* lpSteamApps, AppId_t nAppID, uint64_t* punBytesDownloaded, uint64_t* punBytesTotal) {
+// get download progress for optional DLC
-	return lpSteamApps->GetDlcDownloadProgress(nAppID, punBytesDownloaded, punBytesTotal);
+DLL(int32_t) BS_ISteamApps_GetDlcDownloadProgress(ISteamApps* lpSteamApps, AppId_t nAppID, uint64_t* pLLBytesDownloaded, uint64_t* pLLBytesTotal) {
+	return lpSteamApps->GetDlcDownloadProgress(nAppID, pLLBytesDownloaded, pLLBytesTotal);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetDlcDownloadProgress=_BS_Apps_GetDlcDownloadProgress@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetAppBuildId(ISteamApps* lpSteamApps) {
+// return the buildid of this app, may change at any time based on backend updates to the game
+DLL(int32_t) BS_ISteamApps_GetAppBuildId(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetAppBuildId();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAppBuildId=_BS_Apps_GetAppBuildId@4")

Wrapper/SteamClient.cpp

@@ -14,180 +14,134 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
-DLL_EXPORT HSteamPipe DLL_CALL BS_Client_CreateSteamPipe(ISteamClient* lpSteamClient) {
+DLL(ISteamClient*) BS_SteamClient() {
+	return SteamClient();
+}
+
+DLL(HSteamPipe) BS_ISteamClient_CreateSteamPipe(ISteamClient* lpSteamClient) {
 	return lpSteamClient->CreateSteamPipe();
 }
-#pragma comment(linker, "/EXPORT:BS_Client_CreateSteamPipe=_BS_Client_CreateSteamPipe@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Client_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
+DLL(int32_t) BS_ISteamClient_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
 	return lpSteamClient->BReleaseSteamPipe(hSteamPipe);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_ReleaseSteamPipe=_BS_Client_ReleaseSteamPipe@8")
 
-DLL_EXPORT HSteamUser DLL_CALL BS_Client_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
+DLL(HSteamUser) BS_ISteamClient_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
 	return lpSteamClient->ConnectToGlobalUser(hSteamPipe);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_ConnectToGlobalUser=_BS_Client_ConnectToGlobalUser@8")
 
-DLL_EXPORT void DLL_CALL BS_Client_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) {
+DLL(void) BS_ISteamClient_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) {
 	return lpSteamClient->SetLocalIPBinding(unIP, usPort);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_SetLocalIPBinding=_BS_Client_SetLocalIPBinding@12")
 
-DLL_EXPORT HSteamUser DLL_CALL BS_Client_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) {
+DLL(HSteamUser) BS_ISteamClient_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) {
 	return lpSteamClient->CreateLocalUser(phSteamPipe, eAccountType);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_CreateLocalUser=_BS_Client_CreateLocalUser@12")
 
-DLL_EXPORT void DLL_CALL BS_Client_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) {
+DLL(void) BS_ISteamClient_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) {
 	return lpSteamClient->ReleaseUser(hSteamPipe, hSteamUser);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_ReleaseUser=_BS_Client_ReleaseUser@12")
 
-DLL_EXPORT void DLL_CALL BS_Client_RunFrame(ISteamClient* lpSteamClient) {
+DLL(int32_t) BS_ISteamClient_GetIPCCallCount(ISteamClient* lpSteamClient) {
-	lpSteamClient->RunFrame();
-}
-#pragma comment(linker, "/EXPORT:BS_Client_RunFrame=_BS_Client_RunFrame@4")
-
-DLL_EXPORT uint32_t DLL_CALL BS_Client_GetIPCCallCount(ISteamClient* lpSteamClient) {
 	return lpSteamClient->GetIPCCallCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetIPCCallCount=_BS_Client_GetIPCCallCount@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Client_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) {
+DLL(int32_t) BS_ISteamClient_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) {
 	return lpSteamClient->BShutdownIfAllPipesClosed();
 }
 
 // Interfaces
-DLL_EXPORT ISteamAppList* DLL_CALL BS_Client_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamAppList*) BS_ISteamClient_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamAppList(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamAppList=_BS_Client_GetSteamAppList@16")
 
-DLL_EXPORT ISteamApps* DLL_CALL BS_Client_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamApps*) BS_ISteamClient_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamApps(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamApps=_BS_Client_GetSteamApps@16")
 
-DLL_EXPORT ISteamController* DLL_CALL BS_Client_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamController*) BS_ISteamClient_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamController(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamController=_BS_Client_GetSteamController@16")
 
-DLL_EXPORT ISteamFriends* DLL_CALL BS_Client_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamFriends*) BS_ISteamClient_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamFriends(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamFriends=_BS_Client_GetSteamFriends@16")
 
-DLL_EXPORT ISteamGameServer* DLL_CALL BS_Client_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamGameServer*) BS_ISteamClient_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamGameServer(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServer=_BS_Client_GetSteamGameServer@16")
 
-DLL_EXPORT ISteamGameServerStats* DLL_CALL BS_Client_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamGameServerStats*) BS_ISteamClient_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamGameServerStats(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServerStats=_BS_Client_GetSteamGameServerStats@16")
 
-DLL_EXPORT ISteamHTMLSurface* DLL_CALL BS_Client_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamHTMLSurface*) BS_ISteamClient_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamHTMLSurface(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTMLSurface=_BS_Client_GetSteamHTMLSurface@16")
 
-DLL_EXPORT ISteamHTTP* DLL_CALL BS_Client_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamHTTP*) BS_ISteamClient_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamHTTP(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTTP=_BS_Client_GetSteamHTTP@16")
 
-DLL_EXPORT ISteamInventory* DLL_CALL BS_Client_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamInventory*) BS_ISteamClient_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamInventory(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamInventory=_BS_Client_GetSteamInventory@16")
 
-DLL_EXPORT ISteamMatchmaking* DLL_CALL BS_Client_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamMatchmaking*) BS_ISteamClient_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamMatchmaking(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmaking=_BS_Client_GetSteamMatchmaking@16")
 
-DLL_EXPORT ISteamMatchmakingServers* DLL_CALL BS_Client_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamMatchmakingServers*) BS_ISteamClient_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamMatchmakingServers(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmakingServers=_BS_Client_GetSteamMatchmakingServers@16")
 
-DLL_EXPORT ISteamMusic* DLL_CALL BS_Client_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamMusic*) BS_ISteamClient_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamMusic(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusic=_BS_Client_GetSteamMusic@16")
 
-DLL_EXPORT ISteamMusicRemote* DLL_CALL BS_Client_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamMusicRemote*) BS_ISteamClient_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamMusicRemote(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusicRemote=_BS_Client_GetSteamMusicRemote@16")
 
-DLL_EXPORT ISteamNetworking* DLL_CALL BS_Client_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamNetworking*) BS_ISteamClient_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamNetworking(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamNetworking=_BS_Client_GetSteamNetworking@16")
 
-DLL_EXPORT ISteamRemoteStorage* DLL_CALL BS_Client_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamRemoteStorage*) BS_ISteamClient_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamRemoteStorage(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamRemoteStorage=_BS_Client_GetSteamRemoteStorage@16")
 
-DLL_EXPORT ISteamScreenshots* DLL_CALL BS_Client_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamScreenshots*) BS_ISteamClient_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamScreenshots(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamScreenshots=_BS_Client_GetSteamScreenshots@16")
 
-DLL_EXPORT ISteamUGC* DLL_CALL BS_Client_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamUGC*) BS_ISteamClient_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUGC(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUGC=_BS_Client_GetSteamUGC@16")
 
-DLL_EXPORT ISteamUnifiedMessages* DLL_CALL BS_Client_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamUnifiedMessages*) BS_ISteamClient_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUnifiedMessages(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUnifiedMessages=_BS_Client_GetSteamUnifiedMessages@16")
 
-DLL_EXPORT ISteamUser* DLL_CALL BS_Client_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamUser*) BS_ISteamClient_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUser(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUser=_BS_Client_GetSteamUser@16")
 
-DLL_EXPORT ISteamUserStats* DLL_CALL BS_Client_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamUserStats*) BS_ISteamClient_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUserStats(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUserStats=_BS_Client_GetSteamUserStats@16")
 
-DLL_EXPORT ISteamUtils* DLL_CALL BS_Client_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamUtils*) BS_ISteamClient_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUtils(hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUtils=_BS_Client_GetSteamUtils@12")
 
-DLL_EXPORT ISteamVideo* DLL_CALL BS_Client_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL(ISteamVideo*) BS_ISteamClient_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamVideo(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamVideo=_BS_Client_GetSteamVideo@16")
 
 // Callbacks & Hooks
-DLL_EXPORT void DLL_CALL BS_Client_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) {
+DLL(void) BS_ISteamClient_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) {
 	lpSteamClient->SetWarningMessageHook(fpfunction);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_SetWarningMessageHook=_BS_Client_SetWarningMessageHook@8")
-
-DLL_EXPORT void DLL_CALL BS_Client_Set_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) {
-	lpSteamClient->Set_SteamAPI_CPostAPIResultInProcess(fpFunction);
-}
-#pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CPostAPIResultInProcess=_BS_Client_Set_SteamAPI_CPostAPIResultInProcess@8")
-
-DLL_EXPORT void DLL_CALL BS_Client_Remove_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) {
-	lpSteamClient->Remove_SteamAPI_CPostAPIResultInProcess(fpFunction);
-}
-#pragma comment(linker, "/EXPORT:BS_Client_Remove_SteamAPI_CPostAPIResultInProcess=_BS_Client_Remove_SteamAPI_CPostAPIResultInProcess@8")
-
-DLL_EXPORT void DLL_CALL BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess(ISteamClient* lpSteamClient, SteamAPI_CheckCallbackRegistered_t fpFunction) {
-	lpSteamClient->Set_SteamAPI_CCheckCallbackRegisteredInProcess(fpFunction);
-}
-#pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess=_BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess@8")

Wrapper/SteamController.cpp

@@ -14,36 +14,113 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
-DLL_EXPORT uint32_t DLL_CALL BS_Controller_Init(ISteamController* lpSteamController) {
+//-----------------------------------------------------------------------------
+// Purpose: Native Steam controller support API
+//-----------------------------------------------------------------------------
+DLL(ISteamController*) BS_SteamController() {
+	return SteamController();
+}
+
+// Init and Shutdown must be called when starting/ending use of this interface
+DLL(int32_t) BS_ISteamController_Init(ISteamController* lpSteamController) {
 	return lpSteamController->Init();
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_Init=_BS_Controller_Init@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Controller_Shutdown(ISteamController* lpSteamController) {
+// Init and Shutdown must be called when starting/ending use of this interface
+DLL(int32_t) BS_ISteamController_Shutdown(ISteamController* lpSteamController) {
 	return lpSteamController->Shutdown();
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_Shutdown=_BS_Controller_Shutdown@4")
 
-DLL_EXPORT void DLL_CALL BS_Controller_RunFrame(ISteamController* lpSteamController) {
+// Pump callback/callresult events
+// Note: SteamAPI_RunCallbacks will do this for you, so you should never need to call this directly.
+DLL(void) BS_ISteamController_RunFrame(ISteamController* lpSteamController) {
 	lpSteamController->RunFrame();
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_RunFrame=_BS_Controller_RunFrame@4")
 
-#if 0
+// Enumerate currently connected controllers
-DLL_EXPORT uint32_t DLL_CALL BS_Controller_GetControllerState( ISteamController* lpSteamController, uint32_t unControllerIndex, SteamControllerState_t *pState ) {
+// handlesOut should point to a STEAM_CONTROLLER_MAX_COUNT sized array of ControllerHandle_t handles
-	return lpSteamController->GetControllerState( unControllerIndex, pState );
+// Returns the number of handles written to handlesOut
+DLL(int32_t) BS_ISteamController_GetConnectedControllers(ISteamController* lpSteamController, ControllerHandle_t* pHandlesOut) {
+	return lpSteamController->GetConnectedControllers(pHandlesOut);
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_GetControllerState=_BS_Controller_GetControllerState@12")
 
-DLL_EXPORT void DLL_CALL BS_Controller_TriggerHapticPulse( ISteamController* lpSteamController, uint32_t unControllerIndex, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec ) {
+ControllerHandle_t* pControllerHandles = new ControllerHandle_t[STEAM_CONTROLLER_MAX_COUNT];
-	lpSteamController->TriggerHapticPulse( unControllerIndex, eTargetPad, usDurationMicroSec );
+DLL(int32_t) BS_ISteamController_GetConnectedControllersSimple(ISteamController* lpSteamController) {
+	return lpSteamController->GetConnectedControllers(pControllerHandles);
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_TriggerHapticPulse=_BS_Controller_TriggerHapticPulse@16")
 
-DLL_EXPORT void DLL_CALL BS_Controller_SetOverrideMode( ISteamController* lpSteamController, const char *pchMode ) {
+DLL(ControllerHandle_t*) BS_ISteamController_GetConnectedControllersSimple_Index(uint32_t index) {
-	lpSteamController->SetOverrideMode( pchMode );
+	if (index >= STEAM_CONTROLLER_MAX_COUNT)
+		index = STEAM_CONTROLLER_MAX_COUNT - 1;
+	return &(pControllerHandles[index]);
+}
+
+// Invokes the Steam overlay and brings up the binding screen
+// Returns false is overlay is disabled / unavailable, or the user is not in Big Picture mode
+DLL(int32_t) BS_ISteamController_ShowBindingPanel(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
+	return lpSteamController->ShowBindingPanel(*pControllerHandle);
+}
+
+// ACTION SETS
+// Lookup the handle for an Action Set. Best to do this once on startup, and store the handles for all future API calls.
+DLL(ControllerActionSetHandle_t*) BS_ISteamController_GetActionSetHandle(ISteamController* lpSteamController, const char* pszActionSetName) {
+	return new ControllerActionSetHandle_t(lpSteamController->GetActionSetHandle(pszActionSetName));
+}
+
+// Reconfigure the controller to use the specified action set (ie 'Menu', 'Walk' or 'Drive')
+// This is cheap, and can be safely called repeatedly. It's often easier to repeatedly call it in
+// your state loops, instead of trying to place it in all of your state transitions.
+DLL(void) BS_ISteamController_ActivateActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle) {
+	lpSteamController->ActivateActionSet(*pControllerHandle, *pActionSetHandle);
+}
+
+DLL(ControllerActionSetHandle_t*) BS_ISteamController_GetCurrentActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
+	return new ControllerActionSetHandle_t(lpSteamController->GetCurrentActionSet(*pControllerHandle));
+}
+
+// Lookup the handle for a digital action. Best to do this once on startup, and store the handles for all future API calls.
+DLL(ControllerDigitalActionHandle_t*) BS_ISteamController_GetDigitalActionHandle(ISteamController* lpSteamController, const char* pszActionName) {
+	return new ControllerDigitalActionHandle_t(lpSteamController->GetDigitalActionHandle(pszActionName));
+}
+
+// Returns the current state of the supplied digital game action
+DLL(ControllerDigitalActionData_t*) BS_ISteamController_GetDigitalActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle) {
+	return &lpSteamController->GetDigitalActionData(*pControllerHandle, *pDigitalActionHandle);
+}
+
+// Get the origin(s) for a digital action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action.
+// originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles
+DLL(int32_t) BS_ISteamController_GetDigitalActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
+	return lpSteamController->GetDigitalActionOrigins(*pControllerHandle, *pActionSetHandle, *pDigitalActionHandle, pEControllerActionOrigin);
+}
+
+// Lookup the handle for an analog action. Best to do this once on startup, and store the handles for all future API calls.
+DLL(ControllerAnalogActionHandle_t*) BS_ISteamController_GetAnalogActionHandle(ISteamController* lpSteamController, const char *pszActionName) {
+	return new ControllerAnalogActionHandle_t(lpSteamController->GetAnalogActionHandle(pszActionName));
+}
+
+// Returns the current state of these supplied analog game action
+DLL(ControllerAnalogActionData_t*) BS_ISteamController_GetAnalogActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
+	return &lpSteamController->GetAnalogActionData(*pControllerHandle, *pAnalogActionHandle);
+}
+
+// Get the origin(s) for an analog action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action.
+// originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles
+DLL(int32_t) BS_ISteamController_GetAnalogActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
+	return lpSteamController->GetAnalogActionOrigins(*pControllerHandle, *pActionSetHandle, *pAnalogActionHandle, pEControllerActionOrigin);
+}
+
+DLL(void) BS_ISteamController_StopAnalogActionMomentum(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
+	lpSteamController->StopAnalogActionMomentum(*pControllerHandle, *pAnalogActionHandle);
+}
+
+// Trigger a haptic pulse on a controller
+DLL(void) BS_ISteamController_TriggerHapticPulse(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec) {
+	lpSteamController->TriggerHapticPulse(*pControllerHandle, eTargetPad, (uint16_t)usDurationMicroSec);
+}
+
+DLL(void) BS_ISteamController_TriggerRepeatedHapticPulse(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec, uint32_t usOffMicroSec, uint32_t unRepeat, uint32_t nFlags) {
+	lpSteamController->TriggerRepeatedHapticPulse(*pControllerHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_SetOverrideMode=_BS_Controller_SetOverrideMode@8")  
-#endif // 0

Wrapper/SteamFriends.cpp

@@ -14,365 +14,412 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetPersonaName(ISteamFriends* lpSteamFriends) {
+//-----------------------------------------------------------------------------
+// Purpose: interface to accessing information about individual users,
+//			that can be a friend, in a group, on a game server or in a lobby with the local user
+//-----------------------------------------------------------------------------
+DLL(ISteamFriends*) BS_SteamFriends() {
+	return SteamFriends();
+}
+
+// returns the local players name - guaranteed to not be NULL.
+// this is the same name as on the users community profile page
+// this is stored in UTF-8 format
+// like all the other interface functions that return a char *, it's important that this pointer is not saved
+// off; it will eventually be free'd or re-allocated
+DLL(const char*) BS_ISteamFriends_GetPersonaName(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetPersonaName();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaName=_BS_Friends_GetPersonaName@4")
 
-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) {
+// Sets the player name, stores it on the server and publishes the changes to all friends who are online.
-	return lpSteamFriends->SetPersonaName(pchPersonaName);
+// Changes take place locally immediately, and a PersonaStateChange_t is posted, presuming success.
+//
+// The final results are available through the return value SteamAPICall_t, using SetPersonaNameResponse_t.
+//
+// If the name change fails to happen on the server, then an additional global PersonaStateChange_t will be posted
+// to change the name back, in addition to the SetPersonaNameResponse_t callback.
+DLL(SteamAPICall_t*) BS_ISteamFriends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) {
+	return new uint64_t(lpSteamFriends->SetPersonaName(pchPersonaName));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetPersonaName=_BS_Friends_SetPersonaName@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetPersonaState(ISteamFriends* lpSteamFriends) {
+// gets the status of the current user
+DLL(int32_t) BS_ISteamFriends_GetPersonaState(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetPersonaState();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaState=_BS_Friends_GetPersonaState@4")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) {
+// friend iteration
+// takes a set of k_EFriendFlags, and returns the number of users the client knows about who meet that criteria
+// then GetFriendByIndex() can then be used to return the id's of each of those users
+DLL(int32_t) BS_ISteamFriends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) {
 	return lpSteamFriends->GetFriendCount(iFriendFlags);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCount=_BS_Friends_GetFriendCount@8")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetFriendByIndex(ISteamFriends* lpSteamFriends, int32_t iFriend, int32_t iFriendFlags) {
+// returns the steamID of a user
-	CSteamID* pSteamID = new CSteamID(lpSteamFriends->GetFriendByIndex(iFriend, iFriendFlags));
+// iFriend is a index of range [0, GetFriendCount())
-	return pSteamID;
+// iFriendsFlags must be the same value as used in GetFriendCount()
+// the returned CSteamID can then be used by all the functions below to access details about the user
+DLL(CSteamID*) BS_ISteamFriends_GetFriendByIndex(ISteamFriends* lpSteamFriends, int32_t iFriend, int32_t iFriendFlags) {
+	return new CSteamID(lpSteamFriends->GetFriendByIndex(iFriend, iFriendFlags));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendByIndex=_BS_Friends_GetFriendByIndex@12")
 
-DLL_EXPORT EFriendRelationship DLL_CALL BS_Friends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// returns a relationship to a user
+DLL(EFriendRelationship) BS_ISteamFriends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendRelationship(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRelationship=_BS_Friends_GetFriendRelationship@8")
 
-DLL_EXPORT EPersonaState DLL_CALL BS_Friends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// returns the current status of the specified user
+// this will only be known by the local user if steamIDFriend is in their friends list; on the same game server; in a chat room or lobby; or in a small group with the local user
+DLL(EPersonaState) BS_ISteamFriends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendPersonaState(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaState=_BS_Friends_GetFriendPersonaState@8")
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// returns the name another user - guaranteed to not be NULL.
+// same rules as GetFriendPersonaState() apply as to whether or not the user knowns the name of the other user
+// note that on first joining a lobby, chat room or game server the local user will not known the name of the other users automatically; that information will arrive asyncronously
+DLL(const char*) BS_ISteamFriends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendPersonaName(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaName=_BS_Friends_GetFriendPersonaName@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_GetFriendGamePlayed(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, FriendGameInfo_t *pFriendGameInfo) {
+// returns true if the friend is actually in a game, and fills in pFriendGameInfo with an extra details 
+DLL(uint32_t) BS_ISteamFriends_GetFriendGamePlayed(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, FriendGameInfo_t *pFriendGameInfo) {
 	return lpSteamFriends->GetFriendGamePlayed(*steamIDFriend, pFriendGameInfo);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendGamePlayed=_BS_Friends_GetFriendGamePlayed@12")
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendPersonaNameHistory(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iPersonaName) {
+// accesses old friends names - returns an empty string when their are no more items in the history
+DLL(const char*) BS_ISteamFriends_GetFriendPersonaNameHistory(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iPersonaName) {
 	return lpSteamFriends->GetFriendPersonaNameHistory(*steamIDFriend, iPersonaName);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaNameHistory=_BS_Friends_GetFriendPersonaNameHistory@12")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// friends steam level
+DLL(int32_t) BS_ISteamFriends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendSteamLevel(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendSteamLevel=_BS_Friends_GetFriendSteamLevel@8")
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetPlayerNickname(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriends) {
+// Returns nickname the current user has set for the specified player. Returns NULL if the no nickname has been set for that player.
+DLL(const char*) BS_ISteamFriends_GetPlayerNickname(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriends) {
 	const char* nickname = lpSteamFriends->GetPlayerNickname(*steamIDFriends);
 	if (nickname == NULL) {
 		nickname = "";
 	}
 	return nickname;
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPlayerNickname=_BS_Friends_GetPlayerNickname@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) {
+// friend grouping (tag) apis
+// returns the number of friends groups
+DLL(int32_t) BS_ISteamFriends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetFriendsGroupCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupCount=_BS_Friends_GetFriendsGroupCount@4")
 
-DLL_EXPORT FriendsGroupID_t DLL_CALL BS_Friends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+// returns the friends group ID for the given index (invalid indices return k_FriendsGroupID_Invalid)
+DLL(FriendsGroupID_t) BS_ISteamFriends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupIDByIndex(friendsGroupID);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupIDByIndex=_BS_Friends_GetFriendsGroupIDByIndex@8")
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendsGroupName(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+// returns the name for the given friends group (NULL in the case of invalid friends group IDs)
+DLL(const char*) BS_ISteamFriends_GetFriendsGroupName(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupName(friendsGroupID);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupName=_BS_Friends_GetFriendsGroupName@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+// returns the number of members in a given friends group
+DLL(int32_t) BS_ISteamFriends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupMembersCount(friendsGroupID);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersCount=_BS_Friends_GetFriendsGroupMembersCount@8")
 
-DLL_EXPORT void DLL_CALL BS_Friends_GetFriendsGroupMembersList(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID, CSteamID* pOutSteamIDMembers, int32_t nMembersCount) {
+// gets up to nMembersCount members of the given friends group, if fewer exist than requested those positions' SteamIDs will be invalid
+DLL(void) BS_ISteamFriends_GetFriendsGroupMembersList(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID, CSteamID* pOutSteamIDMembers, int32_t nMembersCount) {
 	lpSteamFriends->GetFriendsGroupMembersList(friendsGroupID, pOutSteamIDMembers, nMembersCount);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersList=_BS_Friends_GetFriendsGroupMembersList@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) {
+// returns true if the specified user meets any of the criteria specified in iFriendFlags
+// iFriendFlags can be the union (binary or, |) of one or more k_EFriendFlags values
+DLL(uint32_t) BS_ISteamFriends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) {
 	return lpSteamFriends->HasFriend(*steamIDFriend, iFriendsFlags);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_HasFriends=_BS_Friends_HasFriend@12")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanCount(ISteamFriends* lpSteamFriends) {
+// clan (group) iteration and access functions
+DLL(int32_t) BS_ISteamFriends_GetClanCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetClanCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanCount=_BS_Friends_GetClanCount@4")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) {
+DLL(CSteamID*) BS_ISteamFriends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) {
 	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanByIndex(iClan));
 	return steamID;
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanByIndex=_BS_Friends_GetClanByIndex@8")
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL(const char*) BS_ISteamFriends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanName(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanName=_BS_Friends_GetClanName@8")
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL(const char*) BS_ISteamFriends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanTag(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanTag=_BS_Friends_GetClanTag@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_GetClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t* pnOnline, int32_t* pnInGame, int32_t* pnChatting) {
+// returns the most recent information we have about what's happening in a clan
+DLL(uint32_t) BS_ISteamFriends_GetClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t* pnOnline, int32_t* pnInGame, int32_t* pnChatting) {
 	return lpSteamFriends->GetClanActivityCounts(*steamIDClan, pnOnline, pnInGame, pnChatting);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanActivityCounts=_BS_Friends_GetClanActivityCounts@20")
 
-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) {
+// for clans a user is a member of, they will have reasonably up-to-date information, but for others you'll have to download the info to have the latest
-	return lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, cClansToRequest);
+DLL(SteamAPICall_t*) BS_ISteamFriends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) {
+	return new uint64_t(lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, cClansToRequest));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_DownloadClanActivityCounts=_BS_Friends_DownloadClanActivityCounts@12")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) {
+// iterators for getting users in a chat room, lobby, game server or clan
+// note that large clans that cannot be iterated by the local user
+// note that the current user must be in a lobby to retrieve CSteamIDs of other users in that lobby
+// steamIDSource can be the steamID of a group, game server, lobby or chat room
+DLL(int32_t) BS_ISteamFriends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) {
 	return lpSteamFriends->GetFriendCountFromSource(*steamIDSource);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCountFromSource=_BS_Friends_GetFriendCountFromSource@8")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) {
+DLL(CSteamID*) BS_ISteamFriends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) {
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend));
+	return new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend));
-	return steamID;
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendFromSourceByIndex=_BS_Friends_GetFriendFromSourceByIndex@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsUserInSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, CSteamID* steamIDSource) {
+// returns true if the local user can see that steamIDUser is a member or in steamIDSource
+DLL(uint32_t) BS_ISteamFriends_IsUserInSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, CSteamID* steamIDSource) {
 	return lpSteamFriends->IsUserInSource(*steamIDUser, *steamIDSource);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_IsUserInSource=_BS_Friends_IsUserInSource@12")
 
-DLL_EXPORT void DLL_CALL BS_Friends_SetInGameVoiceSpeaking(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bSpeaking) {
+// User is in a game pressing the talk button (will suppress the microphone for all voice comms from the Steam friends UI)
+DLL(void) BS_ISteamFriends_SetInGameVoiceSpeaking(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bSpeaking) {
 	lpSteamFriends->SetInGameVoiceSpeaking(*steamIDUser, bSpeaking != 0);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetInGameVoiceSpeaking=_BS_Friends_SetInGameVoiceSpeaking@12")
 
-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) {
+// activates the game overlay, with an optional dialog to open 
+// valid options are "Friends", "Community", "Players", "Settings", "OfficialGameGroup", "Stats", "Achievements"
+DLL(void) BS_ISteamFriends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) {
 	lpSteamFriends->ActivateGameOverlay(pchDialog);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlay=_BS_Friends_ActivateGameOverlay@8")
 
-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) {
+// activates game overlay to a specific place
+// valid options are
+//		"steamid" - opens the overlay web browser to the specified user or groups profile
+//		"chat" - opens a chat window to the specified user, or joins the group chat 
+//		"jointrade" - opens a window to a Steam Trading session that was started with the ISteamEconomy/StartTrade Web API
+//		"stats" - opens the overlay web browser to the specified user's stats
+//		"achievements" - opens the overlay web browser to the specified user's achievements
+//		"friendadd" - opens the overlay in minimal mode prompting the user to add the target user as a friend
+//		"friendremove" - opens the overlay in minimal mode prompting the user to remove the target friend
+//		"friendrequestaccept" - opens the overlay in minimal mode prompting the user to accept an incoming friend invite
+//		"friendrequestignore" - opens the overlay in minimal mode prompting the user to ignore an incoming friend invite
+DLL(void) BS_ISteamFriends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) {
 	lpSteamFriends->ActivateGameOverlayToUser(pchDialog, *steamID);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToUser=_BS_Friends_ActivateGameOverlayToUser@12")
 
-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) {
+// activates game overlay web browser directly to the specified URL
+// full address with protocol type is required, e.g. http://www.steamgames.com/
+DLL(void) BS_ISteamFriends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) {
 	lpSteamFriends->ActivateGameOverlayToWebPage(pchURL);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToWebPage=_BS_Friends_ActivateGameOverlayToWebPage@8")
 
-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) {
+// activates game overlay to store page for app
+DLL(void) BS_ISteamFriends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) {
 	lpSteamFriends->ActivateGameOverlayToStore(nAppID, eFlag);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToStore=_BS_Friends_ActivateGameOverlayToStore@12")
 
-DLL_EXPORT void DLL_CALL BS_Friends_SetPlayedWith(ISteamFriends* lpSteamFriends, CSteamID* steamIDUserPlayedWith) {
+// Mark a target user as 'played with'. This is a client-side only feature that requires that the calling user is 
+// in game 
+DLL(void) BS_ISteamFriends_SetPlayedWith(ISteamFriends* lpSteamFriends, CSteamID* steamIDUserPlayedWith) {
 	lpSteamFriends->SetPlayedWith(*steamIDUserPlayedWith);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetPlayedWith=_BS_Friends_SetPlayedWith@8")
 
-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) {
+// activates game overlay to open the invite dialog. Invitations will be sent for the provided lobby.
+DLL(void) BS_ISteamFriends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) {
 	lpSteamFriends->ActivateGameOverlayInviteDialog(*steamIDLobby);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayInviteDialog=_BS_Friends_ActivateGameOverlayInviteDialog@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetSmallFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// gets the small (32x32) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set
+DLL(int32_t) BS_ISteamFriends_GetSmallFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetSmallFriendAvatar(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetSmallFriendAvatar=_BS_Friends_GetSmallFriendAvatar@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetMediumFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// gets the medium (64x64) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set
+DLL(int32_t) BS_ISteamFriends_GetMediumFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetMediumFriendAvatar(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetMediumFriendAvatar=_BS_Friends_GetMediumFriendAvatar@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetLargeFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// gets the large (184x184) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set
+// returns -1 if this image has yet to be loaded, in this case wait for a AvatarImageLoaded_t callback and then call this again
+DLL(int32_t) BS_ISteamFriends_GetLargeFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetLargeFriendAvatar(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetLargeFriendAvatar=_BS_Friends_GetLargeFriendAvatar@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) {
+// requests information about a user - persona name & avatar
+// if bRequireNameOnly is set, then the avatar of a user isn't downloaded 
+// - it's a lot slower to download avatars and churns the local cache, so if you don't need avatars, don't request them
+// if returns true, it means that data is being requested, and a PersonaStateChanged_t callback will be posted when it's retrieved
+// if returns false, it means that we already have all the details about that user, and functions can be called immediately
+DLL(uint32_t) BS_ISteamFriends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) {
 	return lpSteamFriends->RequestUserInformation(*steamIDUser, bRequireNameOnly != 0);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestUserInformation=_BS_Friends_RequestUserInformation@12")
 
-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+// requests information about a clan officer list
-	return lpSteamFriends->RequestClanOfficerList(*steamIDClan);
+// when complete, data is returned in ClanOfficerListResponse_t call result
+// this makes available the calls below
+// you can only ask about clans that a user is a member of
+// note that this won't download avatars automatically; if you get an officer,
+// and no avatar image is available, call RequestUserInformation( steamID, false ) to download the avatar
+DLL(SteamAPICall_t*) BS_ISteamFriends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+	return new uint64_t(lpSteamFriends->RequestClanOfficerList(*steamIDClan));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestClanOfficerList=_BS_Friends_RequestClanOfficerList@8")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+// iteration of clan officers - can only be done when a RequestClanOfficerList() call has completed
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan));
+
-	return steamID;
+// returns the steamID of the clan owner
+DLL(CSteamID*) BS_ISteamFriends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+	return new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOwner=_BS_Friends_GetClanOwner@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+// returns the number of officers in a clan (including the owner)
+DLL(int32_t) BS_ISteamFriends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanOfficerCount(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerCount=_BS_Friends_GetClanOfficerCount@8")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanOfficerByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iOfficer) {
+// returns the steamID of a clan officer, by index, of range [0,GetClanOfficerCount)
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanOfficerByIndex(*steamIDClan, iOfficer));
+DLL(CSteamID*) BS_ISteamFriends_GetClanOfficerByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iOfficer) {
-	return steamID;
+	return new CSteamID(lpSteamFriends->GetClanOfficerByIndex(*steamIDClan, iOfficer));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerByIndex=_BS_Friends_GetClanOfficerByIndex@12")
 
-DLL_EXPORT EUserRestriction DLL_CALL BS_Friends_GetUserRestrictions(ISteamFriends* lpSteamFriends) {
+// if current user is chat restricted, he can't send or receive any text/voice chat messages.
+// the user can't see custom avatars. But the user can be online and send/recv game invites.
+// a chat restricted user can't add friends or join any groups.
+DLL(EUserRestriction) BS_ISteamFriends_GetUserRestrictions(ISteamFriends* lpSteamFriends) {
 	return (EUserRestriction)lpSteamFriends->GetUserRestrictions();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetUserRestrictions=_BS_Friends_GetUserRestrictions@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_SetRichPresence(ISteamFriends* lpSteamFriends, const char* pchKey, const char* pchValue) {
+// Rich Presence data is automatically shared between friends who are in the same game
+// Each user has a set of Key/Value pairs
+// Up to 20 different keys can be set
+// There are two magic keys:
+//		"status"  - a UTF-8 string that will show up in the 'view game info' dialog in the Steam friends list
+//		"connect" - a UTF-8 string that contains the command-line for how a friend can connect to a game
+// GetFriendRichPresence() returns an empty string "" if no value is set
+// SetRichPresence() to a NULL or an empty string deletes the key
+// You can iterate the current set of keys for a friend with GetFriendRichPresenceKeyCount()
+// and GetFriendRichPresenceKeyByIndex() (typically only used for debugging)
+DLL(uint32_t) BS_ISteamFriends_SetRichPresence(ISteamFriends* lpSteamFriends, const char* pchKey, const char* pchValue) {
 	return lpSteamFriends->SetRichPresence(pchKey, pchValue);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetRichPresence=_BS_Friends_SetRichPresence@12")
 
-DLL_EXPORT void DLL_CALL BS_Friends_ClearRichPresence(ISteamFriends* lpSteamFriends) {
+DLL(void) BS_ISteamFriends_ClearRichPresence(ISteamFriends* lpSteamFriends) {
 	lpSteamFriends->ClearRichPresence();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ClearRichPresence=_BS_Friends_ClearRichPresence@4")
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) {
+DLL(const char*) BS_ISteamFriends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) {
 	return lpSteamFriends->GetFriendRichPresence(*steamIDFriend, pchKey);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresence=_BS_Friends_GetFriendRichPresence@12")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL(int32_t) BS_ISteamFriends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendRichPresenceKeyCount(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyCount=_BS_Friends_GetFriendRichPresenceKeyCount@8")
 
-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) {
+DLL(const char*) BS_ISteamFriends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) {
 	return lpSteamFriends->GetFriendRichPresenceKeyByIndex(*steamIDFriend, iKey);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyByIndex=_BS_Friends_GetFriendRichPresenceKeyByIndex@12")
 
-DLL_EXPORT void DLL_CALL BS_Friends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// Requests rich presence for a specific user.
+DLL(void) BS_ISteamFriends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	lpSteamFriends->RequestFriendRichPresence(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestFriendRichPresence=_BS_Friends_RequestFriendRichPresence@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) {
+// rich invite support
+// if the target accepts the invite, the pchConnectString gets added to the command-line for launching the game
+// if the game is already running, a GameRichPresenceJoinRequested_t callback is posted containing the connect string
+// invites can only be sent to friends
+DLL(uint32_t) BS_ISteamFriends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) {
 	return lpSteamFriends->InviteUserToGame(*steamIDFriend, pchConnectString);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_InviteUserToGame=_BS_Friends_InviteUserToGame@12")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) {
+// recently-played-with friends iteration
+// this iterates the entire list of users recently played with, across games
+// GetFriendCoplayTime() returns as a unix time
+DLL(int32_t) BS_ISteamFriends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetCoplayFriendCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriendCount=_BS_Friends_GetCoplayFriendCount@4")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetCoplayFriend(ISteamFriends* lpSteamFriends, int32_t iCoplayFriend) {
+DLL(CSteamID*) BS_ISteamFriends_GetCoplayFriend(ISteamFriends* lpSteamFriends, int32_t iCoplayFriend) {
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetCoplayFriend(iCoplayFriend));
+	return new CSteamID(lpSteamFriends->GetCoplayFriend(iCoplayFriend));
-	return steamID;
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriend=_BS_Friends_GetCoplayFriend@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL(int32_t) BS_ISteamFriends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendCoplayTime(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayTime=_BS_Friends_GetFriendCoplayTime@8")
 
-DLL_EXPORT AppId_t DLL_CALL BS_Friends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL(AppId_t) BS_ISteamFriends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendCoplayGame(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayGame=_BS_Friends_GetFriendCoplayGame@8")
 
-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+// chat interface for games
-	return lpSteamFriends->JoinClanChatRoom(*steamIDClan);
+// this allows in-game access to group (clan) chats from in the game
+// the behavior is somewhat sophisticated, because the user may or may not be already in the group chat from outside the game or in the overlay
+// use ActivateGameOverlayToUser( "chat", steamIDClan ) to open the in-game overlay version of the chat
+DLL(SteamAPICall_t*) BS_ISteamFriends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+	return new SteamAPICall_t(lpSteamFriends->JoinClanChatRoom(*steamIDClan));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_JoinClanChatRoom=_BS_Friends_JoinClanChatRoom@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL(uint32_t) BS_ISteamFriends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->LeaveClanChatRoom(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_LeaveClanChatRoom=_BS_Friends_LeaveClanChatRoom@8")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL(int32_t) BS_ISteamFriends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanChatMemberCount(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMemberCount=_BS_Friends_GetClanChatMemberCount@8")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetChatMemberByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iUser) {
+DLL(CSteamID*) BS_ISteamFriends_GetChatMemberByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iUser) {
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetChatMemberByIndex(*steamIDClan, iUser));
+	return new CSteamID(lpSteamFriends->GetChatMemberByIndex(*steamIDClan, iUser));
-	return steamID;
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetChatMemberByIndex=_BS_Friends_GetChatMemberByIndex@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) {
+DLL(uint32_t) BS_ISteamFriends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) {
 	return lpSteamFriends->SendClanChatMessage(*steamIDClanChat, pchText);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SendClanChatMessage=_BS_Friends_SendClanChatMessage@12")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) {
+DLL(int32_t) BS_ISteamFriends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) {
 	return lpSteamFriends->GetClanChatMessage(*steamIDClanChat, iMessage, prgchText, cchTextMax, peChatEntryType, psteamidChatter);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMessage=_BS_Friends_GetClanChatMessage@28")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) {
+DLL(uint32_t) BS_ISteamFriends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) {
 	return lpSteamFriends->IsClanChatAdmin(*steamIDClanChat, *steamIDUser);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatAdmin=_BS_Friends_IsClanChatAdmin@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+// interact with the Steam (game overlay / desktop)
+DLL(uint32_t) BS_ISteamFriends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
 	return lpSteamFriends->IsClanChatWindowOpenInSteam(*steamIDClanChat);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatWindowOpenInSteam=_BS_Friends_IsClanChatWindowOpenInSteam@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+DLL(uint32_t) BS_ISteamFriends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
 	return lpSteamFriends->OpenClanChatWindowInSteam(*steamIDClanChat);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_OpenClanChatWindowInSteam=_BS_Friends_OpenClanChatWindowInSteam@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+DLL(uint32_t) BS_ISteamFriends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
 	return lpSteamFriends->CloseClanChatWindowInSteam(*steamIDClanChat);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_CloseClanChatWindowInSteam=_BS_Friends_CloseClanChatWindowInSteam@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) {
+// peer-to-peer chat interception
+// this is so you can show P2P chats inline in the game
+DLL(uint32_t) BS_ISteamFriends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) {
 	return lpSteamFriends->SetListenForFriendsMessages(bInterceptEnabled != 0);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetListenForFriendsMessages=_BS_Friends_SetListenForFriendsMessages@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_Friends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) {
+DLL(uint32_t) BS_ISteamFriends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) {
 	return lpSteamFriends->ReplyToFriendMessage(*steamIDFriend, pchMsgToSend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ReplyToFriendMessage=_BS_Friends_ReplyToFriendMessage@12")
 
-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) {
+DLL(int32_t) BS_ISteamFriends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) {
 	return lpSteamFriends->GetFriendMessage(*steamIDFriend, iMessageID, pvData, cubData, peChatEntryType);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendMessage=_BS_Friends_GetFriendMessage@24")
 
-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
+// following apis
-	return lpSteamFriends->GetFollowerCount(*steamID);
+DLL(SteamAPICall_t*) BS_ISteamFriends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
+	return new SteamAPICall_t(lpSteamFriends->GetFollowerCount(*steamID));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFollowerCount=_BS_Friends_GetFollowerCount@8")
 
-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
+DLL(SteamAPICall_t*) BS_ISteamFriends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
-	return lpSteamFriends->IsFollowing(*steamID);
+	return new SteamAPICall_t(lpSteamFriends->IsFollowing(*steamID));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_IsFollowing=_BS_Friends_IsFollowing@8")
 
-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32 unStartIndex) {
+DLL(SteamAPICall_t*) BS_ISteamFriends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32_t unStartIndex) {
-	return lpSteamFriends->EnumerateFollowingList(unStartIndex);
+	return new SteamAPICall_t(lpSteamFriends->EnumerateFollowingList(unStartIndex));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_EnumerateFollowingList=_BS_Friends_EnumerateFollowingList@8")

Wrapper/SteamGameServer.cpp

@@ -14,55 +14,358 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
-#include "SteamworksSDK/public/steam/steam_gameserver.h"
 
-DLL_EXPORT uint32_t DLL_CALL BS_GameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) {
+// Initialize ISteamGameServer interface object, and set server properties which may not be changed.
+//
+// After calling this function, you should set any additional server parameters, and then
+// call ISteamGameServer::LogOnAnonymous() or ISteamGameServer::LogOn()
+//
+// - usSteamPort is the local port used to communicate with the steam servers.
+// - usGamePort is the port that clients will connect to for gameplay.
+// - usQueryPort is the port that will manage server browser related duties and info
+//		pings from clients.  If you pass MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE for usQueryPort, then it
+//		will use "GameSocketShare" mode, which means that the game is responsible for sending and receiving
+//		UDP packets for the master  server updater. See references to GameSocketShare in isteamgameserver.h.
+// - The version string is usually in the form x.x.x.x, and is used by the master server to detect when the
+//		server is out of date.  (Only servers with the latest version will be listed.)
+DLL(uint32_t) BS_SteamGameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) {
 	return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
 }
 
-DLL_EXPORT void DLL_CALL BS_GameServer_Shutdown() {
+DLL(void) BS_SteamGameServer_Shutdown() {
 	SteamGameServer_Shutdown();
 }
 
-DLL_EXPORT void DLL_CALL BS_GameServer_RunCallbacks() {
+DLL(void) BS_SteamGameServer_RunCallbacks() {
 	SteamGameServer_RunCallbacks();
 }
 
-DLL_EXPORT uint32_t DLL_CALL BS_GameServer_Secure() {
+DLL(uint32_t) BS_SteamGameServer_IsSecure() {
 	return SteamGameServer_BSecure();
 }
 
-DLL_EXPORT uint64_t* DLL_CALL BS_GameServer_GetSteamID() {
+DLL(CSteamID*) BS_SteamGameServer_GetSteamID() {
-	uint64_t* val = new uint64_t(SteamGameServer_GetSteamID());
+	return new CSteamID(SteamGameServer_GetSteamID());
-	return val;
 }
 
-DLL_EXPORT HSteamPipe DLL_CALL BS_GameServer_GetHSteamPipe() {
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+//	steamclient.dll private wrapper functions
+//
+//	The following functions are part of abstracting API access to the steamclient.dll, but should only be used in very specific cases
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+DLL(HSteamPipe) BS_SteamGameServer_GetHSteamPipe() {
 	return SteamGameServer_GetHSteamPipe();
 }
 
-// Interfaces
+// ISteamGameServer Stuff
-DLL_EXPORT ISteamGameServer* DLL_CALL BS_GameServer() {
+//-----------------------------------------------------------------------------
+// Purpose: Functions for authenticating users via Steam to play on a game server
+//-----------------------------------------------------------------------------
+DLL(ISteamGameServer*) BS_SteamGameServer() {
 	return SteamGameServer();
 }
 
-DLL_EXPORT ISteamUtils* DLL_CALL BS_GameServerUtils() {
+//
-	return SteamGameServerUtils();
+// Basic server data.  These properties, if set, must be set before before calling LogOn.  They
+// may not be changed after logged in.
+//
+
+/// This is called by SteamGameServer_Init, and you will usually not need to call it directly
+DLL(uint32_t) BS_ISteamGameServer_InitGameServer(ISteamGameServer* pSteamGameServer, uint32_t unIP, uint16_t usGamePort, uint16_t usQueryPort, uint32_t unFlags, AppId_t nGameAppId, const char *pchVersionString) {
+	return pSteamGameServer->InitGameServer(unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString);
 }
 
-DLL_EXPORT ISteamNetworking* DLL_CALL BS_GameServerNetworking() {
+/// Game product identifier.  This is currently used by the master server for version checking purposes.
-	return SteamGameServerNetworking();
+/// It's a required field, but will eventually will go away, and the AppID will be used for this purpose.
+DLL(void) BS_ISteamGameServer_SetProduct(ISteamGameServer* pSteamGameServer, const char *pszProduct) {
+	pSteamGameServer->SetProduct(pszProduct);
 }
 
-DLL_EXPORT ISteamGameServerStats* DLL_CALL BS_GameServerStats() {
+/// Description of the game.  This is a required field and is displayed in the steam server browser....for now.
-	return SteamGameServerStats();
+/// This is a required field, but it will go away eventually, as the data should be determined from the AppID.
+DLL(void) BS_ISteamGameServer_SetGameDescription(ISteamGameServer* pSteamGameServer, const char *pszGameDescription) {
+	pSteamGameServer->SetGameDescription(pszGameDescription);
 }
 
-DLL_EXPORT ISteamHTTP* DLL_CALL BS_GameServerHTTP() {
+/// If your game is a "mod," pass the string that identifies it.  The default is an empty string, meaning
-	return SteamGameServerHTTP();
+/// this application is the original game, not a mod.
+///
+/// @see k_cbMaxGameServerGameDir
+DLL(void) BS_ISteamGameServer_SetModDir(ISteamGameServer* pSteamGameServer, const char *pszModDir) {
+	pSteamGameServer->SetModDir(pszModDir);
 }
 
-DLL_EXPORT ISteamInventory* DLL_CALL BS_GameServerInventory() {
+/// Is this is a dedicated server?  The default value is false.
-	return SteamGameServerInventory();
+DLL(void) BS_ISteamGameServer_SetDedicatedServer(ISteamGameServer* pSteamGameServer, uint32_t bDedicated) {
+	pSteamGameServer->SetDedicatedServer(!!bDedicated);
+}
+
+//
+// Login
+//
+
+/// Begin process to login to a persistent game server account
+///
+/// You need to register for callbacks to determine the result of this operation.
+/// @see SteamServersConnected_t
+/// @see SteamServerConnectFailure_t
+/// @see SteamServersDisconnected_t
+DLL(void) BS_ISteamGameServer_LogOn(ISteamGameServer* pSteamGameServer, const char *pszToken) {
+	pSteamGameServer->LogOn(pszToken);
+}
+
+/// Login to a generic, anonymous account.
+///
+/// Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init,
+/// but this is no longer the case.
+DLL(void) BS_ISteamGameServer_LogOnAnonymous(ISteamGameServer* pSteamGameServer) {
+	pSteamGameServer->LogOnAnonymous();
+}
+
+/// Begin process of logging game server out of steam
+DLL(void) BS_ISteamGameServer_LogOff(ISteamGameServer* pSteamGameServer) {
+	pSteamGameServer->LogOff();
+}
+
+// status functions
+DLL(uint32_t) BS_ISteamGameServer_IsLoggedOn(ISteamGameServer* pSteamGameServer) {
+	return pSteamGameServer->BLoggedOn();
+}
+
+DLL(uint32_t) BS_ISteamGameServer_IsSecure(ISteamGameServer* pSteamGameServer) {
+	return pSteamGameServer->BSecure();
+}
+
+DLL(CSteamID*) BS_ISteamGameServer_GetSteamID(ISteamGameServer* pSteamGameServer) {
+	return new CSteamID(pSteamGameServer->GetSteamID());
+}
+
+/// Returns true if the master server has requested a restart.
+/// Only returns true once per request.
+DLL(uint32_t) BS_ISteamGameServer_WasRestartRequested(ISteamGameServer* pSteamGameServer) {
+	return pSteamGameServer->WasRestartRequested();
+}
+
+//
+// Server state.  These properties may be changed at any time.
+//
+
+/// Max player count that will be reported to server browser and client queries
+DLL(void) BS_ISteamGameServer_SetMaxPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cPlayersMax) {
+	pSteamGameServer->SetMaxPlayerCount(cPlayersMax);
+}
+
+/// Number of bots.  Default value is zero
+DLL(void) BS_ISteamGameServer_SetBotPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cBotplayers) {
+	pSteamGameServer->SetBotPlayerCount(cBotplayers);
+}
+
+/// Set the name of server as it will appear in the server browser
+///
+/// @see k_cbMaxGameServerName
+DLL(void) BS_ISteamGameServer_SetServerName(ISteamGameServer* pSteamGameServer, const char *pszServerName) {
+	pSteamGameServer->SetServerName(pszServerName);
+}
+
+/// Set name of map to report in the server browser
+///
+/// @see k_cbMaxGameServerName
+DLL(void) BS_ISteamGameServer_SetMapName(ISteamGameServer* pSteamGameServer, const char *pszMapName) {
+	pSteamGameServer->SetMapName(pszMapName);
+}
+
+/// Let people know if your server will require a password
+DLL(void) BS_ISteamGameServer_SetPasswordProtected(ISteamGameServer* pSteamGameServer, uint32_t bPasswordProtected) {
+	pSteamGameServer->SetPasswordProtected(!!bPasswordProtected);
+}
+
+/// Spectator server.  The default value is zero, meaning the service
+/// is not used.
+DLL(void) BS_ISteamGameServer_SetSpectatorPort(ISteamGameServer* pSteamGameServer, uint16_t unSpectatorPort) {
+	pSteamGameServer->SetSpectatorPort(unSpectatorPort);
+}
+
+/// Name of the spectator server.  (Only used if spectator port is nonzero.)
+///
+/// @see k_cbMaxGameServerMapName
+DLL(void) BS_ISteamGameServer_SetSpectatorServerName(ISteamGameServer* pSteamGameServer, const char *pszSpectatorServerName) {
+	pSteamGameServer->SetSpectatorServerName(pszSpectatorServerName);
+}
+
+/// Call this to clear the whole list of key/values that are sent in rules queries.
+DLL(void) BS_ISteamGameServer_ClearAllKeyValues(ISteamGameServer* pSteamGameServer) {
+	pSteamGameServer->ClearAllKeyValues();
+}
+
+/// Call this to add/update a key/value pair.
+DLL(void) BS_ISteamGameServer_SetKeyValue(ISteamGameServer* pSteamGameServer, const char *pKey, const char *pValue) {
+	pSteamGameServer->SetKeyValue(pKey, pValue);
+}
+
+/// Sets a string defining the "gametags" for this server, this is optional, but if it is set
+/// it allows users to filter in the matchmaking/server-browser interfaces based on the value
+///
+/// @see k_cbMaxGameServerTags
+DLL(void) BS_ISteamGameServer_SetGameTags(ISteamGameServer* pSteamGameServer, const char *pchGameTags) {
+	pSteamGameServer->SetGameTags(pchGameTags);
+}
+
+/// Sets a string defining the "gamedata" for this server, this is optional, but if it is set
+/// it allows users to filter in the matchmaking/server-browser interfaces based on the value
+/// don't set this unless it actually changes, its only uploaded to the master once (when
+/// acknowledged)
+///
+/// @see k_cbMaxGameServerGameData
+DLL(void) BS_ISteamGameServer_SetGameData(ISteamGameServer* pSteamGameServer, const char *pchGameData) {
+	pSteamGameServer->SetGameData(pchGameData);
+}
+
+/// Region identifier.  This is an optional field, the default value is empty, meaning the "world" region
+DLL(void) BS_ISteamGameServer_SetRegion(ISteamGameServer* pSteamGameServer, const char *pszRegion) {
+	pSteamGameServer->SetRegion(pszRegion);
+}
+
+//
+// Player list management / authentication
+//
+
+// Handles receiving a new connection from a Steam user.  This call will ask the Steam
+// servers to validate the users identity, app ownership, and VAC status.  If the Steam servers 
+// are off-line, then it will validate the cached ticket itself which will validate app ownership 
+// and identity.  The AuthBlob here should be acquired on the game client using SteamUser()->InitiateGameConnection()
+// and must then be sent up to the game server for authentication.
+//
+// Return Value: returns true if the users ticket passes basic checks. pSteamIDUser will contain the Steam ID of this user. pSteamIDUser must NOT be NULL
+// If the call succeeds then you should expect a GSClientApprove_t or GSClientDeny_t callback which will tell you whether authentication
+// for the user has succeeded or failed (the steamid in the callback will match the one returned by this call)
+DLL(uint32_t) BS_ISteamGameServer_SendUserConnectAndAuthenticate(ISteamGameServer* pSteamGameServer, uint32_t unIPClient, const void *pvAuthBlob, uint32_t cubAuthBlobSize, CSteamID *pSteamIDUser) {
+	return pSteamGameServer->SendUserConnectAndAuthenticate(unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser);
+}
+
+// Creates a fake user (ie, a bot) which will be listed as playing on the server, but skips validation.  
+// 
+// Return Value: Returns a SteamID for the user to be tracked with, you should call HandleUserDisconnect()
+// when this user leaves the server just like you would for a real user.
+DLL(CSteamID*) BS_ISteamGameServer_CreateUnauthenticatedUserConnection(ISteamGameServer* pSteamGameServer) {
+	return new CSteamID(pSteamGameServer->CreateUnauthenticatedUserConnection());
+}
+
+// Should be called whenever a user leaves our game server, this lets Steam internally
+// track which users are currently on which servers for the purposes of preventing a single
+// account being logged into multiple servers, showing who is currently on a server, etc.
+DLL(void) BS_ISteamGameServer_SendUserDisconnect(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser) {
+	pSteamGameServer->SendUserDisconnect(*pSteamIDUser);
+}
+
+// Update the data to be displayed in the server browser and matchmaking interfaces for a user
+// currently connected to the server.  For regular users you must call this after you receive a
+// GSUserValidationSuccess callback.
+// 
+// Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player)
+DLL(uint32_t) BS_ISteamGameServer_UpdateUserData(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, const char *pchPlayerName, uint32_t uScore) {
+	return pSteamGameServer->BUpdateUserData(*pSteamIDUser, pchPlayerName, uScore);
+}
+
+// New auth system APIs - do not mix with the old auth system APIs.
+// ----------------------------------------------------------------
+
+// Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). 
+// pcbTicket retrieves the length of the actual ticket.
+DLL(HAuthTicket) BS_ISteamGameServer_GetAuthSessionTicket(ISteamGameServer* pSteamGameServer, void *pTicket, int32_t cbMaxTicket, uint32_t *pcbTicket) {
+	return pSteamGameServer->GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket);
+}
+
+// Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused
+// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
+DLL(EBeginAuthSessionResult) BS_ISteamGameServer_BeginAuthSession(ISteamGameServer* pSteamGameServer, const void *pAuthTicket, int32_t cbAuthTicket, CSteamID* pSteamID) {
+	return pSteamGameServer->BeginAuthSession(pAuthTicket, cbAuthTicket, *pSteamID);
+}
+
+// Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
+DLL(void) BS_ISteamGameServer_EndAuthSession(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID) {
+	pSteamGameServer->EndAuthSession(*pSteamID);
+}
+
+// Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
+DLL(void) BS_ISteamGameServer_CancelAuthTicket(ISteamGameServer* pSteamGameServer, HAuthTicket hAuthTicket) {
+	pSteamGameServer->CancelAuthTicket(hAuthTicket);
+}
+
+// After receiving a user's authentication data, and passing it to SendUserConnectAndAuthenticate, use this function
+// to determine if the user owns downloadable content specified by the provided AppID.
+DLL(EUserHasLicenseForAppResult) BS_ISteamGameServer_UserHasLicenseForApp(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID, AppId_t appID) {
+	return pSteamGameServer->UserHasLicenseForApp(*pSteamID, appID);
+}
+
+// Ask if a user in in the specified group, results returns async by GSUserGroupStatus_t
+// returns false if we're not connected to the steam servers and thus cannot ask
+DLL(uint32_t) BS_ISteamGameServer_RequestUserGroupStatus(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, CSteamID* pSteamIDGroup) {
+	return pSteamGameServer->RequestUserGroupStatus(*pSteamIDUser, *pSteamIDGroup);
+}
+
+// Returns the public IP of the server according to Steam, useful when the server is 
+// behind NAT and you want to advertise its IP in a lobby for other clients to directly
+// connect to
+DLL(uint32_t) BS_ISteamGameServer_GetPublicIP(ISteamGameServer* pSteamGameServer) {
+	return pSteamGameServer->GetPublicIP();
+}
+
+// These are in GameSocketShare mode, where instead of ISteamGameServer creating its own
+// socket to talk to the master server on, it lets the game use its socket to forward messages
+// back and forth. This prevents us from requiring server ops to open up yet another port
+// in their firewalls.
+//
+// the IP address and port should be in host order, i.e 127.0.0.1 == 0x7f000001
+
+// These are used when you've elected to multiplex the game server's UDP socket
+// rather than having the master server updater use its own sockets.
+// 
+// Source games use this to simplify the job of the server admins, so they 
+// don't have to open up more ports on their firewalls.
+
+// Call this when a packet that starts with 0xFFFFFFFF comes in. That means
+// it's for us.
+DLL(uint32_t) BS_ISteamGameServer_HandleIncomingPacket(ISteamGameServer* pSteamGameServer, const void *pData, int32_t cbData, uint32_t srcIP, uint16_t srcPort) {
+	return pSteamGameServer->HandleIncomingPacket(pData, cbData, srcIP, srcPort);
+}
+
+// AFTER calling HandleIncomingPacket for any packets that came in that frame, call this.
+// This gets a packet that the master server updater needs to send out on UDP.
+// It returns the length of the packet it wants to send, or 0 if there are no more packets to send.
+// Call this each frame until it returns 0.
+DLL(uint32_t) BS_ISteamGameServer_GetNextOutgoingPacket(ISteamGameServer* pSteamGameServer, void *pOut, int32_t cbMaxOut, uint32_t *pNetAdr, uint16_t *pPort) {
+	return pSteamGameServer->GetNextOutgoingPacket(pOut, cbMaxOut, pNetAdr, pPort);
+}
+
+//
+// Control heartbeats / advertisement with master server
+//
+
+// Call this as often as you like to tell the master server updater whether or not
+// you want it to be active (default: off).
+DLL(void) BS_ISteamGameServer_EnableHeartbeats(ISteamGameServer* pSteamGameServer, uint32_t bActive) {
+	pSteamGameServer->EnableHeartbeats(!!bActive);
+}
+
+// You usually don't need to modify this.
+// Pass -1 to use the default value for iHeartbeatInterval.
+// Some mods change this.
+DLL(void) BS_ISteamGameServer_SetHeartbeatInterval(ISteamGameServer* pSteamGameServer, int32_t iHeartbeatInterval) {
+	pSteamGameServer->SetHeartbeatInterval(iHeartbeatInterval);
+}
+
+// Force a heartbeat to steam at the next opportunity
+DLL(void) BS_ISteamGameServer_ForceHeartbeat(ISteamGameServer* pSteamGameServer) {
+	pSteamGameServer->ForceHeartbeat();
+}
+
+// associate this game server with this clan for the purposes of computing player compat
+DLL(SteamAPICall_t*) BS_ISteamGameServer_AssociateWithClan(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDClan) {
+	return new SteamAPICall_t(pSteamGameServer->AssociateWithClan(*pSteamIDClan));
+}
+
+// ask if any of the current players dont want to play with this new player - or vice versa
+DLL(SteamAPICall_t*) BS_ISteamGameServer_ComputeNewPlayerCompatibility(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDNewPlayer) {
+	return new SteamAPICall_t(pSteamGameServer->ComputeNewPlayerCompatibility(*pSteamIDNewPlayer));
 }

Wrapper/SteamGameServerStats.cpp

@@ -0,0 +1,81 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for authenticating users via Steam to play on a game server
+//-----------------------------------------------------------------------------
+DLL(ISteamGameServerStats*) BS_SteamGameServerStats() {
+	return SteamGameServerStats();
+}
+
+// downloads stats for the user
+// returns a GSStatsReceived_t callback when completed
+// if the user has no stats, GSStatsReceived_t.m_eResult will be set to k_EResultFail
+// these stats will only be auto-updated for clients playing on the server. For other
+// users you'll need to call RequestUserStats() again to refresh any data
+DLL(SteamAPICall_t*) BS_ISteamGameServerStats_RequestUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
+	return new SteamAPICall_t(pSteamGameServerStats->RequestUserStats(*steamIDUser));
+}
+
+// Store the current data on the server, will get a GSStatsStored_t callback when set.
+//
+// If the callback has a result of k_EResultInvalidParam, one or more stats 
+// uploaded has been rejected, either because they broke constraints
+// or were out of date. In this case the server sends back updated values.
+// The stats should be re-iterated to keep in sync.
+DLL(SteamAPICall_t*) BS_ISteamGameServerStats_StoreUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
+	return new SteamAPICall_t(pSteamGameServerStats->StoreUserStats(*steamIDUser));
+}
+
+// requests stat information for a user, usable after a successful call to RequestUserStats()
+DLL(uint32_t) BS_ISteamGameServerStats_GetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData) {
+	return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, (int32_t*)pData);
+}
+
+DLL(uint32_t) BS_ISteamGameServerStats_GetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t* pData) {
+	return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, pData);
+}
+
+DLL(uint32_t) BS_ISteamGameServerStats_GetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pbAchieved) {
+	return pSteamGameServerStats->GetUserAchievement(*steamIDUser, pchName, (bool*)pbAchieved);
+}
+
+// Set / update stats and achievements. 
+// Note: These updates will work only on stats game servers are allowed to edit and only for 
+// game servers that have been declared as officially controlled by the game creators. 
+// Set the IP range of your official servers on the Steamworks page
+DLL(uint32_t) BS_ISteamGameServerStats_SetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t nData) {
+	return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, (int32_t)nData);
+}
+
+DLL(uint32_t) BS_ISteamGameServerStats_SetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t fData) {
+	return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, fData);
+}
+
+DLL(uint32_t) BS_ISteamGameServerStats_UpdateUserAvgRateStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char *pchName, float flCountThisSession, double* pdSessionLength) {
+	return pSteamGameServerStats->UpdateUserAvgRateStat(*steamIDUser, pchName, flCountThisSession, *pdSessionLength);
+}
+
+DLL(uint32_t) BS_ISteamGameServerStats_SetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
+	return pSteamGameServerStats->SetUserAchievement(*steamIDUser, pchName);
+}
+
+DLL(uint32_t) BS_ISteamGameServerStats_ClearUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
+	return pSteamGameServerStats->ClearUserAchievement(*steamIDUser, pchName);
+}
+

Wrapper/SteamHTMLSurface.cpp

@@ -0,0 +1,209 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+#include "SteamworksSDK/public/steam/isteamhtmlsurface.h"
+
+DLL(ISteamHTMLSurface*) BS_SteamHTMLSurface() {
+	return SteamHTMLSurface();
+}
+
+// Must call init and shutdown when starting/ending use of the interface
+DLL(uint32_t) BS_ISteamHTMLSurface_Init(ISteamHTMLSurface* pSteamHTMLSurface) {
+	return pSteamHTMLSurface->Init();
+}
+
+DLL(uint32_t) BS_ISteamHTMLSurface_Shutdown(ISteamHTMLSurface* pSteamHTMLSurface) {
+	return pSteamHTMLSurface->Shutdown();
+}
+
+// Create a browser object for display of a html page, when creation is complete the call handle
+// will return a HTML_BrowserReady_t callback for the HHTMLBrowser of your new browser.
+//   The user agent string is a substring to be added to the general user agent string so you can
+// identify your client on web servers.
+//   The userCSS string lets you apply a CSS style sheet to every displayed page, leave null if
+// you do not require this functionality.
+DLL(SteamAPICall_t*) BS_ISteamHTMLSurface_CreateBrowser(ISteamHTMLSurface* pSteamHTMLSurface, const char* pchUserAgent, const char* pchUserCSS) {
+	return new SteamAPICall_t(pSteamHTMLSurface->CreateBrowser(pchUserAgent, pchUserCSS));
+}
+
+// Call this when you are done with a html surface, this lets us free the resources being used by it
+DLL(void) BS_ISteamHTMLSurface_RemoveBrowser(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->RemoveBrowser(unBrowserHandle);
+}
+
+// Navigate to this URL, results in a HTML_StartRequest_t as the request commences 
+DLL(void) BS_ISteamHTMLSurface_LoadURL(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchURL, const char* pchPostData) {
+	pSteamHTMLSurface->LoadURL(unBrowserHandle, pchURL, pchPostData);
+}
+
+// Tells the surface the size in pixels to display the surface
+DLL(void) BS_ISteamHTMLSurface_SetSize(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32_t unWidth, uint32_t unHeight) {
+	pSteamHTMLSurface->SetSize(unBrowserHandle, unWidth, unHeight);
+}
+
+// Stop the load of the current html page
+DLL(void) BS_ISteamHTMLSurface_StopLoad(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->StopLoad(unBrowserHandle);
+}
+
+// Reload (most likely from local cache) the current page
+DLL(void) BS_ISteamHTMLSurface_Reload(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->Reload(unBrowserHandle);
+}
+
+// navigate back in the page history
+DLL(void) BS_ISteamHTMLSurface_GoBack(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->GoBack(unBrowserHandle);
+}
+
+// navigate forward in the page history
+DLL(void) BS_ISteamHTMLSurface_GoForward(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->GoForward(unBrowserHandle);
+}
+
+// add this header to any url requests from this browser
+DLL(void) BS_ISteamHTMLSurface_AddHeader(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchKey, const char* pchValue) {
+	pSteamHTMLSurface->AddHeader(unBrowserHandle, pchKey, pchValue);
+}
+
+// run this javascript script in the currently loaded page
+DLL(void) BS_ISteamHTMLSurface_ExecuteJavascript(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchScript) {
+	pSteamHTMLSurface->ExecuteJavascript(unBrowserHandle, pchScript);
+}
+
+// Mouse click and mouse movement commands
+DLL(void) BS_ISteamHTMLSurface_MouseUp(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+	pSteamHTMLSurface->MouseUp(unBrowserHandle, eMouseButton);
+}
+
+DLL(void) BS_ISteamHTMLSurface_MouseDown(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+	pSteamHTMLSurface->MouseDown(unBrowserHandle, eMouseButton);
+}
+
+DLL(void) BS_ISteamHTMLSurface_MouseDoubleClick(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+	pSteamHTMLSurface->MouseDoubleClick(unBrowserHandle, eMouseButton);
+}
+
+// x and y are relative to the HTML bounds
+DLL(void) BS_ISteamHTMLSurface_MouseMove(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int32_t x, int32_t y) {
+	pSteamHTMLSurface->MouseMove(unBrowserHandle, x, y);
+}
+
+// nDelta is pixels of scroll
+DLL(void) BS_ISteamHTMLSurface_MouseWheel(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int32_t nDelta) {
+	pSteamHTMLSurface->MouseWheel(unBrowserHandle, nDelta);
+}
+
+// keyboard interactions, native keycode is the virtual key code value from your OS
+DLL(void) BS_ISteamHTMLSurface_KeyDown(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+	pSteamHTMLSurface->KeyDown(unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
+}
+
+DLL(void) BS_ISteamHTMLSurface_KeyUp(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+	pSteamHTMLSurface->KeyUp(unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
+}
+
+// cUnicodeChar is the unicode character point for this keypress (and potentially multiple chars per press)
+DLL(void) BS_ISteamHTMLSurface_KeyChar(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+	pSteamHTMLSurface->KeyChar(unBrowserHandle, cUnicodeChar, eHTMLKeyModifiers);
+}
+
+// programmatically scroll this many pixels on the page
+DLL(void) BS_ISteamHTMLSurface_SetHorizontalScroll(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) {
+	pSteamHTMLSurface->SetHorizontalScroll(unBrowserHandle, nAbsolutePixelScroll);
+}
+
+DLL(void) BS_ISteamHTMLSurface_SetVerticalScroll(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) {
+	pSteamHTMLSurface->SetVerticalScroll(unBrowserHandle, nAbsolutePixelScroll);
+}
+
+// tell the html control if it has key focus currently, controls showing the I-beam cursor in text controls amongst other things
+DLL(void) BS_ISteamHTMLSurface_SetKeyFocus(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bHasKeyFocus) {
+	pSteamHTMLSurface->SetKeyFocus(unBrowserHandle, bHasKeyFocus);
+}
+
+// open the current pages html code in the local editor of choice, used for debugging
+DLL(void) BS_ISteamHTMLSurface_ViewSource(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->ViewSource(unBrowserHandle);
+}
+
+// copy the currently selected text on the html page to the local clipboard
+DLL(void) BS_ISteamHTMLSurface_CopyToClipboard(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->CopyToClipboard(unBrowserHandle);
+}
+
+// paste from the local clipboard to the current html page
+DLL(void) BS_ISteamHTMLSurface_PasteFromClipboard(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->PasteFromClipboard(unBrowserHandle);
+}
+
+// find this string in the browser, if bCurrentlyInFind is true then instead cycle to the next matching element
+DLL(void) BS_ISteamHTMLSurface_Find(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char *pchSearchStr, bool bCurrentlyInFind, bool bReverse) {
+	pSteamHTMLSurface->Find(unBrowserHandle, pchSearchStr, bCurrentlyInFind, bReverse);
+}
+
+// cancel a currently running find
+DLL(void) BS_ISteamHTMLSurface_StopFind(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+	pSteamHTMLSurface->StopFind(unBrowserHandle);
+}
+
+// return details about the link at position x,y on the current page
+DLL(void) BS_ISteamHTMLSurface_GetLinkAtPosition(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int x, int y) {
+	pSteamHTMLSurface->GetLinkAtPosition(unBrowserHandle, x, y);
+}
+
+// set a webcookie for the hostname in question
+DLL(void) BS_ISteamHTMLSurface_SetCookie(ISteamHTMLSurface* pSteamHTMLSurface, const char *pchHostname, const char *pchKey, const char *pchValue, const char *pchPath, RTime32 nExpires, bool bSecure, bool bHTTPOnly) {
+	pSteamHTMLSurface->SetCookie(pchHostname, pchKey, pchValue, pchPath, nExpires, bSecure, bHTTPOnly);
+}
+
+// Zoom the current page by flZoom ( from 0.0 to 2.0, so to zoom to 120% use 1.2 ), zooming around point X,Y in the page (use 0,0 if you don't care)
+DLL(void) BS_ISteamHTMLSurface_SetPageScaleFactor(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY) {
+	pSteamHTMLSurface->SetPageScaleFactor(unBrowserHandle, flZoom, nPointX, nPointY);
+}
+
+// Enable/disable low-resource background mode, where javascript and repaint timers are throttled, resources are
+// more aggressively purged from memory, and audio/video elements are paused. When background mode is enabled,
+// all HTML5 video and audio objects will execute ".pause()" and gain the property "._steam_background_paused = 1".
+// When background mode is disabled, any video or audio objects with that property will resume with ".play()".
+DLL(void) BS_ISteamHTMLSurface_SetBackgroundMode(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bBackgroundMode) {
+	pSteamHTMLSurface->SetBackgroundMode(unBrowserHandle, bBackgroundMode);
+}
+
+// CALLBACKS
+//
+//  These set of functions are used as responses to callback requests
+//
+
+// You MUST call this in response to a HTML_StartRequest_t callback
+//  Set bAllowed to true to allow this navigation, false to cancel it and stay 
+// on the current page. You can use this feature to limit the valid pages
+// allowed in your HTML surface.
+DLL(void) BS_ISteamHTMLSurface_AllowStartRequest(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bAllowed) {
+	pSteamHTMLSurface->AllowStartRequest(unBrowserHandle, bAllowed);
+}
+
+// You MUST call this in response to a HTML_JSAlert_t or HTML_JSConfirm_t callback
+//  Set bResult to true for the OK option of a confirm, use false otherwise
+DLL(void) BS_ISteamHTMLSurface_JSDialogResponse(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bResult) {
+	pSteamHTMLSurface->JSDialogResponse(unBrowserHandle, bResult);
+}
+
+// You MUST call this in response to a HTML_FileOpenDialog_t callback
+DLL(void) BS_ISteamHTMLSurface_FileLoadDialogResponse(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles) {
+	pSteamHTMLSurface->FileLoadDialogResponse(unBrowserHandle, pchSelectedFiles);
+}

Wrapper/SteamHTTP.cpp

@@ -0,0 +1,189 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: interface to http client
+//-----------------------------------------------------------------------------
+DLL(ISteamHTTP*) BS_HTTP() {
+	return SteamHTTP();
+}
+
+DLL(ISteamHTTP*) BS_GameServerHTTP() {
+	return SteamGameServerHTTP();
+}
+
+// Initializes a new HTTP request, returning a handle to use in further operations on it.  Requires
+// the method (GET or POST) and the absolute URL for the request.  Both http and https are supported,
+// so this string must start with http:// or https:// and should look like http://store.steampowered.com/app/250/ 
+// or such.
+DLL(HTTPRequestHandle) BS_ISteamHTTP_CreateHTTPRequest(ISteamHTTP* pThis, EHTTPMethod eHTTPRequestMethod, const char* cAbsoluteUrl) {
+	return pThis->CreateHTTPRequest(eHTTPRequestMethod, cAbsoluteUrl);
+}
+
+// Set a context value for the request, which will be returned in the HTTPRequestCompleted_t callback after
+// sending the request.  This is just so the caller can easily keep track of which callbacks go with which request data.
+DLL(int32_t) BS_ISteamHTTP_SetHTTPRequestContextValue(ISteamHTTP* pThis, HTTPRequestHandle hRequest, uint64_t* plContextValue) {
+	return pThis->SetHTTPRequestContextValue(hRequest, *plContextValue);
+}
+
+// Set a timeout in seconds for the HTTP request, must be called prior to sending the request.  Default
+// timeout is 60 seconds if you don't call this.  Returns false if the handle is invalid, or the request
+// has already been sent.
+DLL(int32_t) BS_ISteamHTTP_SetHTTPNetworkActivityTimeout(ISteamHTTP* pThis, HTTPRequestHandle hRequest, uint32 unTimeoutSeconds) {
+	return pThis->SetHTTPRequestNetworkActivityTimeout(hRequest, unTimeoutSeconds);
+}
+
+// Set a request header value for the request, must be called prior to sending the request.  Will 
+// return false if the handle is invalid or the request is already sent.
+DLL(int32_t) BS_ISteamHTTP_SetHTTPRequestHeaderValue(ISteamHTTP* pThis, HTTPRequestHandle hRequest, const char *pchHeaderName, const char *pchHeaderValue) {
+	return pThis->SetHTTPRequestHeaderValue(hRequest, pchHeaderName, pchHeaderValue);
+}
+
+// Set a GET or POST parameter value on the request, which is set will depend on the EHTTPMethod specified
+// when creating the request.  Must be called prior to sending the request.  Will return false if the 
+// handle is invalid or the request is already sent.
+DLL(int32_t) BS_ISteamHTTP_SetHTTPRequestGetOrPostParameter(ISteamHTTP* pThis, HTTPRequestHandle hRequest, const char *pchParamName, const char *pchParamValue) {
+	return pThis->SetHTTPRequestGetOrPostParameter(hRequest, pchParamName, pchParamValue);
+}
+
+// Sends the HTTP request, will return false on a bad handle, otherwise use SteamCallHandle to wait on
+// asynchronous response via callback.
+//
+// Note: If the user is in offline mode in Steam, then this will add a only-if-cached cache-control 
+// header and only do a local cache lookup rather than sending any actual remote request.
+DLL(int32_t) BS_ISteamHTTP_SendHTTPRequest(ISteamHTTP* pThis, HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle) {
+	return pThis->SendHTTPRequest(hRequest, pCallHandle);
+}
+
+// Sends the HTTP request, will return false on a bad handle, otherwise use SteamCallHandle to wait on
+// asynchronous response via callback for completion, and listen for HTTPRequestHeadersReceived_t and 
+// HTTPRequestDataReceived_t callbacks while streaming.
+DLL(int32_t) BS_ISteamHTTP_SendHTTPRequestAndStreamResponse(ISteamHTTP* pThis, HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle) {
+	return pThis->SendHTTPRequestAndStreamResponse(hRequest, pCallHandle);
+}
+
+// Defers a request you have sent, the actual HTTP client code may have many requests queued, and this will move
+// the specified request to the tail of the queue.  Returns false on invalid handle, or if the request is not yet sent.
+DLL(int32_t) BS_ISteamHTTP_DeferHTTPRequest(ISteamHTTP* pThis, HTTPRequestHandle hRequest) {
+	return pThis->DeferHTTPRequest(hRequest);
+}
+
+// Prioritizes a request you have sent, the actual HTTP client code may have many requests queued, and this will move
+// the specified request to the head of the queue.  Returns false on invalid handle, or if the request is not yet sent.
+DLL(int32_t) BS_ISteamHTTP_PrioritizeHTTPRequest(ISteamHTTP* pThis, HTTPRequestHandle hRequest) {
+	return pThis->PrioritizeHTTPRequest(hRequest);
+}
+
+// Checks if a response header is present in a HTTP response given a handle from HTTPRequestCompleted_t, also 
+// returns the size of the header value if present so the caller and allocate a correctly sized buffer for
+// GetHTTPResponseHeaderValue.
+DLL(int32_t) BS_ISteamHTTP_GetHTTPResponseHeaderSize(ISteamHTTP* pThis, HTTPRequestHandle hRequest, const char *pchHeaderName, uint32 *unResponseHeaderSize) {
+	return pThis->GetHTTPResponseHeaderSize(hRequest, pchHeaderName, unResponseHeaderSize);
+}
+
+// Gets header values from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the
+// header is not present or if your buffer is too small to contain it's value.  You should first call 
+// BGetHTTPResponseHeaderSize to check for the presence of the header and to find out the size buffer needed.
+DLL(int32_t) BS_ISteamHTTP_GetHTTPResponseHeaderValue(ISteamHTTP* pThis, HTTPRequestHandle hRequest, const char *pchHeaderName, uint8 *pHeaderValueBuffer, uint32 unBufferSize) {
+	return pThis->GetHTTPResponseHeaderValue(hRequest, pchHeaderName, pHeaderValueBuffer, unBufferSize);
+}
+
+// Gets the size of the body data from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the 
+// handle is invalid.
+DLL(int32_t) BS_ISteamHTTP_GetHTTPResponseBodySize(ISteamHTTP* pThis, HTTPRequestHandle hRequest, uint32 *unBodySize) {
+	return pThis->GetHTTPResponseBodySize(hRequest, unBodySize);
+}
+
+// Gets the body data from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the 
+// handle is invalid or is to a streaming response, or if the provided buffer is not the correct size.  Use BGetHTTPResponseBodySize first to find out
+// the correct buffer size to use.
+DLL(int32_t) BS_ISteamHTTP_GetHTTPResponseBodyData(ISteamHTTP* pThis, HTTPRequestHandle hRequest, uint8 *pBodyDataBuffer, uint32 unBufferSize) {
+	return pThis->GetHTTPResponseBodyData(hRequest, pBodyDataBuffer, unBufferSize);
+}
+
+// Gets the body data from a streaming HTTP response given a handle from HTTPRequestDataReceived_t. Will return false if the 
+// handle is invalid or is to a non-streaming response (meaning it wasn't sent with SendHTTPRequestAndStreamResponse), or if the buffer size and offset 
+// do not match the size and offset sent in HTTPRequestDataReceived_t.
+DLL(int32_t) BS_ISteamHTTP_GetHTTPStreamingResponseBodyData(ISteamHTTP* pThis, HTTPRequestHandle hRequest, uint32 cOffset, uint8 *pBodyDataBuffer, uint32 unBufferSize) {
+	return pThis->GetHTTPStreamingResponseBodyData(hRequest, cOffset, pBodyDataBuffer, unBufferSize);
+}
+
+// Releases an HTTP response handle, should always be called to free resources after receiving a HTTPRequestCompleted_t
+// callback and finishing using the response.
+DLL(int32_t) BS_ISteamHTTP_ReleaseHTTPRequest(ISteamHTTP* pThis, HTTPRequestHandle hRequest) {
+	return pThis->ReleaseHTTPRequest(hRequest);
+}
+
+// Gets progress on downloading the body for the request.  This will be zero unless a response header has already been
+// received which included a content-length field.  For responses that contain no content-length it will report
+// zero for the duration of the request as the size is unknown until the connection closes.
+DLL(int32_t) BS_ISteamHTTP_GetHTTPDownloadProgressPct(ISteamHTTP* pThis, HTTPRequestHandle hRequest, float *pflPercentOut) {
+	return pThis->GetHTTPDownloadProgressPct(hRequest, pflPercentOut);
+}
+
+// Sets the body for an HTTP Post request.  Will fail and return false on a GET request, and will fail if POST params
+// have already been set for the request.  Setting this raw body makes it the only contents for the post, the pchContentType
+// parameter will set the content-type header for the request so the server may know how to interpret the body.
+DLL(int32_t) BS_ISteamHTTP_SetHTTPRequestRawPostBody(ISteamHTTP* pThis, HTTPRequestHandle hRequest, const char *pchContentType, uint8 *pubBody, uint32 unBodyLen) {
+	return pThis->SetHTTPRequestRawPostBody(hRequest, pchContentType, pubBody, unBodyLen);
+}
+
+// Creates a cookie container handle which you must later free with ReleaseCookieContainer().  If bAllowResponsesToModify=true
+// than any response to your requests using this cookie container may add new cookies which may be transmitted with
+// future requests.  If bAllowResponsesToModify=false than only cookies you explicitly set will be sent.  This API is just for
+// during process lifetime, after steam restarts no cookies are persisted and you have no way to access the cookie container across
+// repeat executions of your process.
+DLL(HTTPCookieContainerHandle) BS_ISteamHTTP_CreateCookieContainer(ISteamHTTP* pThis, bool bAllowResponsesToModify) {
+	return pThis->CreateCookieContainer(bAllowResponsesToModify);
+}
+
+// Release a cookie container you are finished using, freeing it's memory
+DLL(int32_t) BS_ISteamHTTP_ReleaseCookieContainer(ISteamHTTP* pThis, HTTPCookieContainerHandle hCookieContainer) {
+	return pThis->ReleaseCookieContainer(hCookieContainer);
+}
+
+// Adds a cookie to the specified cookie container that will be used with future requests.
+DLL(int32_t) BS_ISteamHTTP_SetCookie(ISteamHTTP* pThis, HTTPCookieContainerHandle hCookieContainer, const char *pchHost, const char *pchUrl, const char *pchCookie) {
+	return pThis->SetCookie(hCookieContainer, pchHost, pchUrl, pchCookie);
+}
+
+// Set the cookie container to use for a HTTP request
+DLL(int32_t) BS_ISteamHTTP_SetHTTPRequestCookieContainer(ISteamHTTP* pThis, HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer) {
+	return pThis->SetHTTPRequestCookieContainer(hRequest, hCookieContainer);
+}
+
+// Set the extra user agent info for a request, this doesn't clobber the normal user agent, it just adds the extra info on the end
+DLL(int32_t) BS_ISteamHTTP_SetHTTPRequestUserAgentInfo(ISteamHTTP* pThis, HTTPRequestHandle hRequest, const char *pchUserAgentInfo) {
+	return pThis->SetHTTPRequestUserAgentInfo(hRequest, pchUserAgentInfo);
+}
+
+// Set that https request should require verified SSL certificate via machines certificate trust store
+DLL(int32_t) BS_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate(ISteamHTTP* pThis, HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate) {
+	return pThis->SetHTTPRequestRequiresVerifiedCertificate(hRequest, bRequireVerifiedCertificate);
+}
+
+// Set an absolute timeout on the HTTP request, this is just a total time timeout different than the network activity timeout
+// which can bump everytime we get more data
+DLL(int32_t) BS_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS(ISteamHTTP* pThis, HTTPRequestHandle hRequest, uint32 unMilliseconds) {
+	return pThis->SetHTTPRequestAbsoluteTimeoutMS(hRequest, unMilliseconds);
+}
+
+// Check if the reason the request failed was because we timed it out (rather than some harder failure)
+DLL(int32_t) BS_ISteamHTTP_GetHTTPRequestWasTimedOut(ISteamHTTP* pThis, HTTPRequestHandle hRequest, bool *pbWasTimedOut) {
+	return pThis->GetHTTPRequestWasTimedOut(hRequest, pbWasTimedOut);
+}

Wrapper/SteamInventory.cpp

@@ -0,0 +1,300 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Steam Inventory query and manipulation API
+//-----------------------------------------------------------------------------
+DLL(ISteamInventory*) BS_SteamInventory() {
+	return SteamInventory();
+}
+
+DLL(ISteamInventory*) BS_SteamGameServerInventory() {
+	return SteamGameServerInventory();
+}
+
+// INVENTORY ASYNC RESULT MANAGEMENT
+//
+// Asynchronous inventory queries always output a result handle which can be used with
+// GetResultStatus, GetResultItems, etc. A SteamInventoryResultReady_t callback will
+// be triggered when the asynchronous result becomes ready (or fails).
+//
+
+// Find out the status of an asynchronous inventory result handle. Possible values:
+//  k_EResultPending - still in progress
+//  k_EResultOK - done, result ready
+//  k_EResultExpired - done, result ready, maybe out of date (see DeserializeResult)
+//  k_EResultInvalidParam - ERROR: invalid API call parameters
+//  k_EResultServiceUnavailable - ERROR: service temporarily down, you may retry later
+//  k_EResultLimitExceeded - ERROR: operation would exceed per-user inventory limits
+//  k_EResultFail - ERROR: unknown / generic error
+DLL(EResult) BS_ISteamInventory_GetResultStatus(ISteamInventory* pThis, SteamInventoryResult_t resultHandle) {
+	return pThis->GetResultStatus(resultHandle);
+}
+
+// Copies the contents of a result set into a flat array. The specific
+// contents of the result set depend on which query which was used.
+DLL(bool) BS_ISteamInventory_GetResultItems(ISteamInventory* pThis, SteamInventoryResult_t resultHandle,
+													 OUT_ARRAY_COUNT(punOutItemsArraySize, Output array) SteamItemDetails_t *pOutItemsArray,
+													 uint32 *punOutItemsArraySize) {
+	return pThis->GetResultItems(resultHandle, pOutItemsArray, punOutItemsArraySize);
+}
+
+// Returns the server time at which the result was generated. Compare against
+// the value of IClientUtils::GetServerRealTime() to determine age.
+DLL(uint32) BS_ISteamInventory_GetResultTimestamp(ISteamInventory* pThis, SteamInventoryResult_t resultHandle) {
+	return pThis->GetResultTimestamp(resultHandle);
+}
+
+// Returns true if the result belongs to the target steam ID, false if the
+// result does not. This is important when using DeserializeResult, to verify
+// that a remote player is not pretending to have a different user's inventory.
+DLL(bool) BS_ISteamInventory_CheckResultSteamID(ISteamInventory* pThis, SteamInventoryResult_t resultHandle, CSteamID* steamIDExpected) {
+	return pThis->CheckResultSteamID(resultHandle, *steamIDExpected);
+}
+
+// Destroys a result handle and frees all associated memory.
+DLL(void) BS_ISteamInventory_DestroyResult(ISteamInventory* pThis, SteamInventoryResult_t resultHandle) {
+	return pThis->DestroyResult(resultHandle);
+}
+
+// INVENTORY ASYNC QUERY
+//
+
+// Captures the entire state of the current user's Steam inventory.
+// You must call DestroyResult on this handle when you are done with it.
+// Returns false and sets *pResultHandle to zero if inventory is unavailable.
+// Note: calls to this function are subject to rate limits and may return
+// cached results if called too frequently. It is suggested that you call
+// this function only when you are about to display the user's full inventory,
+// or if you expect that the inventory may have changed.
+DLL(bool) BS_ISteamInventory_GetAllItems(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle) {
+	return pThis->GetAllItems(pResultHandle);
+}
+
+
+// Captures the state of a subset of the current user's Steam inventory,
+// identified by an array of item instance IDs. The results from this call
+// can be serialized and passed to other players to "prove" that the current
+// user owns specific items, without exposing the user's entire inventory.
+// For example, you could call GetItemsByID with the IDs of the user's
+// currently equipped cosmetic items and serialize this to a buffer, and
+// then transmit this buffer to other players upon joining a game.
+DLL(bool) BS_ISteamInventory_GetItemsByID(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle, ARRAY_COUNT(unCountInstanceIDs) const SteamItemInstanceID_t *pInstanceIDs, uint32 unCountInstanceIDs) {
+	return pThis->GetItemsByID(pResultHandle, pInstanceIDs, unCountInstanceIDs);
+}
+
+
+// RESULT SERIALIZATION AND AUTHENTICATION
+//
+// Serialized result sets contain a short signature which can't be forged
+// or replayed across different game sessions. A result set can be serialized
+// on the local client, transmitted to other players via your game networking,
+// and deserialized by the remote players. This is a secure way of preventing
+// hackers from lying about posessing rare/high-value items.
+
+// Serializes a result set with signature bytes to an output buffer. Pass
+// NULL as an output buffer to get the required size via punOutBufferSize.
+// The size of a serialized result depends on the number items which are being
+// serialized. When securely transmitting items to other players, it is
+// recommended to use "GetItemsByID" first to create a minimal result set.
+// Results have a built-in timestamp which will be considered "expired" after
+// an hour has elapsed. See DeserializeResult for expiration handling.
+DLL(bool) BS_ISteamInventory_SerializeResult(ISteamInventory* pThis, SteamInventoryResult_t resultHandle, OUT_BUFFER_COUNT(punOutBufferSize) void *pOutBuffer, uint32 *punOutBufferSize) {
+	return pThis->SerializeResult(resultHandle, pOutBuffer, punOutBufferSize);
+}
+
+// Deserializes a result set and verifies the signature bytes. Returns false
+// if bRequireFullOnlineVerify is set but Steam is running in Offline mode.
+// Otherwise returns true and then delivers error codes via GetResultStatus.
+//
+// The bRESERVED_MUST_BE_FALSE flag is reserved for future use and should not
+// be set to true by your game at this time.
+//
+// DeserializeResult has a potential soft-failure mode where the handle status
+// is set to k_EResultExpired. GetResultItems() still succeeds in this mode.
+// The "expired" result could indicate that the data may be out of date - not
+// just due to timed expiration (one hour), but also because one of the items
+// in the result set may have been traded or consumed since the result set was
+// generated. You could compare the timestamp from GetResultTimestamp() to
+// ISteamUtils::GetServerRealTime() to determine how old the data is. You could
+// simply ignore the "expired" result code and continue as normal, or you
+// could challenge the player with expired data to send an updated result set.
+DLL(bool) BS_ISteamInventory_DeserializeResult(ISteamInventory* pThis, SteamInventoryResult_t *pOutResultHandle, BUFFER_COUNT(punOutBufferSize) const void *pBuffer, uint32 unBufferSize, bool bRESERVED_MUST_BE_FALSE = false) {
+	return pThis->DeserializeResult(pOutResultHandle, pBuffer, unBufferSize, bRESERVED_MUST_BE_FALSE);
+}
+
+
+// INVENTORY ASYNC MODIFICATION
+//
+
+// GenerateItems() creates one or more items and then generates a SteamInventoryCallback_t
+// notification with a matching nCallbackContext parameter. This API is insecure, and could
+// be abused by hacked clients. It is, however, very useful as a development cheat or as
+// a means of prototyping item-related features for your game. The use of GenerateItems can
+// be restricted to certain item definitions or fully blocked via the Steamworks website.
+// If punArrayQuantity is not NULL, it should be the same length as pArrayItems and should
+// describe the quantity of each item to generate.
+DLL(bool) BS_ISteamInventory_GenerateItems(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle, ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength) {
+	return pThis->GenerateItems(pResultHandle, pArrayItemDefs, punArrayQuantity, unArrayLength);
+}
+
+// GrantPromoItems() checks the list of promotional items for which the user may be eligible
+// and grants the items (one time only).  On success, the result set will include items which
+// were granted, if any. If no items were granted because the user isn't eligible for any
+// promotions, this is still considered a success.
+DLL(bool) BS_ISteamInventory_GrantPromoItems(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle) {
+	return pThis->GrantPromoItems(pResultHandle);
+}
+
+// AddPromoItem() / AddPromoItems() are restricted versions of GrantPromoItems(). Instead of
+// scanning for all eligible promotional items, the check is restricted to a single item
+// definition or set of item definitions. This can be useful if your game has custom UI for
+// showing a specific promo item to the user.
+DLL(bool) BS_ISteamInventory_AddPromoItem(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle, SteamItemDef_t itemDef) {
+	return pThis->AddPromoItem(pResultHandle, itemDef);
+}
+DLL(bool) BS_ISteamInventory_AddPromoItems(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle, ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, uint32 unArrayLength) {
+	return pThis->AddPromoItems(pResultHandle, pArrayItemDefs, unArrayLength);
+}
+
+// ConsumeItem() removes items from the inventory, permanently. They cannot be recovered.
+// Not for the faint of heart - if your game implements item removal at all, a high-friction
+// UI confirmation process is highly recommended. Similar to GenerateItems, punArrayQuantity
+// can be NULL or else an array of the same length as pArrayItems which describe the quantity
+// of each item to destroy. ConsumeItem can be restricted to certain item definitions or
+// fully blocked via the Steamworks website to minimize support/abuse issues such as the
+// clasic "my brother borrowed my laptop and deleted all of my rare items".
+DLL(bool) BS_ISteamInventory_ConsumeItem(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity) {
+	return pThis->ConsumeItem(pResultHandle, itemConsume, unQuantity);
+}
+
+// ExchangeItems() is an atomic combination of GenerateItems and DestroyItems. It can be
+// used to implement crafting recipes or transmutations, or items which unpack themselves
+// into other items. Like GenerateItems, this is a flexible and dangerous API which is
+// meant for rapid prototyping. You can configure restrictions on ExchangeItems via the
+// Steamworks website, such as limiting it to a whitelist of input/output combinations
+// corresponding to recipes.
+// (Note: although GenerateItems may be hard or impossible to use securely in your game,
+// ExchangeItems is perfectly reasonable to use once the whitelists are set accordingly.)
+DLL(bool) BS_ISteamInventory_ExchangeItems(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle,
+													ARRAY_COUNT(unArrayGenerateLength) const SteamItemDef_t *pArrayGenerate, ARRAY_COUNT(unArrayGenerateLength) const uint32 *punArrayGenerateQuantity, uint32 unArrayGenerateLength,
+													ARRAY_COUNT(unArrayDestroyLength) const SteamItemInstanceID_t *pArrayDestroy, ARRAY_COUNT(unArrayDestroyLength) const uint32 *punArrayDestroyQuantity, uint32 unArrayDestroyLength) {
+	return pThis->ExchangeItems(pResultHandle, pArrayGenerate, punArrayGenerateQuantity, unArrayGenerateLength, pArrayDestroy, punArrayDestroyQuantity, unArrayDestroyLength);
+}
+
+
+// TransferItemQuantity() is intended for use with items which are "stackable" (can have
+// quantity greater than one). It can be used to split a stack into two, or to transfer
+// quantity from one stack into another stack of identical items. To split one stack into
+// two, pass k_SteamItemInstanceIDInvalid for itemIdDest and a new item will be generated.
+DLL(bool) BS_ISteamInventory_TransferItemQuantity(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest) {
+	return pThis->TransferItemQuantity(pResultHandle, itemIdSource, unQuantity, itemIdDest);
+}
+
+
+// TIMED DROPS AND PLAYTIME CREDIT
+//
+
+// Applications which use timed-drop mechanics should call SendItemDropHeartbeat() when
+// active gameplay begins, and at least once every two minutes afterwards. The backend
+// performs its own time calculations, so the precise timing of the heartbeat is not
+// critical as long as you send at least one heartbeat every two minutes. Calling the
+// function more often than that is not harmful, it will simply have no effect. Note:
+// players may be able to spoof this message by hacking their client, so you should not
+// attempt to use this as a mechanism to restrict playtime credits. It is simply meant
+// to distinguish between being in any kind of gameplay situation vs the main menu or
+// a pre-game launcher window. (If you are stingy with handing out playtime credit, it
+// will only encourage players to run bots or use mouse/kb event simulators.)
+//
+// Playtime credit accumulation can be capped on a daily or weekly basis through your
+// Steamworks configuration.
+//
+DLL(void) BS_ISteamInventory_SendItemDropHeartbeat(ISteamInventory* pThis) {
+	return pThis->SendItemDropHeartbeat();
+}
+
+// Playtime credit must be consumed and turned into item drops by your game. Only item
+// definitions which are marked as "playtime item generators" can be spawned. The call
+// will return an empty result set if there is not enough playtime credit for a drop.
+// Your game should call TriggerItemDrop at an appropriate time for the user to receive
+// new items, such as between rounds or while the player is dead. Note that players who
+// hack their clients could modify the value of "dropListDefinition", so do not use it
+// to directly control rarity. It is primarily useful during testing and development,
+// where you may wish to perform experiments with different types of drops.
+DLL(bool) BS_ISteamInventory_TriggerItemDrop(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition) {
+	return pThis->TriggerItemDrop(pResultHandle, dropListDefinition);
+}
+
+
+// IN-GAME TRADING
+//
+// TradeItems() implements limited in-game trading of items, if you prefer not to use
+// the overlay or an in-game web browser to perform Steam Trading through the website.
+// You should implement a UI where both players can see and agree to a trade, and then
+// each client should call TradeItems simultaneously (+/- 5 seconds) with matching
+// (but reversed) parameters. The result is the same as if both players performed a
+// Steam Trading transaction through the web. Each player will get an inventory result
+// confirming the removal or quantity changes of the items given away, and the new
+// item instance id numbers and quantities of the received items.
+// (Note: new item instance IDs are generated whenever an item changes ownership.)
+DLL(bool) BS_ISteamInventory_TradeItems(ISteamInventory* pThis, SteamInventoryResult_t *pResultHandle, CSteamID* steamIDTradePartner,
+												 ARRAY_COUNT(nArrayGiveLength) const SteamItemInstanceID_t *pArrayGive, ARRAY_COUNT(nArrayGiveLength) const uint32 *pArrayGiveQuantity, uint32 nArrayGiveLength,
+												 ARRAY_COUNT(nArrayGetLength) const SteamItemInstanceID_t *pArrayGet, ARRAY_COUNT(nArrayGetLength) const uint32 *pArrayGetQuantity, uint32 nArrayGetLength) {
+	return pThis->TradeItems(pResultHandle, *steamIDTradePartner, pArrayGive, pArrayGiveQuantity, nArrayGiveLength, pArrayGet, pArrayGetQuantity, nArrayGetLength);
+}
+
+
+// ITEM DEFINITIONS
+//
+// Item definitions are a mapping of "definition IDs" (integers between 1 and 1000000)
+// to a set of string properties. Some of these properties are required to display items
+// on the Steam community web site. Other properties can be defined by applications.
+// Use of these functions is optional; there is no reason to call LoadItemDefinitions
+// if your game hardcodes the numeric definition IDs (eg, purple face mask = 20, blue
+// weapon mod = 55) and does not allow for adding new item types without a client patch.
+//
+
+// LoadItemDefinitions triggers the automatic load and refresh of item definitions.
+// Every time new item definitions are available (eg, from the dynamic addition of new
+// item types while players are still in-game), a SteamInventoryDefinitionUpdate_t
+// callback will be fired.
+DLL(bool) BS_ISteamInventory_LoadItemDefinitions(ISteamInventory* pThis) {
+	return pThis->LoadItemDefinitions();
+}
+
+// GetItemDefinitionIDs returns the set of all defined item definition IDs (which are
+// defined via Steamworks configuration, and not necessarily contiguous integers).
+// If pItemDefIDs is null, the call will return true and *punItemDefIDsArraySize will
+// contain the total size necessary for a subsequent call. Otherwise, the call will
+// return false if and only if there is not enough space in the output array.
+DLL(bool) BS_ISteamInventory_GetItemDefinitionIDs(ISteamInventory* pThis,
+														   OUT_ARRAY_COUNT(punItemDefIDsArraySize, List of item definition IDs) SteamItemDef_t *pItemDefIDs,
+														   DESC(Size of array is passed in and actual size used is returned in this param) uint32 *punItemDefIDsArraySize) {
+	return pThis->GetItemDefinitionIDs(pItemDefIDs, punItemDefIDsArraySize);
+}
+
+// GetItemDefinitionProperty returns a string property from a given item definition.
+// Note that some properties (for example, "name") may be localized and will depend
+// on the current Steam language settings (see ISteamApps::GetCurrentGameLanguage).
+// Property names are always composed of ASCII letters, numbers, and/or underscores.
+// Pass a NULL pointer for pchPropertyName to get a comma - separated list of available
+// property names. 
+DLL(bool) BS_ISteamInventory_GetItemDefinitionProperty(ISteamInventory* pThis, SteamItemDef_t iDefinition, const char *pchPropertyName,
+																OUT_STRING_COUNT(punValueBufferSize) char *pchValueBuffer, uint32 *punValueBufferSize) {
+	return pThis->GetItemDefinitionProperty(iDefinition, pchPropertyName, pchValueBuffer, punValueBufferSize);
+}

Wrapper/SteamMatchmaking.cpp

@@ -0,0 +1,296 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamMatchmaking*) BS_SteamMatchmaking() {
+	return SteamMatchmaking();
+}
+
+
+// game server favorites storage
+// saves basic details about a multiplayer game server locally
+
+// returns the number of favorites servers the user has stored
+DLL(int32_t) BS_ISteamMatchmaking_GetFavoriteGameCount(ISteamMatchmaking* pThis) {
+	return pThis->GetFavoriteGameCount();
+}
+
+// returns the details of the game server
+// iGame is of range [0,GetFavoriteGameCount())
+// *pnIP, *pnConnPort are filled in the with IP:port of the game server
+// *punFlags specify whether the game server was stored as an explicit favorite or in the history of connections
+// *pRTime32LastPlayedOnServer is filled in the with the Unix time the favorite was added
+DLL(int32_t) BS_ISteamMatchmaking_GetFavoriteGame(ISteamMatchmaking* pThis, int32_t iGame,
+	AppId_t *pnAppID, uint32_t *pnIP, uint16_t *pnConnPort, uint16_t *pnQueryPort,
+	uint32_t *punFlags, uint32_t *pRTime32LastPlayedOnServer) {
+	return pThis->GetFavoriteGame(iGame, pnAppID, pnIP, pnConnPort, pnQueryPort, punFlags, pRTime32LastPlayedOnServer);
+}
+
+// adds the game server to the local list; updates the time played of the server if it already exists in the list
+DLL(int) BS_ISteamMatchmaking_AddFavoriteGame(ISteamMatchmaking* pThis, AppId_t nAppID,	uint32 nIP, uint16 nConnPort,
+	uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer) {
+	return pThis->AddFavoriteGame(nAppID, nIP, nConnPort, nQueryPort, unFlags, rTime32LastPlayedOnServer);
+}
+
+// removes the game server from the local storage; returns true if one was removed
+DLL(bool) BS_ISteamMatchmaking_RemoveFavoriteGame(ISteamMatchmaking* pThis, AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags) {
+	return pThis->RemoveFavoriteGame(nAppID, nIP, nConnPort, nQueryPort, unFlags);
+}
+
+///////
+// Game lobby functions
+
+// Get a list of relevant lobbies
+// this is an asynchronous request
+// results will be returned by LobbyMatchList_t callback & call result, with the number of lobbies found
+// this will never return lobbies that are full
+// to add more filter, the filter calls below need to be call before each and every RequestLobbyList() call
+// use the CCallResult<> object in steam_api.h to match the SteamAPICall_t call result to a function in an object, e.g.
+/*
+class CMyLobbyListManager
+{
+CCallResult<CMyLobbyListManager, LobbyMatchList_t> m_CallResultLobbyMatchList;
+void FindLobbies()
+{
+// SteamMatchmaking()->AddRequestLobbyListFilter*() functions would be called here, before RequestLobbyList()
+SteamAPICall_t hSteamAPICall = SteamMatchmaking()->RequestLobbyList();
+m_CallResultLobbyMatchList.Set( hSteamAPICall, this, &CMyLobbyListManager::OnLobbyMatchList );
+}
+
+void OnLobbyMatchList( LobbyMatchList_t *pLobbyMatchList, bool bIOFailure )
+{
+// lobby list has be retrieved from Steam back-end, use results
+}
+}
+*/
+// 
+//CALL_RESULT(LobbyMatchList_t)
+DLL(SteamAPICall_t) BS_ISteamMatchmaking_RequestLobbyList(ISteamMatchmaking* pThis) {
+	return pThis->RequestLobbyList();
+}
+// filters for lobbies
+// this needs to be called before RequestLobbyList() to take effect
+// these are cleared on each call to RequestLobbyList()
+DLL(void) BS_ISteamMatchmaking_AddRequestLobbyListStringFilter(ISteamMatchmaking* pThis, const char *pchKeyToMatch, const char *pchValueToMatch, ELobbyComparison eComparisonType) {
+	pThis->AddRequestLobbyListStringFilter(pchKeyToMatch, pchValueToMatch, eComparisonType);
+}
+// numerical comparison
+DLL(void) BS_ISteamMatchmaking_AddRequestLobbyListNumericalFilter(ISteamMatchmaking* pThis, const char *pchKeyToMatch, int nValueToMatch, ELobbyComparison eComparisonType) {
+	pThis->AddRequestLobbyListNumericalFilter(pchKeyToMatch, nValueToMatch, eComparisonType);
+}
+// returns results closest to the specified value. Multiple near filters can be added, with early filters taking precedence
+DLL(void) BS_ISteamMatchmaking_AddRequestLobbyListNearValueFilter(ISteamMatchmaking* pThis, const char *pchKeyToMatch, int nValueToBeCloseTo) {
+	pThis->AddRequestLobbyListNearValueFilter(pchKeyToMatch, nValueToBeCloseTo);
+}
+// returns only lobbies with the specified number of slots available
+DLL(void) BS_ISteamMatchmaking_AddRequestLobbyListFilterSlotsAvailable(ISteamMatchmaking* pThis, int nSlotsAvailable) {
+	pThis->AddRequestLobbyListFilterSlotsAvailable(nSlotsAvailable);
+}
+// sets the distance for which we should search for lobbies (based on users IP address to location map on the Steam backed)
+DLL(void) BS_ISteamMatchmaking_AddRequestLobbyListDistanceFilter(ISteamMatchmaking* pThis, ELobbyDistanceFilter eLobbyDistanceFilter) {
+	pThis->AddRequestLobbyListDistanceFilter(eLobbyDistanceFilter);
+}
+// sets how many results to return, the lower the count the faster it is to download the lobby results & details to the client
+DLL(void) BS_ISteamMatchmaking_AddRequestLobbyListResultCountFilter(ISteamMatchmaking* pThis, int cMaxResults) {
+	pThis->AddRequestLobbyListResultCountFilter(cMaxResults);
+}
+
+DLL(void) BS_ISteamMatchmaking_AddRequestLobbyListCompatibleMembersFilter(ISteamMatchmaking* pThis, CSteamID* steamIDLobby) {
+	pThis->AddRequestLobbyListCompatibleMembersFilter(*steamIDLobby);
+}
+
+// returns the CSteamID* of a lobby, as retrieved by a RequestLobbyList call
+// should only be called after a LobbyMatchList_t callback is received
+// iLobby is of the range [0, LobbyMatchList_t::m_nLobbiesMatching)
+// the returned CSteamID*::IsValid() will be false if iLobby is out of range
+DLL(CSteamID*) BS_ISteamMatchmaking_GetLobbyByIndex(ISteamMatchmaking* pThis, int iLobby) {
+	return &(pThis->GetLobbyByIndex(iLobby));
+}
+
+// Create a lobby on the Steam servers.
+// If private, then the lobby will not be returned by any RequestLobbyList() call; the CSteamID*
+// of the lobby will need to be communicated via game channels or via InviteUserToLobby()
+// this is an asynchronous request
+// results will be returned by LobbyCreated_t callback and call result; lobby is joined & ready to use at this point
+// a LobbyEnter_t callback will also be received (since the local user is joining their own lobby)
+//CALL_RESULT(LobbyCreated_t)
+DLL(SteamAPICall_t) BS_ISteamMatchmaking_CreateLobby(ISteamMatchmaking* pThis, ELobbyType eLobbyType, int cMaxMembers) {
+	return pThis->CreateLobby(eLobbyType, cMaxMembers);
+}
+
+// Joins an existing lobby
+// this is an asynchronous request
+// results will be returned by LobbyEnter_t callback & call result, check m_EChatRoomEnterResponse to see if was successful
+// lobby metadata is available to use immediately on this call completing
+//CALL_RESULT(LobbyEnter_t)
+DLL(SteamAPICall_t) BS_ISteamMatchmaking_JoinLobby(ISteamMatchmaking* pThis, CSteamID* steamIDLobby) {
+	return pThis->JoinLobby(*steamIDLobby);
+}
+
+// Leave a lobby; this will take effect immediately on the client side
+// other users in the lobby will be notified by a LobbyChatUpdate_t callback
+DLL(void) BS_ISteamMatchmaking_LeaveLobby(ISteamMatchmaking* pThis, CSteamID* steamIDLobby) {
+	return pThis->LeaveLobby(*steamIDLobby);
+}
+
+// Invite another user to the lobby
+// the target user will receive a LobbyInvite_t callback
+// will return true if the invite is successfully sent, whether or not the target responds
+// returns false if the local user is not connected to the Steam servers
+// if the other user clicks the join link, a GameLobbyJoinRequested_t will be posted if the user is in-game,
+// or if the game isn't running yet the game will be launched with the parameter +connect_lobby <64-bit lobby id>
+DLL(bool) BS_ISteamMatchmaking_InviteUserToLobby(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, CSteamID* steamIDInvitee) {
+	return pThis->InviteUserToLobby(*steamIDLobby, *steamIDInvitee);
+}
+
+// Lobby iteration, for viewing details of users in a lobby
+// only accessible if the lobby user is a member of the specified lobby
+// persona information for other lobby members (name, avatar, etc.) will be asynchronously received
+// and accessible via ISteamFriends interface
+
+// returns the number of users in the specified lobby
+DLL(int) BS_ISteamMatchmaking_GetNumLobbyMembers(ISteamMatchmaking* pThis, CSteamID* steamIDLobby) {
+	return pThis->GetNumLobbyMembers(*steamIDLobby);
+}
+// returns the CSteamID* of a user in the lobby
+// iMember is of range [0,GetNumLobbyMembers())
+// note that the current user must be in a lobby to retrieve CSteamID*s of other users in that lobby
+DLL(CSteamID*) BS_ISteamMatchmaking_GetLobbyMemberByIndex(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, int iMember) {
+	return &(pThis->GetLobbyMemberByIndex(*steamIDLobby, iMember));
+}
+
+// Get data associated with this lobby
+// takes a simple key, and returns the string associated with it
+// "" will be returned if no value is set, or if steamIDLobby is invalid
+DLL(const char*) BS_ISteamMatchmaking_GetLobbyData(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, const char *pchKey) {
+	return pThis->GetLobbyData(*steamIDLobby, pchKey);
+}
+// Sets a key/value pair in the lobby metadata
+// each user in the lobby will be broadcast this new value, and any new users joining will receive any existing data
+// this can be used to set lobby names, map, etc.
+// to reset a key, just set it to ""
+// other users in the lobby will receive notification of the lobby data change via a LobbyDataUpdate_t callback
+DLL(bool) BS_ISteamMatchmaking_SetLobbyData(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, const char *pchKey, const char *pchValue) {
+	return pThis->SetLobbyData(*steamIDLobby, pchKey, pchValue);
+}
+
+// returns the number of metadata keys set on the specified lobby
+DLL(int) BS_ISteamMatchmaking_GetLobbyDataCount(ISteamMatchmaking* pThis, CSteamID* steamIDLobby) {
+	return pThis->GetLobbyDataCount(*steamIDLobby);
+}
+
+// returns a lobby metadata key/values pair by index, of range [0, GetLobbyDataCount())
+DLL(bool) BS_ISteamMatchmaking_GetLobbyDataByIndex(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, int iLobbyData, char *pchKey, int cchKeyBufferSize, char *pchValue, int cchValueBufferSize) {
+	return pThis->GetLobbyDataByIndex(*steamIDLobby, iLobbyData, pchKey, cchKeyBufferSize, pchValue, cchValueBufferSize);
+}
+
+// removes a metadata key from the lobby
+DLL(bool) BS_ISteamMatchmaking_DeleteLobbyData(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, const char *pchKey) {
+	return pThis->DeleteLobbyData(*steamIDLobby, pchKey);
+}
+
+// Gets per-user metadata for someone in this lobby
+DLL(const char*) BS_ISteamMatchmaking_GetLobbyMemberData(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, CSteamID* steamIDUser, const char *pchKey) {
+	return pThis->GetLobbyMemberData(*steamIDLobby, *steamIDUser, pchKey);
+}
+// Sets per-user metadata (for the local user implicitly)
+DLL(void) BS_ISteamMatchmaking_SetLobbyMemberData(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, const char *pchKey, const char *pchValue) {
+	pThis->SetLobbyMemberData(*steamIDLobby, pchKey, pchValue);
+}
+
+// Broadcasts a chat message to the all the users in the lobby
+// users in the lobby (including the local user) will receive a LobbyChatMsg_t callback
+// returns true if the message is successfully sent
+// pvMsgBody can be binary or text data, up to 4k
+// if pvMsgBody is text, cubMsgBody should be strlen( text ) + 1, to include the null terminator
+DLL(bool) BS_ISteamMatchmaking_SendLobbyChatMsg(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, const void *pvMsgBody, int cubMsgBody) {
+	return pThis->SendLobbyChatMsg(*steamIDLobby, pvMsgBody, cubMsgBody);
+}
+// Get a chat message as specified in a LobbyChatMsg_t callback
+// iChatID is the LobbyChatMsg_t::m_iChatID value in the callback
+// *pSteamIDUser is filled in with the CSteamID* of the member
+// *pvData is filled in with the message itself
+// return value is the number of bytes written into the buffer
+DLL(int) BS_ISteamMatchmaking_GetLobbyChatEntry(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, int iChatID, OUT_STRUCT() CSteamID* *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType) {
+	return pThis->GetLobbyChatEntry(*steamIDLobby, iChatID, *pSteamIDUser, pvData, cubData, peChatEntryType);
+}
+
+// Refreshes metadata for a lobby you're not necessarily in right now
+// you never do this for lobbies you're a member of, only if your
+// this will send down all the metadata associated with a lobby
+// this is an asynchronous call
+// returns false if the local user is not connected to the Steam servers
+// results will be returned by a LobbyDataUpdate_t callback
+// if the specified lobby doesn't exist, LobbyDataUpdate_t::m_bSuccess will be set to false
+DLL(bool) BS_ISteamMatchmaking_RequestLobbyData(ISteamMatchmaking* pThis, CSteamID* steamIDLobby) {
+	return pThis->RequestLobbyData(*steamIDLobby);
+}
+
+// sets the game server associated with the lobby
+// usually at this point, the users will join the specified game server
+// either the IP/Port or the steamID of the game server has to be valid, depending on how you want the clients to be able to connect
+DLL(void) BS_ISteamMatchmaking_SetLobbyGameServer(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, CSteamID* steamIDGameServer) {
+	pThis->SetLobbyGameServer(*steamIDLobby, unGameServerIP, unGameServerPort, *steamIDGameServer);
+}
+
+// returns the details of a game server set in a lobby - returns false if there is no game server set, or that lobby doesn't exist
+DLL(bool) BS_ISteamMatchmaking_GetLobbyGameServer(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, OUT_STRUCT() CSteamID* *psteamIDGameServer) {
+	return pThis->GetLobbyGameServer(*steamIDLobby, punGameServerIP, punGameServerPort, *psteamIDGameServer);
+}
+
+// set the limit on the # of users who can join the lobby
+DLL(bool) BS_ISteamMatchmaking_SetLobbyMemberLimit(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, int cMaxMembers) {
+	return pThis->SetLobbyMemberLimit(*steamIDLobby, cMaxMembers);
+}
+
+// returns the current limit on the # of users who can join the lobby; returns 0 if no limit is defined
+DLL(int) BS_ISteamMatchmaking_GetLobbyMemberLimit(ISteamMatchmaking* pThis, CSteamID* steamIDLobby) {
+	return pThis->GetLobbyMemberLimit(*steamIDLobby);
+}
+
+// updates which type of lobby it is
+// only lobbies that are k_ELobbyTypePublic or k_ELobbyTypeInvisible, and are set to joinable, will be returned by RequestLobbyList() calls
+DLL(bool) BS_ISteamMatchmaking_SetLobbyType(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, ELobbyType eLobbyType) {
+	return pThis->SetLobbyType(*steamIDLobby, eLobbyType);
+}
+
+// sets whether or not a lobby is joinable - defaults to true for a new lobby
+// if set to false, no user can join, even if they are a friend or have been invited
+DLL(bool) BS_ISteamMatchmaking_SetLobbyJoinable(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, bool bLobbyJoinable) {
+	return pThis->SetLobbyJoinable(*steamIDLobby, bLobbyJoinable);
+}
+
+// returns the current lobby owner
+// you must be a member of the lobby to access this
+// there always one lobby owner - if the current owner leaves, another user will become the owner
+// it is possible (bur rare) to join a lobby just as the owner is leaving, thus entering a lobby with self as the owner
+DLL(CSteamID*) BS_ISteamMatchmaking_GetLobbyOwner(ISteamMatchmaking* pThis, CSteamID* steamIDLobby) {
+	return &(pThis->GetLobbyOwner(*steamIDLobby));
+}
+
+// changes who the lobby owner is
+// you must be the lobby owner for this to succeed, and steamIDNewOwner must be in the lobby
+// after completion, the local user will no longer be the owner
+DLL(bool) BS_ISteamMatchmaking_SetLobbyOwner(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, CSteamID* steamIDNewOwner) {
+	return pThis->SetLobbyOwner(*steamIDLobby, *steamIDNewOwner);
+}
+
+// link two lobbies for the purposes of checking player compatibility
+// you must be the lobby owner of both lobbies
+DLL(bool) BS_ISteamMatchmaking_SetLinkedLobby(ISteamMatchmaking* pThis, CSteamID* steamIDLobby, CSteamID* steamIDLobbyDependent) {
+	return pThis->SetLinkedLobby(*steamIDLobby, *steamIDLobbyDependent);
+}

Wrapper/SteamMatchmakingServers.cpp

@@ -0,0 +1,190 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for match making services for clients to get to game lists and details
+//-----------------------------------------------------------------------------
+DLL(ISteamMatchmakingServers*) BS_SteamMatchmakingServers() {
+	return SteamMatchmakingServers();
+}
+
+// Request a new list of servers of a particular type.  These calls each correspond to one of the EMatchMakingType values.
+// Each call allocates a new asynchronous request object.
+// Request object must be released by calling ReleaseRequest( hServerListRequest )
+DLL(HServerListRequest) BS_ISteamMatchmakingServers_RequestInternetServerList(ISteamMatchmakingServers* pThis, AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+	return pThis->RequestInternetServerList(iApp, ppchFilters, nFilters, pRequestServersResponse);
+}
+DLL(HServerListRequest) BS_ISteamMatchmakingServers_RequestLANServerList(ISteamMatchmakingServers* pThis, AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+	return pThis->RequestLANServerList(iApp, pRequestServersResponse);
+}
+DLL(HServerListRequest) BS_ISteamMatchmakingServers_RequestFriendsServerList(ISteamMatchmakingServers* pThis, AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+	return pThis->RequestFriendsServerList(iApp, ppchFilters, nFilters, pRequestServersResponse);
+}
+DLL(HServerListRequest) BS_ISteamMatchmakingServers_RequestFavoritesServerList(ISteamMatchmakingServers* pThis, AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+	return pThis->RequestFavoritesServerList(iApp, ppchFilters, nFilters, pRequestServersResponse);
+}
+DLL(HServerListRequest) BS_ISteamMatchmakingServers_RequestHistoryServerList(ISteamMatchmakingServers* pThis, AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+	return pThis->RequestHistoryServerList(iApp, ppchFilters, nFilters, pRequestServersResponse);
+}
+DLL(HServerListRequest) BS_ISteamMatchmakingServers_RequestSpectatorServerList(ISteamMatchmakingServers* pThis, AppId_t iApp, ARRAY_COUNT(nFilters) MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+	return pThis->RequestSpectatorServerList(iApp, ppchFilters, nFilters, pRequestServersResponse);
+}
+
+// Releases the asynchronous request object and cancels any pending query on it if there's a pending query in progress.
+// RefreshComplete callback is not posted when request is released.
+DLL(void) BS_ISteamMatchmakingServers_ReleaseRequest(ISteamMatchmakingServers* pThis, HServerListRequest hServerListRequest) {
+	pThis->ReleaseRequest(hServerListRequest);
+}
+
+/* the filter operation codes that go in the key part of MatchMakingKeyValuePair_t should be one of these:
+
+"map"
+- Server passes the filter if the server is playing the specified map.
+"gamedataand"
+- Server passes the filter if the server's game data (ISteamGameServer::SetGameData) contains all of the
+specified strings.  The value field is a comma-delimited list of strings to match.
+"gamedataor"
+- Server passes the filter if the server's game data (ISteamGameServer::SetGameData) contains at least one of the
+specified strings.  The value field is a comma-delimited list of strings to match.
+"gamedatanor"
+- Server passes the filter if the server's game data (ISteamGameServer::SetGameData) does not contain any
+of the specified strings.  The value field is a comma-delimited list of strings to check.
+"gametagsand"
+- Server passes the filter if the server's game tags (ISteamGameServer::SetGameTags) contains all
+of the specified strings.  The value field is a comma-delimited list of strings to check.
+"gametagsnor"
+- Server passes the filter if the server's game tags (ISteamGameServer::SetGameTags) does not contain any
+of the specified strings.  The value field is a comma-delimited list of strings to check.
+"and" (x1 && x2 && ... && xn)
+"or" (x1 || x2 || ... || xn)
+"nand" !(x1 && x2 && ... && xn)
+"nor" !(x1 || x2 || ... || xn)
+- Performs Boolean operation on the following filters.  The operand to this filter specifies
+the "size" of the Boolean inputs to the operation, in Key/value pairs.  (The keyvalue
+pairs must immediately follow, i.e. this is a prefix logical operator notation.)
+In the simplest case where Boolean expressions are not nested, this is simply
+the number of operands.
+
+For example, to match servers on a particular map or with a particular tag, would would
+use these filters.
+
+( server.map == "cp_dustbowl" || server.gametags.contains("payload") )
+"or", "2"
+"map", "cp_dustbowl"
+"gametagsand", "payload"
+
+If logical inputs are nested, then the operand specifies the size of the entire
+"length" of its operands, not the number of immediate children.
+
+( server.map == "cp_dustbowl" || ( server.gametags.contains("payload") && !server.gametags.contains("payloadrace") ) )
+"or", "4"
+"map", "cp_dustbowl"
+"and", "2"
+"gametagsand", "payload"
+"gametagsnor", "payloadrace"
+
+Unary NOT can be achieved using either "nand" or "nor" with a single operand.
+
+"addr"
+- Server passes the filter if the server's query address matches the specified IP or IP:port.
+"gameaddr"
+- Server passes the filter if the server's game address matches the specified IP or IP:port.
+
+The following filter operations ignore the "value" part of MatchMakingKeyValuePair_t
+
+"dedicated"
+- Server passes the filter if it passed true to SetDedicatedServer.
+"secure"
+- Server passes the filter if the server is VAC-enabled.
+"notfull"
+- Server passes the filter if the player count is less than the reported max player count.
+"hasplayers"
+- Server passes the filter if the player count is greater than zero.
+"noplayers"
+- Server passes the filter if it doesn't have any players.
+"linux"
+- Server passes the filter if it's a linux server
+*/
+
+// Get details on a given server in the list, you can get the valid range of index
+// values by calling GetServerCount().  You will also receive index values in 
+// ISteamMatchmakingServerListResponse::ServerResponded() callbacks
+DLL(gameserveritem_t*) BS_ISteamMatchmakingServers_GetServerDetails(ISteamMatchmakingServers* pThis, HServerListRequest hRequest, int iServer) {
+	return pThis->GetServerDetails(hRequest, iServer);
+}
+
+// Cancel an request which is operation on the given list type.  You should call this to cancel
+// any in-progress requests before destructing a callback object that may have been passed 
+// to one of the above list request calls.  Not doing so may result in a crash when a callback
+// occurs on the destructed object.
+// Canceling a query does not release the allocated request handle.
+// The request handle must be released using ReleaseRequest( hRequest )
+DLL(void) BS_ISteamMatchmakingServers_CancelQuery(ISteamMatchmakingServers* pThis, HServerListRequest hRequest) {
+	pThis->CancelQuery(hRequest);
+}
+
+// Ping every server in your list again but don't update the list of servers
+// Query callback installed when the server list was requested will be used
+// again to post notifications and RefreshComplete, so the callback must remain
+// valid until another RefreshComplete is called on it or the request
+// is released with ReleaseRequest( hRequest )
+DLL(void) BS_ISteamMatchmakingServers_RefreshQuery(ISteamMatchmakingServers* pThis, HServerListRequest hRequest) {
+	pThis->RefreshQuery(hRequest);
+}
+
+// Returns true if the list is currently refreshing its server list
+DLL(bool) BS_ISteamMatchmakingServers_IsRefreshing(ISteamMatchmakingServers* pThis, HServerListRequest hRequest) {
+	return pThis->IsRefreshing(hRequest);
+}
+
+// How many servers in the given list, GetServerDetails above takes 0... GetServerCount() - 1
+DLL(int) BS_ISteamMatchmakingServers_GetServerCount(ISteamMatchmakingServers* pThis, HServerListRequest hRequest) {
+	return pThis->GetServerCount(hRequest);
+}
+
+// Refresh a single server inside of a query (rather than all the servers )
+DLL(void) BS_ISteamMatchmakingServers_RefreshServer(ISteamMatchmakingServers* pThis, HServerListRequest hRequest, int iServer) {
+	pThis->RefreshServer(hRequest, iServer);
+}
+
+
+//-----------------------------------------------------------------------------
+// Queries to individual servers directly via IP/Port
+//-----------------------------------------------------------------------------
+
+// Request updated ping time and other details from a single server
+DLL(HServerQuery) BS_ISteamMatchmakingServers_PingServer(ISteamMatchmakingServers* pThis, uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse) {
+	return pThis->PingServer(unIP, usPort, pRequestServersResponse);
+}
+
+// Request the list of players currently playing on a server
+DLL(HServerQuery) BS_ISteamMatchmakingServers_PlayerDetails(ISteamMatchmakingServers* pThis, uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse) {
+	return pThis->PlayerDetails(unIP, usPort, pRequestServersResponse);
+}
+
+// Request the list of rules that the server is running (See ISteamGameServer::SetKeyValue() to set the rules server side)
+DLL(HServerQuery) BS_ISteamMatchmakingServers_ServerRules(ISteamMatchmakingServers* pThis, uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse) {
+	return pThis->ServerRules(unIP, usPort, pRequestServersResponse);
+}
+
+// Cancel an outstanding Ping/Players/Rules query from above.  You should call this to cancel
+// any in-progress requests before destructing a callback object that may have been passed 
+// to one of the above calls to avoid crashing when callbacks occur.
+DLL(void) BS_ISteamMatchmakingServers_CancelServerQuery(ISteamMatchmakingServers* pThis, HServerQuery hServerQuery) {
+	pThis->CancelServerQuery(hServerQuery);
+}

Wrapper/SteamMusic.cpp

@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamMusic*) BS_SteamMusic() {
+	return SteamMusic();
+}
+
+#pragma message("SteamMusic is not ported yet. TODO!")

Wrapper/SteamMusicRemote.cpp

@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamMusicRemote*) BS_SteamMusicRemote() {
+	return SteamMusicRemote();
+}
+
+#pragma message("SteamMusicRemote is not ported yet. TODO!")

Wrapper/SteamNetworking.cpp

@@ -0,0 +1,98 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for making connections and sending data between clients,
+//			traversing NAT's where possible
+//-----------------------------------------------------------------------------
+DLL(ISteamNetworking*) BS_SteamNetworking() {
+	return SteamNetworking();
+}
+
+DLL(ISteamNetworking*) BS_SteamGameServerNetworking() {
+	return SteamGameServerNetworking();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// Session-less connection functions
+//    automatically establishes NAT-traversing or Relay server connections
+
+// Sends a P2P packet to the specified user
+// UDP-like, unreliable and a max packet size of 1200 bytes
+// the first packet send may be delayed as the NAT-traversal code runs
+// if we can't get through to the user, an error will be posted via the callback P2PSessionConnectFail_t
+// see EP2PSend enum above for the descriptions of the different ways of sending packets
+//
+// nChannel is a routing number you can use to help route message to different systems 	- you'll have to call ReadP2PPacket() 
+// with the same channel number in order to retrieve the data on the other end
+// using different channels to talk to the same user will still use the same underlying p2p connection, saving on resources
+DLL(uint32_t) BS_ISteamNetworking_SendP2PPacket(ISteamNetworking* pThis, CSteamID* pSteamIDRemote, const void* pubData, uint32_t cubData, EP2PSend eP2PSendType, uint32_t nChannel) {
+	return pThis->SendP2PPacket(*pSteamIDRemote, pubData, cubData, eP2PSendType, nChannel);
+}
+
+// returns true if any data is available for read, and the amount of data that will need to be read
+DLL(uint32_t) BS_ISteamNetworking_IsP2PPacketAvailable(ISteamNetworking* pThis, uint32_t* pcubMsgSize, uint32_t nChannel) {
+	return pThis->IsP2PPacketAvailable(pcubMsgSize, nChannel);
+}
+
+// reads in a packet that has been sent from another user via SendP2PPacket()
+// returns the size of the message and the steamID of the user who sent it in the last two parameters
+// if the buffer passed in is too small, the message will be truncated
+// this call is not blocking, and will return false if no data is available
+DLL(uint32_t) BS_ISteamNetworking_ReadP2PPacket(ISteamNetworking* pThis, void** pubDest, uint32_t cubDest, uint32_t* pcubMsgSize, CSteamID* pSteamIDRemote, uint32_t nChannel) {
+	return pThis->ReadP2PPacket(*pubDest, cubDest, pcubMsgSize, static_cast<CSteamID*>(pSteamIDRemote), nChannel);
+}
+
+// AcceptP2PSessionWithUser() should only be called in response to a P2PSessionRequest_t callback
+// P2PSessionRequest_t will be posted if another user tries to send you a packet that you haven't talked to yet
+// if you don't want to talk to the user, just ignore the request
+// if the user continues to send you packets, another P2PSessionRequest_t will be posted periodically
+// this may be called multiple times for a single user
+// (if you've called SendP2PPacket() on the other user, this implicitly accepts the session request)
+DLL(uint32_t) BS_ISteamNetworking_AcceptP2PSessionWithUser(ISteamNetworking* pThis, CSteamID* pSteamIDRemote) {
+	return pThis->AcceptP2PSessionWithUser(*pSteamIDRemote);
+}
+
+// call CloseP2PSessionWithUser() when you're done talking to a user, will free up resources under-the-hood
+// if the remote user tries to send data to you again, another P2PSessionRequest_t callback will be posted
+DLL(uint32_t) BS_ISteamNetworking_CloseP2PSessionWithUser(ISteamNetworking* pThis, CSteamID* pSteamIDRemote) {
+	return pThis->CloseP2PSessionWithUser(*pSteamIDRemote);
+}
+
+// call CloseP2PChannelWithUser() when you're done talking to a user on a specific channel. Once all channels
+// open channels to a user have been closed, the open session to the user will be closed and new data from this
+// user will trigger a P2PSessionRequest_t callback
+DLL(uint32_t) BS_ISteamNetworking_CloseP2PChannelWithUser(ISteamNetworking* pThis, CSteamID* pSteamIDRemote, uint32_t nChannel) {
+	return pThis->CloseP2PChannelWithUser(*pSteamIDRemote, nChannel);
+}
+
+// fills out P2PSessionState_t structure with details about the underlying connection to the user
+// should only needed for debugging purposes
+// returns false if no connection exists to the specified user
+DLL(uint32_t) BS_ISteamNetworking_GetP2PSessionState(ISteamNetworking* pThis, CSteamID* pSteamIDRemote, P2PSessionState_t* pConnectionState) {
+	return pThis->GetP2PSessionState(*pSteamIDRemote, pConnectionState);
+}
+
+// Allow P2P connections to fall back to being relayed through the Steam servers if a direct connection
+// or NAT-traversal cannot be established. Only applies to connections created after setting this value,
+// or to existing connections that need to automatically reconnect after this value is set.
+//
+// P2P packet relay is allowed by default
+DLL(uint32_t) BS_ISteamNetworking_AllowP2PPacketRelay(ISteamNetworking* pThis, uint32_t bAllow) {
+	return pThis->AllowP2PPacketRelay(!!bAllow);
+}

Wrapper/SteamRemoteStorage.cpp

@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamRemoteStorage*) BS_SteamRemoteStorage() {
+	return SteamRemoteStorage();
+}
+
+#pragma message("SteamRemoteStorage is not ported yet. TODO!")

Wrapper/SteamScreenshots.cpp

@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamScreenshots*) BS_SteamScreenshots() {
+	return SteamScreenshots();
+}
+
+#pragma message("SteamScreenshots is not ported yet. TODO!")

Wrapper/SteamUGC.cpp

@@ -0,0 +1,28 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamUGC*) BS_SteamUGC() {
+	return SteamUGC();
+}
+
+DLL(ISteamUGC*) BS_SteamGameServerUGC() {
+	return SteamGameServerUGC();
+}
+
+#pragma message("SteamUGC is not ported yet. TODO!")
+

Wrapper/SteamUnifiedMessages.cpp

@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamUnifiedMessages*) BS_SteamUnifiedMessages() {
+	return SteamUnifiedMessages();
+}
+
+#pragma message("SteamUnifiedMessages is not ported yet. TODO!")

Wrapper/SteamUser.cpp

@@ -14,129 +14,201 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
-DLL_EXPORT HSteamUser DLL_CALL BS_User_GetHSteamUser( ISteamUser* lpSteamUser ) {
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing and manipulating a steam account
+//			associated with one client instance
+//-----------------------------------------------------------------------------
+DLL(ISteamUser*) BS_SteamUser() {
+	return SteamUser();
+}
+
+// returns the HSteamUser this interface represents
+// this is only used internally by the API, and by a few select interfaces that support multi-user
+DLL(HSteamUser) BS_ISteamUser_GetHSteamUser( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetHSteamUser( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetHSteamUser=_BS_User_GetHSteamUser@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_User_IsLoggedOn( ISteamUser* lpSteamUser ) {
+// returns true if the Steam client current has a live connection to the Steam servers. 
+// If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
+// The Steam client will automatically be trying to recreate the connection as often as possible.
+DLL(uint32_t) BS_ISteamUser_IsLoggedOn( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->BLoggedOn( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_IsLoggedOn=_BS_User_IsLoggedOn@4")
 
-DLL_EXPORT CSteamID* DLL_CALL BS_User_GetSteamID( ISteamUser* lpSteamUser ) {
+// returns the CSteamID of the account currently logged into the Steam client
+// a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
+DLL(CSteamID*) BS_ISteamUser_GetSteamID( ISteamUser* lpSteamUser ) {
 	return &(lpSteamUser->GetSteamID( ));
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetSteamID=_BS_User_GetSteamID@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_User_InitiateGameConnection( ISteamUser* lpSteamUser, void* pAuthBlob, uint32_t cbMaxAuthBlob, CSteamID* SteamIDGameServer, uint32_t unIPServer, uint16_t usPortServer, uint32_t bSecure ) {
+// Multiplayer Authentication functions
+
+// InitiateGameConnection() starts the state machine for authenticating the game client with the game server
+// It is the client portion of a three-way handshake between the client, the game server, and the steam servers
+//
+// Parameters:
+// void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token.
+// int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes.
+// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
+// CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( <appID> )
+// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
+// bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running)
+//
+// return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed
+// The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process.
+DLL(uint32_t) BS_ISteamUser_InitiateGameConnection( ISteamUser* lpSteamUser, void* pAuthBlob, uint32_t cbMaxAuthBlob, CSteamID* SteamIDGameServer, uint32_t unIPServer, uint16_t usPortServer, uint32_t bSecure ) {
 	return lpSteamUser->InitiateGameConnection( pAuthBlob, cbMaxAuthBlob, *SteamIDGameServer, unIPServer, usPortServer, bSecure != 0 );
 }
-#pragma comment(linker, "/EXPORT:BS_User_InitiateGameConnection=_BS_User_InitiateGameConnection@28")
 
-DLL_EXPORT void DLL_CALL BS_User_TerminateGameConnection( ISteamUser* lpSteamUser, uint32_t unIPServer, uint16_t usPortServer ) {
+// notify of disconnect
+// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
+DLL(void) BS_ISteamUser_TerminateGameConnection( ISteamUser* lpSteamUser, uint32_t unIPServer, uint16_t usPortServer ) {
 	lpSteamUser->TerminateGameConnection( unIPServer, usPortServer );
 }
-#pragma comment(linker, "/EXPORT:BS_User_TerminateGameConnection=_BS_User_TerminateGameConnection@12")
 
-DLL_EXPORT void DLL_CALL BS_User_TrackAppUsageEvent( ISteamUser* lpSteamUser, CGameID* gameId, uint32_t eAppUsageEvent, const char* pchExtraInfo ) {
+// Legacy functions
+
+// used by only a few games to track usage events
+DLL(void) BS_ISteamUser_TrackAppUsageEvent( ISteamUser* lpSteamUser, CGameID* gameId, uint32_t eAppUsageEvent, const char* pchExtraInfo ) {
 	lpSteamUser->TrackAppUsageEvent( *gameId, eAppUsageEvent, pchExtraInfo );
 }
-#pragma comment(linker, "/EXPORT:BS_User_TrackAppUsageEvent=_BS_User_TrackAppUsageEvent@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_User_GetUserDataFolder( ISteamUser* lpSteamUser, char* pchBuffer, uint32_t cubBuffer ) {
+// get the local storage folder for current Steam account to write application data, e.g. save games, configs etc.
+// this will usually be something like "C:\Progam Files\Steam\userdata\<SteamID>\<AppID>\local"
+DLL(uint32_t) BS_ISteamUser_GetUserDataFolder( ISteamUser* lpSteamUser, char* pchBuffer, uint32_t cubBuffer ) {
 	return lpSteamUser->GetUserDataFolder( pchBuffer, cubBuffer );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetUserDataFolder=_BS_User_GetUserDataFolder@12")
 
-DLL_EXPORT void DLL_CALL BS_User_StartVoiceRecording( ISteamUser* lpSteamUser ) {
+// Starts voice recording. Once started, use GetVoice() to get the data
+DLL(void) BS_ISteamUser_StartVoiceRecording( ISteamUser* lpSteamUser ) {
 	lpSteamUser->StartVoiceRecording( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_StartVoiceRecording=_BS_User_StartVoiceRecording@4")
 
-DLL_EXPORT void DLL_CALL BS_User_StopVoiceRecording( ISteamUser* lpSteamUser ) {
+// Stops voice recording. Because people often release push-to-talk keys early, the system will keep recording for
+// a little bit after this function is called. GetVoice() should continue to be called until it returns
+// k_eVoiceResultNotRecording
+DLL(void) BS_ISteamUser_StopVoiceRecording( ISteamUser* lpSteamUser ) {
 	lpSteamUser->StopVoiceRecording( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_StopVoiceRecording=_BS_User_StopVoiceRecording@4")
 
-DLL_EXPORT EVoiceResult DLL_CALL BS_User_GetAvailableVoice( ISteamUser* lpSteamUser, uint32_t* pcbCompressed, uint32_t* pcbUncompressed, uint32_t nUncompressedVoiceDesiredSampleRate ) {
+// Determine the amount of captured audio data that is available in bytes.
+// This provides both the compressed and uncompressed data. Please note that the uncompressed
+// data is not the raw feed from the microphone: data may only be available if audible 
+// levels of speech are detected.
+// nUncompressedVoiceDesiredSampleRate is necessary to know the number of bytes to return in pcbUncompressed - can be set to 0 if you don't need uncompressed (the usual case)
+// If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nUncompressedVoiceDesiredSampleRate
+DLL(EVoiceResult) BS_ISteamUser_GetAvailableVoice( ISteamUser* lpSteamUser, uint32_t* pcbCompressed, uint32_t* pcbUncompressed, uint32_t nUncompressedVoiceDesiredSampleRate ) {
 	return lpSteamUser->GetAvailableVoice( pcbCompressed, pcbUncompressed, nUncompressedVoiceDesiredSampleRate );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetAvailableVoice=_BS_User_GetAvailableVoice@16")
 
-DLL_EXPORT EVoiceResult DLL_CALL BS_User_GetVoice( ISteamUser* lpSteamUser, uint32_t bWantCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t bWantUncompressed, void *pUncompressedDestBuffer, uint32_t cbUncompressedDestBufferSize, uint32_t *nUncompressBytesWritten, uint32_t nUncompressedVoiceDesiredSampleRate ) {
+// Gets the latest voice data from the microphone. Compressed data is an arbitrary format, and is meant to be handed back to 
+// DecompressVoice() for playback later as a binary blob. Uncompressed data is 16-bit, signed integer, 11025Hz PCM format.
+// Please note that the uncompressed data is not the raw feed from the microphone: data may only be available if audible 
+// levels of speech are detected, and may have passed through denoising filters, etc.
+// This function should be called as often as possible once recording has started; once per frame at least.
+// nBytesWritten is set to the number of bytes written to pDestBuffer. 
+// nUncompressedBytesWritten is set to the number of bytes written to pUncompressedDestBuffer. 
+// You must grab both compressed and uncompressed here at the same time, if you want both.
+// Matching data that is not read during this call will be thrown away.
+// GetAvailableVoice() can be used to determine how much data is actually available.
+// If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nUncompressedVoiceDesiredSampleRate
+DLL(EVoiceResult) BS_ISteamUser_GetVoice( ISteamUser* lpSteamUser, uint32_t bWantCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t bWantUncompressed, void *pUncompressedDestBuffer, uint32_t cbUncompressedDestBufferSize, uint32_t *nUncompressBytesWritten, uint32_t nUncompressedVoiceDesiredSampleRate ) {
 	return lpSteamUser->GetVoice( bWantCompressed != 0, pDestBuffer, cbDestBufferSize, nBytesWritten, bWantUncompressed != 0, pUncompressedDestBuffer, cbUncompressedDestBufferSize, nUncompressBytesWritten, nUncompressedVoiceDesiredSampleRate );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetVoice=_BS_User_GetVoice@40")
 
-DLL_EXPORT EVoiceResult DLL_CALL BS_User_DecompressVoice( ISteamUser* lpSteamUser, const void *pCompressed, uint32_t cbCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t nDesiredSampleRate ) {
+// Decompresses a chunk of compressed data produced by GetVoice().
+// nBytesWritten is set to the number of bytes written to pDestBuffer unless the return value is k_EVoiceResultBufferTooSmall.
+// In that case, nBytesWritten is set to the size of the buffer required to decompress the given
+// data. The suggested buffer size for the destination buffer is 22 kilobytes.
+// The output format of the data is 16-bit signed at the requested samples per second.
+// If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nDesiredSampleRate
+DLL(EVoiceResult) BS_ISteamUser_DecompressVoice( ISteamUser* lpSteamUser, const void *pCompressed, uint32_t cbCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t nDesiredSampleRate ) {
 	return lpSteamUser->DecompressVoice( pCompressed, cbCompressed, pDestBuffer, cbDestBufferSize, nBytesWritten, nDesiredSampleRate );
 }
-#pragma comment(linker, "/EXPORT:BS_User_DecompressVoice=_BS_User_DecompressVoice@28")
 
-DLL_EXPORT uint32_t DLL_CALL BS_User_GetVoiceOptimalSampleRate( ISteamUser* lpSteamUser ) {
+// This returns the frequency of the voice data as it's stored internally; calling DecompressVoice() with this size will yield the best results
+DLL(uint32_t) BS_ISteamUser_GetVoiceOptimalSampleRate( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetVoiceOptimalSampleRate( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetVoiceOptimalSampleRate=_BS_User_GetVoiceOptimalSampleRate@4")
 
-DLL_EXPORT HAuthTicket DLL_CALL BS_User_GetAuthSessionTicket( ISteamUser* lpSteamUser, void* pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) {
+// Retrieve ticket to be sent to the entity who wishes to authenticate you. 
+// pcbTicket retrieves the length of the actual ticket.
+DLL(HAuthTicket) BS_ISteamUser_GetAuthSessionTicket( ISteamUser* lpSteamUser, void* pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) {
 	return lpSteamUser->GetAuthSessionTicket( pTicket, cbMaxTicket, pcbTicket );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetAuthSessionTicket=_BS_User_GetAuthSessionTicket@16")
 
-DLL_EXPORT EBeginAuthSessionResult DLL_CALL BS_User_BeginAuthSession( ISteamUser* lpSteamUser, const void *pAuthTicket, uint32_t cbAuthTicket, CSteamID* steamID ) {
+// Authenticate ticket from entity steamID to be sure it is valid and isnt reused
+// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
+DLL(EBeginAuthSessionResult) BS_ISteamUser_BeginAuthSession( ISteamUser* lpSteamUser, const void* pAuthTicket, uint32_t cbAuthTicket, CSteamID* steamID ) {
 	return lpSteamUser->BeginAuthSession( pAuthTicket, cbAuthTicket, *steamID );
 }
-#pragma comment(linker, "/EXPORT:BS_User_BeginAuthSession=_BS_User_BeginAuthSession@16")
 
-DLL_EXPORT void DLL_CALL BS_User_EndAuthSession( ISteamUser* lpSteamUser, CSteamID* steamID ) {
+// Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
+DLL(void) BS_ISteamUser_EndAuthSession( ISteamUser* lpSteamUser, CSteamID* steamID ) {
 	lpSteamUser->EndAuthSession( *steamID );
 }
-#pragma comment(linker, "/EXPORT:BS_User_EndAuthSession=_BS_User_EndAuthSession@8")
 
-DLL_EXPORT void DLL_CALL BS_User_CancelAuthTicket( ISteamUser* lpSteamUser, HAuthTicket hAuthTicket ) {
+// Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
+DLL(void) BS_ISteamUser_CancelAuthTicket( ISteamUser* lpSteamUser, HAuthTicket hAuthTicket ) {
 	lpSteamUser->CancelAuthTicket( hAuthTicket );
 }
-#pragma comment(linker, "/EXPORT:BS_User_EndAuthSession=_BS_User_EndAuthSession@8")
 
-DLL_EXPORT EUserHasLicenseForAppResult DLL_CALL BS_User_UserHasLicenseForApp( ISteamUser* lpSteamUser, CSteamID* steamID, AppId_t appID ) {
+// After receiving a user's authentication data, and passing it to BeginAuthSession, use this function
+// to determine if the user owns downloadable content specified by the provided AppID.
+DLL(EUserHasLicenseForAppResult) BS_ISteamUser_UserHasLicenseForApp( ISteamUser* lpSteamUser, CSteamID* steamID, AppId_t appID ) {
 	return lpSteamUser->UserHasLicenseForApp( *steamID, appID );
 }
-#pragma comment(linker, "/EXPORT:BS_User_UserHasLicenseForApp=_BS_User_UserHasLicenseForApp@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_User_IsBehindNAT( ISteamUser* lpSteamUser ) {
+// returns true if this users looks like they are behind a NAT device. Only valid once the user has connected to steam 
+// (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT.
+DLL(uint32_t) BS_ISteamUser_IsBehindNAT( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->BIsBehindNAT( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_IsBehindNAT=_BS_User_IsBehindNAT@4")
 
-DLL_EXPORT void DLL_CALL BS_User_AdvertiseGame( ISteamUser* lpSteamUser, CSteamID* steamIDGameServer, uint32_t unIPServer, uint16_t usPortServer ) {
+// set data to be replicated to friends so that they can join your game
+// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
+// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
+DLL(void) BS_ISteamUser_AdvertiseGame( ISteamUser* lpSteamUser, CSteamID* steamIDGameServer, uint32_t unIPServer, uint16_t usPortServer ) {
 	lpSteamUser->AdvertiseGame( *steamIDGameServer, unIPServer, usPortServer );
 }
-#pragma comment(linker, "/EXPORT:BS_User_AdvertiseGame=_BS_User_AdvertiseGame@16")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_User_RequestEncryptedAppTicket( ISteamUser* lpSteamUser, void* pDataToInclude, uint32_t cbDataToInclude ) {
+// Requests a ticket encrypted with an app specific shared key
+// pDataToInclude, cbDataToInclude will be encrypted into the ticket
+// ( This is asynchronous, you must wait for the ticket to be completed by the server )
+//CALL_RESULT( EncryptedAppTicketResponse_t )
+DLL(SteamAPICall_t*) BS_ISteamUser_RequestEncryptedAppTicket( ISteamUser* lpSteamUser, void* pDataToInclude, uint32_t cbDataToInclude ) {
 	return new uint64_t(lpSteamUser->RequestEncryptedAppTicket( pDataToInclude, cbDataToInclude ));
 }
-#pragma comment(linker, "/EXPORT:BS_User_RequestEncryptedAppTicket=_BS_User_RequestEncryptedAppTicket@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_User_GetEncryptedAppTicket( ISteamUser* lpSteamUser, void *pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) {
+// retrieve a finished ticket
+DLL(uint32_t) BS_ISteamUser_GetEncryptedAppTicket( ISteamUser* lpSteamUser, void *pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) {
 	return lpSteamUser->GetEncryptedAppTicket( pTicket, cbMaxTicket, pcbTicket );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetEncryptedAppTicket=_BS_User_GetEncryptedAppTicket@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_User_GetGameBadgeLevel( ISteamUser* lpSteamUser, uint32_t nSeries, uint32_t bFoil ) {
+// Trading Card badges data access
+// if you only have one set of cards, the series will be 1
+// the user has can have two different badges for a series; the regular (max level 5) and the foil (max level 1)
+DLL(uint32_t) BS_ISteamUser_GetGameBadgeLevel( ISteamUser* lpSteamUser, uint32_t nSeries, uint32_t bFoil ) {
 	return lpSteamUser->GetGameBadgeLevel( nSeries, bFoil != 0 );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetGameBadgeLevel=_BS_User_GetGameBadgeLevel@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_User_GetPlayerSteamLevel( ISteamUser* lpSteamUser ) {
+// gets the Steam Level of the user, as shown on their profile
+DLL(uint32_t) BS_ISteamUser_GetPlayerSteamLevel( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetPlayerSteamLevel( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetPlayerSteamLevel=_BS_User_GetPlayerSteamLevel@4")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_User_RequestStoreAuthURL( ISteamUser* lpSteamUser, const char* pchRedirectURL ) {
+// Requests a URL which authenticates an in-game browser for store check-out,
+// and then redirects to the specified URL. As long as the in-game browser
+// accepts and handles session cookies, Steam microtransaction checkout pages
+// will automatically recognize the user instead of presenting a login page.
+// The result of this API call will be a StoreAuthURLResponse_t callback.
+// NOTE: The URL has a very short lifetime to prevent history-snooping attacks,
+// so you should only call this API when you are about to launch the browser,
+// or else immediately navigate to the result URL using a hidden browser window.
+// NOTE 2: The resulting authorization cookie has an expiration time of one day,
+// so it would be a good idea to request and visit a new auth URL every 12 hours.
+DLL(SteamAPICall_t*) BS_ISteamUser_RequestStoreAuthURL( ISteamUser* lpSteamUser, const char* pchRedirectURL ) {
 	return new uint64_t(lpSteamUser->RequestStoreAuthURL( pchRedirectURL ));
 }
-#pragma comment(linker, "/EXPORT:BS_User_RequestStoreAuthURL=_BS_User_RequestStoreAuthURL@8")

Wrapper/SteamUserStats.cpp

@@ -14,219 +14,295 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_RequestCurrentStats( ISteamUserStats* lpSteamUserStats ) {
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing stats, achievements, and leaderboard information
+//-----------------------------------------------------------------------------
+DLL(ISteamUserStats*) BS_SteamUserStats() {
+	return SteamUserStats();
+}
+
+// Ask the server to send down this user's data and achievements for this game
+//CALL_BACK(UserStatsReceived_t)
+DLL(uint32_t) BS_ISteamUserStats_RequestCurrentStats( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->RequestCurrentStats( );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_RequestCurrentStats=_BS_UserStats_RequestCurrentStats@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t* pData ) {
+// Data accessors
+DLL(uint32_t) BS_ISteamUserStats_GetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t* pData ) {
 	return lpSteamUserStats->GetStat( pchName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetStat=_BS_UserStats_GetStat@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t* pData ) {
+DLL(uint32_t) BS_ISteamUserStats_GetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t* pData ) {
 	return lpSteamUserStats->GetStat( pchName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetStatF=_BS_UserStats_GetStatF@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t pData ) {
+// Set / update data
+DLL(uint32_t) BS_ISteamUserStats_SetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t pData ) {
 	return lpSteamUserStats->SetStat( pchName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_SetStat=_BS_UserStats_SetStat@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t pData ) {
+DLL(uint32_t) BS_ISteamUserStats_SetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t pData ) {
 	return lpSteamUserStats->SetStat( pchName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_SetStatF=_BS_UserStats_SetStatF@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_UpdateAvgRateStat( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t flCountThisSession, double_t* dSessionLength ) {
+DLL(uint32_t) BS_ISteamUserStats_UpdateAvgRateStat( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t flCountThisSession, double_t* dSessionLength ) {
 	return lpSteamUserStats->UpdateAvgRateStat( pchName, flCountThisSession, *dSessionLength );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_UpdateAvgRateStat=_BS_UserStats_UpdateAvgRateStat@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved ) {
+// Achievement flag accessors
+DLL(uint32_t) BS_ISteamUserStats_GetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved ) {
 	return lpSteamUserStats->GetAchievement( pchName, (bool*)pbAchieved );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievement=_BS_UserStats_GetAchievement@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
+DLL(uint32_t) BS_ISteamUserStats_SetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->SetAchievement( pchName );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_SetAchievement=_BS_UserStats_SetAchievement@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_ClearAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
+DLL(uint32_t) BS_ISteamUserStats_ClearAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->ClearAchievement( pchName );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_ClearAchievement=_BS_UserStats_ClearAchievement@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) {
+// Get the achievement status, and the time it was unlocked if unlocked.
+// If the return value is true, but the unlock time is zero, that means it was unlocked before Steam 
+// began tracking achievement unlock times (December 2009). Time is seconds since January 1, 1970.
+DLL(uint32_t) BS_ISteamUserStats_GetAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) {
 	return lpSteamUserStats->GetAchievementAndUnlockTime( pchName, (bool*)pbAchieved, punUnlockTime );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementAndUnlockTime=_BS_UserStats_GetAchievementAndUnlockTime@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_StoreStats( ISteamUserStats* lpSteamUserStats ) {
+// Store the current data on the server, will get a callback when set
+// And one callback for every new achievement
+//
+// If the callback has a result of k_EResultInvalidParam, one or more stats 
+// uploaded has been rejected, either because they broke constraints
+// or were out of date. In this case the server sends back updated values.
+// The stats should be re-iterated to keep in sync.
+DLL(uint32_t) BS_ISteamUserStats_StoreStats( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->StoreStats( );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_StoreStats=_BS_UserStats_StoreStats@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementIcon( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
+// Achievement / GroupAchievement metadata
+
+// Gets the icon of the achievement, which is a handle to be used in ISteamUtils::GetImageRGBA(), or 0 if none set. 
+// A return value of 0 may indicate we are still fetching data, and you can wait for the UserAchievementIconFetched_t callback
+// which will notify you when the bits are ready. If the callback still returns zero, then there is no image set for the
+// specified achievement.
+DLL(uint32_t) BS_ISteamUserStats_GetAchievementIcon( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->GetAchievementIcon( pchName );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementIcon=_BS_UserStats_GetAchievementIcon@8")
 
-DLL_EXPORT const char* DLL_CALL BS_UserStats_GetAchievementDisplayAttribute( ISteamUserStats* lpSteamUserStats, const char* pchName, const char* pchKey ) {
+// Get general attributes for an achievement. Accepts the following keys:
+// - "name" and "desc" for retrieving the localized achievement name and description (returned in UTF8)
+// - "hidden" for retrieving if an achievement is hidden (returns "0" when not hidden, "1" when hidden)
+DLL(const char*) BS_ISteamUserStats_GetAchievementDisplayAttribute( ISteamUserStats* lpSteamUserStats, const char* pchName, const char* pchKey ) {
 	return lpSteamUserStats->GetAchievementDisplayAttribute( pchName, pchKey );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementDisplayAttribute=_BS_UserStats_GetAchievementDisplayAttribute@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_IndicateAchievementProgress( ISteamUserStats* lpSteamUserStats, const char* pchName, uint32_t nCurProgress, uint32_t nMaxProgress ) {
+// Achievement progress - triggers an AchievementProgress callback, that is all.
+// Calling this w/ N out of N progress will NOT set the achievement, the game must still do that.
+DLL(uint32_t) BS_ISteamUserStats_IndicateAchievementProgress( ISteamUserStats* lpSteamUserStats, const char* pchName, uint32_t nCurProgress, uint32_t nMaxProgress ) {
 	return lpSteamUserStats->IndicateAchievementProgress( pchName, nCurProgress, nMaxProgress );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_IndicateAchievementProgress=_BS_UserStats_IndicateAchievementProgress@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetNumAchievements( ISteamUserStats* lpSteamUserStats ) {
+// Used for iterating achievements. In general games should not need these functions because they should have a
+// list of existing achievements compiled into them
+DLL(uint32_t) BS_ISteamUserStats_GetNumAchievements( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->GetNumAchievements( );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetNumAchievements=_BS_UserStats_GetNumAchievements@4")
 
-DLL_EXPORT const char* DLL_CALL BS_UserStats_GetAchievementName( ISteamUserStats* lpSteamUserStats, uint32 iAchievement ) {
+// Get achievement name iAchievement in [0,GetNumAchievements)
+DLL(const char*) BS_ISteamUserStats_GetAchievementName( ISteamUserStats* lpSteamUserStats, uint32_t iAchievement ) {
 	return lpSteamUserStats->GetAchievementName( iAchievement );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementName=_BS_UserStats_GetAchievementName@8")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestUserStats( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser ) {
+// Friends stats & achievements
+
+// downloads stats for the user
+// returns a UserStatsReceived_t received when completed
+// if the other user has no stats, UserStatsReceived_t.m_eResult will be set to k_EResultFail
+// these stats won't be auto-updated; you'll need to call RequestUserStats() again to refresh any data
+//CALL_RESULT(UserStatsReceived_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_RequestUserStats( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser ) {
 	return new uint64_t( lpSteamUserStats->RequestUserStats( *steamIDUser ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_RequestUserStats=_BS_UserStats_RequestUserStats@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserStat( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData ) {
+// requests stat information for a user, usable after a successful call to RequestUserStats()
+DLL(uint32_t) BS_ISteamUserStats_GetUserStat( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData ) {
 	return lpSteamUserStats->GetUserStat( *steamIDUser, pchName, (int32_t*)pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetUserStat=_BS_UserStats_GetUserStat@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserStatF( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, float_t* pData ) {
+DLL(uint32_t) BS_ISteamUserStats_GetUserStatF( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, float_t* pData ) {
 	return lpSteamUserStats->GetUserStat( *steamIDUser, pchName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetUserStatF=_BS_UserStats_GetUserStatF@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserAchievement( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved ) {
+DLL(uint32_t) BS_ISteamUserStats_GetUserAchievement( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved ) {
 	return lpSteamUserStats->GetUserAchievement( *steamIDUser, pchName, (bool*)pbAchieved );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetUserAchievement=_BS_UserStats_GetUserAchievement@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) {
+// See notes for GetAchievementAndUnlockTime above
+DLL(uint32_t) BS_ISteamUserStats_GetUserAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) {
 	return lpSteamUserStats->GetUserAchievementAndUnlockTime( *steamIDUser, pchName, (bool*)pbAchieved, punUnlockTime );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetUserAchievementAndUnlockTime=_BS_UserStats_GetUserAchievementAndUnlockTime@20")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_ResetAllStats( ISteamUserStats* lpSteamUserStats, uint32_t bAchievementsToo ) {
+// Reset stats 
+DLL(uint32_t) BS_ISteamUserStats_ResetAllStats( ISteamUserStats* lpSteamUserStats, uint32_t bAchievementsToo ) {
 	return lpSteamUserStats->ResetAllStats( bAchievementsToo != 0 );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_ResetAllStats=_BS_UserStats_ResetAllStats@8")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_FindOrCreateLeaderboard( ISteamUserStats* lpSteamUserStats, const char* pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) {
+// Leaderboard functions
+
+// asks the Steam back-end for a leaderboard by name, and will create it if it's not yet
+// This call is asynchronous, with the result returned in LeaderboardFindResult_t
+//CALL_RESULT(LeaderboardFindResult_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_FindOrCreateLeaderboard( ISteamUserStats* lpSteamUserStats, const char* pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) {
 	return new uint64_t( lpSteamUserStats->FindOrCreateLeaderboard( pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_FindOrCreateLeaderboard=_BS_UserStats_FindOrCreateLeaderboard@16")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_FindLeaderboard( ISteamUserStats* lpSteamUserStats, const char *pchLeaderboardName ) {
+// as above, but won't create the leaderboard if it's not found
+// This call is asynchronous, with the result returned in LeaderboardFindResult_t
+//CALL_RESULT(LeaderboardFindResult_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_FindLeaderboard( ISteamUserStats* lpSteamUserStats, const char *pchLeaderboardName ) {
 	return new uint64_t( lpSteamUserStats->FindLeaderboard( pchLeaderboardName ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_FindLeaderboard=_BS_UserStats_FindLeaderboard@8")
 
-DLL_EXPORT const char* DLL_CALL BS_UserStats_GetLeaderboardName( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
+// returns the name of a leaderboard
+DLL(const char*) BS_ISteamUserStats_GetLeaderboardName( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardName( *hSteamLeaderboard );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardName=_BS_UserStats_GetLeaderboardName@8")
 
-DLL_EXPORT int DLL_CALL BS_UserStats_GetLeaderboardEntryCount( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
+// returns the total number of entries in a leaderboard, as of the last request
+DLL(int) BS_ISteamUserStats_GetLeaderboardEntryCount( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardEntryCount( *hSteamLeaderboard );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardEntryCount=_BS_UserStats_GetLeaderboardEntryCount@8")
 
-DLL_EXPORT ELeaderboardSortMethod DLL_CALL BS_UserStats_GetLeaderboardSortMethod( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
+// returns the sort method of the leaderboard
+DLL(ELeaderboardSortMethod) BS_ISteamUserStats_GetLeaderboardSortMethod( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardSortMethod( *hSteamLeaderboard );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardSortMethod=_BS_UserStats_GetLeaderboardSortMethod@8")
 
-DLL_EXPORT ELeaderboardDisplayType DLL_CALL BS_UserStats_GetLeaderboardDisplayType( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
+// returns the display type of the leaderboard
+DLL(ELeaderboardDisplayType) BS_ISteamUserStats_GetLeaderboardDisplayType( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardDisplayType( *hSteamLeaderboard );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardDisplayType=_BS_UserStats_GetLeaderboardDisplayType@8")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_DownloadLeaderboardEntries( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) {
+// Asks the Steam back-end for a set of rows in the leaderboard.
+// This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t
+// LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below)
+// You can ask for more entries than exist, and it will return as many as do exist.
+// k_ELeaderboardDataRequestGlobal requests rows in the leaderboard from the full table, with nRangeStart & nRangeEnd in the range [1, TotalEntries]
+// k_ELeaderboardDataRequestGlobalAroundUser requests rows around the current user, nRangeStart being negate
+//   e.g. DownloadLeaderboardEntries( hLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -3, 3 ) will return 7 rows, 3 before the user, 3 after
+// k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user 
+//CALL_RESULT(LeaderboardScoresDownloaded_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_DownloadLeaderboardEntries( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) {
 	return new uint64_t( lpSteamUserStats->DownloadLeaderboardEntries( *hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_DownloadLeaderboardEntries=_BS_UserStats_DownloadLeaderboardEntries@20")
+///#####
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_DownloadLeaderboardEntriesForUsers( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, CSteamID* prgUsers, int cUsers ) {
+// as above, but downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers
+// if a user doesn't have a leaderboard entry, they won't be included in the result
+// a max of 100 users can be downloaded at a time, with only one outstanding call at a time
+//CALL_RESULT(LeaderboardScoresDownloaded_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_DownloadLeaderboardEntriesForUsers( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, CSteamID* prgUsers, int cUsers ) {
 	return new uint64_t( lpSteamUserStats->DownloadLeaderboardEntriesForUsers( *hSteamLeaderboard, prgUsers, cUsers ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_DownloadLeaderboardEntriesForUsers=_BS_UserStats_DownloadLeaderboardEntriesForUsers@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetDownloadedLeaderboardEntry( ISteamUserStats* lpSteamUserStats, SteamLeaderboardEntries_t* hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) {
+// Returns data about a single leaderboard entry
+// use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries
+// e.g.
+//		void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded )
+//		{
+//			for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ )
+//			{
+//				LeaderboardEntry_t leaderboardEntry;
+//				int32 details[3];		// we know this is how many we've stored previously
+//				GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 );
+//				assert( leaderboardEntry.m_cDetails == 3 );
+//				...
+//			}
+// once you've accessed all the entries, the data will be free'd, and the SteamLeaderboardEntries_t handle will become invalid
+DLL(uint32_t) BS_ISteamUserStats_GetDownloadedLeaderboardEntry( ISteamUserStats* lpSteamUserStats, SteamLeaderboardEntries_t* hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) {
 	return lpSteamUserStats->GetDownloadedLeaderboardEntry( *hSteamLeaderboardEntries, index, pLeaderboardEntry, pDetails, cDetailsMax );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetDownloadedLeaderboardEntry=_BS_UserStats_GetDownloadedLeaderboardEntry@24")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_UploadLeaderboardScore( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32_t* pScoreDetails, int cScoreDetailsCount ) {
+// Uploads a user score to the Steam back-end.
+// This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t
+// Details are extra game-defined information regarding how the user got that score
+// pScoreDetails points to an array of int32's, cScoreDetailsCount is the number of int32's in the list
+//CALL_RESULT(LeaderboardScoreUploaded_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_UploadLeaderboardScore( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32_t* pScoreDetails, int cScoreDetailsCount ) {
 	return new uint64_t(lpSteamUserStats->UploadLeaderboardScore( *hSteamLeaderboard, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount ));
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_UploadLeaderboardScore=_BS_UserStats_UploadLeaderboardScore@24")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_AttachLeaderboardUGC( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, UGCHandle_t* hUGC ) {
+// Attaches a piece of user generated content the user's entry on a leaderboard.
+// hContent is a handle to a piece of user generated content that was shared using ISteamUserRemoteStorage::FileShare().
+// This call is asynchronous, with the result returned in LeaderboardUGCSet_t.
+//CALL_RESULT(LeaderboardUGCSet_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_AttachLeaderboardUGC( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, UGCHandle_t* hUGC ) {
 	return new uint64_t( lpSteamUserStats->AttachLeaderboardUGC( *hSteamLeaderboard, *hUGC ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_AttachLeaderboardUGC=_BS_UserStats_AttachLeaderboardUGC@12")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_GetNumberOfCurrentPlayers( ISteamUserStats* lpSteamUserStats ) {
+// Retrieves the number of players currently playing your game (online + offline)
+// This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t
+//CALL_RESULT(NumberOfCurrentPlayers_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_GetNumberOfCurrentPlayers( ISteamUserStats* lpSteamUserStats ) {
 	return new uint64_t( lpSteamUserStats->GetNumberOfCurrentPlayers( ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetNumberOfCurrentPlayers=_BS_UserStats_GetNumberOfCurrentPlayers@4")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestGlobalAchievementPercentages( ISteamUserStats* lpSteamUserStats ) {
+// Requests that Steam fetch data on the percentage of players who have received each achievement
+// for the game globally.
+// This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t.
+//CALL_RESULT(GlobalAchievementPercentagesReady_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_RequestGlobalAchievementPercentages( ISteamUserStats* lpSteamUserStats ) {
 	return new uint64_t( lpSteamUserStats->RequestGlobalAchievementPercentages( ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_RequestGlobalAchievementPercentages=_BS_UserStats_RequestGlobalAchievementPercentages@4")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, char *pchName, uint32 unNameBufLen, float *pflPercent, bool* pbAchieved ) {
+// Get the info on the most achieved achievement for the game, returns an iterator index you can use to fetch
+// the next most achieved afterwards.  Will return -1 if there is no data on achievement 
+// percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback).
+DLL(uint32_t) BS_ISteamUserStats_GetMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, char *pchName, uint32_t unNameBufLen, float *pflPercent, bool* pbAchieved ) {
 	return lpSteamUserStats->GetMostAchievedAchievementInfo( pchName, unNameBufLen, pflPercent, pbAchieved );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetMostAchievedAchievementInfo=_BS_UserStats_GetMostAchievedAchievementInfo@20")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetNextMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) {
+// Get the info on the next most achieved achievement for the game. Call this after GetMostAchievedAchievementInfo or another
+// GetNextMostAchievedAchievementInfo call passing the iterator from the previous call. Returns -1 after the last
+// achievement has been iterated.
+DLL(uint32_t) BS_ISteamUserStats_GetNextMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, int iIteratorPrevious, char *pchName, uint32_t unNameBufLen, float *pflPercent, bool *pbAchieved ) {
 	return lpSteamUserStats->GetNextMostAchievedAchievementInfo( iIteratorPrevious, pchName, unNameBufLen, pflPercent, pbAchieved );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetNextMostAchievedAchievementInfo=_BS_UserStats_GetNextMostAchievedAchievementInfo@24")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementAchievedPercent( ISteamUserStats* lpSteamUserStats, const char *pchName, float *pflPercent ) {
+// Returns the percentage of users who have achieved the specified achievement.
+DLL(uint32_t) BS_ISteamUserStats_GetAchievementAchievedPercent( ISteamUserStats* lpSteamUserStats, const char *pchName, float *pflPercent ) {
 	return lpSteamUserStats->GetAchievementAchievedPercent( pchName, pflPercent );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementAchievedPercent=_BS_UserStats_GetAchievementAchievedPercent@12")
 
-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestGlobalStats( ISteamUserStats* lpSteamUserStats, int nHistoryDays ) {
+// Requests global stats data, which is available for stats marked as "aggregated".
+// This call is asynchronous, with the results returned in GlobalStatsReceived_t.
+// nHistoryDays specifies how many days of day-by-day history to retrieve in addition
+// to the overall totals. The limit is 60.
+//CALL_RESULT(GlobalStatsReceived_t)
+DLL(SteamAPICall_t*) BS_ISteamUserStats_RequestGlobalStats( ISteamUserStats* lpSteamUserStats, int nHistoryDays ) {
 	return new uint64_t( lpSteamUserStats->RequestGlobalStats( nHistoryDays ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_RequestGlobalStats=_BS_UserStats_RequestGlobalStats@8")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64* pData ) {
+// Gets the lifetime totals for an aggregated stat
+DLL(uint32_t) BS_ISteamUserStats_GetGlobalStatL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64* pData ) {
 	return lpSteamUserStats->GetGlobalStat( pchStatName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatLL=_BS_UserStats_GetGlobalStatLL@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double* pData ) {
+DLL(uint32_t) BS_ISteamUserStats_GetGlobalStatD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double* pData ) {
 	return lpSteamUserStats->GetGlobalStat( pchStatName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatD=_BS_UserStats_GetGlobalStatD@12")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatHistoryLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64 *pData, uint32 cubData ) {
+// Gets history for an aggregated stat. pData will be filled with daily values, starting with today.
+// So when called, pData[0] will be today, pData[1] will be yesterday, and pData[2] will be two days ago, 
+// etc. cubData is the size in bytes of the pubData buffer. Returns the number of 
+// elements actually set.
+DLL(uint32_t) BS_ISteamUserStats_GetGlobalStatHistoryL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64 *pData, uint32_t cubData ) {
 	return lpSteamUserStats->GetGlobalStatHistory( pchStatName, pData, cubData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatHistoryLL=_BS_UserStats_GetGlobalStatHistoryLL@16")
 
-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatHistoryD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double *pData, uint32 cubData ) {
+DLL(uint32_t) BS_ISteamUserStats_GetGlobalStatHistoryD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double *pData, uint32_t cubData ) {
 	return lpSteamUserStats->GetGlobalStatHistory( pchStatName, pData, cubData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatHistoryD=_BS_UserStats_GetGlobalStatHistoryD@16")

Wrapper/SteamUtils.cpp

@@ -0,0 +1,27 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamUtils*) BS_SteamUtils() {
+	return SteamUtils();
+}
+
+DLL(ISteamUtils*) BS_SteamGameServerUtils() {
+	return SteamGameServerUtils();
+}
+
+#pragma message("SteamUtils is not ported yet. TODO!")

Wrapper/SteamVideo.cpp

@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL(ISteamVideo*) BS_SteamVideo() {
+	return SteamVideo();
+}
+
+#pragma message("SteamVideo is not ported yet. TODO!")