More Steam functionality, less renaming. functions now closely relate to the original function/class/method structure and many helper types have been added native to BlitzSteam (no need for BlitzUtility).

Blitz/BlitzSteam.decls

@@ -1,543 +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"
-
-; Steam -----------------------------------------------------------------------
-BS_Steam_Init%()
-BS_Steam_Shutdown()
-BS_Steam_IsSteamRunning%()
-BS_Steam_RestartAppIfNecessary%(unOwnAppID%)
-BS_Steam_SetMiniDumpComment(pchMsg$)
-BS_Steam_WriteMiniDump(uStructuredExceptionCode%, pvExceptionInfo*, uBuildID%)
-BS_Steam_WriteMiniDumpEx(uStructuredExceptionCode%, pvExceptionInfo%, uBuildID%) : "BS_WriteMiniDump"
-BS_Steam_RunCallbacks()
-BS_Steam_RegisterCallback(pCallback%, iCallback%)
-BS_Steam_UnregisterCallback(pCallback%)
-BS_Steam_RegisterCallResult(pCallback%, hAPICall%)
-BS_Steam_UnregisterCallResult(pCallback%, hAPICall%)
-
-; AppList ---------------------------------------------------------------------
-BS_AppList%()
-BS_AppList_GetNumInstalledApps%(lpSteamAppList%)
-BS_AppList_GetInstalledApps%(lpSteamAppList%, pvecAppID*, unMaxIDs%)
-BS_AppList_GetInstalledAppsEx%(lpSteamAppList%, pvecAppID%, unMaxIDs%) : "BS_AppList_GetInstalledApps"
-BS_AppList_GetAppName%(lpSteamAppList%, nAppId%, pchNameBuffer*, cchNameMax%)
-BS_AppList_GetAppNameEx%(lpSteamAppList%, nAppId%, pchNameBuffer%, cchNameMax%) : "BS_AppList_GetAppName"
-BS_AppList_GetAppInstallDir%(lpSteamAppList%, nAppId%, pchDirectoryBuffer*, cchDirectoryMax%)
-BS_AppList_GetAppInstallDirEx%(lpSteamAppList%, nAppId%, pchDirectoryBuffer%, cchDirectoryMax%) : "BS_AppList_GetAppInstallDir"
-BS_AppList_GetAppBuildId%(lpSteamAppList%, nAppId%)
-
-; Apps ------------------------------------------------------------------------
-BS_Apps%()
-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%, pAppIdBuffer*, pbAvailableBuffer*, pchNameBuffer*, cchNameBufferSize%)
-BS_Apps_GetDLCDataByIndexEx%(lpSteamApps%, iDLC%, pAppIdBuffer%, pbAvailableBuffer%, pchNameBuffer%, cchNameBufferSize%) : "BS_Apps_GetDLCDataByIndex"
-BS_Apps_InstallDLC(lpSteamApps%, nAppID%)
-BS_Apps_UninstallDLC(lpSteamApps%, nAppID%)
-BS_Apps_RequestAppProofOfPurchaseKey(lpSteamApps%, nAppID%)
-BS_Apps_GetCurrentBetaName%(lpSteamApps%, pchNameBuffer*, cchNameBufferSize%)
-BS_Apps_GetCurrentBetaNameEx%(lpSteamApps%, pchNameBuffer%, cchNameBufferSize%) : "BS_Apps_GetCurrentBetaName"
-BS_Apps_MarkContentCorrupt%(lpSteamApps%, bMissingFilesOnly%)
-BS_Apps_GetInstalledDepots%(lpSteamApps%, nAppID%, pDepotsBuffer*, cMaxDepots%)
-BS_Apps_GetInstalledDepotsEx%(lpSteamApps%, nAppID%, pDepotsBuffer%, cMaxDepots%) : "BS_Apps_GetInstalledDepots"
-BS_Apps_GetAppInstallDir%(lpSteamApps%, nAppID%, pchFolderBuffer*, cchFolderBufferSize%)
-BS_Apps_GetAppInstallDirEx%(lpSteamApps%, nAppID%, pchFolderBuffer%, cchFolderBufferSize%) : "BS_Apps_GetAppInstallDir"
-BS_Apps_IsAppInstalled%(lpSteamApps%, nAppID%)
-BS_Apps_GetAppOwner%(lpSteamApps%)
-BS_Apps_GetLaunchQueryParam$(lpSteamApps%, pchKey$)
-BS_Apps_GetDlcDownloadProgress%(lpSteamApps%, nAppID%, pLLBytesDownloaded*, pLLBytesTotal*)
-BS_Apps_GetDlcDownloadProgressEx%(lpSteamApps%, nAppID%, pLLBytesDownloaded%, pLLBytesTotal%) : "BS_Apps_GetDlcDownloadProgress"
-BS_Apps_GetAppBuildId%(lpSteamApps%)
-
-; Client ----------------------------------------------------------------------
-BS_Client%()
-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_GetIPCCallCount%(lpSteamClient%)
-BS_Client_ShutdownIfAllPipesClosed%(lpSteamClient%)
-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$)
-BS_Client_SetWarningMessageHook(lpSteamClient%, fpFunction%)
-
-; Controller ------------------------------------------------------------------
-BS_Controller%()
-BS_Controller_Init%(lpSteamController%, pchAbsolutePathToControllerConfigVDF$)
-BS_Controller_Shutdown%(lpSteamController%)
-BS_Controller_RunFrame(lpSteamController%)
-BS_Controller_GetConnectedControllers%(lpSteamController%, pHandlesOut*)
-BS_Controller_GetConnectedControllersEx%(lpSteamController%, pHandlesOut%) : "BS_Controller_GetConnectedControllersEx"
-BS_Controller_GetConnectedControllersSimple%(lpSteamController%)
-BS_Controller_GetConnectedControllersSimple_Index%(index%)
-BS_Controller_ShowBindingPanel%(lpSteamController%, pControllerHandle%)
-BS_Controller_GetActionSetHandle%(lpSteamController%, pszActionSetName$)
-;! Function above returns a ControllerActionSetHandle_t*, clean it up afterwards!
-BS_Controller_ActivateActionSet(lpSteamController%, pControllerHandle%, pActionSetHandle%)
-BS_Controller_GetCurrentActionSet%(lpSteamController%, )
-;! Function above returns a ControllerActionSetHandle_t*, clean it up afterwards!
-BS_Controller_GetDigitalActionHandle%(lpSteamController%, pszActionName$)
-;! Function above returns a ControllerDigitalActionHandle_t*, clean it up afterwards!
-BS_Controller_GetDigitalActionData%(lpSteamController%, pControllerHandle%, pDigitalActionHandle%)
-;! Function above returns a ControllerDigitalActionData_t*, clean it up afterwards?
-BS_Controller_GetDigitalActionOrigins%(lpSteamController%, pControllerHandle%, pActionSetHandle%, pDigitalActionHandle%, pEControllerActionOrigin*)
-BS_Controller_GetDigitalActionOriginsEx%(lpSteamController%, pControllerHandle%, pActionSetHandle%, pDigitalActionHandle%, pEControllerActionOrigin%) : "BS_Controller_GetDigitalActionOrigins"
-BS_Controller_GetAnalogActionHandle%(lpSteamController%, pszActionName$)
-;! Function above returns a ControllerAnalogActionHandle_t*, clean it up afterwards!
-BS_Controller_GetAnalogActionData%(lpSteamController%, pControllerHandle%, pAnalogActionHandle%)
-;! Function above returns a ControllerAnalogActionData_t*, clean it up afterwards?
-BS_Controller_GetAnalogActionOrigins%(lpSteamController%, pControllerHandle%, pActionSetHandle%, pAnalogActionHandle%, pEControllerActionOrigin*)
-BS_Controller_GetAnalogActionOriginsEx%(lpSteamController%, pControllerHandle%, pActionSetHandle%, pAnalogActionHandle%, pEControllerActionOrigin*) : "BS_Controller_GetAnalogActionOrigins"
-BS_Controller_StopAnalogActionMomentum(lpSteamController%, pControllerHandle%, pAnalogActionHandle%)
-BS_Controller_TriggerHapticPulse(lpSteamController%, pControllerHandle%, ESteamControllerPad%, usDurationMicroSec%)
-BS_Controller_TriggerRepeatedHapticPulse(lpSteamController%, pControllerHandle%, ESteamControllerPad%, usDurationMicroSec%, osOffMicroSec%, unRepeat%, nFlags%)
-
-; Friends ---------------------------------------------------------------------
-BS_Friends%()
-BS_Friends_GetPersonaName$(lpSteamFriends%)
-BS_Friends_SetPersonaName%(lpSteamFriends%, pchPersonaName$)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_Friends_GetPersonaState%(lpSteamFriends%)
-BS_Friends_GetFriendCount%(lpSteamFriends%, iFriendFlags%)
-BS_Friends_GetFriendByIndex%(lpSteamFriends%, iFriend%, iFriendFlags%)
-;! Function above returns a CSteamID*, clean it up afterwards!
-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%)
-;! Function above returns a CSteamID*, clean it up afterwards!
-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%)
-;! Function above returns a CSteamID*, clean it up afterwards!
-BS_Friends_GetFriendCoplayTime%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_GetFriendCoplayGame%(lpSteamFriends%, steamIDFriend%)
-BS_Friends_JoinClanChatRoom%(lpSteamFriends%, steamIDClan%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_Friends_LeaveClanChatRoom%(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetClanChatMemberCount%(lpSteamFriends%, steamIDClan%)
-BS_Friends_GetChatMemberByIndex%(lpSteamFriends%, steamIDClan%, iUser%)
-;! Function above returns a CSteamID*, clean it up afterwards!
-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%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_Friends_IsFollowing%(lpSteamFriends%, steamID%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_Friends_EnumerateFollowingList%(lpSteamFriends%, unStartIndex%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-
-; GameServer ------------------------------------------------------------------
-BS_SteamGameServer_Init%(unIP%, usSteamPort%, usGamePort%, usQueryPort%, eServerMode%, pchVersionString$)
-BS_SteamGameServer_Shutdown()
-BS_SteamGameServer_RunCallbacks()
-BS_SteamGameServer_GetHSteamPipe%()
-BS_SteamGameServer_IsSecure%()
-BS_SteamGameServer_GetSteamID%()
-;! Function above returns a CSteamID*, clean it up afterwards!
-BS_GameServer%()
-BS_GameServer_InitGameServer%(pSteamGameServer%, unIP%, usGamePort%, usQueryPort%, unFlags%, nGameAppId%, pchVersionString$)
-BS_GameServer_SetProduct(pSteamGameServer%, pszProduct$)
-BS_GameServer_SetGameDescription(pSteamGameServer%, pszGameDescription$)
-BS_GameServer_SetModDir(pSteamGameServer%, pszModDir$)
-BS_GameServer_SetDedicatedServer(pSteamGameServer%, bDedicated%)
-BS_GameServer_LogOn(pSteamGameServer%, pszToken$)
-BS_GameServer_LogOnAnonymous(pSteamGameServer%)
-BS_GameServer_LogOff(pSteamGameServer%)
-BS_GameServer_IsLoggedOn%(pSteamGameServer%)
-BS_GameServer_IsSecure%(pSteamGameServer%)
-BS_GameServer_GetSteamID%(pSteamGameServer%)
-BS_GameServer_WasRestartRequested%(pSteamGameServer%)
-BS_GameServer_SetMaxPlayerCount(pSteamGameServer%, cPlayersMax%)
-BS_GameServer_SetBotPlayerCount(pSteamGameServer%, cBotPlayers%)
-BS_GameServer_SetServerName(pSteamGameServer%, pszServerName$)
-BS_GameServer_SetMapName(pSteamGameServer%, pszMapName$)
-BS_GameServer_SetPasswordProtected(pSteamGameServer%, bPasswordProtected%)
-BS_GameServer_SetSpectatorPort(pSteamGameServer%, unSpectatorPort%)
-BS_GameServer_SetSpectatorServerName(pSteamGameServer%, pszSpectatorServerName$)
-BS_GameServer_ClearAllKeyValues(pSteamGameServer%)
-BS_GameServer_SetKeyValue(pSteamGameServer%, pKey$, pValue$)
-BS_GameServer_SetGameTags(pSteamGameServer%, pchGameTags$)
-BS_GameServer_SetGameData(pSteamGameServer%, pchGameData$)
-BS_GameServer_SetRegion(pSteamGameServer%, pszRegion$)
-BS_GameServer_SendUserConnectAndAuthenticate%(pSteamGameServer%, unIPClient%, pvAuthBlob*, cubAuthBlobSize%, pSteamIDUser%)
-BS_GameServer_SendUserConnectAndAuthenticateEx%(pSteamGameServer%, unIPClient%, pvAuthBlob%, cubAuthBlobSize%, pSteamIDUser%) : "BS_GameServer_SendUserConnectAndAuthenticate"
-BS_GameServer_CreateUnauthenticatedUserConnection%(pSteamGameServer%)
-;! Function above returns a CSteamID*, clean it up afterwards!
-BS_GameServer_SendUserDisconnect(pSteamGameServer%, pSteamIDUser%)
-BS_GameServer_UpdateUserData%(pSteamGameServer%, pSteamIDUser%, pchPlayerName$, uScore%)
-BS_GameServer_GetAuthSessionTicket%(pSteamGameServer%, pTicket*, cbMaxTicket%, pcbTicket%)
-BS_GameServer_GetAuthSessionTicketEx%(pSteamGameServer%, pTicket%, cbMaxTicket%, pcbTicket%) : "BS_GameServer_GetAuthSessionTicket"
-BS_GameServer_BeginAuthSession%(pSteamGameServer%, pAuthTicker*, cbAuthTicket%, pSteamID%)
-BS_GameServer_BeginAuthSessionEx%(pSteamGameServer%, pAuthTicker%, cbAuthTicket%, pSteamID%) : "BS_GameServer_BeginAuthSession"
-BS_GameServer_EndAuthSession(pSteamGameServer%, pSteamID%)
-BS_GameServer_CancelAuthTicket(pSteamGameServer%, hAuthTicket%)
-BS_GameServer_UserHasLicenseForApp%(pSteamGameServer%, pSteamID%, appID%)
-BS_GameServer_RequestUserGroupStatus%(pSteamGameServer%, pSteamIDUser%, pSteamIDGroup%)
-BS_GameServer_GetGameplayStats(pSteamGameServer%)
-BS_GameServer_GetServerReputation%(pSteamGameServer%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_GameServer_GetPublicIP%(pSteamGameServer%)
-BS_GameServer_HandleIncomingPacket%(pSteamGameServer%, pData*, cbData%, srvIP%, srvPort%)
-BS_GameServer_HandleIncomingPacketEx%(pSteamGameServer%, pData%, cbData%, srvIP%, srvPort%) : "BS_GameServer_HandleIncomingPacket"
-BS_GameServer_GetNextOutgoingPacket%(pSteamGameServer%, pOut*, cbMaxOut%, pNetAdr*, pPort*)
-BS_GameServer_GetNextOutgoingPacketEx%(pSteamGameServer%, pOut%, cbMaxOut%, pNetAdr%, pPort%) : "BS_GameServer_GetNextOutgoingPacket"
-BS_GameServer_EnableHeartbeats(pSteamGameServer%, bActive%)
-BS_GameServer_SetHeartbeatInterval(pSteamGameServer%, iHeartbeatInterval%)
-BS_GameServer_ForceHeartbeat(pSteamGameServer%)
-BS_GameServer_AssociateWithClan%(pSteamGameServer%, pSteamIDClan%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_GameServer_ComputeNewPlayerCompatibility%(pSteamGameServer%, pSteamIDNewPlayer%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-
-; GameServerStats -------------------------------------------------------------
-BS_GameServerStats%()
-BS_GameServerStats_RequestUserStats%(pSteamGameServerStats%, steamIDUser%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_GameServerStats_StoreUserStats%(pSteamGameServerStats%, steamIDUser%)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_GameServerStats_GetUserStat%(pSteamGameServerStats%, steamIDUser%, pchName$, pData*)
-BS_GameServerStats_GetUserStatEx%(pSteamGameServerStats%, steamIDUser%, pchName$, pData%) : "BS_GameServerStats_GetUserStat"
-BS_GameServerStats_GetUserStatF%(pSteamGameServerStats%, steamIDUser%, pchName$, pData*)
-BS_GameServerStats_GetUserStatFEx%(pSteamGameServerStats%, steamIDUser%, pchName$, pData%) : "BS_GameServerStats_GetUserStatF"
-BS_GameServerStats_GetUserAchievement%(pSteamGameServerStats%, steamIDUser%, pchName$, pbAchieved*)
-BS_GameServerStats_GetUserAchievementEx%(pSteamGameServerStats%, steamIDUser%, pchName$, pbAchieved%) : "BS_GameServerStats_GetUserAchievement"
-BS_GameServerStats_SetUserStat%(pSteamGameServerStats%, steamIDUser%, pchName%, nData%)
-BS_GameServerStats_SetUserStatF%(pSteamGameServerStats%, steamIDUser%, pchName%, fData#)
-BS_GameServerStats_UpdateUserAvgRateStat%(pSteamGameServerStats%, steamIDUser%, pchName$, flCountThisSession#, pdSessionLength%)
-;! Function above takes a Double* as last parameter.
-BS_GameServerStats_SetUserAchievement%(pSteamGameServerStats%, steamIDUser%, pchName$)
-BS_GameServerStats_ClearUserAchievement%(pSteamGameServerStats%, steamIDUser%, pchName$)
-
-; HTMLSurface -----------------------------------------------------------------
-BS_HTMLSurface%()
-BS_HTMLSurface_Init%(pSteamHTMLSurface%)
-BS_HTMLSurface_Shutdown%(pSteamHTMLSurface%)
-BS_HTMLSurface_CreateBrowser%(pSteamHTMLSurface%, pchUserAgent$, pchUserCSS$)
-;! Function above returns a SteamAPICall_t*, clean it up afterwards!
-BS_HTMLSurface_RemoveBrowser(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_LoadURL(pSteamHTMLSurface%, unBrowserHandle%, pchURL$, pchPostData$)
-BS_HTMLSurface_SetSize(pSteamHTMLSurface%, unBrowserHandle%, unWidth%, unHeight%)
-BS_HTMLSurface_StopLoad(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_Reload(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_GoBack(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_GoForward(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_AddHeader(pSteamHTMLSurface%, unBrowserHandle%, pchKey$, pchValue$)
-BS_HTMLSurface_ExecuteJavascript(pSteamHTMLSurface%, unBrowserHandle%, pchScript$)
-BS_HTMLSurface_MouseUp(pSteamHTMLSurface%, unBrowserHandle%, EMouseButton%)
-BS_HTMLSurface_MouseDown(pSteamHTMLSurface%, unBrowserHandle%, EMouseButton%)
-BS_HTMLSurface_MouseDoubleClick(pSteamHTMLSurface%, unBrowserHandle%, EMouseButton%)
-BS_HTMLSurface_MouseMove(pSteamHTMLSurface%, unBrowserHandle%, X%, Y%)
-BS_HTMLSurface_MouseWheel(pSteamHTMLSurface%, unBrowserHandle%, nDelta%)
-BS_HTMLSurface_KeyDown(pSteamHTMLSurface%, unBrowserHandle%, nNativeKeyCode%, EHTMLKeyModifiers%)
-BS_HTMLSurface_KeyUp(pSteamHTMLSurface%, unBrowserHandle%, nNativeKeyCode%, EHTMLKeyModifiers%)
-BS_HTMLSurface_KeyChar(pSteamHTMLSurface%, unBrowserHandle%, cUnicodeChar%, EHTMLKeyModifiers%)
-BS_HTMLSurface_SetHorizontalScroll(pSteamHTMLSurface%, unBrowserHandle%, nAbsolutePixelScroll%)
-BS_HTMLSurface_SetVerticalScroll(pSteamHTMLSurface%, unBrowserHandle%, nAbsolutePixelScroll%)
-BS_HTMLSurface_SetKeyFocus(pSteamHTMLSurface%, unBrowserHandle%, bHasKeyFocus%)
-BS_HTMLSurface_ViewSource(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_CopyToClipboard(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_PasteFromClipboard(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_Find(pSteamHTMLSurface%, unBrowserHandle%, pchSearchStr$, bCurrentlyInFind%, bReverse%)
-BS_HTMLSurface_StopFind(pSteamHTMLSurface%, unBrowserHandle%)
-BS_HTMLSurface_GetLinkAtPosition(pSteamHTMLSurface%, unBrowserHandle%, X%, Y%)
-BS_HTMLSurface_SetCookie(pSteamHTMLSurface%, unBrowserHandle%, pchHostname$, pchKey$, pchValue$, pchPath$, nExpires%, bSecure%, bHTTPOnly%)
-BS_HTMLSurface_SetPageScaleFactor(pSteamHTMLSurface%, unBrowserHandle%, flZoom#, nPointX%, nPointY%)
-BS_HTMLSurface_SetBackgroundMode(pSteamHTMLSurface%, unBrowserHandle%, bBackgroundMode%)
-BS_HTMLSurface_AllowStartRequest(pSteamHTMLSurface%, unBrowserHandle%, bAllowed%)
-BS_HTMLSurface_JSDialogResponse(pSteamHTMLSurface%, unBrowserHandle%, bResult%)
-BS_HTMLSurface_FileLoadDialogResponse(pSteamHTMLSurface%, unBrowserHandle%, pchSelectedFiles%)
-
-; Networking ------------------------------------------------------------------
-BS_Networking%()
-BS_GameServerNetworking%()
-BS_Networking_SendP2PPacket%(pSteamNetworking%, pSteamIDRemote%, pubData*, cubData%, eP2PSendType%, nChannel%)
-BS_Networking_SendP2PPacketEx%(pSteamNetworking%, pSteamIDRemote%, pubData%, cubData%, eP2PSendType%, nChannel%) : "BS_Networking_SendP2PPacket"
-BS_Networking_IsP2PPacketAvailable%(pSteamNetworking%, pcubMsgSize*, nChannel%)
-BS_Networking_IsP2PPacketAvailableEx%(pSteamNetworking%, pcubMsgSize*, nChannel%) : "BS_Networking_IsP2PPacketAvailable"
-BS_Networking_ReadP2PPacket%(pSteamNetworking%, pubDest*, cubDest%, pcubMsgSize*, pSteamIDRemote%, nChannel%)
-BS_Networking_ReadP2PPacketEx%(pSteamNetworking%, pubDest%, cubDest%, pcubMsgSize%, pSteamIDRemote%, nChannel%) : "BS_Networking_ReadP2PPacket"
-BS_Networking_AcceptP2PSessionWithUser%(pSteamNetworking%, pSteamIDRemote%)
-BS_Networking_CloseP2PSessionWithUser%(pSteamNetworking%, pSteamIDRemote%)
-BS_Networking_CloseP2PChannelWithUser%(pSteamNetworking%, pSteamIDRemote%, nChannel%)
-BS_Networking_GetP2PSessionState%(pSteamNetworking%, pSteamIDRemote%, pConnectionState*)
-BS_Networking_AllowP2PPacketRelay%(pSteamNetworking%, bAllow%)
-
-; User ------------------------------------------------------------------------
-BS_User%()
-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$)
-
-; UserStats -------------------------------------------------------------------
-BS_UserStats%()
-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"
-
-; -- Interfaces
-BS_HTTP%()
-BS_GameServerHTTP%()
-BS_Inventory%()
-BS_GameServerInventory%()
-BS_Matchmaking%()
-BS_MatchmakingServers%()
-BS_Music%()
-BS_MusicRemote%()
-BS_RemoteStorage%()
-BS_Screenshots%()
-BS_UGC%()
-BS_GameServerUGC%()
-BS_UnifiedMessages%()
-BS_Utils%()
-BS_GameServerUtils%()
-BS_Video%()
-
-; Helpers ---------------------------------------------------------------------
-; -- Generic
-BS_Helper_FormatUnixTime$(unixTime%, pchFormat$)
-BS_Helper_DeleteLong(longlong%)
-BS_Helper_CreateDouble%(value#)
-BS_Helper_DeleteDouble(pDouble%)
-; -- 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%)
-; -- Callbacks
-BS_Callback_Create%(pFunctionPointer%)
-BS_Callback_Destroy%(pCallback%)
-BS_Callback_IsRegistered%(pCallback%)
-BS_Callback_IsGameServer%(pCallback%)
-BS_Callback_SetGameServerFlag%(pCallback%, bIsGameServer%)
-BS_Callback_Register(pCallback%, iCallback%)
-BS_Callback_Unregister(pCallback%)
-BS_Callback_RegisterResult(pCallback%, pSteamAPICall%)
-BS_Callback_UnregisterResult(pCallback%)
-; -- Memory
-BS_Memory_Alloc%(iSize%)
-BS_Memory_ReAlloc%(pMemory%, iSize%)
-BS_Memory_Free(pMemory%)
-BS_Memory_PeekByte%(pMemory%, offset%)
-BS_Memory_PeekShort%(pMemory%, offset%)
-BS_Memory_PeekInt%(pMemory%, offset%)
-BS_Memory_PeekFloat#(pMemory%, offset%)
-BS_Memory_PokeByte(pMemory%, offset%, value%)
-BS_Memory_PokeShort(pMemory%, offset%, value%)
-BS_Memory_PokeInt(pMemory%, offset%, value%)
-BS_Memory_PokeFloat(pMemory%, offset%, value#)

BlitzSteam.h

@@ -14,11 +14,10 @@
 //	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
+BS_I
-
 // Macros
-#define DLL_FUNCTION(type) extern "C" type __stdcall
+//#define DLL_FUNCTION(type) extern "C" type __stdcall
-//#define DLL_FUNCTION(type) extern "C" __declspec(dllexport) type __stdcall
+#define DLL_FUNCTION(type) extern "C" __declspec(dllexport) type __stdcall
 
 // Standard Library
 #include <time.h>
@@ -32,3 +31,11 @@
 // Steam
 #include "SteamworksSDK/public/steam/steam_api.h"
 #include "SteamworksSDK/public/steam/steam_gameserver.h"
+
+// Our Stuff
+#include "Helpers/BlitzCallback.h"
+#include "Helpers/BlitzPointer.h"
+#include "Helpers/Memory.h"
+#include "Types/CSteamID.h"
+#include "Types/Double.h"
+#include "Types/Long.h"

BlitzSteam.vcxproj

@@ -44,13 +44,12 @@
     <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
     <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>
     <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
     <TargetExt>.dll</TargetExt>
-    <LinkIncremental>false</LinkIncremental>
+    <LinkIncremental>true</LinkIncremental>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -60,7 +59,7 @@
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <WholeProgramOptimization>false</WholeProgramOptimization>
       <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <BufferSecurityCheck>false</BufferSecurityCheck>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <StructMemberAlignment>4Bytes</StructMemberAlignment>
@@ -83,25 +82,26 @@
       <FloatingPointExceptions>true</FloatingPointExceptions>
       <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
       <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
     </ClCompile>
     <Link>
       <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>
@@ -119,7 +119,7 @@
       <CompileAsWinRT>false</CompileAsWinRT>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <CreateHotpatchableImage>false</CreateHotpatchableImage>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <OpenMPSupport>false</OpenMPSupport>
       <ForcedIncludeFiles>
       </ForcedIncludeFiles>
@@ -133,31 +133,35 @@
       <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
       <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <DebugInformationFormat>None</DebugInformationFormat>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
     </ClCompile>
     <Link>
       <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="BlitzSteam.cpp" />
-    <ClCompile Include="Helpers\CSteamID.cpp" />
     <ClCompile Include="Helpers\BlitzCallback.cpp" />
     <ClCompile Include="Helpers\Helper.cpp" />
     <ClCompile Include="Helpers\Memory.cpp" />
+    <ClCompile Include="Types\CSteamID.cpp" />
+    <ClCompile Include="Types\Double.cpp" />
+    <ClCompile Include="Types\Long.cpp" />
     <ClCompile Include="Wrapper\Steam.cpp" />
     <ClCompile Include="Wrapper\SteamAppList.cpp" />
     <ClCompile Include="Wrapper\SteamApps.cpp" />
@@ -187,23 +191,18 @@
     <ClInclude Include="BlitzSteam.h" />
     <ClInclude Include="Helpers\BlitzPointer.h" />
     <ClInclude Include="Helpers\BlitzCallback.h" />
-    <ClInclude Include="Helpers\CSteamID.h" />
     <ClInclude Include="Helpers\Helper.h" />
     <ClInclude Include="Helpers\Memory.h" />
+    <ClInclude Include="Types\CSteamID.h" />
+    <ClInclude Include="Types\Double.h" />
+    <ClInclude Include="Types\Long.h" />
   </ItemGroup>
   <Target Name="CopyResources" AfterTargets="Build">
     <ItemGroup>
-		<Resources Include="LICENSE" />
+      <Resources Include="$(ProjectDir)\Resources\**\*.*" />
-		<Resources Include="$(ProjectDir)\LICENSE.lesser" />
-		<Resources Include="$(ProjectDir)\Blitz\*.*" />
-		<Resources Include="$(ProjectDir)\Blitz\**\*.*" />
       <Resources Include="$(ProjectDir)\SteamworksSDK\redistributable_bin\steam_api.dll" />
     </ItemGroup>
-	  <Copy 
+    <Copy SourceFiles="@(Resources)" DestinationFiles="@(Resources->'$(TargetDir)%(RecursiveDir)\%(Filename)%(Extension)')" SkipUnchangedFiles="True" UseHardlinksIfPossible="True" />
-		SourceFiles="@(Resources)"
-		DestinationFiles="@(Resources->'$(TargetDir)%(RecursiveDir)\%(Filename)%(Extension)')" 
-		SkipUnchangedFiles="True"
-		UseHardlinksIfPossible="True" />
   </Target>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

BlitzSteam.vcxproj.filters

@@ -18,11 +18,14 @@
     <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>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="Wrapper\Steam.cpp">
-      <Filter>Source Files\Wrapper</Filter>
-    </ClCompile>
     <ClCompile Include="Wrapper\SteamClient.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
@@ -89,9 +92,6 @@
     <ClCompile Include="Wrapper\SteamVideo.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
-    <ClCompile Include="Helpers\CSteamID.cpp">
-      <Filter>Source Files\Helpers</Filter>
-    </ClCompile>
     <ClCompile Include="BlitzSteam.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -107,6 +107,18 @@
     <ClCompile Include="Helpers\BlitzCallback.cpp">
       <Filter>Source Files\Helpers</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>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BlitzSteam.h">
@@ -118,15 +130,21 @@
     <ClInclude Include="Helpers\BlitzPointer.h">
       <Filter>Header Files\Helpers</Filter>
     </ClInclude>
-    <ClInclude Include="Helpers\CSteamID.h">
-      <Filter>Header Files\Helpers</Filter>
-    </ClInclude>
     <ClInclude Include="Helpers\Helper.h">
       <Filter>Header Files\Helpers</Filter>
     </ClInclude>
     <ClInclude Include="Helpers\Memory.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>
   </ItemGroup>
   <ItemGroup>
     <None Include="$(ProjectDir)\Blitz\*.*" />

Helpers/BlitzCallback.cpp

@@ -16,8 +16,76 @@
 
 #include "BlitzCallback.h"
 
-BlitzCallback::BlitzCallback(BP_Function3_t pFunctionPointer) {
+std::map<uint32_t, size_t>* BlitzCallback_Sizes;
+#define BlitzCallback_Sizes_Add(T) BlitzCallback_Sizes->emplace(T::k_iCallback, sizeof(T))
+
+void BlitzCallback_Init() {
+	BlitzCallback_Sizes = new std::map<uint32_t, size_t>();
+	BlitzCallback_Sizes->emplace(0, sizeof(BlitzCallback));
+
+	// SteamAPI
+
+	// SteamAppList
+	BlitzCallback_Sizes_Add(SteamAppInstalled_t);
+	BlitzCallback_Sizes_Add(SteamAppUninstalled_t);
+
+	// SteamApps
+	BlitzCallback_Sizes_Add(DlcInstalled_t);
+	BlitzCallback_Sizes_Add(RegisterActivationCodeResponse_t);
+	BlitzCallback_Sizes_Add(AppProofOfPurchaseKeyResponse_t);
+	BlitzCallback_Sizes_Add(NewLaunchQueryParameters_t);
+
+	// SteamController
+	
+	// SteamFriends
+	BlitzCallback_Sizes_Add(PersonaStateChange_t);
+	BlitzCallback_Sizes_Add(GameOverlayActivated_t);
+	BlitzCallback_Sizes_Add(GameServerChangeRequested_t);
+	BlitzCallback_Sizes_Add(GameLobbyJoinRequested_t);
+	BlitzCallback_Sizes_Add(AvatarImageLoaded_t);
+	BlitzCallback_Sizes_Add(ClanOfficerListResponse_t);
+	BlitzCallback_Sizes_Add(FriendRichPresenceUpdate_t);
+	BlitzCallback_Sizes_Add(GameRichPresenceJoinRequested_t);
+	BlitzCallback_Sizes_Add(GameConnectedClanChatMsg_t);
+	BlitzCallback_Sizes_Add(GameConnectedChatJoin_t);
+	BlitzCallback_Sizes_Add(GameConnectedChatLeave_t);
+	BlitzCallback_Sizes_Add(DownloadClanActivityCountsResult_t);
+	BlitzCallback_Sizes_Add(JoinClanChatRoomCompletionResult_t);
+	BlitzCallback_Sizes_Add(GameConnectedFriendChatMsg_t);
+	BlitzCallback_Sizes_Add(FriendsGetFollowerCount_t);
+	BlitzCallback_Sizes_Add(FriendsIsFollowing_t);
+	BlitzCallback_Sizes_Add(FriendsEnumerateFollowingList_t);
+	BlitzCallback_Sizes_Add(SetPersonaNameResponse_t);
+
+	// SteamGameServer
+	BlitzCallback_Sizes_Add(GSClientApprove_t);
+	BlitzCallback_Sizes_Add(GSClientDeny_t);
+	BlitzCallback_Sizes_Add(GSClientKick_t);
+	BlitzCallback_Sizes_Add(GSClientAchievementStatus_t);
+	BlitzCallback_Sizes_Add(GSPolicyResponse_t);
+	BlitzCallback_Sizes_Add(GSGameplayStats_t);
+	BlitzCallback_Sizes_Add(GSClientGroupStatus_t);
+	BlitzCallback_Sizes_Add(GSReputation_t);
+	BlitzCallback_Sizes_Add(AssociateWithClanResult_t);
+	BlitzCallback_Sizes_Add(ComputeNewPlayerCompatibilityResult_t);
+
+	// SteamGameServerStats
+	BlitzCallback_Sizes_Add(GSStatsReceived_t);
+	BlitzCallback_Sizes_Add(GSStatsStored_t);
+	BlitzCallback_Sizes_Add(GSStatsUnloaded_t);
+
+	// SteamHTMLSurface
+	BlitzCallback_Sizes_Add(HTML_BrowserReady_t);
+}
+
+BlitzCallback::BlitzCallback(BP_BlitzFunction3_t pFunctionPointer) {
 	this->m_pFunctionPointer = pFunctionPointer;
+	this->m_hSteamAPICall = 0;
+	this->m_iCallback = 0;
+
+	// Initialize BlitzCallback_Sizes
+	if (BlitzCallback_Sizes == 0)
+		BlitzCallback_Init();
 }
 
 BlitzCallback::~BlitzCallback() {
@@ -26,21 +94,21 @@ BlitzCallback::~BlitzCallback() {
 }
 
 int BlitzCallback::GetCallbackSizeBytes() {
-	return sizeof(BlitzCallback);
+	return (BlitzCallback_Sizes->find(this->m_iCallback)->second);
 }
 
 void BlitzCallback::Run(void *pvParam) {
-	if (this->m_hSteamAPICall != 0)
+	if (m_hSteamAPICall != 0)
-		this->m_hSteamAPICall = 0; // Caller unregisters for us.
+		m_hSteamAPICall = 0; // Caller unregisters for us.
 
-	BP_CallFunction3(m_pFunctionPointer, reinterpret_cast<uint32_t>(pvParam), 0, 0);
+	BP_CallFunction3(m_pFunctionPointer, reinterpret_cast<int32_t>(pvParam), 0, 0);
 }
 
 void BlitzCallback::Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall) {
-	if (this->m_hSteamAPICall != 0)
+	if (m_hSteamAPICall != 0)
-		this->m_hSteamAPICall = 0; // Caller unregisters for us.
+		m_hSteamAPICall = 0; // Caller unregisters for us.
 
-	BP_CallFunction3(m_pFunctionPointer, reinterpret_cast<uint32_t>(pvParam), (uint32_t)bIOFailure, (uint32_t)&hSteamAPICall);
+	BP_CallFunction3(m_pFunctionPointer, reinterpret_cast<int32_t>(pvParam), (bIOFailure ? 0 : 1), reinterpret_cast<int32_t>(&hSteamAPICall));
 }
 
 bool BlitzCallback::IsRegistered() {
@@ -48,7 +116,9 @@ bool BlitzCallback::IsRegistered() {
 }
 
 void BlitzCallback::Register(uint32_t iCallback) {
-	if (!this->IsRegistered())
+	if (this->IsRegistered())
+		this->Unregister();
+
 	SteamAPI_RegisterCallback(this, iCallback);
 }
 
@@ -57,19 +127,22 @@ void BlitzCallback::Unregister() {
 		SteamAPI_UnregisterCallback(this);
 }
 
-void BlitzCallback::RegisterResult(SteamAPICall_t hSteamAPICall) {
+void BlitzCallback::RegisterResult(SteamAPICall_t hSteamAPICall, uint32_t iCallback) {
-	if (this->m_hSteamAPICall == 0) {
+	if (this->m_hSteamAPICall == 0)
-		SteamAPI_RegisterCallResult(this, hSteamAPICall);
+		this->UnregisterResult();
+
 	this->m_hSteamAPICall = hSteamAPICall;
-	}
+	this->m_iCallback = iCallback;
+
+	SteamAPI_RegisterCallResult(this, hSteamAPICall);
 }
 
-void BlitzCallback::UnregisterResult()
+void BlitzCallback::UnregisterResult() {
-{
+	if (this->m_hSteamAPICall != 0)
-	if (this->m_hSteamAPICall != 0) {
 		SteamAPI_UnregisterCallResult(this, this->m_hSteamAPICall);
+
 	this->m_hSteamAPICall = 0;
-	}
+	this->m_iCallback = 0;
 }
 
 bool BlitzCallback::IsGameServer() {
@@ -83,49 +156,40 @@ void BlitzCallback::SetGameServer(bool bIsGameServer) {
 }
 
 // DLL-Callables
-DLL_FUNCTION(BlitzCallback*) BS_Callback_Create(BP_Function3_t pFunctionPointer) {
+DLL_FUNCTION(BlitzCallback*) BS_Callback_Create(BP_BlitzFunction3_t pFunctionPointer) {
-#pragma comment(linker, "/EXPORT:BS_Callback_Create=_BS_Callback_Create@4")
 	return new BlitzCallback(pFunctionPointer);
 }
 
 DLL_FUNCTION(void) BS_Callback_Destroy(BlitzCallback* pCallback) {
-#pragma comment(linker, "/EXPORT:BS_Callback_Destroy=_BS_Callback_Destroy@4")
 	delete pCallback;
 }
 
 DLL_FUNCTION(int32_t) BS_Callback_IsRegistered(BlitzCallback* pCallback) {
-#pragma comment(linker, "/EXPORT:BS_Callback_IsRegistered=_BS_Callback_IsRegistered@4")
 	return pCallback->IsRegistered();
 }
 
 DLL_FUNCTION(int32_t) BS_Callback_IsGameServer(BlitzCallback* pCallback) {
-#pragma comment(linker, "/EXPORT:BS_Callback_IsGameServer=_BS_Callback_IsGameServer@4")
 	return pCallback->IsGameServer();
 }
 
 DLL_FUNCTION(int32_t) BS_Callback_SetGameServerFlag(BlitzCallback* pCallback, int32_t bIsGameServer) {
-#pragma comment(linker, "/EXPORT:BS_Callback_SetGameServerFlag=_BS_Callback_SetGameServerFlag@8")
 	bool isGameServer = pCallback->IsGameServer();
 	pCallback->SetGameServer(!!bIsGameServer);
 	return isGameServer;
 }
 
 DLL_FUNCTION(void) BS_Callback_Register(BlitzCallback* pCallback, uint32_t iCallback) {
-#pragma comment(linker, "/EXPORT:BS_Callback_Register=_BS_Callback_Register@8")
 	pCallback->Register(iCallback);
 }
 
 DLL_FUNCTION(void) BS_Callback_Unregister(BlitzCallback* pCallback) {
-#pragma comment(linker, "/EXPORT:BS_Callback_Unregister=_BS_Callback_Unregister@4")
 	pCallback->Unregister();
 }
 
-DLL_FUNCTION(void) BS_Callback_RegisterResult(BlitzCallback* pCallback, SteamAPICall_t* pSteamAPICall) {
+DLL_FUNCTION(void) BS_Callback_RegisterResult(BlitzCallback* pCallback, SteamAPICall_t* pSteamAPICall, uint32_t iCallback) {
-#pragma comment(linker, "/EXPORT:BS_Callback_RegisterResult=_BS_Callback_RegisterResult@8")
+	pCallback->RegisterResult(*pSteamAPICall, iCallback);
-	pCallback->RegisterResult(*pSteamAPICall);
 }
 
 DLL_FUNCTION(void) BS_Callback_UnregisterResult(BlitzCallback* pCallback) {
-#pragma comment(linker, "/EXPORT:BS_Callback_UnregisterResult=_BS_Callback_UnregisterResult@4")
 	pCallback->UnregisterResult();
 }

Helpers/BlitzCallback.h

@@ -14,13 +14,16 @@
 //	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
+BS_I#include "BlitzSteam.h"
-#include "BlitzSteam.h"
 #include "BlitzPointer.h"
 
+#include <list>
+#include <vector>
+#include <map>
+
 class BlitzCallback : public CCallbackBase {
 	public:
-	BlitzCallback(BP_Function3_t pFunctionPointer);
+	BlitzCallback(BP_BlitzFunction3_t pFunctionPointer);
 	~BlitzCallback();
 
 	virtual void Run(void *pvParam);
@@ -34,15 +37,16 @@ class BlitzCallback : public CCallbackBase {
 	void Register(uint32_t iCallback);
 	void Unregister();
 
-	void RegisterResult(SteamAPICall_t hSteamAPICall);
+	void RegisterResult(SteamAPICall_t hSteamAPICall, uint32_t iCallback);
 	void UnregisterResult();
 
 	private:
-	BP_Function3_t m_pFunctionPointer;
+	BP_BlitzFunction3_t m_pFunctionPointer;
+	uint32_t m_iCallback;
 	SteamAPICall_t m_hSteamAPICall;
 };
 
-DLL_FUNCTION(BlitzCallback*) BS_Callback_Create(BP_Function3_t pFunctionPointer);
+DLL_FUNCTION(BlitzCallback*) BS_Callback_Create(BP_BlitzFunction3_t pFunctionPointer);
 DLL_FUNCTION(void) BS_Callback_Destroy(BlitzCallback* pCallback);
 
 DLL_FUNCTION(int32_t) BS_Callback_IsRegistered(BlitzCallback* pCallback);
@@ -51,5 +55,5 @@ DLL_FUNCTION(int32_t) BS_Callback_SetGameServerFlag(BlitzCallback* pCallback, in
 
 DLL_FUNCTION(void) BS_Callback_Register(BlitzCallback* pCallback, uint32_t iCallback);
 DLL_FUNCTION(void) BS_Callback_Unregister(BlitzCallback* pCallback);
-DLL_FUNCTION(void) BS_Callback_RegisterResult(BlitzCallback* pCallback, SteamAPICall_t* pSteamAPICall);
+DLL_FUNCTION(void) BS_Callback_RegisterResult(BlitzCallback* pCallback, SteamAPICall_t* pSteamAPICall, uint32_t iCallback);
 DLL_FUNCTION(void) BS_Callback_UnregisterResult(BlitzCallback* pCallback);

Helpers/BlitzPointer.h

@@ -14,16 +14,18 @@
 //	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
+BS_I
+// Types of Blitz Functions.
+typedef int32_t(__stdcall *BP_BlitzFunction0_t)();
+typedef int32_t(__stdcall *BP_BlitzFunction1_t)(int32_t);
+typedef int32_t(__stdcall *BP_BlitzFunction2_t)(int32_t, int32_t);
+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);
 
-typedef void*(__stdcall *BP_Function0_t)();
+#define BP_CallFunction0(ptr)						(reinterpret_cast<BP_BlitzFunction0_t>(ptr))()
-typedef void*(__stdcall *BP_Function1_t)(uint32_t);
+#define BP_CallFunction1(ptr, p1)					(reinterpret_cast<BP_BlitzFunction1_t>(ptr))(p1)
-typedef void*(__stdcall *BP_Function2_t)(uint32_t, uint32_t);
+#define BP_CallFunction2(ptr, p1, p2)				(reinterpret_cast<BP_BlitzFunction2_t>(ptr))(p1, p2)
-typedef void*(__stdcall *BP_Function3_t)(uint32_t, uint32_t, uint32_t);
+#define BP_CallFunction3(ptr, p1, p2, p3)			(reinterpret_cast<BP_BlitzFunction3_t>(ptr))(p1, p2, p3)
-typedef void*(__stdcall *BP_Function4_t)(uint32_t, uint32_t, uint32_t, uint32_t);
+#define BP_CallFunction4(ptr, p1, p2, p3, p4)		(reinterpret_cast<BP_BlitzFunction4_t>(ptr))(p1, p2, p3, p4)
-
+#define BP_CallFunction5(ptr, p1, p2, p3, p4, p5)	(reinterpret_cast<BP_BlitzFunction5_t>(ptr))(p1, p2, p3, p4, p5)
-#define BP_CallFunction0(ptr) ((BP_Function0_t)ptr)()
-#define BP_CallFunction1(ptr, p1) ((BP_Function1_t)ptr)(p1)
-#define BP_CallFunction2(ptr, p1, p2) ((BP_Function2_t)ptr)(p1, p2)
-#define BP_CallFunction3(ptr, p1, p2, p3) ((BP_Function3_t)ptr)(p1, p2, p3)
-#define BP_CallFunction4(ptr, p1, p2, p3, p4) ((BP_Function4_t)ptr)(p1, p2, p3, p4)

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 "CSteamID.h"
-
-DLL_FUNCTION(CSteamID*) BS_CSteamID_New() {
-	return new CSteamID();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_New=_BS_CSteamID_New@0")
-
-DLL_FUNCTION(CSteamID*) 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_FUNCTION(CSteamID*) 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_FUNCTION(CSteamID*) BS_CSteamID_FromSteamID(uint64_t* ulSteamID) {
-	return new CSteamID(*ulSteamID);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_FromSteamID=_BS_CSteamID_FromSteamID@4")
-
-DLL_FUNCTION(CSteamID*) BS_CSteamID_Copy(CSteamID* pSteamID) {
-	return new CSteamID(*pSteamID);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_Copy=_BS_CSteamID_Copy@4")
-
-DLL_FUNCTION(void) BS_CSteamID_Destroy(CSteamID* pSteamID) {
-	delete pSteamID;
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_Destroy=_BS_CSteamID_Destroy@4")
-
-DLL_FUNCTION(void) 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_FUNCTION(void) 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_FUNCTION(void) 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_FUNCTION(void) BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID) {
-	pSteamID->SetFromUint64(*ulSteamID);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_SetFromUInt64=_BS_CSteamID_SetFromUInt64@8")
-
-DLL_FUNCTION(void) BS_CSteamID_Clear(CSteamID* pSteamID) {
-	pSteamID->Clear();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_Clear=_BS_CSteamID_Clear@4")
-
-DLL_FUNCTION(uint64_t*) 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_FUNCTION(uint64_t*) 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_FUNCTION(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse) {
-	pSteamID->CreateBlankAnonLogon(eUniverse);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_CreateBlankAnonLogon=_BS_CSteamID_CreateBlankAnonLogon@8")
-
-DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse) {
-	pSteamID->CreateBlankAnonUserLogon(eUniverse);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_CreateBlankAnonUserLogon=_BS_CSteamID_CreateBlankAnonUserLogon@8")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID) {
-	return pSteamID->BBlankAnonAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_BlankAnonAccount=_BS_CSteamID_BlankAnonAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_GameServerAccount(CSteamID* pSteamID) {
-	return pSteamID->BGameServerAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GameServerAccount=_BS_CSteamID_GameServerAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID) {
-	return pSteamID->BPersistentGameServerAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_PersistentGameServerAccount=_BS_CSteamID_PersistentGameServerAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID) {
-	return pSteamID->BAnonGameServerAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_AnonGameServerAccount=_BS_CSteamID_AnonGameServerAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_ContentServerAccount(CSteamID* pSteamID) {
-	return pSteamID->BContentServerAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ContentServerAccount=_BS_CSteamID_ContentServerAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_ClanAccount(CSteamID* pSteamID) {
-	return pSteamID->BClanAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ClanAccount=_BS_CSteamID_ClanAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_ChatAccount(CSteamID* pSteamID) {
-	return pSteamID->BChatAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ChatAccount=_BS_CSteamID_ChatAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_IsLobby(CSteamID* pSteamID) {
-	return pSteamID->IsLobby();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_IsLobby=_BS_CSteamID_IsLobby@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_IndividualAccount(CSteamID* pSteamID) {
-	return pSteamID->BIndividualAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_IndividualAccount=_BS_CSteamID_IndividualAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_AnonAccount(CSteamID* pSteamID) {
-	return pSteamID->BAnonAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_AnonAccount=_BS_CSteamID_AnonAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_AnonUserAccount(CSteamID* pSteamID) {
-	return pSteamID->BAnonUserAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_AnonUserAccount=_BS_CSteamID_AnonUserAccount@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID) {
-	return pSteamID->BConsoleUserAccount();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ConsoleUserAccount=_BS_CSteamID_ConsoleUserAccount@4")
-
-DLL_FUNCTION(void) BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID) {
-	pSteamID->SetAccountID(unAccountID);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_SetAccountID=_BS_CSteamID_SetAccountID@8")
-
-DLL_FUNCTION(void) BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance) {
-	pSteamID->SetAccountInstance(unInstance);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_SetAccountInstance=_BS_CSteamID_SetAccountInstance@8")
-
-DLL_FUNCTION(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID) {
-	pSteamID->ClearIndividualInstance();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_ClearIndividualInstance=_BS_CSteamID_ClearIndividualInstance@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID) {
-	return pSteamID->HasNoIndividualInstance();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_HasNoIndividualInstance=_BS_CSteamID_HasNoIndividualInstance@4")
-
-DLL_FUNCTION(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pSteamID) {
-	return pSteamID->GetAccountID();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetAccountID=_BS_CSteamID_GetAccountID@4")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pSteamID) {
-	return pSteamID->GetUnAccountInstance();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetAccountInstance=_BS_CSteamID_GetAccountInstance@4")
-
-DLL_FUNCTION(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pSteamID) {
-	return pSteamID->GetEAccountType();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetEAccountType=_BS_CSteamID_GetEAccountType@4")
-
-DLL_FUNCTION(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pSteamID) {
-	return pSteamID->GetEUniverse();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_GetEUniverse=_BS_CSteamID_GetEUniverse@4")
-
-DLL_FUNCTION(void) BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse) {
-	pSteamID->SetEUniverse(eUniverse);
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_SetEUniverse=_BS_CSteamID_SetEUniverse@8")
-
-DLL_FUNCTION(uint32_t) BS_CSteamID_IsValid(CSteamID* pSteamID) {
-	return pSteamID->IsValid();
-}
-#pragma comment(linker, "/EXPORT:BS_CSteamID_IsValid=_BS_CSteamID_IsValid@4")
-
-DLL_FUNCTION(uint32_t) 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,57 +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/>.
-
-#pragma once
-#include "BlitzSteam.h"
-
-DLL_FUNCTION(CSteamID*) BS_CSteamID_New();
-DLL_FUNCTION(CSteamID*) BS_CSteamID_FromID(uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType);
-DLL_FUNCTION(CSteamID*) BS_CSteamID_FromIDInstance(uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType);
-DLL_FUNCTION(CSteamID*) BS_CSteamID_FromSteamID(uint64_t* ulSteamID);
-DLL_FUNCTION(CSteamID*) BS_CSteamID_Copy(CSteamID* pSteamID);
-DLL_FUNCTION(void) BS_CSteamID_Destroy(CSteamID* pSteamID);
-DLL_FUNCTION(void) BS_CSteamID_Set(CSteamID* pSteamID, uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType);
-DLL_FUNCTION(void) BS_CSteamID_InstancedSet(CSteamID* pSteamID, uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType);
-DLL_FUNCTION(void) BS_CSteamID_FullSet(CSteamID* pSteamID, uint64_t* ulIdentifier, EUniverse eUniverse, EAccountType eAccountType);
-DLL_FUNCTION(void) BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID);
-DLL_FUNCTION(void) BS_CSteamID_Clear(CSteamID* pSteamID);
-DLL_FUNCTION(uint64_t*) BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID);
-DLL_FUNCTION(uint64_t*) BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID);
-DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_FUNCTION(uint32_t) BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_GameServerAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_ContentServerAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_ClanAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_ChatAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_IsLobby(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_IndividualAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_AnonAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_AnonUserAccount(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID);
-DLL_FUNCTION(void) BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID);
-DLL_FUNCTION(void) BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance);
-DLL_FUNCTION(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID);
-DLL_FUNCTION(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pSteamID);
-DLL_FUNCTION(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pSteamID);
-DLL_FUNCTION(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pSteamID);
-DLL_FUNCTION(void) BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_FUNCTION(uint32_t) BS_CSteamID_IsValid(CSteamID* pSteamID);
-DLL_FUNCTION(uint32_t) BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther);

Helpers/Helper.cpp

@@ -17,7 +17,6 @@
 #include "Helper.h"
 
 DLL_FUNCTION(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat) {
-#pragma comment(linker, "/EXPORT:BS_Helper_FormatUnixTime=_BS_Helper_FormatUnixTime@8")
 	char* output = new char[strlen(pchFormat) * 4];
 	time_t t = unTime;
 	struct tm *tm = localtime(&t);
@@ -25,18 +24,10 @@ DLL_FUNCTION(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char*
 	delete tm;
 	return output;
 }
-
-DLL_FUNCTION(void) BS_Helper_DeleteLong(uint64_t* pLong) {
-#pragma comment(linker, "/EXPORT:BS_Helper_DeleteLong=_BS_Helper_DeleteLong@4")
-	delete pLong;
-}
-
 DLL_FUNCTION(double_t*) BS_Helper_CreateDouble(float_t value) {
-#pragma comment(linker, "/EXPORT:BS_Helper_CreateDouble=_BS_Helper_CreateDouble@4")
 	return new double_t(value);
 }
 
 DLL_FUNCTION(void) BS_Helper_DeleteDouble(double_t* pDouble) {
-#pragma comment(linker, "/EXPORT:BS_Helper_DeleteDouble=_BS_Helper_DeleteDouble@4")
 	delete pDouble;
 }

Helpers/Helper.h

@@ -14,7 +14,6 @@
 //	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
+BS_I#include "BlitzSteam.h"
-#include "BlitzSteam.h"
 
 DLL_FUNCTION(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat);

Helpers/Memory.cpp

@@ -17,56 +17,45 @@
 #include "Memory.h"
 
 DLL_FUNCTION(void*) BS_Memory_Alloc(uint32_t iSize) {
-#pragma comment(linker, "/EXPORT:BS_Memory_Alloc=_BS_Memory_Alloc@4")
 	return malloc(iSize);
 }
 
 DLL_FUNCTION(void*) BS_Memory_ReAlloc(void* pMemory, uint32_t iNewSize) {
-#pragma comment(linker, "/EXPORT:BS_Memory_ReAlloc=_BS_Memory_ReAlloc@8")
 	return realloc(pMemory, iNewSize);
 }
 
 DLL_FUNCTION(void) BS_Memory_Free(void* pMemory) {
-#pragma comment(linker, "/EXPORT:BS_Memory_Free=_BS_Memory_Free@4")
 	free(pMemory);
 }
 
 DLL_FUNCTION(uint8_t) BS_Memory_PeekByte(void* pMemory, uint32_t offset) {
-#pragma comment(linker, "/EXPORT:BS_Memory_PeekByte=_BS_Memory_PeekByte@8")
 	return *(reinterpret_cast<uint8_t*>(pMemory) + offset);
 }
 
 DLL_FUNCTION(uint16_t) BS_Memory_PeekShort(void* pMemory, uint32_t offset) {
-#pragma comment(linker, "/EXPORT:BS_Memory_PeekShort=_BS_Memory_PeekShort@8")
 	return *(uint16_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
 }
 
 DLL_FUNCTION(uint32_t) BS_Memory_PeekInt(void* pMemory, uint32_t offset) {
-#pragma comment(linker, "/EXPORT:BS_Memory_PeekInt=_BS_Memory_PeekInt@8")
 	return *(uint32_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
 }
 
 DLL_FUNCTION(float_t) BS_Memory_PeekFloat(void* pMemory, uint32_t offset) {
-#pragma comment(linker, "/EXPORT:BS_Memory_PeekFloat=_BS_Memory_PeekFloat@8")
 	return *(float_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
 }
 
 DLL_FUNCTION(void) BS_Memory_PokeByte(void* pMemory, uint32_t offset, uint8_t value) {
-#pragma comment(linker, "/EXPORT:BS_Memory_PokeByte=_BS_Memory_PokeByte@12")
 	*((reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
 }
 
 DLL_FUNCTION(void) BS_Memory_PokeShort(void* pMemory, uint32_t offset, uint16_t value) {
-#pragma comment(linker, "/EXPORT:BS_Memory_PokeShort=_BS_Memory_PokeShort@12")
 	*(reinterpret_cast<uint16_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
 }
 
 DLL_FUNCTION(void) BS_Memory_PokeInt(void* pMemory, uint32_t offset, uint32_t value) {
-#pragma comment(linker, "/EXPORT:BS_Memory_PokeInt=_BS_Memory_PokeInt@12")
 	*(reinterpret_cast<uint32_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
 }
 
 DLL_FUNCTION(void) BS_Memory_PokeFloat(void* pMemory, uint32_t offset, float_t value) {
-#pragma comment(linker, "/EXPORT:BS_Memory_PokeFloat=_BS_Memory_PokeFloat@12")
 	*(reinterpret_cast<float_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
 }

Helpers/Memory.h

@@ -14,8 +14,7 @@
 //	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
+BS_I#include "BlitzSteam.h"
-#include "BlitzSteam.h"
 
 DLL_FUNCTION(void*) BS_Memory_Alloc(uint32_t iSize);
 DLL_FUNCTION(void*) BS_Memory_ReAlloc(void* pMemory, uint32_t iNewSize);

Resources/BlitzSteamUtility.bb

@@ -534,7 +534,7 @@ End Function
 ;! 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_GameServer_Init(IPv4, SteamPort, Port, QueryPort, ServerMode, Version) Then
+	If BS_SteamGameServer_Init(IPv4, SteamPort, Port, QueryPort, ServerMode, Version) Then
 		BSU_GameServer = BS_GameServer()
 		BSU_GameServerStats = BS_GameServerStats()
 		BSU_HTTP = BS_GameServerHTTP()
@@ -549,7 +549,7 @@ End Function
 
 Function BSU_GameServer_Shutdown()
 	If BSU_Initialized = True
-		BS_GameServer_Shutdown()
+		BS_SteamGameServer_Shutdown()
 		
 		BSU_GameServer=0
 		BSU_GameServerStats=0

Resources/Decls/BlitzSteam.decls

@@ -0,0 +1,161 @@
+;	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_Networking%()
+BS_GameServerNetworking%()
+BS_Networking_SendP2PPacket%(pSteamNetworking%, pSteamIDRemote%, pubData*, cubData%, eP2PSendType%, nChannel%)
+BS_Networking_SendP2PPacketEx%(pSteamNetworking%, pSteamIDRemote%, pubData%, cubData%, eP2PSendType%, nChannel%) : "BS_Networking_SendP2PPacket"
+BS_Networking_IsP2PPacketAvailable%(pSteamNetworking%, pcubMsgSize*, nChannel%)
+BS_Networking_IsP2PPacketAvailableEx%(pSteamNetworking%, pcubMsgSize*, nChannel%) : "BS_Networking_IsP2PPacketAvailable"
+BS_Networking_ReadP2PPacket%(pSteamNetworking%, pubDest*, cubDest%, pcubMsgSize*, pSteamIDRemote%, nChannel%)
+BS_Networking_ReadP2PPacketEx%(pSteamNetworking%, pubDest%, cubDest%, pcubMsgSize%, pSteamIDRemote%, nChannel%) : "BS_Networking_ReadP2PPacket"
+BS_Networking_AcceptP2PSessionWithUser%(pSteamNetworking%, pSteamIDRemote%)
+BS_Networking_CloseP2PSessionWithUser%(pSteamNetworking%, pSteamIDRemote%)
+BS_Networking_CloseP2PChannelWithUser%(pSteamNetworking%, pSteamIDRemote%, nChannel%)
+BS_Networking_GetP2PSessionState%(pSteamNetworking%, pSteamIDRemote%, pConnectionState*)
+BS_Networking_AllowP2PPacketRelay%(pSteamNetworking%, bAllow%)
+
+; User ------------------------------------------------------------------------
+BS_User%()
+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$)
+
+; UserStats -------------------------------------------------------------------
+BS_UserStats%()
+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"
+
+; -- Interfaces
+BS_HTTP%()
+BS_GameServerHTTP%()
+BS_Inventory%()
+BS_GameServerInventory%()
+BS_Matchmaking%()
+BS_MatchmakingServers%()
+BS_Music%()
+BS_MusicRemote%()
+BS_RemoteStorage%()
+BS_Screenshots%()
+BS_UGC%()
+BS_GameServerUGC%()
+BS_UnifiedMessages%()
+BS_Utils%()
+BS_GameServerUtils%()
+BS_Video%()
+
+; Helpers ---------------------------------------------------------------------
+; -- Generic
+BS_Helper_FormatUnixTime$(unixTime%, pchFormat$)
+; -- Memory
+BS_Memory_Alloc%(iSize%)
+BS_Memory_ReAlloc%(pMemory%, iSize%)
+BS_Memory_Free(pMemory%)
+BS_Memory_PeekByte%(pMemory%, offset%)
+BS_Memory_PeekShort%(pMemory%, offset%)
+BS_Memory_PeekInt%(pMemory%, offset%)
+BS_Memory_PeekFloat#(pMemory%, offset%)
+BS_Memory_PokeByte(pMemory%, offset%, value%)
+BS_Memory_PokeShort(pMemory%, offset%, value%)
+BS_Memory_PokeInt(pMemory%, offset%, value%)
+BS_Memory_PokeFloat(pMemory%, offset%, value#)

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_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/Examples/SteamHTMLSurface_Example.bb

@@ -1,4 +1,5 @@
 Include "../BlitzSteam.bb"
+Stop
 
 ;----------------------------------------------------------------
 ;! Steam Stuff
@@ -73,12 +74,12 @@ Function Browser_HTMLSurface_BrowserReady(pvParam%, bIOFailure, llSteamAPICall)
 	Browser_SetSize(Browser, Browser\ImageSize[0], Browser\ImageSize[1])
 	
 	; Cleanup
-	BS_Helper_DeleteLong(Browser\z_llSteamAPICall):Browser\z_llSteamAPICall = 0
+	BS_Long_Destroy Browser\z_llSteamAPICall : Browser\z_llSteamAPICall = 0
 	BS_Callback_UnregisterResult Browser_HTMLSurface_BrowserReady_c ; Caller does this too.
 End Function:Browser_HTMLSurface_BrowserReady(0, 0, 0)
 
 Global Browser_HTMLSurface_NeedsPaint_p = 0, Browser_HTMLSurface_NeedsPaint_c = 0
-Function Browser_HTMLSurface_NeedsPaint(pvParam%)
+Function Browser_HTMLSurface_NeedsPaint(pvParam%, p2, p3)
 	If (Browser_HTMLSurface_NeedsPaint_p = 0) Then
 		Browser_HTMLSurface_NeedsPaint_p = BP_GetFunctionPointer()
 		Browser_HTMLSurface_NeedsPaint_c = BS_Callback_Create(Browser_HTMLSurface_NeedsPaint_p)
@@ -103,10 +104,10 @@ Function Browser_HTMLSurface_NeedsPaint(pvParam%)
 	;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:Browser_HTMLSurface_NeedsPaint(0)
+End Function:Browser_HTMLSurface_NeedsPaint(0, 0, 0)
 
 Global Browser_HTMLSurface_StartRequest_p = 0, Browser_HTMLSurface_StartRequest_c = 0
-Function Browser_HTMLSurface_StartRequest(pvParam%)
+Function Browser_HTMLSurface_StartRequest(pvParam%, p2, p3)
 	If (Browser_HTMLSurface_StartRequest_p = 0) Then
 		Browser_HTMLSurface_StartRequest_p = BP_GetFunctionPointer()
 		Browser_HTMLSurface_StartRequest_c = BS_Callback_Create(Browser_HTMLSurface_StartRequest_p)
@@ -117,13 +118,13 @@ Function Browser_HTMLSurface_StartRequest(pvParam%)
 	
 	; Default to allow all requests. (Why not? For an Example, this is good enough.)
 	BS_HTMLSurface_AllowStartRequest BS_HTMLSurface(), PeekMemoryInt(pvParam), True
-End Function:Browser_HTMLSurface_StartRequest(0)
+End Function:Browser_HTMLSurface_StartRequest(0, 0, 0)
 
 Function Browser_Create.Browser(Width%, Height, UserAgent$="BlitzSteam", UserCSS$="")
 	DebugLog "[Browser::Create] Creating with UserAgent '"+UserAgent+"' and CSS '"+UserCSS+"'."
 	
 	; Register Callbacks (Can do this in an Init function too)
-	BS_Callback_Register Browser_HTMLSurface_BrowserReady_c, BS_HTMLSurface_BrowserReady
+	;BS_Callback_Register Browser_HTMLSurface_BrowserReady_c, BS_HTMLSurface_BrowserReady
 	BS_Callback_Register Browser_HTMLSurface_NeedsPaint_c, BS_HTMLSurface_NeedsPaint
 	BS_Callback_Register Browser_HTMLSurface_StartRequest_c, BS_HTMLSurface_StartRequest
 	
@@ -132,9 +133,10 @@ Function Browser_Create.Browser(Width%, Height, UserAgent$="BlitzSteam", UserCSS
 	Browser\z_llSteamAPICall = BS_HTMLSurface_CreateBrowser(BS_HTMLSurface(), UserAgent, UserCSS)
 	Browser\ImageSize[0] = Width
 	Browser\ImageSize[1] = Height
+	DebugLog "llSteamAPICall: " + Hex(BS_Long_ToIH(Browser\z_llSteamAPICall)) + Hex(BS_Long_ToIL(Browser\z_llSteamAPICall))
 	
 	; Register CallResult
-	BS_Callback_RegisterResult Browser_HTMLSurface_BrowserReady_c, Browser\z_llSteamAPICall 
+	BS_Callback_RegisterResult Browser_HTMLSurface_BrowserReady_c, Browser\z_llSteamAPICall, BS_HTMLSurface_BrowserReady
 	
 	Return Browser
 End Function
@@ -142,7 +144,7 @@ End Function
 Function Browser_IsReady(Browser.Browser)
 	If Browser = Null Then Return False
 	
-	DebugLog "[Browser::IsReady] Checking if '"+Browser\Id+"'/'"+Browser\z_llSteamAPICall+"' is ready."
+	DebugLog "[Browser::IsReady] Checking if '"+Browser\Id+"'/'"+Hex(BS_Long_ToIH(Browser\z_llSteamAPICall)) + Hex(BS_Long_ToIL(Browser\z_llSteamAPICall))+"' is ready."
 	
 	Return (Browser\Id <> 0)
 End Function
@@ -167,7 +169,7 @@ Function Browser_FindBySteamAPICall.Browser(llSteamAPICall%)
 	
 	Local Browser.Browser
 	For Browser = Each Browser
-		If Browser\z_llSteamAPICall = llSteamAPICall Then Return Browser
+		If BS_Long_Compare(Browser\z_llSteamAPICall,llSteamAPICall) = 0 Then Return Browser
 	Next
 	
 	Return Null
@@ -231,10 +233,11 @@ Graphics3D 1024, 768, 32, 2:SetBuffer BackBuffer()
 ; Create a Browser
 Local myBrowser.Browser = Browser_Create(512, 512)
 
-While Not Browser_IsReady(myBrowser)
+Repeat 
 	BS_Steam_RunCallbacks()
+	
 	Delay 100
-Wend
+Until Browser_IsReady(myBrowser)
 
 While Not KeyHit(1)
 	Cls

Types/CSteamID.cpp

@@ -0,0 +1,169 @@
+//	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_FUNCTION(CSteamID*) BS_CSteamID_New() {
+	return new CSteamID();
+}
+
+DLL_FUNCTION(CSteamID*) BS_CSteamID_Copy(CSteamID* pOther) {
+	return new CSteamID(*pOther);
+}
+
+DLL_FUNCTION(void) BS_CSteamID_Destroy(CSteamID* pThis) {
+	delete pThis;
+}
+
+DLL_FUNCTION(CSteamID*) BS_CSteamID_New_IdUniverseType(AccountID_t iAccountId, EUniverse eUniverse, EAccountType eAccountType) {
+	return new CSteamID(iAccountId, eUniverse, eAccountType);
+}
+
+DLL_FUNCTION(CSteamID*) BS_CSteamID_New_IdInstanceUniverseType(AccountID_t iAccountId, uint32_t iInstance, EUniverse eUniverse, EAccountType eAccountType) {
+	return new CSteamID(iAccountId, iInstance, eUniverse, eAccountType);
+}
+
+DLL_FUNCTION(CSteamID*) BS_CSteamID_FromL(int64_t* pOther) {
+	return new CSteamID((uint64_t)*pOther);
+}
+
+DLL_FUNCTION(int64_t*) BS_CSteamID_ToL(CSteamID* pThis) {
+	return new int64_t(pThis->ConvertToUint64());
+}
+
+DLL_FUNCTION(void) BS_CSteamID_Set(CSteamID* pThis, AccountID_t iAccountID, EUniverse eUniverse, EAccountType eAccountType) {
+	pThis->Set(iAccountID, eUniverse, eAccountType);
+}
+
+DLL_FUNCTION(void) BS_CSteamID_InstancedSet(CSteamID* pThis, AccountID_t iAccountId, uint32_t iInstance, EUniverse eUniverse, EAccountType eAccountType) {
+	pThis->InstancedSet(iAccountId, iInstance, eUniverse, eAccountType);
+}
+
+DLL_FUNCTION(void) BS_CSteamID_FullSet(CSteamID* pThis, int64_t* plIdentifier, EUniverse eUniverse, EAccountType eAccountType) {
+	pThis->FullSet(*plIdentifier, eUniverse, eAccountType);
+}
+
+DLL_FUNCTION(void) BS_CSteamID_SetFromLong(CSteamID* pThis, int64_t* plSteamID) {
+	pThis->SetFromUint64(*plSteamID);
+}
+
+DLL_FUNCTION(void) BS_CSteamID_Clear(CSteamID* pThis) {
+	pThis->Clear();
+}
+
+DLL_FUNCTION(int64_t*) BS_CSteamID_GetStaticAccountKey(CSteamID* pThis) {
+	return new int64_t(pThis->GetStaticAccountKey());
+}
+
+DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pThis, EUniverse eUniverse) {
+	pThis->CreateBlankAnonLogon(eUniverse);
+}
+
+DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pThis, EUniverse eUniverse) {
+	pThis->CreateBlankAnonUserLogon(eUniverse);
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsBlankAnonAccount(CSteamID* pThis) {
+	return pThis->BBlankAnonAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsGameServerAccount(CSteamID* pThis) {
+	return pThis->BGameServerAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsPersistentGameServerAccount(CSteamID* pThis) {
+	return pThis->BPersistentGameServerAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsAnonGameServerAccount(CSteamID* pThis) {
+	return pThis->BAnonGameServerAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsContentServerAccount(CSteamID* pThis) {
+	return pThis->BContentServerAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsClanAccount(CSteamID* pThis) {
+	return pThis->BClanAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsChatAccount(CSteamID* pThis) {
+	return pThis->BChatAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsLobby(CSteamID* pThis) {
+	return pThis->IsLobby();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsIndividualAccount(CSteamID* pThis) {
+	return pThis->BIndividualAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsAnonAccount(CSteamID* pThis) {
+	return pThis->BAnonAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsAnonUserAccount(CSteamID* pThis) {
+	return pThis->BAnonUserAccount();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_IsConsoleUserAccount(CSteamID* pThis) {
+	return pThis->BConsoleUserAccount();
+}
+
+DLL_FUNCTION(void) BS_CSteamID_SetAccountID(CSteamID* pThis, AccountID_t iAccountId) {
+	pThis->SetAccountID(iAccountId);
+}
+
+DLL_FUNCTION(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pThis) {
+	return pThis->GetAccountID();
+}
+
+DLL_FUNCTION(void) BS_CSteamID_SetAccountInstance(CSteamID* pThis, uint32_t iInstance) {
+	pThis->SetAccountInstance(iInstance);
+}
+
+DLL_FUNCTION(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pThis) {
+	pThis->ClearIndividualInstance();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pThis) {
+	return pThis->HasNoIndividualInstance();
+}
+
+DLL_FUNCTION(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pThis) {
+	return pThis->GetUnAccountInstance();
+}
+
+DLL_FUNCTION(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pThis) {
+	return pThis->GetEAccountType();
+}
+
+DLL_FUNCTION(void) BS_CSteamID_SetEUniverse(CSteamID* pThis, EUniverse eUniverse) {
+	pThis->SetEUniverse(eUniverse);
+}
+
+DLL_FUNCTION(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pThis) {
+	return pThis->GetEUniverse();
+}
+
+DLL_FUNCTION(int32_t) BS_CSteamID_Compare(CSteamID* pThis, CSteamID* pOther) {
+	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,178 @@
+//	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/>.
+
+BS_I#include "BlitzSteam.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(CSteamID*) BS_CSteamID_New();
+DLL_FUNCTION(CSteamID*) BS_CSteamID_Copy(CSteamID* pOther);
+DLL_FUNCTION(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_FUNCTION(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_FUNCTION(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_FUNCTION(CSteamID*) BS_CSteamID_FromL(int64_t* pOther);
+DLL_FUNCTION(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_FUNCTION(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_FUNCTION(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_FUNCTION(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_FUNCTION(void) BS_CSteamID_SetFromLong(CSteamID* pThis, int64_t* plSteamID);
+
+//-----------------------------------------------------------------------------
+// Purpose: Clear all fields, leaving an invalid ID.
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(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_FUNCTION(int64_t*) BS_CSteamID_GetStaticAccountKey(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: create an anonymous game server login to be filled in by the AM
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pThis, EUniverse eUniverse);
+
+//-----------------------------------------------------------------------------
+// Purpose: create an anonymous game server login to be filled in by the AM
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pThis, EUniverse eUniverse);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an anonymous game server login that will be filled in?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsBlankAnonAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a game server account id?  (Either persistent or anonymous)
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsGameServerAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a persistent (not anonymous) game server account id?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsPersistentGameServerAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an anonymous game server account id?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsAnonGameServerAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a content server account id?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsContentServerAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a clan account id?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsClanAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a chat account id?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsChatAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a Lobby?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsLobby(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an individual user account id?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsIndividualAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an anonymous account?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsAnonAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this an anonymous user account? ( used to create an account or reset a password )
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsAnonUserAccount(CSteamID* pThis);
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this a faked up Steam ID for a PSN friend account?
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(int32_t) BS_CSteamID_IsConsoleUserAccount(CSteamID* pThis);
+
+// simple accessors
+DLL_FUNCTION(void) BS_CSteamID_SetAccountID(CSteamID* pThis, AccountID_t iAccountId);
+DLL_FUNCTION(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pThis);
+
+DLL_FUNCTION(void) BS_CSteamID_SetAccountInstance(CSteamID* pThis, uint32_t iInstance);
+DLL_FUNCTION(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pThis);
+DLL_FUNCTION(int32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pThis);
+DLL_FUNCTION(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pThis);
+
+DLL_FUNCTION(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pThis);
+
+DLL_FUNCTION(void) BS_CSteamID_SetEUniverse(CSteamID* pThis, EUniverse eUniverse);
+DLL_FUNCTION(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pThis);
+
+DLL_FUNCTION(int32_t) BS_CSteamID_Compare(CSteamID* pThis, CSteamID* pOther);

Types/Double.cpp

@@ -0,0 +1,122 @@
+//	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_FUNCTION(double_t*) BS_Double_New() {
+	return new double_t;
+}
+DLL_FUNCTION(double_t*) BS_Double_Copy(double_t* pOther) {
+	return new double_t(*pOther);
+}
+DLL_FUNCTION(void) BS_Double_Destroy(double_t* pThis) {
+	delete pThis;
+}
+
+char* BS_Double_Buffer = new char[32];
+DLL_FUNCTION(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_FUNCTION(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_FUNCTION(double_t*) BS_Double_FromF(float_t fOther) {
+	return new double_t(fOther);
+}
+DLL_FUNCTION(float_t) BS_Double_ToF(double_t* pThis) {
+	return (float_t)*pThis;
+}
+
+DLL_FUNCTION(double_t*) BS_Double_FromI(int32_t iOther) {
+	return new double_t(iOther);
+}
+DLL_FUNCTION(int32_t) BS_Double_ToI(double_t* pThis) {
+	return (int32_t)*pThis;
+}
+
+DLL_FUNCTION(double_t*) BS_Double_FromL(int64_t* pOther) {
+	return new double_t((double_t)*pOther);
+}
+DLL_FUNCTION(int64_t*) BS_Double_ToL(double_t* pThis) {
+	return new int64_t((int64_t)*pThis);
+}
+
+DLL_FUNCTION(int32_t) BS_Double_Compare(double_t* pThis, double_t* pOther) {
+	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_FUNCTION(double_t*) BS_Double_Set(double_t* pThis, double_t* pOther) {
+	*pThis = *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_Add(double_t* pThis, double_t* pOther) {
+	*pThis += *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_Sub(double_t* pThis, double_t* pOther) {
+	*pThis -= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_Div(double_t* pThis, double_t* pOther) {
+	*pThis /= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_Mul(double_t* pThis, double_t* pOther) {
+	*pThis *= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_Mod(double_t* pThis, double_t* pOther) {
+	*pThis = fmod(*pThis, *pOther);
+	return pThis;
+}
+
+DLL_FUNCTION(double_t*) BS_Double_SetF(double_t* pThis, float_t fOther) {
+	*pThis = fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_AddF(double_t* pThis, float_t fOther) {
+	*pThis += fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_SubF(double_t* pThis, float_t fOther) {
+	*pThis -= fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_DivF(double_t* pThis, float_t fOther) {
+	*pThis /= fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_MulF(double_t* pThis, float_t fOther) {
+	*pThis *= fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BS_Double_ModF(double_t* pThis, float_t fOther) {
+	*pThis = fmod(*pThis, fOther);
+	return pThis;
+}

Types/Double.h

@@ -0,0 +1,50 @@
+//	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/>.
+
+BS_I#include "BlitzSteam.h"
+#include <sstream>
+
+DLL_FUNCTION(double_t*) BS_Double_New();
+DLL_FUNCTION(double_t*) BS_Double_Copy(double_t* pRight);
+DLL_FUNCTION(void) BS_Double_Destroy(double_t* pThis);
+
+DLL_FUNCTION(const char*) BS_Double_ToString(double_t* pThis);
+DLL_FUNCTION(double_t*) BS_Double_FromString(const char* pString);
+
+DLL_FUNCTION(double_t*) BS_Double_FromF(float_t fOther);
+DLL_FUNCTION(float_t) BS_Double_ToF(double_t* pThis);
+
+DLL_FUNCTION(double_t*) BS_Double_FromI(int32_t iOther);
+DLL_FUNCTION(int32_t) BS_Double_ToI(double_t* pThis);
+
+DLL_FUNCTION(double_t*) BS_Double_FromL(int64_t* pOther);
+DLL_FUNCTION(int64_t*) BS_Double_ToL(double_t* pThis);
+
+DLL_FUNCTION(int32_t) BS_Double_Compare(double_t* pThis, double_t* pOther);
+
+DLL_FUNCTION(double_t*) BS_Double_Set(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BS_Double_Add(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BS_Double_Sub(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BS_Double_Div(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BS_Double_Mul(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BS_Double_Mod(double_t* pThis, double_t* pOther);
+
+DLL_FUNCTION(double_t*) BS_Double_SetF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BS_Double_AddF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BS_Double_SubF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BS_Double_DivF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BS_Double_MulF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BS_Double_ModF(double_t* pThis, float_t fOther);

Types/Long.cpp

@@ -0,0 +1,167 @@
+//	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_FUNCTION(int64_t*) BS_Long_New() {
+	return new int64_t;
+}
+DLL_FUNCTION(int64_t*) BS_Long_Copy(int64_t* pOther) {
+	return new int64_t(*pOther);
+}
+DLL_FUNCTION(void) BS_Long_Destroy(int64_t* pThis) {
+	delete pThis;
+}
+
+char* BS_Long_Buffer = new char[32];
+DLL_FUNCTION(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_FUNCTION(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_FUNCTION(int64_t*) BS_Long_FromI(int32_t iRight) {
+	return new int64_t(iRight);
+}
+DLL_FUNCTION(int64_t*) BS_Long_FromII(int32_t iLeft, int32_t iRight) {
+	return new int64_t(((int64_t)(iLeft) << 32) + iRight);
+}
+DLL_FUNCTION(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_FUNCTION(int32_t) BS_Long_ToIH(int64_t* pThis) {
+	return (int32_t)(*pThis >> 32);
+}
+DLL_FUNCTION(int32_t) BS_Long_ToIL(int64_t* pThis) {
+	return (int32_t)*pThis;
+}
+
+DLL_FUNCTION(int64_t*) BS_Long_FromF(float_t fOther) {
+	return new int64_t((int64_t)fOther);
+}
+DLL_FUNCTION(float_t) BS_Long_ToF(int64_t* pThis) {
+	return (float_t)*pThis;
+}
+
+DLL_FUNCTION(int64_t*) BS_Long_FromD(double_t* pOther) {
+	return new int64_t((int64_t)*pOther);
+}
+DLL_FUNCTION(double_t*) BS_Long_ToD(int64_t* pThis) {
+	return new double_t((double_t)*pThis);
+}
+
+DLL_FUNCTION(int32_t) BS_Long_Compare(int64_t* pThis, int64_t* pOther) {
+	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_FUNCTION(int64_t*) BS_Long_Set(int64_t* pThis, int64_t* pOther) {
+	*pThis = *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_Add(int64_t* pThis, int64_t* pOther) {
+	*pThis += *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_Sub(int64_t* pThis, int64_t* pOther) {
+	*pThis -= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_Div(int64_t* pThis, int64_t* pOther) {
+	*pThis /= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_Mul(int64_t* pThis, int64_t* pOther) {
+	*pThis *= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_Mod(int64_t* pThis, int64_t* pOther) {
+	*pThis %= *pOther;
+	return pThis;
+}
+
+DLL_FUNCTION(int64_t*) BS_Long_SetI(int64_t* pThis, int32_t iRight) {
+	*pThis = iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_AddI(int64_t* pThis, int32_t iRight) {
+	*pThis += iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_SubI(int64_t* pThis, int32_t iRight) {
+	*pThis -= iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_DivI(int64_t* pThis, int32_t iRight) {
+	*pThis /= iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_MulI(int64_t* pThis, int32_t iRight) {
+	*pThis *= iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_ModI(int64_t* pThis, int32_t iRight) {
+	*pThis %= iRight;
+	return pThis;
+}
+
+DLL_FUNCTION(int64_t*) BS_Long_SetII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis = (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_AddII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis += (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_SubII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis -= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_DivII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis /= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_MulII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis *= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BS_Long_ModII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis %= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+
+DLL_FUNCTION(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,62 @@
+//	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/>.
+
+BS_I#include "BlitzSteam.h"
+#include <sstream>
+
+DLL_FUNCTION(int64_t*) BS_Long_New();
+DLL_FUNCTION(int64_t*) BS_Long_Copy(int64_t* pRight);
+DLL_FUNCTION(void) BS_Long_Destroy(int64_t* pThis);
+
+DLL_FUNCTION(const char*) BS_Long_ToString(int64_t* pThis);
+DLL_FUNCTION(int64_t*) BS_Long_FromString(const char* pString);
+
+DLL_FUNCTION(int64_t*) BS_Long_FromI(int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_FromII(int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int32_t) BS_Long_ToI(int64_t* pThis, int32_t iShift);
+DLL_FUNCTION(int32_t) BS_Long_ToIH(int64_t* pThis);
+DLL_FUNCTION(int32_t) BS_Long_ToIL(int64_t* pThis);
+
+DLL_FUNCTION(int64_t*) BS_Long_FromF(float_t fOther);
+DLL_FUNCTION(float_t) BS_Long_ToF(int64_t* pThis);
+
+DLL_FUNCTION(int64_t*) BS_Long_FromD(double_t* pOther);
+DLL_FUNCTION(double_t*) BS_Long_ToD(int64_t* pThis);
+
+DLL_FUNCTION(int32_t) BS_Long_Compare(int64_t* pThis, int64_t* pOther);
+
+DLL_FUNCTION(int64_t*) BS_Long_Set(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BS_Long_Add(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BS_Long_Sub(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BS_Long_Div(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BS_Long_Mul(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BS_Long_Mod(int64_t* pThis, int64_t* pOther);
+
+DLL_FUNCTION(int64_t*) BS_Long_SetI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_AddI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_SubI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_DivI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_MulI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_ModI(int64_t* pThis, int32_t iRight);
+
+DLL_FUNCTION(int64_t*) BS_Long_SetII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_AddII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_SubII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_DivII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_MulII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BS_Long_ModII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+
+DLL_FUNCTION(int64_t*) BS_Long_Shift(int64_t* pThis, int32_t iShift);

Wrapper/Steam.cpp

@@ -15,59 +15,86 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "BlitzSteam.h"
+#include "Helpers\BlitzCallback.h"
 
-DLL_FUNCTION(uint32_t) BS_Steam_Init() {
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
-#pragma comment(linker, "/EXPORT:BS_Steam_Init=_BS_Steam_Init@0")
+//	Steam API setup & shutdown
+//
+//	These functions manage loading, initializing and shutdown of the steamclient.dll
+//
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+DLL_FUNCTION(int32_t) BS_SteamAPI_Init() {
 	return SteamAPI_Init();
 }
 
-DLL_FUNCTION(void) BS_Steam_Shutdown() {
+DLL_FUNCTION(void) BS_SteamAPI_Shutdown() {
-#pragma comment(linker, "/EXPORT:BS_Steam_Shutdown=_BS_Steam_Shutdown@0")
 	SteamAPI_Shutdown();
 }
 
-DLL_FUNCTION(uint32_t) BS_Steam_IsSteamRunning() {
+// checks if a local Steam client is running 
-#pragma comment(linker, "/EXPORT:BS_Steam_IsSteamRunning=_BS_Steam_IsSteamRunning@0")
+DLL_FUNCTION(int32_t) BS_SteamAPI_IsSteamRunning() {
 	return SteamAPI_IsSteamRunning();
 }
 
-DLL_FUNCTION(uint32_t) BS_Steam_RestartAppIfNecessary(uint32_t unOwnAppID) {
+// Detects if your executable was launched through the Steam client, and restarts your game through 
-#pragma comment(linker, "/EXPORT:BS_Steam_RestartAppIfNecessary=_BS_Steam_RestartAppIfNecessary@4")
+// 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_FUNCTION(int32_t) BS_SteamAPI_RestartAppIfNecessary(uint32_t unOwnAppID) {
 	return SteamAPI_RestartAppIfNecessary(unOwnAppID);
 }
 
-DLL_FUNCTION(void) BS_Steam_SetMiniDumpComment(const char* pchMsg) {
+// crash dump recording functions
-#pragma comment(linker, "/EXPORT:BS_Steam_SetMiniDumpComment=_BS_Steam_SetMiniDumpComment@4")
+DLL_FUNCTION(void) BS_SteamAPI_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32_t uBuildID) {
-	SteamAPI_SetMiniDumpComment(pchMsg);
-}
-
-DLL_FUNCTION(void) BS_Steam_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32_t uBuildID) {
-#pragma comment(linker, "/EXPORT:BS_Steam_WriteMiniDump=_BS_Steam_WriteMiniDump@12")
 	SteamAPI_WriteMiniDump(uStructuredExceptionCode, pvExceptionInfo, uBuildID);
 }
 
+DLL_FUNCTION(void) BS_SteamAPI_SetMiniDumpComment(const char* pchMsg) {
+	SteamAPI_SetMiniDumpComment(pchMsg);
+}
+
+// Most Steam API functions allocate some amount of thread-local memory for
+// 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_FUNCTION(void) BS_SteamAPI_ReleaseCurrentThreadMemory() {
+	return SteamAPI_ReleaseCurrentThreadMemory();
+}
+
 // -- Callbacks
-DLL_FUNCTION(void) BS_Steam_RunCallbacks() {
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
-#pragma comment(linker, "/EXPORT:BS_Steam_RunCallbacks=_BS_Steam_RunCallbacks@0")
+//	steam callback and call-result helpers
+//
+//	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().
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+// SteamAPI_RunCallbacks is safe to call from multiple threads simultaneously,
+// but if you choose to do this, callback code may be executed on any thread.
+DLL_FUNCTION(void) BS_SteamAPI_RunCallbacks() {
 	SteamAPI_RunCallbacks();
 }
-
-DLL_FUNCTION(void) BS_Steam_RegisterCallback(class CCallbackBase *pCallback, uint32_t iCallback) {
-#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallback=_BS_Steam_RegisterCallback@8")
-	SteamAPI_RegisterCallback(pCallback, iCallback);
-}
-
-DLL_FUNCTION(void) BS_Steam_UnregisterCallback(class CCallbackBase *pCallback) {
-#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallback=_BS_Steam_UnregisterCallback@4")
-	SteamAPI_UnregisterCallback(pCallback);
-}
-
-DLL_FUNCTION(void) BS_Steam_RegisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) {
-#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallResult=_BS_Steam_RegisterCallResult@8")
-	SteamAPI_RegisterCallResult(pCallback, *phAPICall);
-}
-
-DLL_FUNCTION(void) BS_Steam_UnregisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) {
-#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallResult=_BS_Steam_UnregisterCallResult@8")
-	SteamAPI_UnregisterCallResult(pCallback, *phAPICall);
-}

Wrapper/SteamAppList.cpp

@@ -16,32 +16,35 @@
 
 #include "BlitzSteam.h"
 
-DLL_FUNCTION(ISteamAppList*) BS_AppList() {
+//-----------------------------------------------------------------------------
-#pragma comment(linker, "/EXPORT:BS_AppList=_BS_AppList@0")
+// 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_FUNCTION(ISteamAppList*) BS_SteamAppList() {
 	return SteamAppList();
 }
 
-DLL_FUNCTION(uint32_t) BS_AppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) {
+DLL_FUNCTION(int32_t) BS_ISteamAppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) {
-#pragma comment(linker, "/EXPORT:BS_AppList_GetNumInstalledApps=_BS_AppList_GetNumInstalledApps@4")
 	return lpSteamAppList->GetNumInstalledApps();
 }
 
-DLL_FUNCTION(uint32_t) BS_AppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32_t unMaxAppIDs) {
+DLL_FUNCTION(int32_t) BS_ISteamAppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32_t unMaxAppIDs) {
-#pragma comment(linker, "/EXPORT:BS_AppList_GetInstalledApps=_BS_AppList_GetInstalledApps@12")
 	return lpSteamAppList->GetInstalledApps(pvecAppID, unMaxAppIDs);
 }
 
-DLL_FUNCTION(uint32_t) BS_AppList_GetAppName(ISteamAppList* lpSteamAppList, AppId_t nAppID, const char* pchName, uint32_t cchNameMax) {
+// returns -1 if no name was found
-#pragma comment(linker, "/EXPORT:BS_AppList_GetAppName=_BS_AppList_GetAppName@16")
+DLL_FUNCTION(int32_t) BS_ISteamAppList_GetAppName(ISteamAppList* lpSteamAppList, AppId_t nAppID, const char* pchName, uint32_t cchNameMax) {
 	return lpSteamAppList->GetAppName(nAppID, (char*)pchName, cchNameMax);
 }
 
-DLL_FUNCTION(uint32_t) BS_AppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectoryBuffer, uint32_t cchDirectoryMax) {
+// returns -1 if no dir was found
-#pragma comment(linker, "/EXPORT:BS_AppList_GetAppInstallDir=_BS_AppList_GetAppInstallDir@16")
+DLL_FUNCTION(int32_t) BS_ISteamAppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectoryBuffer, uint32_t cchDirectoryMax) {
 	return lpSteamAppList->GetAppInstallDir(nAppID, pchDirectoryBuffer, cchDirectoryMax);
 }
 
-DLL_FUNCTION(uint32_t) 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
-#pragma comment(linker, "/EXPORT:BS_AppList_GetAppBuildId=_BS_AppList_GetAppBuildId@8")
+DLL_FUNCTION(int32_t) BS_ISteamAppList_GetAppBuildId(ISteamAppList* lpSteamAppList, AppId_t nAppID) {
 	return lpSteamAppList->GetAppBuildId(nAppID);
 }

Wrapper/SteamApps.cpp

@@ -16,127 +16,131 @@
 
 #include "BlitzSteam.h"
 
-DLL_FUNCTION(ISteamApps*) BS_Apps() {
+//-----------------------------------------------------------------------------
-#pragma comment(linker, "/EXPORT:BS_Apps=_BS_Apps@0")
+// Purpose: interface to app data
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(ISteamApps*) BS_SteamApps() {
 	return SteamApps();
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribed(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(int32_t) BS_ISteamApps_IsSubscribed(ISteamApps* lpSteamApps) {
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribed=_BS_Apps_IsSubscribed@4")
 	return lpSteamApps->BIsSubscribed();
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_IsLowViolence(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(int32_t) BS_ISteamApps_IsLowViolence(ISteamApps* lpSteamApps) {
-#pragma comment(linker, "/EXPORT:BS_Apps_IsLowViolence=_BS_Apps_IsLowViolence@4")
 	return lpSteamApps->BIsLowViolence();
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_IsCybercafe(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(int32_t) BS_ISteamApps_IsCybercafe(ISteamApps* lpSteamApps) {
-#pragma comment(linker, "/EXPORT:BS_Apps_IsCybercafe=_BS_Apps_IsCybercafe@4")
 	return lpSteamApps->BIsCybercafe();
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_IsVACBanned(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(int32_t) BS_ISteamApps_IsVACBanned(ISteamApps* lpSteamApps) {
-#pragma comment(linker, "/EXPORT:BS_Apps_IsVACBanned=_BS_Apps_IsVACBanned@4")
 	return lpSteamApps->BIsVACBanned();
 }
 
-DLL_FUNCTION(const char*) BS_Apps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(const char*) BS_ISteamApps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) {
-#pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentGameLanguage=_BS_Apps_GetCurrentGameLanguage@4")
 	return lpSteamApps->GetCurrentGameLanguage();
 }
 
-DLL_FUNCTION(const char*) BS_Apps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(const char*) BS_ISteamApps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) {
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAvailableGameLanguages=_BS_Apps_GetAvailableGameLanguages@4")
 	return lpSteamApps->GetAvailableGameLanguages();
 }
 
-DLL_FUNCTION(uint32_t) 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
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedApp=_BS_Apps_IsSubscribedApp@8")
+DLL_FUNCTION(int32_t) BS_ISteamApps_IsSubscribedApp(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsSubscribedApp(appID);
 }
 
-DLL_FUNCTION(uint32_t) 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
-#pragma comment(linker, "/EXPORT:BS_Apps_IsDlcInstalled=_BS_Apps_IsDlcInstalled@8")
+DLL_FUNCTION(int32_t) BS_ISteamApps_IsDlcInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsDlcInstalled(appID);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) {
+// returns the Unix time of the purchase of the app
-#pragma comment(linker, "/EXPORT:BS_Apps_GetEarliestPurchaseUnixTime=_BS_Apps_GetEarliestPurchaseUnixTime@8")
+DLL_FUNCTION(int32_t) BS_ISteamApps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->GetEarliestPurchaseUnixTime(appID);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) {
+// Checks if the user is subscribed to the current app through a free weekend
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedFromFreeWeekend=_BS_Apps_IsSubscribedFromFreeWeekend@4")
+// 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_FUNCTION(int32_t) BS_ISteamApps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsSubscribedFromFreeWeekend();
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetDLCCount(ISteamApps* lpSteamApps) {
+// Returns the number of DLC pieces for the running app
-#pragma comment(linker, "/EXPORT:BS_Apps_GetDLCCount=_BS_Apps_GetDLCCount@4")
+DLL_FUNCTION(int32_t) BS_ISteamApps_GetDLCCount(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetDLCCount();
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetDLCDataByIndex(ISteamApps* lpSteamApps, uint32_t iDLC, AppId_t *pAppIdBuffer, bool* pbAvailableBuffer, char *pchNameBuffer, uint32_t cchNameBufferSize) {
+// Returns metadata for DLC by index, of range [0, GetDLCCount()]
-#pragma comment(linker, "/EXPORT:BS_Apps_GetDLCDataByIndex=_BS_Apps_GetDLCDataByIndex@24")
+DLL_FUNCTION(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);
 }
 
-DLL_FUNCTION(void) BS_Apps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
+// Install/Uninstall control for optional DLC
-#pragma comment(linker, "/EXPORT:BS_Apps_InstallDLC=_BS_Apps_InstallDLC@8")
+DLL_FUNCTION(void) BS_ISteamApps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
 	lpSteamApps->InstallDLC(nAppID);
 }
 
-DLL_FUNCTION(void) BS_Apps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
+DLL_FUNCTION(void) BS_ISteamApps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
-#pragma comment(linker, "/EXPORT:BS_Apps_UninstallDLC=_BS_Apps_UninstallDLC@8")
 	lpSteamApps->UninstallDLC(nAppID);
 }
 
-DLL_FUNCTION(void) BS_Apps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) {
+// Request cd-key for yourself or owned DLC. If you are interested in this
-#pragma comment(linker, "/EXPORT:BS_Apps_RequestAppProofOfPurchaseKey=_BS_Apps_RequestAppProofOfPurchaseKey@8")
+// 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_FUNCTION(void) BS_ISteamApps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) {
 	lpSteamApps->RequestAppProofOfPurchaseKey(nAppID);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetCurrentBetaName(ISteamApps* lpSteamApps, char* pchNameBuffer, int cchNameBufferSize) {
+// returns current beta branch name, 'public' is the default branch
-#pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentBetaName=_BS_Apps_GetCurrentBetaName@12")
+DLL_FUNCTION(int32_t) BS_ISteamApps_GetCurrentBetaName(ISteamApps* lpSteamApps, char* pchNameBuffer, int cchNameBufferSize) {
 	return lpSteamApps->GetCurrentBetaName(pchNameBuffer, cchNameBufferSize);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) {
+// signal Steam that game files seems corrupt or missing
-#pragma comment(linker, "/EXPORT:BS_Apps_MarkContentCorrupt=_BS_Apps_MarkContentCorrupt@8")
+DLL_FUNCTION(int32_t) BS_ISteamApps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) {
 	return lpSteamApps->MarkContentCorrupt(bMissingFilesOnly != 0);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetInstalledDepots(ISteamApps* lpSteamApps, AppId_t nAppID, DepotId_t *pDepotsBuffer, uint32_t cMaxDepots) {
+// return installed depots in mount order
-#pragma comment(linker, "/EXPORT:BS_Apps_GetInstalledDepots=_BS_Apps_GetInstalledDepots@16")
+DLL_FUNCTION(int32_t) BS_ISteamApps_GetInstalledDepots(ISteamApps* lpSteamApps, AppId_t nAppID, DepotId_t *pDepotsBuffer, uint32_t cMaxDepots) {
 	return lpSteamApps->GetInstalledDepots(nAppID, pDepotsBuffer, cMaxDepots);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolderBuffer, uint32_t cchFolderBufferSize) {
+// returns current app install folder for AppID, returns folder name length
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAppInstallDir=_BS_Apps_GetAppInstallDir@16")
+DLL_FUNCTION(int32_t) BS_ISteamApps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolderBuffer, uint32_t cchFolderBufferSize) {
 	return lpSteamApps->GetAppInstallDir(appID, pchFolderBuffer, cchFolderBufferSize);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
+// returns true if that app is installed (not necessarily owned)
-#pragma comment(linker, "/EXPORT:BS_Apps_IsAppInstalled=_BS_Apps_IsAppInstalled@8")
+DLL_FUNCTION(int32_t) BS_ISteamApps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsAppInstalled(appID);
 }
 
-DLL_FUNCTION(CSteamID*) BS_Apps_GetAppOwner(ISteamApps* lpSteamApps) {
+// returns the SteamID of the original owner. If different from current user, it's borrowed
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAppOwner=_BS_Apps_GetAppOwner@4")
+DLL_FUNCTION(CSteamID*) BS_ISteamApps_GetAppOwner(ISteamApps* lpSteamApps) {
 	return new CSteamID(lpSteamApps->GetAppOwner());
 }
 
-DLL_FUNCTION(const char*) 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.
-#pragma comment(linker, "/EXPORT:BS_Apps_GetLaunchQueryParam=_BS_Apps_GetLaunchQueryParam@8")
+// 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_FUNCTION(const char*) BS_ISteamApps_GetLaunchQueryParam(ISteamApps* lpSteamApps, const char *pchKey) {
 	return lpSteamApps->GetLaunchQueryParam(pchKey);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetDlcDownloadProgress(ISteamApps* lpSteamApps, AppId_t nAppID, uint64_t* pLLBytesDownloaded, uint64_t* pLLBytesTotal) {
+// get download progress for optional DLC
-#pragma comment(linker, "/EXPORT:BS_Apps_GetDlcDownloadProgress=_BS_Apps_GetDlcDownloadProgress@16")
+DLL_FUNCTION(int32_t) BS_ISteamApps_GetDlcDownloadProgress(ISteamApps* lpSteamApps, AppId_t nAppID, uint64_t* pLLBytesDownloaded, uint64_t* pLLBytesTotal) {
 	return lpSteamApps->GetDlcDownloadProgress(nAppID, pLLBytesDownloaded, pLLBytesTotal);
 }
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetAppBuildId(ISteamApps* lpSteamApps) {
+// return the buildid of this app, may change at any time based on backend updates to the game
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAppBuildId=_BS_Apps_GetAppBuildId@4")
+DLL_FUNCTION(int32_t) BS_ISteamApps_GetAppBuildId(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetAppBuildId();
 }

Wrapper/SteamClient.cpp

@@ -16,164 +16,132 @@
 
 #include "BlitzSteam.h"
 
-DLL_FUNCTION(ISteamClient*) BS_Client() {
+DLL_FUNCTION(ISteamClient*) BS_SteamClient() {
-#pragma comment(linker, "/EXPORT:BS_Client=_BS_Client@0")
 	return SteamClient();
 }
 
-DLL_FUNCTION(HSteamPipe) BS_Client_CreateSteamPipe(ISteamClient* lpSteamClient) {
+DLL_FUNCTION(HSteamPipe) BS_ISteamClient_CreateSteamPipe(ISteamClient* lpSteamClient) {
-#pragma comment(linker, "/EXPORT:BS_Client_CreateSteamPipe=_BS_Client_CreateSteamPipe@4")
 	return lpSteamClient->CreateSteamPipe();
 }
 
-DLL_FUNCTION(uint32_t) BS_Client_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
+DLL_FUNCTION(int32_t) BS_ISteamClient_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
-#pragma comment(linker, "/EXPORT:BS_Client_ReleaseSteamPipe=_BS_Client_ReleaseSteamPipe@8")
 	return lpSteamClient->BReleaseSteamPipe(hSteamPipe);
 }
 
-DLL_FUNCTION(HSteamUser) BS_Client_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
+DLL_FUNCTION(HSteamUser) BS_ISteamClient_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
-#pragma comment(linker, "/EXPORT:BS_Client_ConnectToGlobalUser=_BS_Client_ConnectToGlobalUser@8")
 	return lpSteamClient->ConnectToGlobalUser(hSteamPipe);
 }
 
-DLL_FUNCTION(void) BS_Client_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) {
+DLL_FUNCTION(void) BS_ISteamClient_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) {
-#pragma comment(linker, "/EXPORT:BS_Client_SetLocalIPBinding=_BS_Client_SetLocalIPBinding@12")
 	return lpSteamClient->SetLocalIPBinding(unIP, usPort);
 }
 
-DLL_FUNCTION(HSteamUser) BS_Client_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) {
+DLL_FUNCTION(HSteamUser) BS_ISteamClient_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) {
-#pragma comment(linker, "/EXPORT:BS_Client_CreateLocalUser=_BS_Client_CreateLocalUser@12")
 	return lpSteamClient->CreateLocalUser(phSteamPipe, eAccountType);
 }
 
-DLL_FUNCTION(void) BS_Client_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) {
+DLL_FUNCTION(void) BS_ISteamClient_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) {
-#pragma comment(linker, "/EXPORT:BS_Client_ReleaseUser=_BS_Client_ReleaseUser@12")
 	return lpSteamClient->ReleaseUser(hSteamPipe, hSteamUser);
 }
 
-DLL_FUNCTION(uint32_t) BS_Client_GetIPCCallCount(ISteamClient* lpSteamClient) {
+DLL_FUNCTION(int32_t) BS_ISteamClient_GetIPCCallCount(ISteamClient* lpSteamClient) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetIPCCallCount=_BS_Client_GetIPCCallCount@4")
 	return lpSteamClient->GetIPCCallCount();
 }
 
-DLL_FUNCTION(uint32_t) BS_Client_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) {
+DLL_FUNCTION(int32_t) BS_ISteamClient_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) {
-#pragma comment(linker, "/EXPORT:BS_Client_ShutdownIfAllPipesClosed=_BS_Client_ShutdownIfAllPipesClosed@4")
 	return lpSteamClient->BShutdownIfAllPipesClosed();
 }
 
 // Interfaces
-DLL_FUNCTION(ISteamAppList*) BS_Client_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamAppList*) BS_ISteamClient_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamAppList=_BS_Client_GetSteamAppList@16")
 	return lpSteamClient->GetISteamAppList(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamApps*) BS_Client_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamApps*) BS_ISteamClient_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamApps=_BS_Client_GetSteamApps@16")
 	return lpSteamClient->GetISteamApps(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamController*) BS_Client_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamController*) BS_ISteamClient_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamController=_BS_Client_GetSteamController@16")
 	return lpSteamClient->GetISteamController(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamFriends*) BS_Client_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamFriends*) BS_ISteamClient_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamFriends=_BS_Client_GetSteamFriends@16")
 	return lpSteamClient->GetISteamFriends(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamGameServer*) BS_Client_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamGameServer*) BS_ISteamClient_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServer=_BS_Client_GetSteamGameServer@16")
 	return lpSteamClient->GetISteamGameServer(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamGameServerStats*) BS_Client_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamGameServerStats*) BS_ISteamClient_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServerStats=_BS_Client_GetSteamGameServerStats@16")
 	return lpSteamClient->GetISteamGameServerStats(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamHTMLSurface*) BS_Client_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamHTMLSurface*) BS_ISteamClient_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTMLSurface=_BS_Client_GetSteamHTMLSurface@16")
 	return lpSteamClient->GetISteamHTMLSurface(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamHTTP*) BS_Client_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamHTTP*) BS_ISteamClient_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTTP=_BS_Client_GetSteamHTTP@16")
 	return lpSteamClient->GetISteamHTTP(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamInventory*) BS_Client_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamInventory*) BS_ISteamClient_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamInventory=_BS_Client_GetSteamInventory@16")
 	return lpSteamClient->GetISteamInventory(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamMatchmaking*) BS_Client_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamMatchmaking*) BS_ISteamClient_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmaking=_BS_Client_GetSteamMatchmaking@16")
 	return lpSteamClient->GetISteamMatchmaking(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamMatchmakingServers*) BS_Client_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamMatchmakingServers*) BS_ISteamClient_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmakingServers=_BS_Client_GetSteamMatchmakingServers@16")
 	return lpSteamClient->GetISteamMatchmakingServers(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamMusic*) BS_Client_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamMusic*) BS_ISteamClient_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusic=_BS_Client_GetSteamMusic@16")
 	return lpSteamClient->GetISteamMusic(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamMusicRemote*) BS_Client_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamMusicRemote*) BS_ISteamClient_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusicRemote=_BS_Client_GetSteamMusicRemote@16")
 	return lpSteamClient->GetISteamMusicRemote(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamNetworking*) BS_Client_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamNetworking*) BS_ISteamClient_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamNetworking=_BS_Client_GetSteamNetworking@16")
 	return lpSteamClient->GetISteamNetworking(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamRemoteStorage*) BS_Client_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamRemoteStorage*) BS_ISteamClient_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamRemoteStorage=_BS_Client_GetSteamRemoteStorage@16")
 	return lpSteamClient->GetISteamRemoteStorage(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamScreenshots*) BS_Client_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamScreenshots*) BS_ISteamClient_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamScreenshots=_BS_Client_GetSteamScreenshots@16")
 	return lpSteamClient->GetISteamScreenshots(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamUGC*) BS_Client_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUGC*) BS_ISteamClient_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUGC=_BS_Client_GetSteamUGC@16")
 	return lpSteamClient->GetISteamUGC(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamUnifiedMessages*) BS_Client_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUnifiedMessages*) BS_ISteamClient_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUnifiedMessages=_BS_Client_GetSteamUnifiedMessages@16")
 	return lpSteamClient->GetISteamUnifiedMessages(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamUser*) BS_Client_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUser*) BS_ISteamClient_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUser=_BS_Client_GetSteamUser@16")
 	return lpSteamClient->GetISteamUser(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamUserStats*) BS_Client_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUserStats*) BS_ISteamClient_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUserStats=_BS_Client_GetSteamUserStats@16")
 	return lpSteamClient->GetISteamUserStats(hSteamUser, hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamUtils*) BS_Client_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUtils*) BS_ISteamClient_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUtils=_BS_Client_GetSteamUtils@12")
 	return lpSteamClient->GetISteamUtils(hSteamPipe, pchVersion);
 }
 
-DLL_FUNCTION(ISteamVideo*) BS_Client_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamVideo*) BS_ISteamClient_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamVideo=_BS_Client_GetSteamVideo@16")
 	return lpSteamClient->GetISteamVideo(hSteamUser, hSteamPipe, pchVersion);
 }
 
 // Callbacks & Hooks
-DLL_FUNCTION(void) BS_Client_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) {
+DLL_FUNCTION(void) BS_ISteamClient_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) {
-#pragma comment(linker, "/EXPORT:BS_Client_SetWarningMessageHook=_BS_Client_SetWarningMessageHook@8")
 	lpSteamClient->SetWarningMessageHook(fpfunction);
 }

Wrapper/SteamController.cpp

@@ -16,46 +16,42 @@
 
 #include "BlitzSteam.h"
 
-DLL_FUNCTION(ISteamController*) BS_Controller() {
+//-----------------------------------------------------------------------------
-#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0")
+// Purpose: Native Steam controller support API
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(ISteamController*) BS_SteamController() {
 	return SteamController();
 }
 
 // Init and Shutdown must be called when starting/ending use of this interface
-DLL_FUNCTION(uint32_t) BS_Controller_Init(ISteamController* lpSteamController) {
+DLL_FUNCTION(int32_t) BS_ISteamController_Init(ISteamController* lpSteamController) {
-#pragma comment(linker, "/EXPORT:BS_Controller_Init=_BS_Controller_Init@4")
 	return lpSteamController->Init();
 }
 
 // Init and Shutdown must be called when starting/ending use of this interface
-DLL_FUNCTION(uint32_t) BS_Controller_Shutdown(ISteamController* lpSteamController) {
+DLL_FUNCTION(int32_t) BS_ISteamController_Shutdown(ISteamController* lpSteamController) {
-#pragma comment(linker, "/EXPORT:BS_Controller_Shutdown=_BS_Controller_Shutdown@4")
 	return lpSteamController->Shutdown();
 }
 
 // Pump callback/callresult events
 // Note: SteamAPI_RunCallbacks will do this for you, so you should never need to call this directly.
-DLL_FUNCTION(void) BS_Controller_RunFrame(ISteamController* lpSteamController) {
+DLL_FUNCTION(void) BS_ISteamController_RunFrame(ISteamController* lpSteamController) {
-#pragma comment(linker, "/EXPORT:BS_Controller_RunFrame=_BS_Controller_RunFrame@4")
 	lpSteamController->RunFrame();
 }
 
 // Enumerate currently connected controllers
 // handlesOut should point to a STEAM_CONTROLLER_MAX_COUNT sized array of ControllerHandle_t handles
 // Returns the number of handles written to handlesOut
-DLL_FUNCTION(uint32_t) BS_Controller_GetConnectedControllers(ISteamController* lpSteamController, ControllerHandle_t* pHandlesOut) {
+DLL_FUNCTION(int32_t) BS_ISteamController_GetConnectedControllers(ISteamController* lpSteamController, ControllerHandle_t* pHandlesOut) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllers=_BS_Controller_GetConnectedControllers@8")
 	return lpSteamController->GetConnectedControllers(pHandlesOut);
 }
 
 ControllerHandle_t* pControllerHandles = new ControllerHandle_t[STEAM_CONTROLLER_MAX_COUNT];
-DLL_FUNCTION(uint32_t) BS_Controller_GetConnectedControllersSimple(ISteamController* lpSteamController) {
+DLL_FUNCTION(int32_t) BS_ISteamController_GetConnectedControllersSimple(ISteamController* lpSteamController) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllersSimple=_BS_Controller_GetConnectedControllersSimple@4")
 	return lpSteamController->GetConnectedControllers(pControllerHandles);
 }
 
-DLL_FUNCTION(ControllerHandle_t*) BS_Controller_GetConnectedControllersSimple_Index(uint32_t index) {
+DLL_FUNCTION(ControllerHandle_t*) BS_ISteamController_GetConnectedControllersSimple_Index(uint32_t index) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllersSimple_Index=_BS_Controller_GetConnectedControllersSimple_Index@4")
 	if (index >= STEAM_CONTROLLER_MAX_COUNT)
 		index = STEAM_CONTROLLER_MAX_COUNT - 1;
 	return &(pControllerHandles[index]);
@@ -63,82 +59,68 @@ DLL_FUNCTION(ControllerHandle_t*) BS_Controller_GetConnectedControllersSimple_In
 
 // 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_FUNCTION(uint32_t) BS_Controller_ShowBindingPanel(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
+DLL_FUNCTION(int32_t) BS_ISteamController_ShowBindingPanel(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
-#pragma comment(linker, "/EXPORT:BS_Controller_ShowBindingPanel=_BS_Controller_ShowBindingPanel@8")
 	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_FUNCTION(ControllerActionSetHandle_t*) BS_Controller_GetActionSetHandle(ISteamController* lpSteamController, const char* pszActionSetName) {
+DLL_FUNCTION(ControllerActionSetHandle_t*) BS_ISteamController_GetActionSetHandle(ISteamController* lpSteamController, const char* pszActionSetName) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetActionSetHandle=_BS_Controller_GetActionSetHandle@8")
 	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_FUNCTION(void) BS_Controller_ActivateActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle) {
+DLL_FUNCTION(void) BS_ISteamController_ActivateActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle) {
-#pragma comment(linker, "/EXPORT:BS_Controller_ActivateActionSet=_BS_Controller_ActivateActionSet@12")
 	lpSteamController->ActivateActionSet(*pControllerHandle, *pActionSetHandle);
 }
 
-DLL_FUNCTION(ControllerActionSetHandle_t*) BS_Controller_GetCurrentActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
+DLL_FUNCTION(ControllerActionSetHandle_t*) BS_ISteamController_GetCurrentActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetCurrentActionSet=_BS_Controller_GetCurrentActionSet@8")
 	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_FUNCTION(ControllerDigitalActionHandle_t*) BS_Controller_GetDigitalActionHandle(ISteamController* lpSteamController, const char* pszActionName) {
+DLL_FUNCTION(ControllerDigitalActionHandle_t*) BS_ISteamController_GetDigitalActionHandle(ISteamController* lpSteamController, const char* pszActionName) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionHandle=_BS_Controller_GetDigitalActionHandle@8")
 	return new ControllerDigitalActionHandle_t(lpSteamController->GetDigitalActionHandle(pszActionName));
 }
 
 // Returns the current state of the supplied digital game action
-DLL_FUNCTION(ControllerDigitalActionData_t*) BS_Controller_GetDigitalActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle) {
+DLL_FUNCTION(ControllerDigitalActionData_t*) BS_ISteamController_GetDigitalActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionData=_BS_Controller_GetDigitalActionData@12")
 	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_FUNCTION(int32_t) BS_Controller_GetDigitalActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
+DLL_FUNCTION(int32_t) BS_ISteamController_GetDigitalActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
 	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_FUNCTION(ControllerAnalogActionHandle_t*) BS_Controller_GetAnalogActionHandle(ISteamController* lpSteamController, const char *pszActionName) {
+DLL_FUNCTION(ControllerAnalogActionHandle_t*) BS_ISteamController_GetAnalogActionHandle(ISteamController* lpSteamController, const char *pszActionName) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
 	return new ControllerAnalogActionHandle_t(lpSteamController->GetAnalogActionHandle(pszActionName));
-	//BlitzSteam: Cleanup using BS_Helper_DeleteLongLong
 }
 
 // Returns the current state of these supplied analog game action
-DLL_FUNCTION(ControllerAnalogActionData_t*) BS_Controller_GetAnalogActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
+DLL_FUNCTION(ControllerAnalogActionData_t*) BS_ISteamController_GetAnalogActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
 	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_FUNCTION(uint32_t) BS_Controller_GetAnalogActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
+DLL_FUNCTION(int32_t) BS_ISteamController_GetAnalogActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
-#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
 	return lpSteamController->GetAnalogActionOrigins(*pControllerHandle, *pActionSetHandle, *pAnalogActionHandle, pEControllerActionOrigin);
 }
 
-DLL_FUNCTION(void) BS_Controller_StopAnalogActionMomentum(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
+DLL_FUNCTION(void) BS_ISteamController_StopAnalogActionMomentum(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
-#pragma comment(linker, "/EXPORT:BS_Controller_StopAnalogActionMomentum=_BS_Controller_StopAnalogActionMomentum@12")
 	lpSteamController->StopAnalogActionMomentum(*pControllerHandle, *pAnalogActionHandle);
 }
 
 // Trigger a haptic pulse on a controller
-DLL_FUNCTION(void) BS_Controller_TriggerHapticPulse(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec) {
+DLL_FUNCTION(void) BS_ISteamController_TriggerHapticPulse(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec) {
-#pragma comment(linker, "/EXPORT:BS_Controller_TriggerHapticPulse=_BS_Controller_TriggerHapticPulse@16")
 	lpSteamController->TriggerHapticPulse(*pControllerHandle, eTargetPad, (uint16_t)usDurationMicroSec);
 }
 
-DLL_FUNCTION(void) BS_Controller_TriggerRepeatedHapticPulse(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec, uint32_t usOffMicroSec, uint32_t unRepeat, uint32_t nFlags) {
+DLL_FUNCTION(void) BS_ISteamController_TriggerRepeatedHapticPulse(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec, uint32_t usOffMicroSec, uint32_t unRepeat, uint32_t nFlags) {
-#pragma comment(linker, "/EXPORT:BS_Controller_TriggerRepeatedHapticPulse=_BS_Controller_TriggerRepeatedHapticPulse@28")
 	lpSteamController->TriggerRepeatedHapticPulse(*pControllerHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
 }

Wrapper/SteamFriends.cpp

@@ -16,68 +16,89 @@
 
 #include "BlitzSteam.h"
 
-DLL_FUNCTION(ISteamFriends*) BS_Friends() {
+//-----------------------------------------------------------------------------
-#pragma comment(linker, "/EXPORT:BS_Friends=_BS_Friends@0")
+// 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_FUNCTION(ISteamFriends*) BS_SteamFriends() {
 	return SteamFriends();
 }
 
-DLL_FUNCTION(const char*) BS_Friends_GetPersonaName(ISteamFriends* lpSteamFriends) {
+// returns the local players name - guaranteed to not be NULL.
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaName=_BS_Friends_GetPersonaName@4")
+// 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_FUNCTION(const char*) BS_ISteamFriends_GetPersonaName(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetPersonaName();
 }
 
-DLL_FUNCTION(SteamAPICall_t*) 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.
-#pragma comment(linker, "/EXPORT:BS_Friends_SetPersonaName=_BS_Friends_SetPersonaName@8")
+// 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_FUNCTION(SteamAPICall_t*) BS_ISteamFriends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) {
 	return new uint64_t(lpSteamFriends->SetPersonaName(pchPersonaName));
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetPersonaState(ISteamFriends* lpSteamFriends) {
+// gets the status of the current user
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaState=_BS_Friends_GetPersonaState@4")
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetPersonaState(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetPersonaState();
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) {
+// friend iteration
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCount=_BS_Friends_GetFriendCount@8")
+// 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_FUNCTION(int32_t) BS_ISteamFriends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) {
 	return lpSteamFriends->GetFriendCount(iFriendFlags);
 }
 
-DLL_FUNCTION(CSteamID*) BS_Friends_GetFriendByIndex(ISteamFriends* lpSteamFriends, int32_t iFriend, int32_t iFriendFlags) {
+// returns the steamID of a user
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendByIndex=_BS_Friends_GetFriendByIndex@12")
+// iFriend is a index of range [0, GetFriendCount())
+// 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_FUNCTION(CSteamID*) BS_ISteamFriends_GetFriendByIndex(ISteamFriends* lpSteamFriends, int32_t iFriend, int32_t iFriendFlags) {
 	return new CSteamID(lpSteamFriends->GetFriendByIndex(iFriend, iFriendFlags));
 }
 
-DLL_FUNCTION(EFriendRelationship) BS_Friends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// returns a relationship to a user
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRelationship=_BS_Friends_GetFriendRelationship@8")
+DLL_FUNCTION(EFriendRelationship) BS_ISteamFriends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendRelationship(*steamIDFriend);
 }
 
-DLL_FUNCTION(EPersonaState) BS_Friends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// returns the current status of the specified user
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaState=_BS_Friends_GetFriendPersonaState@8")
+// 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_FUNCTION(EPersonaState) BS_ISteamFriends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendPersonaState(*steamIDFriend);
 }
 
-DLL_FUNCTION(const char*) BS_Friends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// returns the name another user - guaranteed to not be NULL.
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaName=_BS_Friends_GetFriendPersonaName@8")
+// 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_FUNCTION(const char*) BS_ISteamFriends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendPersonaName(*steamIDFriend);
 }
 
-DLL_FUNCTION(uint32_t) 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 
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendGamePlayed=_BS_Friends_GetFriendGamePlayed@12")
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_GetFriendGamePlayed(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, FriendGameInfo_t *pFriendGameInfo) {
 	return lpSteamFriends->GetFriendGamePlayed(*steamIDFriend, pFriendGameInfo);
 }
 
-DLL_FUNCTION(const char*) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaNameHistory=_BS_Friends_GetFriendPersonaNameHistory@12")
+DLL_FUNCTION(const char*) BS_ISteamFriends_GetFriendPersonaNameHistory(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iPersonaName) {
 	return lpSteamFriends->GetFriendPersonaNameHistory(*steamIDFriend, iPersonaName);
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// friends steam level
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendSteamLevel=_BS_Friends_GetFriendSteamLevel@8")
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendSteamLevel(*steamIDFriend);
 }
 
-DLL_FUNCTION(const char*) 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.
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPlayerNickname=_BS_Friends_GetPlayerNickname@8")
+DLL_FUNCTION(const char*) BS_ISteamFriends_GetPlayerNickname(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriends) {
 	const char* nickname = lpSteamFriends->GetPlayerNickname(*steamIDFriends);
 	if (nickname == NULL) {
 		nickname = "";
@@ -85,293 +106,320 @@ DLL_FUNCTION(const char*) BS_Friends_GetPlayerNickname(ISteamFriends* lpSteamFri
 	return nickname;
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) {
+// friend grouping (tag) apis
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupCount=_BS_Friends_GetFriendsGroupCount@4")
+// returns the number of friends groups
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetFriendsGroupCount();
 }
 
-DLL_FUNCTION(FriendsGroupID_t) BS_Friends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+// returns the friends group ID for the given index (invalid indices return k_FriendsGroupID_Invalid)
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupIDByIndex=_BS_Friends_GetFriendsGroupIDByIndex@8")
+DLL_FUNCTION(FriendsGroupID_t) BS_ISteamFriends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupIDByIndex(friendsGroupID);
 }
 
-DLL_FUNCTION(const char*) 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)
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupName=_BS_Friends_GetFriendsGroupName@8")
+DLL_FUNCTION(const char*) BS_ISteamFriends_GetFriendsGroupName(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupName(friendsGroupID);
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+// returns the number of members in a given friends group
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersCount=_BS_Friends_GetFriendsGroupMembersCount@8")
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupMembersCount(friendsGroupID);
 }
 
-DLL_FUNCTION(void) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersList=_BS_Friends_GetFriendsGroupMembersList@16")
+DLL_FUNCTION(void) BS_ISteamFriends_GetFriendsGroupMembersList(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID, CSteamID* pOutSteamIDMembers, int32_t nMembersCount) {
 	lpSteamFriends->GetFriendsGroupMembersList(friendsGroupID, pOutSteamIDMembers, nMembersCount);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) {
+// returns true if the specified user meets any of the criteria specified in iFriendFlags
-#pragma comment(linker, "/EXPORT:BS_Friends_HasFriends=_BS_Friends_HasFriend@12")
+// iFriendFlags can be the union (binary or, |) of one or more k_EFriendFlags values
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) {
 	return lpSteamFriends->HasFriend(*steamIDFriend, iFriendsFlags);
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetClanCount(ISteamFriends* lpSteamFriends) {
+// clan (group) iteration and access functions
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanCount=_BS_Friends_GetClanCount@4")
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetClanCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetClanCount();
 }
 
-DLL_FUNCTION(CSteamID*) BS_Friends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) {
+DLL_FUNCTION(CSteamID*) BS_ISteamFriends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanByIndex=_BS_Friends_GetClanByIndex@8")
 	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanByIndex(iClan));
 	return steamID;
 }
 
-DLL_FUNCTION(const char*) BS_Friends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(const char*) BS_ISteamFriends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanName=_BS_Friends_GetClanName@8")
 	return lpSteamFriends->GetClanName(*steamIDClan);
 }
 
-DLL_FUNCTION(const char*) BS_Friends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(const char*) BS_ISteamFriends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanTag=_BS_Friends_GetClanTag@8")
 	return lpSteamFriends->GetClanTag(*steamIDClan);
 }
 
-DLL_FUNCTION(uint32_t) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanActivityCounts=_BS_Friends_GetClanActivityCounts@20")
+DLL_FUNCTION(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);
 }
 
-DLL_FUNCTION(SteamAPICall_t*) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_DownloadClanActivityCounts=_BS_Friends_DownloadClanActivityCounts@12")
+DLL_FUNCTION(SteamAPICall_t*) BS_ISteamFriends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) {
 	return new uint64_t(lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, cClansToRequest));
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) {
+// iterators for getting users in a chat room, lobby, game server or clan
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCountFromSource=_BS_Friends_GetFriendCountFromSource@8")
+// 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_FUNCTION(int32_t) BS_ISteamFriends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) {
 	return lpSteamFriends->GetFriendCountFromSource(*steamIDSource);
 }
 
-DLL_FUNCTION(CSteamID*) BS_Friends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) {
+DLL_FUNCTION(CSteamID*) BS_ISteamFriends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendFromSourceByIndex=_BS_Friends_GetFriendFromSourceByIndex@12")
 	return new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend));
 }
 
-DLL_FUNCTION(uint32_t) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_IsUserInSource=_BS_Friends_IsUserInSource@12")
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_IsUserInSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, CSteamID* steamIDSource) {
 	return lpSteamFriends->IsUserInSource(*steamIDUser, *steamIDSource);
 }
 
-DLL_FUNCTION(void) 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)
-#pragma comment(linker, "/EXPORT:BS_Friends_SetInGameVoiceSpeaking=_BS_Friends_SetInGameVoiceSpeaking@12")
+DLL_FUNCTION(void) BS_ISteamFriends_SetInGameVoiceSpeaking(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bSpeaking) {
 	lpSteamFriends->SetInGameVoiceSpeaking(*steamIDUser, bSpeaking != 0);
 }
 
-DLL_FUNCTION(void) BS_Friends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) {
+// activates the game overlay, with an optional dialog to open 
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlay=_BS_Friends_ActivateGameOverlay@8")
+// valid options are "Friends", "Community", "Players", "Settings", "OfficialGameGroup", "Stats", "Achievements"
+DLL_FUNCTION(void) BS_ISteamFriends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) {
 	lpSteamFriends->ActivateGameOverlay(pchDialog);
 }
 
-DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) {
+// activates game overlay to a specific place
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToUser=_BS_Friends_ActivateGameOverlayToUser@12")
+// 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_FUNCTION(void) BS_ISteamFriends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) {
 	lpSteamFriends->ActivateGameOverlayToUser(pchDialog, *steamID);
 }
 
-DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) {
+// activates game overlay web browser directly to the specified URL
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToWebPage=_BS_Friends_ActivateGameOverlayToWebPage@8")
+// full address with protocol type is required, e.g. http://www.steamgames.com/
+DLL_FUNCTION(void) BS_ISteamFriends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) {
 	lpSteamFriends->ActivateGameOverlayToWebPage(pchURL);
 }
 
-DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) {
+// activates game overlay to store page for app
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToStore=_BS_Friends_ActivateGameOverlayToStore@12")
+DLL_FUNCTION(void) BS_ISteamFriends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) {
 	lpSteamFriends->ActivateGameOverlayToStore(nAppID, eFlag);
 }
 
-DLL_FUNCTION(void) 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 
-#pragma comment(linker, "/EXPORT:BS_Friends_SetPlayedWith=_BS_Friends_SetPlayedWith@8")
+// in game 
+DLL_FUNCTION(void) BS_ISteamFriends_SetPlayedWith(ISteamFriends* lpSteamFriends, CSteamID* steamIDUserPlayedWith) {
 	lpSteamFriends->SetPlayedWith(*steamIDUserPlayedWith);
 }
 
-DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) {
+// activates game overlay to open the invite dialog. Invitations will be sent for the provided lobby.
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayInviteDialog=_BS_Friends_ActivateGameOverlayInviteDialog@8")
+DLL_FUNCTION(void) BS_ISteamFriends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) {
 	lpSteamFriends->ActivateGameOverlayInviteDialog(*steamIDLobby);
 }
 
-DLL_FUNCTION(int32_t) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_GetSmallFriendAvatar=_BS_Friends_GetSmallFriendAvatar@8")
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetSmallFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetSmallFriendAvatar(*steamIDFriend);
 }
 
-DLL_FUNCTION(int32_t) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_GetMediumFriendAvatar=_BS_Friends_GetMediumFriendAvatar@8")
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetMediumFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetMediumFriendAvatar(*steamIDFriend);
 }
 
-DLL_FUNCTION(int32_t) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_GetLargeFriendAvatar=_BS_Friends_GetLargeFriendAvatar@8")
+// 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_FUNCTION(int32_t) BS_ISteamFriends_GetLargeFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetLargeFriendAvatar(*steamIDFriend);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) {
+// requests information about a user - persona name & avatar
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestUserInformation=_BS_Friends_RequestUserInformation@12")
+// 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_FUNCTION(uint32_t) BS_ISteamFriends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) {
 	return lpSteamFriends->RequestUserInformation(*steamIDUser, bRequireNameOnly != 0);
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_Friends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+// requests information about a clan officer list
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestClanOfficerList=_BS_Friends_RequestClanOfficerList@8")
+// 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_FUNCTION(SteamAPICall_t*) BS_ISteamFriends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return new uint64_t(lpSteamFriends->RequestClanOfficerList(*steamIDClan));
 }
 
-DLL_FUNCTION(CSteamID*) BS_Friends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+// iteration of clan officers - can only be done when a RequestClanOfficerList() call has completed
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOwner=_BS_Friends_GetClanOwner@8")
+
+// returns the steamID of the clan owner
+DLL_FUNCTION(CSteamID*) BS_ISteamFriends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan));
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+// returns the number of officers in a clan (including the owner)
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerCount=_BS_Friends_GetClanOfficerCount@8")
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanOfficerCount(*steamIDClan);
 }
 
-DLL_FUNCTION(CSteamID*) BS_Friends_GetClanOfficerByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iOfficer) {
+// returns the steamID of a clan officer, by index, of range [0,GetClanOfficerCount)
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerByIndex=_BS_Friends_GetClanOfficerByIndex@12")
+DLL_FUNCTION(CSteamID*) BS_ISteamFriends_GetClanOfficerByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iOfficer) {
 	return new CSteamID(lpSteamFriends->GetClanOfficerByIndex(*steamIDClan, iOfficer));
 }
 
-DLL_FUNCTION(EUserRestriction) BS_Friends_GetUserRestrictions(ISteamFriends* lpSteamFriends) {
+// if current user is chat restricted, he can't send or receive any text/voice chat messages.
-#pragma comment(linker, "/EXPORT:BS_Friends_GetUserRestrictions=_BS_Friends_GetUserRestrictions@4")
+// 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_FUNCTION(EUserRestriction) BS_ISteamFriends_GetUserRestrictions(ISteamFriends* lpSteamFriends) {
 	return (EUserRestriction)lpSteamFriends->GetUserRestrictions();
 }
 
-DLL_FUNCTION(uint32_t) 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
-#pragma comment(linker, "/EXPORT:BS_Friends_SetRichPresence=_BS_Friends_SetRichPresence@12")
+// 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_FUNCTION(uint32_t) BS_ISteamFriends_SetRichPresence(ISteamFriends* lpSteamFriends, const char* pchKey, const char* pchValue) {
 	return lpSteamFriends->SetRichPresence(pchKey, pchValue);
 }
 
-DLL_FUNCTION(void) BS_Friends_ClearRichPresence(ISteamFriends* lpSteamFriends) {
+DLL_FUNCTION(void) BS_ISteamFriends_ClearRichPresence(ISteamFriends* lpSteamFriends) {
-#pragma comment(linker, "/EXPORT:BS_Friends_ClearRichPresence=_BS_Friends_ClearRichPresence@4")
 	lpSteamFriends->ClearRichPresence();
 }
 
-DLL_FUNCTION(const char*) BS_Friends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) {
+DLL_FUNCTION(const char*) BS_ISteamFriends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresence=_BS_Friends_GetFriendRichPresence@12")
 	return lpSteamFriends->GetFriendRichPresence(*steamIDFriend, pchKey);
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyCount=_BS_Friends_GetFriendRichPresenceKeyCount@8")
 	return lpSteamFriends->GetFriendRichPresenceKeyCount(*steamIDFriend);
 }
 
-DLL_FUNCTION(const char*) BS_Friends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) {
+DLL_FUNCTION(const char*) BS_ISteamFriends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyByIndex=_BS_Friends_GetFriendRichPresenceKeyByIndex@12")
 	return lpSteamFriends->GetFriendRichPresenceKeyByIndex(*steamIDFriend, iKey);
 }
 
-DLL_FUNCTION(void) BS_Friends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+// Requests rich presence for a specific user.
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestFriendRichPresence=_BS_Friends_RequestFriendRichPresence@8")
+DLL_FUNCTION(void) BS_ISteamFriends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	lpSteamFriends->RequestFriendRichPresence(*steamIDFriend);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) {
+// rich invite support
-#pragma comment(linker, "/EXPORT:BS_Friends_InviteUserToGame=_BS_Friends_InviteUserToGame@12")
+// 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_FUNCTION(uint32_t) BS_ISteamFriends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) {
 	return lpSteamFriends->InviteUserToGame(*steamIDFriend, pchConnectString);
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) {
+// recently-played-with friends iteration
-#pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriendCount=_BS_Friends_GetCoplayFriendCount@4")
+// this iterates the entire list of users recently played with, across games
+// GetFriendCoplayTime() returns as a unix time
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetCoplayFriendCount();
 }
 
-DLL_FUNCTION(CSteamID*) BS_Friends_GetCoplayFriend(ISteamFriends* lpSteamFriends, int32_t iCoplayFriend) {
+DLL_FUNCTION(CSteamID*) BS_ISteamFriends_GetCoplayFriend(ISteamFriends* lpSteamFriends, int32_t iCoplayFriend) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriend=_BS_Friends_GetCoplayFriend@8")
 	return new CSteamID(lpSteamFriends->GetCoplayFriend(iCoplayFriend));
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayTime=_BS_Friends_GetFriendCoplayTime@8")
 	return lpSteamFriends->GetFriendCoplayTime(*steamIDFriend);
 }
 
-DLL_FUNCTION(AppId_t) BS_Friends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(AppId_t) BS_ISteamFriends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayGame=_BS_Friends_GetFriendCoplayGame@8")
 	return lpSteamFriends->GetFriendCoplayGame(*steamIDFriend);
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_Friends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+// chat interface for games
-#pragma comment(linker, "/EXPORT:BS_Friends_JoinClanChatRoom=_BS_Friends_JoinClanChatRoom@8")
+// 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_FUNCTION(SteamAPICall_t*) BS_ISteamFriends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return new SteamAPICall_t(lpSteamFriends->JoinClanChatRoom(*steamIDClan));
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-#pragma comment(linker, "/EXPORT:BS_Friends_LeaveClanChatRoom=_BS_Friends_LeaveClanChatRoom@8")
 	return lpSteamFriends->LeaveClanChatRoom(*steamIDClan);
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMemberCount=_BS_Friends_GetClanChatMemberCount@8")
 	return lpSteamFriends->GetClanChatMemberCount(*steamIDClan);
 }
 
-DLL_FUNCTION(CSteamID*) BS_Friends_GetChatMemberByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iUser) {
+DLL_FUNCTION(CSteamID*) BS_ISteamFriends_GetChatMemberByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iUser) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetChatMemberByIndex=_BS_Friends_GetChatMemberByIndex@12")
 	return new CSteamID(lpSteamFriends->GetChatMemberByIndex(*steamIDClan, iUser));
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) {
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) {
-#pragma comment(linker, "/EXPORT:BS_Friends_SendClanChatMessage=_BS_Friends_SendClanChatMessage@12")
 	return lpSteamFriends->SendClanChatMessage(*steamIDClanChat, pchText);
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) {
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMessage=_BS_Friends_GetClanChatMessage@28")
 	return lpSteamFriends->GetClanChatMessage(*steamIDClanChat, iMessage, prgchText, cchTextMax, peChatEntryType, psteamidChatter);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) {
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) {
-#pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatAdmin=_BS_Friends_IsClanChatAdmin@12")
 	return lpSteamFriends->IsClanChatAdmin(*steamIDClanChat, *steamIDUser);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+// interact with the Steam (game overlay / desktop)
-#pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatWindowOpenInSteam=_BS_Friends_IsClanChatWindowOpenInSteam@8")
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
 	return lpSteamFriends->IsClanChatWindowOpenInSteam(*steamIDClanChat);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
-#pragma comment(linker, "/EXPORT:BS_Friends_OpenClanChatWindowInSteam=_BS_Friends_OpenClanChatWindowInSteam@8")
 	return lpSteamFriends->OpenClanChatWindowInSteam(*steamIDClanChat);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
-#pragma comment(linker, "/EXPORT:BS_Friends_CloseClanChatWindowInSteam=_BS_Friends_CloseClanChatWindowInSteam@8")
 	return lpSteamFriends->CloseClanChatWindowInSteam(*steamIDClanChat);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) {
+// peer-to-peer chat interception
-#pragma comment(linker, "/EXPORT:BS_Friends_SetListenForFriendsMessages=_BS_Friends_SetListenForFriendsMessages@8")
+// this is so you can show P2P chats inline in the game
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) {
 	return lpSteamFriends->SetListenForFriendsMessages(bInterceptEnabled != 0);
 }
 
-DLL_FUNCTION(uint32_t) BS_Friends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) {
+DLL_FUNCTION(uint32_t) BS_ISteamFriends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) {
-#pragma comment(linker, "/EXPORT:BS_Friends_ReplyToFriendMessage=_BS_Friends_ReplyToFriendMessage@12")
 	return lpSteamFriends->ReplyToFriendMessage(*steamIDFriend, pchMsgToSend);
 }
 
-DLL_FUNCTION(int32_t) BS_Friends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) {
+DLL_FUNCTION(int32_t) BS_ISteamFriends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) {
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendMessage=_BS_Friends_GetFriendMessage@24")
 	return lpSteamFriends->GetFriendMessage(*steamIDFriend, iMessageID, pvData, cubData, peChatEntryType);
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_Friends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
+// following apis
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFollowerCount=_BS_Friends_GetFollowerCount@8")
+DLL_FUNCTION(SteamAPICall_t*) BS_ISteamFriends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
 	return new SteamAPICall_t(lpSteamFriends->GetFollowerCount(*steamID));
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_Friends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
+DLL_FUNCTION(SteamAPICall_t*) BS_ISteamFriends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
-#pragma comment(linker, "/EXPORT:BS_Friends_IsFollowing=_BS_Friends_IsFollowing@8")
 	return new SteamAPICall_t(lpSteamFriends->IsFollowing(*steamID));
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_Friends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32_t unStartIndex) {
+DLL_FUNCTION(SteamAPICall_t*) BS_ISteamFriends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32_t unStartIndex) {
-#pragma comment(linker, "/EXPORT:BS_Friends_EnumerateFollowingList=_BS_Friends_EnumerateFollowingList@8")
 	return new SteamAPICall_t(lpSteamFriends->EnumerateFollowingList(unStartIndex));
 }

Wrapper/SteamGameServer.cpp

@@ -16,258 +16,356 @@
 
 #include "BlitzSteam.h"
 
+// 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_FUNCTION(uint32_t) BS_SteamGameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) {
-#pragma comment(linker, "/EXPORT:BS_SteamGameServer_Init=_BS_SteamGameServer_Init@24")
 	return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
 }
 
 DLL_FUNCTION(void) BS_SteamGameServer_Shutdown() {
-#pragma comment(linker, "/EXPORT:BS_SteamGameServer_Shutdown=_BS_SteamGameServer_Shutdown@0")
 	SteamGameServer_Shutdown();
 }
 
 DLL_FUNCTION(void) BS_SteamGameServer_RunCallbacks() {
-#pragma comment(linker, "/EXPORT:BS_SteamGameServer_RunCallbacks=_BS_SteamGameServer_RunCallbacks@0")
 	SteamGameServer_RunCallbacks();
 }
 
-DLL_FUNCTION(HSteamPipe) BS_SteamGameServer_GetHSteamPipe() {
-#pragma comment(linker, "/EXPORT:BS_SteamGameServer_GetHSteamPipe=_BS_SteamGameServer_GetHSteamPipe@0")
-	return SteamGameServer_GetHSteamPipe();
-}
-
 DLL_FUNCTION(uint32_t) BS_SteamGameServer_IsSecure() {
-#pragma comment(linker, "/EXPORT:BS_SteamGameServer_IsSecure=_BS_SteamGameServer_IsSecure@0")
 	return SteamGameServer_BSecure();
 }
 
 DLL_FUNCTION(CSteamID*) BS_SteamGameServer_GetSteamID() {
-#pragma comment(linker, "/EXPORT:BS_SteamGameServer_GetSteamID=_BS_SteamGameServer_GetSteamID@0")
 	return new CSteamID(SteamGameServer_GetSteamID());
 }
 
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+//	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_FUNCTION(HSteamPipe) BS_SteamGameServer_GetHSteamPipe() {
+	return SteamGameServer_GetHSteamPipe();
+}
+
 // ISteamGameServer Stuff
-DLL_FUNCTION(ISteamGameServer*) BS_GameServer() {
+//-----------------------------------------------------------------------------
-#pragma comment(linker, "/EXPORT:BS_GameServer=_BS_GameServer@0")
+// Purpose: Functions for authenticating users via Steam to play on a game server
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(ISteamGameServer*) BS_SteamGameServer() {
 	return SteamGameServer();
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_InitGameServer(ISteamGameServer* pSteamGameServer, uint32_t unIP, uint16_t usGamePort, uint16_t usQueryPort, uint32_t unFlags, AppId_t nGameAppId, const char *pchVersionString) {
+//
-#pragma comment(linker, "/EXPORT:BS_GameServer_InitGameServer=_BS_GameServer_InitGameServer@28")
+// 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_FUNCTION(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_FUNCTION(void) BS_GameServer_SetProduct(ISteamGameServer* pSteamGameServer, const char *pszProduct) {
+/// Game product identifier.  This is currently used by the master server for version checking purposes.
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetProduct=_BS_GameServer_SetProduct@8")
+/// It's a required field, but will eventually will go away, and the AppID will be used for this purpose.
+DLL_FUNCTION(void) BS_ISteamGameServer_SetProduct(ISteamGameServer* pSteamGameServer, const char *pszProduct) {
 	pSteamGameServer->SetProduct(pszProduct);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetGameDescription(ISteamGameServer* pSteamGameServer, const char *pszGameDescription) {
+/// Description of the game.  This is a required field and is displayed in the steam server browser....for now.
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameDescription=_BS_GameServer_SetGameDescription@8")
+/// This is a required field, but it will go away eventually, as the data should be determined from the AppID.
+DLL_FUNCTION(void) BS_ISteamGameServer_SetGameDescription(ISteamGameServer* pSteamGameServer, const char *pszGameDescription) {
 	pSteamGameServer->SetGameDescription(pszGameDescription);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetModDir(ISteamGameServer* pSteamGameServer, const char *pszModDir) {
+/// If your game is a "mod," pass the string that identifies it.  The default is an empty string, meaning
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetModDir=_BS_GameServer_SetModDir@8")
+/// this application is the original game, not a mod.
+///
+/// @see k_cbMaxGameServerGameDir
+DLL_FUNCTION(void) BS_ISteamGameServer_SetModDir(ISteamGameServer* pSteamGameServer, const char *pszModDir) {
 	pSteamGameServer->SetModDir(pszModDir);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetDedicatedServer(ISteamGameServer* pSteamGameServer, uint32_t bDedicated) {
+/// Is this is a dedicated server?  The default value is false.
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetDedicatedServer=_BS_GameServer_SetDedicatedServer@8")
+DLL_FUNCTION(void) BS_ISteamGameServer_SetDedicatedServer(ISteamGameServer* pSteamGameServer, uint32_t bDedicated) {
 	pSteamGameServer->SetDedicatedServer(!!bDedicated);
 }
 
-DLL_FUNCTION(void) BS_GameServer_LogOn(ISteamGameServer* pSteamGameServer, const char *pszToken) {
+//
-#pragma comment(linker, "/EXPORT:BS_GameServer_LogOn=_BS_GameServer_LogOn@8")
+// 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_FUNCTION(void) BS_ISteamGameServer_LogOn(ISteamGameServer* pSteamGameServer, const char *pszToken) {
 	pSteamGameServer->LogOn(pszToken);
 }
 
-DLL_FUNCTION(void) BS_GameServer_LogOnAnonymous(ISteamGameServer* pSteamGameServer) {
+/// Login to a generic, anonymous account.
-#pragma comment(linker, "/EXPORT:BS_GameServer_LogOnAnonymous=_BS_GameServer_LogOnAnonymous@4")
+///
+/// Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init,
+/// but this is no longer the case.
+DLL_FUNCTION(void) BS_ISteamGameServer_LogOnAnonymous(ISteamGameServer* pSteamGameServer) {
 	pSteamGameServer->LogOnAnonymous();
 }
 
-DLL_FUNCTION(void) BS_GameServer_LogOff(ISteamGameServer* pSteamGameServer) {
+/// Begin process of logging game server out of steam
-#pragma comment(linker, "/EXPORT:BS_GameServer_LogOff=_BS_GameServer_LogOff@4")
+DLL_FUNCTION(void) BS_ISteamGameServer_LogOff(ISteamGameServer* pSteamGameServer) {
 	pSteamGameServer->LogOff();
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_IsLoggedOn(ISteamGameServer* pSteamGameServer) {
+// status functions
-#pragma comment(linker, "/EXPORT:BS_GameServer_IsLoggedOn=_BS_GameServer_IsLoggedOn@4")
+DLL_FUNCTION(uint32_t) BS_ISteamGameServer_IsLoggedOn(ISteamGameServer* pSteamGameServer) {
 	return pSteamGameServer->BLoggedOn();
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_IsSecure(ISteamGameServer* pSteamGameServer) {
+DLL_FUNCTION(uint32_t) BS_ISteamGameServer_IsSecure(ISteamGameServer* pSteamGameServer) {
-#pragma comment(linker, "/EXPORT:BS_GameServer_IsSecure=_BS_GameServer_IsSecure@4")
 	return pSteamGameServer->BSecure();
 }
 
-DLL_FUNCTION(CSteamID*) BS_GameServer_GetSteamID(ISteamGameServer* pSteamGameServer) {
+DLL_FUNCTION(CSteamID*) BS_ISteamGameServer_GetSteamID(ISteamGameServer* pSteamGameServer) {
-#pragma comment(linker, "/EXPORT:BS_GameServer_GetSteamID=_BS_GameServer_GetSteamID@4")
 	return new CSteamID(pSteamGameServer->GetSteamID());
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_WasRestartRequested(ISteamGameServer* pSteamGameServer) {
+/// Returns true if the master server has requested a restart.
-#pragma comment(linker, "/EXPORT:BS_GameServer_WasRestartRequested=_BS_GameServer_WasRestartRequested@4")
+/// Only returns true once per request.
+DLL_FUNCTION(uint32_t) BS_ISteamGameServer_WasRestartRequested(ISteamGameServer* pSteamGameServer) {
 	return pSteamGameServer->WasRestartRequested();
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetMaxPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cPlayersMax) {
+//
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetMaxPlayerCount=_BS_GameServer_SetMaxPlayerCount@8")
+// Server state.  These properties may be changed at any time.
+//
+
+/// Max player count that will be reported to server browser and client queries
+DLL_FUNCTION(void) BS_ISteamGameServer_SetMaxPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cPlayersMax) {
 	pSteamGameServer->SetMaxPlayerCount(cPlayersMax);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetBotPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cBotplayers) {
+/// Number of bots.  Default value is zero
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetBotPlayerCount=_BS_GameServer_SetBotPlayerCount@8")
+DLL_FUNCTION(void) BS_ISteamGameServer_SetBotPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cBotplayers) {
 	pSteamGameServer->SetBotPlayerCount(cBotplayers);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetServerName(ISteamGameServer* pSteamGameServer, const char *pszServerName) {
+/// Set the name of server as it will appear in the server browser
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetServerName=_BS_GameServer_SetServerName@8")
+///
+/// @see k_cbMaxGameServerName
+DLL_FUNCTION(void) BS_ISteamGameServer_SetServerName(ISteamGameServer* pSteamGameServer, const char *pszServerName) {
 	pSteamGameServer->SetServerName(pszServerName);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetMapName(ISteamGameServer* pSteamGameServer, const char *pszMapName) {
+/// Set name of map to report in the server browser
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetMapName=_BS_GameServer_SetMapName@8")
+///
+/// @see k_cbMaxGameServerName
+DLL_FUNCTION(void) BS_ISteamGameServer_SetMapName(ISteamGameServer* pSteamGameServer, const char *pszMapName) {
 	pSteamGameServer->SetMapName(pszMapName);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetPasswordProtected(ISteamGameServer* pSteamGameServer, uint32_t bPasswordProtected) {
+/// Let people know if your server will require a password
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetPasswordProtected=_BS_GameServer_SetPasswordProtected@8")
+DLL_FUNCTION(void) BS_ISteamGameServer_SetPasswordProtected(ISteamGameServer* pSteamGameServer, uint32_t bPasswordProtected) {
 	pSteamGameServer->SetPasswordProtected(!!bPasswordProtected);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetSpectatorPort(ISteamGameServer* pSteamGameServer, uint16_t unSpectatorPort) {
+/// Spectator server.  The default value is zero, meaning the service
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetSpectatorPort=_BS_GameServer_SetSpectatorPort@8")
+/// is not used.
+DLL_FUNCTION(void) BS_ISteamGameServer_SetSpectatorPort(ISteamGameServer* pSteamGameServer, uint16_t unSpectatorPort) {
 	pSteamGameServer->SetSpectatorPort(unSpectatorPort);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetSpectatorServerName(ISteamGameServer* pSteamGameServer, const char *pszSpectatorServerName) {
+/// Name of the spectator server.  (Only used if spectator port is nonzero.)
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetSpectatorServerName=_BS_GameServer_SetSpectatorServerName@8")
+///
+/// @see k_cbMaxGameServerMapName
+DLL_FUNCTION(void) BS_ISteamGameServer_SetSpectatorServerName(ISteamGameServer* pSteamGameServer, const char *pszSpectatorServerName) {
 	pSteamGameServer->SetSpectatorServerName(pszSpectatorServerName);
 }
 
-DLL_FUNCTION(void) BS_GameServer_ClearAllKeyValues(ISteamGameServer* pSteamGameServer) {
+/// Call this to clear the whole list of key/values that are sent in rules queries.
-#pragma comment(linker, "/EXPORT:BS_GameServer_ClearAllKeyValues=_BS_GameServer_ClearAllKeyValues@4")
+DLL_FUNCTION(void) BS_ISteamGameServer_ClearAllKeyValues(ISteamGameServer* pSteamGameServer) {
 	pSteamGameServer->ClearAllKeyValues();
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetKeyValue(ISteamGameServer* pSteamGameServer, const char *pKey, const char *pValue) {
+/// Call this to add/update a key/value pair.
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetKeyValue=_BS_GameServer_SetKeyValue@12")
+DLL_FUNCTION(void) BS_ISteamGameServer_SetKeyValue(ISteamGameServer* pSteamGameServer, const char *pKey, const char *pValue) {
 	pSteamGameServer->SetKeyValue(pKey, pValue);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetGameTags(ISteamGameServer* pSteamGameServer, const char *pchGameTags) {
+/// Sets a string defining the "gametags" for this server, this is optional, but if it is set
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameTags=_BS_GameServer_SetGameTags@8")
+/// it allows users to filter in the matchmaking/server-browser interfaces based on the value
+///
+/// @see k_cbMaxGameServerTags
+DLL_FUNCTION(void) BS_ISteamGameServer_SetGameTags(ISteamGameServer* pSteamGameServer, const char *pchGameTags) {
 	pSteamGameServer->SetGameTags(pchGameTags);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetGameData(ISteamGameServer* pSteamGameServer, const char *pchGameData) {
+/// Sets a string defining the "gamedata" for this server, this is optional, but if it is set
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameData=_BS_GameServer_SetGameData@8")
+/// 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_FUNCTION(void) BS_ISteamGameServer_SetGameData(ISteamGameServer* pSteamGameServer, const char *pchGameData) {
 	pSteamGameServer->SetGameData(pchGameData);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetRegion(ISteamGameServer* pSteamGameServer, const char *pszRegion) {
+/// Region identifier.  This is an optional field, the default value is empty, meaning the "world" region
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetRegion=_BS_GameServer_SetRegion@8")
+DLL_FUNCTION(void) BS_ISteamGameServer_SetRegion(ISteamGameServer* pSteamGameServer, const char *pszRegion) {
 	pSteamGameServer->SetRegion(pszRegion);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_SendUserConnectAndAuthenticate(ISteamGameServer* pSteamGameServer, uint32_t unIPClient, const void *pvAuthBlob, uint32_t cubAuthBlobSize, CSteamID *pSteamIDUser) {
+//
-#pragma comment(linker, "/EXPORT:BS_GameServer_SendUserConnectAndAuthenticate=_BS_GameServer_SendUserConnectAndAuthenticate@20")
+// 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_FUNCTION(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);
 }
 
-DLL_FUNCTION(CSteamID*) BS_GameServer_CreateUnauthenticatedUserConnection(ISteamGameServer* pSteamGameServer) {
+// Creates a fake user (ie, a bot) which will be listed as playing on the server, but skips validation.  
-#pragma comment(linker, "/EXPORT:BS_GameServer_CreateUnauthenticatedUserConnection=_BS_GameServer_CreateUnauthenticatedUserConnection@4")
+// 
+// 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_FUNCTION(CSteamID*) BS_ISteamGameServer_CreateUnauthenticatedUserConnection(ISteamGameServer* pSteamGameServer) {
 	return new CSteamID(pSteamGameServer->CreateUnauthenticatedUserConnection());
 }
 
-DLL_FUNCTION(void) BS_GameServer_SendUserDisconnect(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser) {
+// Should be called whenever a user leaves our game server, this lets Steam internally
-#pragma comment(linker, "/EXPORT:BS_GameServer_SendUserDisconnect=_BS_GameServer_SendUserDisconnect@8")
+// 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_FUNCTION(void) BS_ISteamGameServer_SendUserDisconnect(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser) {
 	pSteamGameServer->SendUserDisconnect(*pSteamIDUser);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_UpdateUserData(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, const char *pchPlayerName, uint32_t uScore) {
+// Update the data to be displayed in the server browser and matchmaking interfaces for a user
-#pragma comment(linker, "/EXPORT:BS_GameServer_UpdateUserData=_BS_GameServer_UpdateUserData@16")
+// 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_FUNCTION(uint32_t) BS_ISteamGameServer_UpdateUserData(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, const char *pchPlayerName, uint32_t uScore) {
 	return pSteamGameServer->BUpdateUserData(*pSteamIDUser, pchPlayerName, uScore);
 }
 
-DLL_FUNCTION(HAuthTicket) BS_GameServer_GetAuthSessionTicket(ISteamGameServer* pSteamGameServer, void *pTicket, int32_t cbMaxTicket, uint32_t *pcbTicket) {
+// New auth system APIs - do not mix with the old auth system APIs.
-#pragma comment(linker, "/EXPORT:BS_GameServer_GetAuthSessionTicket=_BS_GameServer_GetAuthSessionTicket@16")
+// ----------------------------------------------------------------
+
+// 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_FUNCTION(HAuthTicket) BS_ISteamGameServer_GetAuthSessionTicket(ISteamGameServer* pSteamGameServer, void *pTicket, int32_t cbMaxTicket, uint32_t *pcbTicket) {
 	return pSteamGameServer->GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket);
 }
 
-DLL_FUNCTION(EBeginAuthSessionResult) BS_GameServer_BeginAuthSession(ISteamGameServer* pSteamGameServer, const void *pAuthTicket, int32_t cbAuthTicket, CSteamID* pSteamID) {
+// Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused
-#pragma comment(linker, "/EXPORT:BS_GameServer_BeginAuthSession=_BS_GameServer_BeginAuthSession@16")
+// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
+DLL_FUNCTION(EBeginAuthSessionResult) BS_ISteamGameServer_BeginAuthSession(ISteamGameServer* pSteamGameServer, const void *pAuthTicket, int32_t cbAuthTicket, CSteamID* pSteamID) {
 	return pSteamGameServer->BeginAuthSession(pAuthTicket, cbAuthTicket, *pSteamID);
 }
 
-DLL_FUNCTION(void) BS_GameServer_EndAuthSession(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID) {
+// Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
-#pragma comment(linker, "/EXPORT:BS_GameServer_EndAuthSession=_BS_GameServer_EndAuthSession@8")
+DLL_FUNCTION(void) BS_ISteamGameServer_EndAuthSession(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID) {
 	pSteamGameServer->EndAuthSession(*pSteamID);
 }
 
-DLL_FUNCTION(void) BS_GameServer_CancelAuthTicket(ISteamGameServer* pSteamGameServer, HAuthTicket hAuthTicket) {
+// Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
-#pragma comment(linker, "/EXPORT:BS_GameServer_CancelAuthTicket=_BS_GameServer_CancelAuthTicket@8")
+DLL_FUNCTION(void) BS_ISteamGameServer_CancelAuthTicket(ISteamGameServer* pSteamGameServer, HAuthTicket hAuthTicket) {
 	pSteamGameServer->CancelAuthTicket(hAuthTicket);
 }
 
-DLL_FUNCTION(EUserHasLicenseForAppResult) BS_GameServer_UserHasLicenseForApp(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID, AppId_t appID) {
+// After receiving a user's authentication data, and passing it to SendUserConnectAndAuthenticate, use this function
-#pragma comment(linker, "/EXPORT:BS_GameServer_UserHasLicenseForApp=_BS_GameServer_UserHasLicenseForApp@12")
+// to determine if the user owns downloadable content specified by the provided AppID.
+DLL_FUNCTION(EUserHasLicenseForAppResult) BS_ISteamGameServer_UserHasLicenseForApp(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID, AppId_t appID) {
 	return pSteamGameServer->UserHasLicenseForApp(*pSteamID, appID);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_RequestUserGroupStatus(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, CSteamID* pSteamIDGroup) {
+// Ask if a user in in the specified group, results returns async by GSUserGroupStatus_t
-#pragma comment(linker, "/EXPORT:BS_GameServer_RequestUserGroupStatus=_BS_GameServer_RequestUserGroupStatus@12")
+// returns false if we're not connected to the steam servers and thus cannot ask
+DLL_FUNCTION(uint32_t) BS_ISteamGameServer_RequestUserGroupStatus(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, CSteamID* pSteamIDGroup) {
 	return pSteamGameServer->RequestUserGroupStatus(*pSteamIDUser, *pSteamIDGroup);
 }
 
-DLL_FUNCTION(void) BS_GameServer_GetGameplayStats(ISteamGameServer* pSteamGameServer) {
+// Returns the public IP of the server according to Steam, useful when the server is 
-#pragma comment(linker, "/EXPORT:BS_GameServer_GetGameplayStats=_BS_GameServer_GetGameplayStats@4")
+// behind NAT and you want to advertise its IP in a lobby for other clients to directly
-	pSteamGameServer->GetGameplayStats();
+// connect to
-}
+DLL_FUNCTION(uint32_t) BS_ISteamGameServer_GetPublicIP(ISteamGameServer* pSteamGameServer) {
-
-DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_GetServerReputation(ISteamGameServer* pSteamGameServer) {
-#pragma comment(linker, "/EXPORT:BS_GameServer_GetServerReputation=_BS_GameServer_GetServerReputation@4")
-	return new uint64_t(pSteamGameServer->GetServerReputation());
-}
-
-DLL_FUNCTION(uint32_t) BS_GameServer_GetPublicIP(ISteamGameServer* pSteamGameServer) {
-#pragma comment(linker, "/EXPORT:BS_GameServer_GetPublicIP=_BS_GameServer_GetPublicIP@4")
 	return pSteamGameServer->GetPublicIP();
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_HandleIncomingPacket(ISteamGameServer* pSteamGameServer, const void *pData, int32_t cbData, uint32_t srcIP, uint16_t srcPort) {
+// These are in GameSocketShare mode, where instead of ISteamGameServer creating its own
-#pragma comment(linker, "/EXPORT:BS_GameServer_HandleIncomingPacket=_BS_GameServer_HandleIncomingPacket@20")
+// 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_FUNCTION(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);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_GetNextOutgoingPacket(ISteamGameServer* pSteamGameServer, void *pOut, int32_t cbMaxOut, uint32_t *pNetAdr, uint16_t *pPort) {
+// AFTER calling HandleIncomingPacket for any packets that came in that frame, call this.
-#pragma comment(linker, "/EXPORT:BS_GameServer_GetNextOutgoingPacket=_BS_GameServer_GetNextOutgoingPacket@20")
+// 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_FUNCTION(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);
 }
 
-DLL_FUNCTION(void) BS_GameServer_EnableHeartbeats(ISteamGameServer* pSteamGameServer, uint32_t bActive) {
+//
-#pragma comment(linker, "/EXPORT:BS_GameServer_EnableHeartbeats=_BS_GameServer_EnableHeartbeats@8")
+// 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_FUNCTION(void) BS_ISteamGameServer_EnableHeartbeats(ISteamGameServer* pSteamGameServer, uint32_t bActive) {
 	pSteamGameServer->EnableHeartbeats(!!bActive);
 }
 
-DLL_FUNCTION(void) BS_GameServer_SetHeartbeatInterval(ISteamGameServer* pSteamGameServer, int32_t iHeartbeatInterval) {
+// You usually don't need to modify this.
-#pragma comment(linker, "/EXPORT:BS_GameServer_SetHeartbeatInterval=_BS_GameServer_SetHeartbeatInterval@8")
+// Pass -1 to use the default value for iHeartbeatInterval.
+// Some mods change this.
+DLL_FUNCTION(void) BS_ISteamGameServer_SetHeartbeatInterval(ISteamGameServer* pSteamGameServer, int32_t iHeartbeatInterval) {
 	pSteamGameServer->SetHeartbeatInterval(iHeartbeatInterval);
 }
 
-DLL_FUNCTION(void) BS_GameServer_ForceHeartbeat(ISteamGameServer* pSteamGameServer) {
+// Force a heartbeat to steam at the next opportunity
-#pragma comment(linker, "/EXPORT:BS_GameServer_ForceHeartbeat=_BS_GameServer_ForceHeartbeat@4")
+DLL_FUNCTION(void) BS_ISteamGameServer_ForceHeartbeat(ISteamGameServer* pSteamGameServer) {
 	pSteamGameServer->ForceHeartbeat();
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_AssociateWithClan(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDClan) {
+// associate this game server with this clan for the purposes of computing player compat
-#pragma comment(linker, "/EXPORT:BS_GameServer_AssociateWithClan=_BS_GameServer_AssociateWithClan@8")
+DLL_FUNCTION(SteamAPICall_t*) BS_ISteamGameServer_AssociateWithClan(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDClan) {
 	return new SteamAPICall_t(pSteamGameServer->AssociateWithClan(*pSteamIDClan));
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_ComputeNewPlayerCompatibility(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDNewPlayer) {
+// ask if any of the current players dont want to play with this new player - or vice versa
-#pragma comment(linker, "/EXPORT:BS_GameServer_ComputeNewPlayerCompatibility=_BS_GameServer_ComputeNewPlayerCompatibility@8")
+DLL_FUNCTION(SteamAPICall_t*) BS_ISteamGameServer_ComputeNewPlayerCompatibility(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDNewPlayer) {
 	return new SteamAPICall_t(pSteamGameServer->ComputeNewPlayerCompatibility(*pSteamIDNewPlayer));
 }

Wrapper/SteamGameServerStats.cpp

@@ -16,58 +16,66 @@
 
 #include "BlitzSteam.h"
 
-DLL_FUNCTION(ISteamGameServerStats*) BS_GameServerStats() {
+//-----------------------------------------------------------------------------
-#pragma comment(linker, "/EXPORT:BS_GameServerStats=_BS_GameServerStats@0")
+// Purpose: Functions for authenticating users via Steam to play on a game server
+//-----------------------------------------------------------------------------
+DLL_FUNCTION(ISteamGameServerStats*) BS_SteamGameServerStats() {
 	return SteamGameServerStats();
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_GameServerStats_RequestUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
+// downloads stats for the user
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_RequestUserStats=_BS_GameServerStats_RequestUserStats@8")
+// 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_FUNCTION(SteamAPICall_t*) BS_ISteamGameServerStats_RequestUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
 	return new SteamAPICall_t(pSteamGameServerStats->RequestUserStats(*steamIDUser));
 }
 
-DLL_FUNCTION(SteamAPICall_t*) BS_GameServerStats_StoreUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
+// Store the current data on the server, will get a GSStatsStored_t callback when set.
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_StoreUserStats=_BS_GameServerStats_StoreUserStats@8")
+//
+// 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_FUNCTION(SteamAPICall_t*) BS_ISteamGameServerStats_StoreUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
 	return new SteamAPICall_t(pSteamGameServerStats->StoreUserStats(*steamIDUser));
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData) {
+// requests stat information for a user, usable after a successful call to RequestUserStats()
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_GetUserStat=_BS_GameServerStats_GetUserStat@16")
+DLL_FUNCTION(uint32_t) BS_ISteamGameServerStats_GetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData) {
 	return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, (int32_t*)pData);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t* pData) {
+DLL_FUNCTION(uint32_t) BS_ISteamGameServerStats_GetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t* pData) {
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_GetUserStatF=_BS_GameServerStats_GetUserStatF@16")
 	return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, pData);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pbAchieved) {
+DLL_FUNCTION(uint32_t) BS_ISteamGameServerStats_GetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pbAchieved) {
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_GetUserAchievement=_BS_GameServerStats_GetUserAchievement@16")
 	return pSteamGameServerStats->GetUserAchievement(*steamIDUser, pchName, (bool*)pbAchieved);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t nData) {
+// Set / update stats and achievements. 
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_SetUserStat=_BS_GameServerStats_SetUserStat@16")
+// 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_FUNCTION(uint32_t) BS_ISteamGameServerStats_SetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t nData) {
 	return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, (int32_t)nData);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t fData) {
+DLL_FUNCTION(uint32_t) BS_ISteamGameServerStats_SetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t fData) {
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_SetUserStatF=_BS_GameServerStats_SetUserStatF@16")
 	return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, fData);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServerStats_UpdateUserAvgRateStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char *pchName, float flCountThisSession, double* pdSessionLength) {
+DLL_FUNCTION(uint32_t) BS_ISteamGameServerStats_UpdateUserAvgRateStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char *pchName, float flCountThisSession, double* pdSessionLength) {
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_UpdateUserAvgRateStat=_BS_GameServerStats_UpdateUserAvgRateStat@20")
 	return pSteamGameServerStats->UpdateUserAvgRateStat(*steamIDUser, pchName, flCountThisSession, *pdSessionLength);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
+DLL_FUNCTION(uint32_t) BS_ISteamGameServerStats_SetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_SetUserAchievement=_BS_GameServerStats_SetUserAchievement@12")
 	return pSteamGameServerStats->SetUserAchievement(*steamIDUser, pchName);
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServerStats_ClearUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
+DLL_FUNCTION(uint32_t) BS_ISteamGameServerStats_ClearUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
-#pragma comment(linker, "/EXPORT:BS_GameServerStats_ClearUserAchievement=_BS_GameServerStats_ClearUserAchievement@12")
 	return pSteamGameServerStats->ClearUserAchievement(*steamIDUser, pchName);
 }
 

Wrapper/SteamHTMLSurface.cpp

@@ -17,19 +17,16 @@
 #include "BlitzSteam.h"
 #include "SteamworksSDK/public/steam/isteamhtmlsurface.h"
 
-DLL_FUNCTION(ISteamHTMLSurface*) BS_HTMLSurface() {
+DLL_FUNCTION(ISteamHTMLSurface*) BS_SteamHTMLSurface() {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0")
 	return SteamHTMLSurface();
 }
 
 // Must call init and shutdown when starting/ending use of the interface
-DLL_FUNCTION(uint32_t) BS_HTMLSurface_Init(ISteamHTMLSurface* pSteamHTMLSurface) {
+DLL_FUNCTION(uint32_t) BS_SteamHTMLSurface_Init(ISteamHTMLSurface* pSteamHTMLSurface) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_Init=_BS_HTMLSurface_Init@4")
 	return pSteamHTMLSurface->Init();
 }
 
-DLL_FUNCTION(uint32_t) BS_HTMLSurface_Shutdown(ISteamHTMLSurface* pSteamHTMLSurface) {
+DLL_FUNCTION(uint32_t) BS_SteamHTMLSurface_Shutdown(ISteamHTMLSurface* pSteamHTMLSurface) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_Shutdown=_BS_HTMLSurface_Shutdown@4")
 	return pSteamHTMLSurface->Shutdown();
 }
 
@@ -39,172 +36,143 @@ DLL_FUNCTION(uint32_t) BS_HTMLSurface_Shutdown(ISteamHTMLSurface* pSteamHTMLSurf
 // 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_FUNCTION(SteamAPICall_t*) BS_HTMLSurface_CreateBrowser(ISteamHTMLSurface* pSteamHTMLSurface, const char* pchUserAgent, const char* pchUserCSS) {
+DLL_FUNCTION(SteamAPICall_t*) BS_SteamHTMLSurface_CreateBrowser(ISteamHTMLSurface* pSteamHTMLSurface, const char* pchUserAgent, const char* pchUserCSS) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_CreateBrowser=_BS_HTMLSurface_CreateBrowser@12")
 	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_FUNCTION(void) BS_HTMLSurface_RemoveBrowser(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_RemoveBrowser(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_RemoveBrowser=_BS_HTMLSurface_RemoveBrowser@8")
 	pSteamHTMLSurface->RemoveBrowser(unBrowserHandle);
 }
 
 // Navigate to this URL, results in a HTML_StartRequest_t as the request commences 
-DLL_FUNCTION(void) BS_HTMLSurface_LoadURL(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchURL, const char* pchPostData) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_LoadURL(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchURL, const char* pchPostData) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_LoadURL=_BS_HTMLSurface_LoadURL@16")
 	pSteamHTMLSurface->LoadURL(unBrowserHandle, pchURL, pchPostData);
 }
 
 // Tells the surface the size in pixels to display the surface
-DLL_FUNCTION(void) BS_HTMLSurface_SetSize(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32_t unWidth, uint32_t unHeight) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_SetSize(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32_t unWidth, uint32_t unHeight) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetSize=_BS_HTMLSurface_SetSize@16")
 	pSteamHTMLSurface->SetSize(unBrowserHandle, unWidth, unHeight);
 }
 
 // Stop the load of the current html page
-DLL_FUNCTION(void) BS_HTMLSurface_StopLoad(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_StopLoad(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_StopLoad=_BS_HTMLSurface_StopLoad@8")
 	pSteamHTMLSurface->StopLoad(unBrowserHandle);
 }
 
 // Reload (most likely from local cache) the current page
-DLL_FUNCTION(void) BS_HTMLSurface_Reload(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_Reload(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_Reload=_BS_HTMLSurface_Reload@8")
 	pSteamHTMLSurface->Reload(unBrowserHandle);
 }
 
 // navigate back in the page history
-DLL_FUNCTION(void) BS_HTMLSurface_GoBack(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_GoBack(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_GoBack=_BS_HTMLSurface_GoBack@8")
 	pSteamHTMLSurface->GoBack(unBrowserHandle);
 }
 
 // navigate forward in the page history
-DLL_FUNCTION(void) BS_HTMLSurface_GoForward(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_GoForward(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_GoForward=_BS_HTMLSurface_GoForward@8")
 	pSteamHTMLSurface->GoForward(unBrowserHandle);
 }
 
 // add this header to any url requests from this browser
-DLL_FUNCTION(void) BS_HTMLSurface_AddHeader(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchKey, const char* pchValue) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_AddHeader(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchKey, const char* pchValue) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_AddHeader=_BS_HTMLSurface_AddHeader@16")
 	pSteamHTMLSurface->AddHeader(unBrowserHandle, pchKey, pchValue);
 }
 
 // run this javascript script in the currently loaded page
-DLL_FUNCTION(void) BS_HTMLSurface_ExecuteJavascript(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchScript) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_ExecuteJavascript(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchScript) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_ExecuteJavascript=_BS_HTMLSurface_ExecuteJavascript@12")
 	pSteamHTMLSurface->ExecuteJavascript(unBrowserHandle, pchScript);
 }
 
 // Mouse click and mouse movement commands
-DLL_FUNCTION(void) BS_HTMLSurface_MouseUp(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_MouseUp(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseUp=_BS_HTMLSurface_MouseUp@12")
 	pSteamHTMLSurface->MouseUp(unBrowserHandle, eMouseButton);
 }
 
-DLL_FUNCTION(void) BS_HTMLSurface_MouseDown(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_MouseDown(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseDown=_BS_HTMLSurface_MouseDown@12")
 	pSteamHTMLSurface->MouseDown(unBrowserHandle, eMouseButton);
 }
 
-DLL_FUNCTION(void) BS_HTMLSurface_MouseDoubleClick(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_MouseDoubleClick(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseDoubleClick=_BS_HTMLSurface_MouseDoubleClick@12")
 	pSteamHTMLSurface->MouseDoubleClick(unBrowserHandle, eMouseButton);
 }
 
 // x and y are relative to the HTML bounds
-DLL_FUNCTION(void) BS_HTMLSurface_MouseMove(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int32_t x, int32_t y) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_MouseMove(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int32_t x, int32_t y) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseMove=_BS_HTMLSurface_MouseMove@16")
 	pSteamHTMLSurface->MouseMove(unBrowserHandle, x, y);
 }
 
 // nDelta is pixels of scroll
-DLL_FUNCTION(void) BS_HTMLSurface_MouseWheel(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int32_t nDelta) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_MouseWheel(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int32_t nDelta) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseWheel=_BS_HTMLSurface_MouseWheel@12")
 	pSteamHTMLSurface->MouseWheel(unBrowserHandle, nDelta);
 }
 
 // keyboard interactions, native keycode is the virtual key code value from your OS
-DLL_FUNCTION(void) BS_HTMLSurface_KeyDown(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_KeyDown(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_KeyDown=_BS_HTMLSurface_KeyDown@16")
 	pSteamHTMLSurface->KeyDown(unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
 }
 
-DLL_FUNCTION(void) BS_HTMLSurface_KeyUp(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_KeyUp(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_KeyUp=_BS_HTMLSurface_KeyUp@16")
 	pSteamHTMLSurface->KeyUp(unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
 }
 
 // cUnicodeChar is the unicode character point for this keypress (and potentially multiple chars per press)
-DLL_FUNCTION(void) BS_HTMLSurface_KeyChar(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_KeyChar(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_KeyChar=_BS_HTMLSurface_KeyChar@16")
 	pSteamHTMLSurface->KeyChar(unBrowserHandle, cUnicodeChar, eHTMLKeyModifiers);
 }
 
 // programmatically scroll this many pixels on the page
-DLL_FUNCTION(void) BS_HTMLSurface_SetHorizontalScroll(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_SetHorizontalScroll(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetHorizontalScroll=_BS_HTMLSurface_SetHorizontalScroll@12")
 	pSteamHTMLSurface->SetHorizontalScroll(unBrowserHandle, nAbsolutePixelScroll);
 }
 
-DLL_FUNCTION(void) BS_HTMLSurface_SetVerticalScroll(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_SetVerticalScroll(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetVerticalScroll=_BS_HTMLSurface_SetVerticalScroll@12")
 	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_FUNCTION(void) BS_HTMLSurface_SetKeyFocus(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bHasKeyFocus) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_SetKeyFocus(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bHasKeyFocus) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetKeyFocus=_BS_HTMLSurface_SetKeyFocus@12")
 	pSteamHTMLSurface->SetKeyFocus(unBrowserHandle, bHasKeyFocus);
 }
 
 // open the current pages html code in the local editor of choice, used for debugging
-DLL_FUNCTION(void) BS_HTMLSurface_ViewSource(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_ViewSource(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_ViewSource=_BS_HTMLSurface_ViewSource@8")
 	pSteamHTMLSurface->ViewSource(unBrowserHandle);
 }
 
 // copy the currently selected text on the html page to the local clipboard
-DLL_FUNCTION(void) BS_HTMLSurface_CopyToClipboard(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_CopyToClipboard(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_CopyToClipboard=_BS_HTMLSurface_CopyToClipboard@8")
 	pSteamHTMLSurface->CopyToClipboard(unBrowserHandle);
 }
 
 // paste from the local clipboard to the current html page
-DLL_FUNCTION(void) BS_HTMLSurface_PasteFromClipboard(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_PasteFromClipboard(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_PasteFromClipboard=_BS_HTMLSurface_PasteFromClipboard@8")
 	pSteamHTMLSurface->PasteFromClipboard(unBrowserHandle);
 }
 
 // find this string in the browser, if bCurrentlyInFind is true then instead cycle to the next matching element
-DLL_FUNCTION(void) BS_HTMLSurface_Find(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char *pchSearchStr, bool bCurrentlyInFind, bool bReverse) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_Find(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char *pchSearchStr, bool bCurrentlyInFind, bool bReverse) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_Find=_BS_HTMLSurface_Find@20")
 	pSteamHTMLSurface->Find(unBrowserHandle, pchSearchStr, bCurrentlyInFind, bReverse);
 }
 
 // cancel a currently running find
-DLL_FUNCTION(void) BS_HTMLSurface_StopFind(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_StopFind(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_StopFind=_BS_HTMLSurface_StopFind@8")
 	pSteamHTMLSurface->StopFind(unBrowserHandle);
 }
 
 // return details about the link at position x,y on the current page
-DLL_FUNCTION(void) BS_HTMLSurface_GetLinkAtPosition(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int x, int y) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_GetLinkAtPosition(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int x, int y) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_GetLinkAtPosition=_BS_HTMLSurface_GetLinkAtPosition@16")
 	pSteamHTMLSurface->GetLinkAtPosition(unBrowserHandle, x, y);
 }
 
 // set a webcookie for the hostname in question
-DLL_FUNCTION(void) BS_HTMLSurface_SetCookie(ISteamHTMLSurface* pSteamHTMLSurface, const char *pchHostname, const char *pchKey, const char *pchValue, const char *pchPath, RTime32 nExpires, bool bSecure, bool bHTTPOnly) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_SetCookie(ISteamHTMLSurface* pSteamHTMLSurface, const char *pchHostname, const char *pchKey, const char *pchValue, const char *pchPath, RTime32 nExpires, bool bSecure, bool bHTTPOnly) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetCookie=_BS_HTMLSurface_SetCookie@32")
 	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_FUNCTION(void) BS_HTMLSurface_SetPageScaleFactor(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_SetPageScaleFactor(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetPageScaleFactor=_BS_HTMLSurface_SetPageScaleFactor@20")
 	pSteamHTMLSurface->SetPageScaleFactor(unBrowserHandle, flZoom, nPointX, nPointY);
 }
 
@@ -212,8 +180,7 @@ DLL_FUNCTION(void) BS_HTMLSurface_SetPageScaleFactor(ISteamHTMLSurface* pSteamHT
 // 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_FUNCTION(void) BS_HTMLSurface_SetBackgroundMode(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bBackgroundMode) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_SetBackgroundMode(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bBackgroundMode) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetBackgroundMode=_BS_HTMLSurface_SetBackgroundMode@12")
 	pSteamHTMLSurface->SetBackgroundMode(unBrowserHandle, bBackgroundMode);
 }
 
@@ -226,20 +193,17 @@ DLL_FUNCTION(void) BS_HTMLSurface_SetBackgroundMode(ISteamHTMLSurface* pSteamHTM
 //  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_FUNCTION(void) BS_HTMLSurface_AllowStartRequest(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bAllowed) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_AllowStartRequest(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bAllowed) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_AllowStartRequest=_BS_HTMLSurface_AllowStartRequest@12")
 	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_FUNCTION(void) BS_HTMLSurface_JSDialogResponse(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bResult) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_JSDialogResponse(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bResult) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_JSDialogResponse=_BS_HTMLSurface_JSDialogResponse@12")
 	pSteamHTMLSurface->JSDialogResponse(unBrowserHandle, bResult);
 }
 
 // You MUST call this in response to a HTML_FileOpenDialog_t callback
-DLL_FUNCTION(void) BS_HTMLSurface_FileLoadDialogResponse(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles) {
+DLL_FUNCTION(void) BS_SteamHTMLSurface_FileLoadDialogResponse(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles) {
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface_FileLoadDialogResponse=_BS_HTMLSurface_FileLoadDialogResponse@12")
 	pSteamHTMLSurface->FileLoadDialogResponse(unBrowserHandle, pchSelectedFiles);
 }

Wrapper/SteamHTTP.cpp

@@ -19,10 +19,11 @@
 DLL_FUNCTION(ISteamHTTP*) BS_HTTP() {
 	return SteamHTTP();
 }
-#pragma comment(linker, "/EXPORT:BS_HTTP=_BS_HTTP@0")
 
 DLL_FUNCTION(ISteamHTTP*) BS_GameServerHTTP() {
-#pragma comment(linker, "/EXPORT:BS_GameServerHTTP=_BS_GameServerHTTP@0")
 	return SteamGameServerHTTP();
 }
 
+DLL_FUNCTION(HTTPRequestHandle) BS_ISteamHTTP_CreateHTTPRequest(ISteamHTTP* pThis, EHTTPMethod eHTTPRequestMethod, const char* cAbsoluteUrl) {
+	return pThis->CreateHTTPRequest(eHTTPRequestMethod, cAbsoluteUrl);
+}

Wrapper/SteamInventory.cpp

@@ -19,10 +19,8 @@
 DLL_FUNCTION(ISteamInventory*) BS_Inventory() {
 	return SteamInventory();
 }
-#pragma comment(linker, "/EXPORT:BS_Inventory=_BS_Inventory@0")
 
 DLL_FUNCTION(ISteamInventory*) BS_GameServerInventory() {
-#pragma comment(linker, "/EXPORT:BS_GameServerInventory=_BS_GameServerInventory@0")
 	return SteamGameServerInventory();
 }
 

Wrapper/SteamMatchmaking.cpp

@@ -19,5 +19,4 @@
 DLL_FUNCTION(ISteamMatchmaking*) BS_Matchmaking() {
 	return SteamMatchmaking();
 }
-#pragma comment(linker, "/EXPORT:BS_Matchmaking=_BS_Matchmaking@0")
+BS_I
-

Wrapper/SteamMatchmakingServers.cpp

@@ -17,7 +17,6 @@
 #include "BlitzSteam.h"
 
 DLL_FUNCTION(ISteamMatchmakingServers*) BS_MatchmakingServers() {
-#pragma comment(linker, "/EXPORT:BS_MatchmakingServers=_BS_MatchmakingServers@0")
 	return SteamMatchmakingServers();
 }
 

Wrapper/SteamMusic.cpp

@@ -19,5 +19,4 @@
 DLL_FUNCTION(ISteamMusic*) BS_Music() {
 	return SteamMusic();
 }
-#pragma comment(linker, "/EXPORT:BS_Music=_BS_Music@0")
+BS_I
-

Wrapper/SteamMusicRemote.cpp

@@ -19,5 +19,4 @@
 DLL_FUNCTION(ISteamMusicRemote*) BS_MusicRemote() {
 	return SteamMusicRemote();
 }
-#pragma comment(linker, "/EXPORT:BS_MusicRemote=_BS_MusicRemote@0")
+BS_I
-

Wrapper/SteamNetworking.cpp

@@ -19,49 +19,39 @@
 DLL_FUNCTION(ISteamNetworking*) BS_Networking() {
 	return SteamNetworking();
 }
-#pragma comment(linker, "/EXPORT:BS_Networking=_BS_Networking@0")
 
 DLL_FUNCTION(ISteamNetworking*) BS_GameServerNetworking() {
-#pragma comment(linker, "/EXPORT:BS_GameServerNetworking=_BS_GameServerNetworking@0")
 	return SteamGameServerNetworking();
 }
 
 DLL_FUNCTION(uint32_t) BS_Networking_SendP2PPacket(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, const void* pubData, uint32_t cubData, EP2PSend eP2PSendType, uint32_t nChannel) {
-#pragma comment(linker, "/EXPORT:BS_Networking_SendP2PPacket=_BS_Networking_SendP2PPacket@24")
 	return pSteamNetworking->SendP2PPacket(*pSteamIDRemote, pubData, cubData, eP2PSendType, nChannel);
 }
 
 DLL_FUNCTION(uint32_t) BS_Networking_IsP2PPacketAvailable(ISteamNetworking* pSteamNetworking, uint32_t* pcubMsgSize, uint32_t nChannel) {
-#pragma comment(linker, "/EXPORT:BS_Networking_IsP2PPacketAvailable=_BS_Networking_IsP2PPacketAvailable@12")
 	return pSteamNetworking->IsP2PPacketAvailable(pcubMsgSize, nChannel);
 }
 
 DLL_FUNCTION(uint32_t) BS_Networking_ReadP2PPacket(ISteamNetworking* pSteamNetworking, void* pubDest, uint32_t cubDest, uint32_t* pcubMsgSize, CSteamID* pSteamIDRemote, uint32_t nChannel) {
-#pragma comment(linker, "/EXPORT:BS_Networking_ReadP2PPacket=_BS_Networking_ReadP2PPacket@24")
 	return pSteamNetworking->ReadP2PPacket(pubDest, cubDest, pcubMsgSize, pSteamIDRemote, nChannel);
 }
 
 DLL_FUNCTION(uint32_t) BS_Networking_AcceptP2PSessionWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote) {
-#pragma comment(linker, "/EXPORT:BS_Networking_AcceptP2PSessionWithUser=_BS_Networking_AcceptP2PSessionWithUser@8")
 	return pSteamNetworking->AcceptP2PSessionWithUser(*pSteamIDRemote);
 }
 
 DLL_FUNCTION(uint32_t) BS_Networking_CloseP2PSessionWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote) {
-#pragma comment(linker, "/EXPORT:BS_Networking_CloseP2PSessionWithUser=_BS_Networking_CloseP2PSessionWithUser@8")
 	return pSteamNetworking->CloseP2PSessionWithUser(*pSteamIDRemote);
 }
 
 DLL_FUNCTION(uint32_t) BS_Networking_CloseP2PChannelWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, uint32_t nChannel) {
-#pragma comment(linker, "/EXPORT:BS_Networking_CloseP2PChannelWithUser=_BS_Networking_CloseP2PChannelWithUser@12")
 	return pSteamNetworking->CloseP2PChannelWithUser(*pSteamIDRemote, nChannel);
 }
 
 DLL_FUNCTION(uint32_t) BS_Networking_GetP2PSessionState(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, P2PSessionState_t* pConnectionState) {
-#pragma comment(linker, "/EXPORT:BS_Networking_GetP2PSessionState=_BS_Networking_GetP2PSessionState@12")
 	return pSteamNetworking->GetP2PSessionState(*pSteamIDRemote, pConnectionState);
 }
 
 DLL_FUNCTION(uint32_t) BS_Networking_AllowP2PPacketRelay(ISteamNetworking* pSteamNetworking, uint32_t bAllow) {
-#pragma comment(linker, "/EXPORT:BS_Networking_AllowP2PPacketRelay=_BS_Networking_AllowP2PPacketRelay@8")
 	return pSteamNetworking->AllowP2PPacketRelay(!!bAllow);
 }

Wrapper/SteamRemoteStorage.cpp

@@ -19,5 +19,4 @@
 DLL_FUNCTION(ISteamRemoteStorage*) BS_RemoteStorage() {
 	return SteamRemoteStorage();
 }
-#pragma comment(linker, "/EXPORT:BS_RemoteStorage=_BS_RemoteStorage@0")
+BS_I
-

Wrapper/SteamScreenshots.cpp

@@ -19,5 +19,4 @@
 DLL_FUNCTION(ISteamScreenshots*) BS_Screenshots() {
 	return SteamScreenshots();
 }
-#pragma comment(linker, "/EXPORT:BS_Screenshots=_BS_Screenshots@0")
+BS_I
-

Wrapper/SteamUGC.cpp

@@ -19,10 +19,8 @@
 DLL_FUNCTION(ISteamUGC*) BS_UGC() {
 	return SteamUGC();
 }
-#pragma comment(linker, "/EXPORT:BS_UGC=_BS_UGC@0")
 
 DLL_FUNCTION(ISteamUGC*) BS_GameServerUGC() {
-#pragma comment(linker, "/EXPORT:BS_GameServerUGC=_BS_GameServerUGC@0")
 	return SteamGameServerUGC();
 }
 

Wrapper/SteamUnifiedMessages.cpp

@@ -19,5 +19,4 @@
 DLL_FUNCTION(ISteamUnifiedMessages*) BS_UnifiedMessages() {
 	return SteamUnifiedMessages();
 }
-#pragma comment(linker, "/EXPORT:BS_UnifiedMessages=_BS_UnifiedMessages@0")
+BS_I
-

Wrapper/SteamUser.cpp

@@ -19,128 +19,103 @@
 DLL_FUNCTION(ISteamUser*) BS_User() {
 	return SteamUser();
 }
-#pragma comment(linker, "/EXPORT:BS_User=_BS_User@0")
+BS_I
-
 DLL_FUNCTION(HSteamUser) BS_User_GetHSteamUser( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetHSteamUser( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetHSteamUser=_BS_User_GetHSteamUser@4")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_User_IsLoggedOn( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->BLoggedOn( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_IsLoggedOn=_BS_User_IsLoggedOn@4")
+BS_I
-
 DLL_FUNCTION(CSteamID*) BS_User_GetSteamID( ISteamUser* lpSteamUser ) {
 	return &(lpSteamUser->GetSteamID( ));
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetSteamID=_BS_User_GetSteamID@4")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_User_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")
+BS_I
-
 DLL_FUNCTION(void) BS_User_TerminateGameConnection( ISteamUser* lpSteamUser, uint32_t unIPServer, uint16_t usPortServer ) {
 	lpSteamUser->TerminateGameConnection( unIPServer, usPortServer );
 }
-#pragma comment(linker, "/EXPORT:BS_User_TerminateGameConnection=_BS_User_TerminateGameConnection@12")
+BS_I
-
 DLL_FUNCTION(void) BS_User_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_User_GetUserDataFolder( ISteamUser* lpSteamUser, char* pchBuffer, uint32_t cubBuffer ) {
 	return lpSteamUser->GetUserDataFolder( pchBuffer, cubBuffer );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetUserDataFolder=_BS_User_GetUserDataFolder@12")
+BS_I
-
 DLL_FUNCTION(void) BS_User_StartVoiceRecording( ISteamUser* lpSteamUser ) {
 	lpSteamUser->StartVoiceRecording( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_StartVoiceRecording=_BS_User_StartVoiceRecording@4")
+BS_I
-
 DLL_FUNCTION(void) BS_User_StopVoiceRecording( ISteamUser* lpSteamUser ) {
 	lpSteamUser->StopVoiceRecording( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_StopVoiceRecording=_BS_User_StopVoiceRecording@4")
+BS_I
-
 DLL_FUNCTION(EVoiceResult) BS_User_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")
+BS_I
-
 DLL_FUNCTION(EVoiceResult) 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 ) {
 	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")
+BS_I
-
 DLL_FUNCTION(EVoiceResult) BS_User_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_User_GetVoiceOptimalSampleRate( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetVoiceOptimalSampleRate( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetVoiceOptimalSampleRate=_BS_User_GetVoiceOptimalSampleRate@4")
+BS_I
-
 DLL_FUNCTION(HAuthTicket) BS_User_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")
+BS_I
-
 DLL_FUNCTION(EBeginAuthSessionResult) BS_User_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")
+BS_I
-
 DLL_FUNCTION(void) BS_User_EndAuthSession( ISteamUser* lpSteamUser, CSteamID* steamID ) {
 	lpSteamUser->EndAuthSession( *steamID );
 }
-#pragma comment(linker, "/EXPORT:BS_User_EndAuthSession=_BS_User_EndAuthSession@8")
+BS_I
-
 DLL_FUNCTION(void) BS_User_CancelAuthTicket( ISteamUser* lpSteamUser, HAuthTicket hAuthTicket ) {
 	lpSteamUser->CancelAuthTicket( hAuthTicket );
 }
-#pragma comment(linker, "/EXPORT:BS_User_EndAuthSession=_BS_User_EndAuthSession@8")
+BS_I
-
 DLL_FUNCTION(EUserHasLicenseForAppResult) BS_User_UserHasLicenseForApp( ISteamUser* lpSteamUser, CSteamID* steamID, AppId_t appID ) {
 	return lpSteamUser->UserHasLicenseForApp( *steamID, appID );
 }
-#pragma comment(linker, "/EXPORT:BS_User_UserHasLicenseForApp=_BS_User_UserHasLicenseForApp@12")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_User_IsBehindNAT( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->BIsBehindNAT( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_IsBehindNAT=_BS_User_IsBehindNAT@4")
+BS_I
-
 DLL_FUNCTION(void) BS_User_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")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_User_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_User_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_User_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_User_GetPlayerSteamLevel( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetPlayerSteamLevel( );
 }
-#pragma comment(linker, "/EXPORT:BS_User_GetPlayerSteamLevel=_BS_User_GetPlayerSteamLevel@4")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_User_RequestStoreAuthURL( ISteamUser* lpSteamUser, const char* pchRedirectURL ) {
 	return new uint64_t(lpSteamUser->RequestStoreAuthURL( pchRedirectURL ));
 }

Wrapper/SteamUserStats.cpp

@@ -19,218 +19,175 @@
 DLL_FUNCTION(ISteamUserStats*) BS_UserStats() {
 	return SteamUserStats();
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats=_BS_UserStats@0")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_RequestCurrentStats( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->RequestCurrentStats( );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_RequestCurrentStats=_BS_UserStats_RequestCurrentStats@4")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_SetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->SetAchievement( pchName );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_SetAchievement=_BS_UserStats_SetAchievement@8")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_ClearAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->ClearAchievement( pchName );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_ClearAchievement=_BS_UserStats_ClearAchievement@8")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_StoreStats( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->StoreStats( );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_StoreStats=_BS_UserStats_StoreStats@4")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievementIcon( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->GetAchievementIcon( pchName );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementIcon=_BS_UserStats_GetAchievementIcon@8")
+BS_I
-
 DLL_FUNCTION(const char*) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_GetNumAchievements( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->GetNumAchievements( );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetNumAchievements=_BS_UserStats_GetNumAchievements@4")
+BS_I
-
 DLL_FUNCTION(const char*) BS_UserStats_GetAchievementName( ISteamUserStats* lpSteamUserStats, uint32_t iAchievement ) {
 	return lpSteamUserStats->GetAchievementName( iAchievement );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementName=_BS_UserStats_GetAchievementName@8")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestUserStats( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser ) {
 	return new uint64_t( lpSteamUserStats->RequestUserStats( *steamIDUser ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_RequestUserStats=_BS_UserStats_RequestUserStats@8")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_ResetAllStats( ISteamUserStats* lpSteamUserStats, uint32_t bAchievementsToo ) {
 	return lpSteamUserStats->ResetAllStats( bAchievementsToo != 0 );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_ResetAllStats=_BS_UserStats_ResetAllStats@8")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_FindLeaderboard( ISteamUserStats* lpSteamUserStats, const char *pchLeaderboardName ) {
 	return new uint64_t( lpSteamUserStats->FindLeaderboard( pchLeaderboardName ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_FindLeaderboard=_BS_UserStats_FindLeaderboard@8")
+BS_I
-
 DLL_FUNCTION(const char*) BS_UserStats_GetLeaderboardName( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardName( *hSteamLeaderboard );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardName=_BS_UserStats_GetLeaderboardName@8")
+BS_I
-
 DLL_FUNCTION(int) BS_UserStats_GetLeaderboardEntryCount( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardEntryCount( *hSteamLeaderboard );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardEntryCount=_BS_UserStats_GetLeaderboardEntryCount@8")
+BS_I
-
 DLL_FUNCTION(ELeaderboardSortMethod) BS_UserStats_GetLeaderboardSortMethod( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardSortMethod( *hSteamLeaderboard );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardSortMethod=_BS_UserStats_GetLeaderboardSortMethod@8")
+BS_I
-
 DLL_FUNCTION(ELeaderboardDisplayType) BS_UserStats_GetLeaderboardDisplayType( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardDisplayType( *hSteamLeaderboard );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardDisplayType=_BS_UserStats_GetLeaderboardDisplayType@8")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_GetNumberOfCurrentPlayers( ISteamUserStats* lpSteamUserStats ) {
 	return new uint64_t( lpSteamUserStats->GetNumberOfCurrentPlayers( ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetNumberOfCurrentPlayers=_BS_UserStats_GetNumberOfCurrentPlayers@4")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestGlobalAchievementPercentages( ISteamUserStats* lpSteamUserStats ) {
 	return new uint64_t( lpSteamUserStats->RequestGlobalAchievementPercentages( ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_RequestGlobalAchievementPercentages=_BS_UserStats_RequestGlobalAchievementPercentages@4")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievementAchievedPercent( ISteamUserStats* lpSteamUserStats, const char *pchName, float *pflPercent ) {
 	return lpSteamUserStats->GetAchievementAchievedPercent( pchName, pflPercent );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementAchievedPercent=_BS_UserStats_GetAchievementAchievedPercent@12")
+BS_I
-
 DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestGlobalStats( ISteamUserStats* lpSteamUserStats, int nHistoryDays ) {
 	return new uint64_t( lpSteamUserStats->RequestGlobalStats( nHistoryDays ) );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_RequestGlobalStats=_BS_UserStats_RequestGlobalStats@8")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64* pData ) {
 	return lpSteamUserStats->GetGlobalStat( pchStatName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatLL=_BS_UserStats_GetGlobalStatLL@12")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double* pData ) {
 	return lpSteamUserStats->GetGlobalStat( pchStatName, pData );
 }
-#pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatD=_BS_UserStats_GetGlobalStatD@12")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatHistoryLL( 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")
+BS_I
-
 DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatHistoryD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double *pData, uint32_t cubData ) {
 	return lpSteamUserStats->GetGlobalStatHistory( pchStatName, pData, cubData );
 }

Wrapper/SteamUtils.cpp

@@ -19,5 +19,4 @@
 DLL_FUNCTION(ISteamUtils*) BS_Utils() {
 	return SteamUtils();
 }
-#pragma comment(linker, "/EXPORT:BS_Utils=_BS_Utils@0")
+BS_I
-

Wrapper/SteamVideo.cpp

@@ -19,5 +19,4 @@
 DLL_FUNCTION(ISteamVideo*) BS_Video() {
 	return SteamVideo();
 }
-#pragma comment(linker, "/EXPORT:BS_Video=_BS_Video@0")
+BS_I
-