diff --git a/lsteamclient/cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001.cpp b/lsteamclient/cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001.cpp
new file mode 100644
index 00000000..99d53c2e
--- /dev/null
+++ b/lsteamclient/cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001.cpp
@@ -0,0 +1,171 @@
+#include "steam_defs.h"
+#include "steamworks_sdk_130x/steam_api.h"
+#include "steamclient_private.h"
+#include "cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "struct_converters_130x.h"
+bool cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Init(void *linux_side)
+{
+ return ((ISteamHTMLSurface*)linux_side)->Init();
+}
+
+bool cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Shutdown(void *linux_side)
+{
+ return ((ISteamHTMLSurface*)linux_side)->Shutdown();
+}
+
+SteamAPICall_t cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CreateBrowser(void *linux_side, const char * pchUserAgent, const char * pchUserCSS)
+{
+ return ((ISteamHTMLSurface*)linux_side)->CreateBrowser((const char *)pchUserAgent, (const char *)pchUserCSS);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_RemoveBrowser(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->RemoveBrowser((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_LoadURL(void *linux_side, HHTMLBrowser unBrowserHandle, const char * pchURL, const char * pchPostData)
+{
+ ((ISteamHTMLSurface*)linux_side)->LoadURL((HHTMLBrowser)unBrowserHandle, (const char *)pchURL, (const char *)pchPostData);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetSize(void *linux_side, HHTMLBrowser unBrowserHandle, uint32 unWidth, uint32 unHeight)
+{
+ ((ISteamHTMLSurface*)linux_side)->SetSize((HHTMLBrowser)unBrowserHandle, (uint32)unWidth, (uint32)unHeight);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopLoad(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->StopLoad((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Reload(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->Reload((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoBack(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->GoBack((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoForward(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->GoForward((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AddHeader(void *linux_side, HHTMLBrowser unBrowserHandle, const char * pchKey, const char * pchValue)
+{
+ ((ISteamHTMLSurface*)linux_side)->AddHeader((HHTMLBrowser)unBrowserHandle, (const char *)pchKey, (const char *)pchValue);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ExecuteJavascript(void *linux_side, HHTMLBrowser unBrowserHandle, const char * pchScript)
+{
+ ((ISteamHTMLSurface*)linux_side)->ExecuteJavascript((HHTMLBrowser)unBrowserHandle, (const char *)pchScript);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseUp(void *linux_side, HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton)
+{
+ ((ISteamHTMLSurface*)linux_side)->MouseUp((HHTMLBrowser)unBrowserHandle, (ISteamHTMLSurface::EHTMLMouseButton)eMouseButton);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDown(void *linux_side, HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton)
+{
+ ((ISteamHTMLSurface*)linux_side)->MouseDown((HHTMLBrowser)unBrowserHandle, (ISteamHTMLSurface::EHTMLMouseButton)eMouseButton);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDoubleClick(void *linux_side, HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton)
+{
+ ((ISteamHTMLSurface*)linux_side)->MouseDoubleClick((HHTMLBrowser)unBrowserHandle, (ISteamHTMLSurface::EHTMLMouseButton)eMouseButton);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseMove(void *linux_side, HHTMLBrowser unBrowserHandle, int x, int y)
+{
+ ((ISteamHTMLSurface*)linux_side)->MouseMove((HHTMLBrowser)unBrowserHandle, (int)x, (int)y);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseWheel(void *linux_side, HHTMLBrowser unBrowserHandle, int32 nDelta)
+{
+ ((ISteamHTMLSurface*)linux_side)->MouseWheel((HHTMLBrowser)unBrowserHandle, (int32)nDelta);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyDown(void *linux_side, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers)
+{
+ ((ISteamHTMLSurface*)linux_side)->KeyDown((HHTMLBrowser)unBrowserHandle, (uint32)nNativeKeyCode, (ISteamHTMLSurface::EHTMLKeyModifiers)eHTMLKeyModifiers);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyUp(void *linux_side, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers)
+{
+ ((ISteamHTMLSurface*)linux_side)->KeyUp((HHTMLBrowser)unBrowserHandle, (uint32)nNativeKeyCode, (ISteamHTMLSurface::EHTMLKeyModifiers)eHTMLKeyModifiers);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyChar(void *linux_side, HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, EHTMLKeyModifiers eHTMLKeyModifiers)
+{
+ ((ISteamHTMLSurface*)linux_side)->KeyChar((HHTMLBrowser)unBrowserHandle, (uint32)cUnicodeChar, (ISteamHTMLSurface::EHTMLKeyModifiers)eHTMLKeyModifiers);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetHorizontalScroll(void *linux_side, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll)
+{
+ ((ISteamHTMLSurface*)linux_side)->SetHorizontalScroll((HHTMLBrowser)unBrowserHandle, (uint32)nAbsolutePixelScroll);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetVerticalScroll(void *linux_side, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll)
+{
+ ((ISteamHTMLSurface*)linux_side)->SetVerticalScroll((HHTMLBrowser)unBrowserHandle, (uint32)nAbsolutePixelScroll);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetKeyFocus(void *linux_side, HHTMLBrowser unBrowserHandle, bool bHasKeyFocus)
+{
+ ((ISteamHTMLSurface*)linux_side)->SetKeyFocus((HHTMLBrowser)unBrowserHandle, (bool)bHasKeyFocus);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ViewSource(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->ViewSource((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CopyToClipboard(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->CopyToClipboard((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_PasteFromClipboard(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->PasteFromClipboard((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Find(void *linux_side, HHTMLBrowser unBrowserHandle, const char * pchSearchStr, bool bCurrentlyInFind, bool bReverse)
+{
+ ((ISteamHTMLSurface*)linux_side)->Find((HHTMLBrowser)unBrowserHandle, (const char *)pchSearchStr, (bool)bCurrentlyInFind, (bool)bReverse);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopFind(void *linux_side, HHTMLBrowser unBrowserHandle)
+{
+ ((ISteamHTMLSurface*)linux_side)->StopFind((HHTMLBrowser)unBrowserHandle);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GetLinkAtPosition(void *linux_side, HHTMLBrowser unBrowserHandle, int x, int y)
+{
+ ((ISteamHTMLSurface*)linux_side)->GetLinkAtPosition((HHTMLBrowser)unBrowserHandle, (int)x, (int)y);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AllowStartRequest(void *linux_side, HHTMLBrowser unBrowserHandle, bool bAllowed)
+{
+ ((ISteamHTMLSurface*)linux_side)->AllowStartRequest((HHTMLBrowser)unBrowserHandle, (bool)bAllowed);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_JSDialogResponse(void *linux_side, HHTMLBrowser unBrowserHandle, bool bResult)
+{
+ ((ISteamHTMLSurface*)linux_side)->JSDialogResponse((HHTMLBrowser)unBrowserHandle, (bool)bResult);
+}
+
+void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_FileLoadDialogResponse(void *linux_side, HHTMLBrowser unBrowserHandle, const char ** pchSelectedFiles)
+{
+ ((ISteamHTMLSurface*)linux_side)->FileLoadDialogResponse((HHTMLBrowser)unBrowserHandle, (const char **)pchSelectedFiles);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lsteamclient/cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001.h b/lsteamclient/cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001.h
new file mode 100644
index 00000000..eb98cbb6
--- /dev/null
+++ b/lsteamclient/cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001.h
@@ -0,0 +1,38 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern bool cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Init(void *);
+extern bool cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Shutdown(void *);
+extern SteamAPICall_t cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CreateBrowser(void *, const char *, const char *);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_RemoveBrowser(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_LoadURL(void *, HHTMLBrowser, const char *, const char *);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetSize(void *, HHTMLBrowser, uint32, uint32);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopLoad(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Reload(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoBack(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoForward(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AddHeader(void *, HHTMLBrowser, const char *, const char *);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ExecuteJavascript(void *, HHTMLBrowser, const char *);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseUp(void *, HHTMLBrowser, EHTMLMouseButton);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDown(void *, HHTMLBrowser, EHTMLMouseButton);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDoubleClick(void *, HHTMLBrowser, EHTMLMouseButton);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseMove(void *, HHTMLBrowser, int, int);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseWheel(void *, HHTMLBrowser, int32);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyDown(void *, HHTMLBrowser, uint32, EHTMLKeyModifiers);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyUp(void *, HHTMLBrowser, uint32, EHTMLKeyModifiers);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyChar(void *, HHTMLBrowser, uint32, EHTMLKeyModifiers);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetHorizontalScroll(void *, HHTMLBrowser, uint32);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetVerticalScroll(void *, HHTMLBrowser, uint32);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetKeyFocus(void *, HHTMLBrowser, bool);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ViewSource(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CopyToClipboard(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_PasteFromClipboard(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Find(void *, HHTMLBrowser, const char *, bool, bool);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopFind(void *, HHTMLBrowser);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GetLinkAtPosition(void *, HHTMLBrowser, int, int);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AllowStartRequest(void *, HHTMLBrowser, bool);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_JSDialogResponse(void *, HHTMLBrowser, bool);
+extern void cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_FileLoadDialogResponse(void *, HHTMLBrowser, const char **);
+#ifdef __cplusplus
+}
+#endif
diff --git a/lsteamclient/gen_wrapper.py b/lsteamclient/gen_wrapper.py
index 5122a6f4..06d37d43 100755
--- a/lsteamclient/gen_wrapper.py
+++ b/lsteamclient/gen_wrapper.py
@@ -30,6 +30,7 @@ sdk_versions = [
"132x",
"132",
"131",
+ "130x",
"130",
"129a",
"129",
diff --git a/lsteamclient/steamworks_sdk_130x/isteamapplist.h b/lsteamclient/steamworks_sdk_130x/isteamapplist.h
new file mode 100644
index 00000000..fc1d49ee
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamapplist.h
@@ -0,0 +1,63 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to app data in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMAPPLIST_H
+#define ISTEAMAPPLIST_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "steamtypes.h"
+
+//-----------------------------------------------------------------------------
+// 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.
+//-----------------------------------------------------------------------------
+class ISteamAppList
+{
+public:
+ virtual uint32 GetNumInstalledApps() = 0;
+ virtual uint32 GetInstalledApps( AppId_t *pvecAppID, uint32 unMaxAppIDs ) = 0;
+
+ virtual int GetAppName( AppId_t nAppID, char *pchName, int cchNameMax ) = 0; // returns -1 if no name was found
+ virtual int GetAppInstallDir( AppId_t nAppID, char *pchDirectory, int cchNameMax ) = 0; // returns -1 if no dir was found
+
+ virtual int GetAppBuildId( AppId_t nAppID ) = 0; // return the buildid of this app, may change at any time based on backend updates to the game
+};
+
+#define STEAMAPPLIST_INTERFACE_VERSION "STEAMAPPLIST_INTERFACE_VERSION001"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+
+//---------------------------------------------------------------------------------
+// Purpose: Sent when a new app is installed
+//---------------------------------------------------------------------------------
+DEFINE_CALLBACK( SteamAppInstalled_t, k_iSteamAppListCallbacks + 1 );
+ CALLBACK_MEMBER( 0, AppId_t, m_nAppID ) // ID of the app that installs
+END_DEFINE_CALLBACK_1()
+
+
+//---------------------------------------------------------------------------------
+// Purpose: Sent when an app is uninstalled
+//---------------------------------------------------------------------------------
+DEFINE_CALLBACK( SteamAppUninstalled_t, k_iSteamAppListCallbacks + 2 );
+ CALLBACK_MEMBER( 0, AppId_t, m_nAppID ) // ID of the app that installs
+END_DEFINE_CALLBACK_1()
+
+
+#pragma pack( pop )
+#endif // ISTEAMAPPLIST_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamapps.h b/lsteamclient/steamworks_sdk_130x/isteamapps.h
new file mode 100644
index 00000000..87bcdc30
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamapps.h
@@ -0,0 +1,149 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to app data in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMAPPS_H
+#define ISTEAMAPPS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+const int k_cubAppProofOfPurchaseKeyMax = 64; // max bytes of a legacy cd key we support
+
+
+//-----------------------------------------------------------------------------
+// Purpose: interface to app data
+//-----------------------------------------------------------------------------
+class ISteamApps
+{
+public:
+ virtual bool BIsSubscribed() = 0;
+ virtual bool BIsLowViolence() = 0;
+ virtual bool BIsCybercafe() = 0;
+ virtual bool BIsVACBanned() = 0;
+ virtual const char *GetCurrentGameLanguage() = 0;
+ virtual const char *GetAvailableGameLanguages() = 0;
+
+ // only use this member if you need to check ownership of another game related to yours, a demo for example
+ virtual bool BIsSubscribedApp( AppId_t appID ) = 0;
+
+ // Takes AppID of DLC and checks if the user owns the DLC & if the DLC is installed
+ virtual bool BIsDlcInstalled( AppId_t appID ) = 0;
+
+ // returns the Unix time of the purchase of the app
+ virtual uint32 GetEarliestPurchaseUnixTime( AppId_t nAppID ) = 0;
+
+ // Checks if the user is subscribed to the current app through a free weekend
+ // This function will return false for users who have a retail or other type of license
+ // Before using, please ask your Valve technical contact how to package and secure your free weekened
+ virtual bool BIsSubscribedFromFreeWeekend() = 0;
+
+ // Returns the number of DLC pieces for the running app
+ virtual int GetDLCCount() = 0;
+
+ // Returns metadata for DLC by index, of range [0, GetDLCCount()]
+ virtual bool BGetDLCDataByIndex( int iDLC, AppId_t *pAppID, bool *pbAvailable, char *pchName, int cchNameBufferSize ) = 0;
+
+ // Install/Uninstall control for optional DLC
+ virtual void InstallDLC( AppId_t nAppID ) = 0;
+ virtual void UninstallDLC( AppId_t nAppID ) = 0;
+
+ // Request cd-key for yourself or owned DLC. If you are interested in this
+ // data then make sure you provide us with a list of valid keys to be distributed
+ // to users when they purchase the game, before the game ships.
+ // You'll receive an AppProofOfPurchaseKeyResponse_t callback when
+ // the key is available (which may be immediately).
+ virtual void RequestAppProofOfPurchaseKey( AppId_t nAppID ) = 0;
+
+ virtual bool GetCurrentBetaName( char *pchName, int cchNameBufferSize ) = 0; // returns current beta branch name, 'public' is the default branch
+ virtual bool MarkContentCorrupt( bool bMissingFilesOnly ) = 0; // signal Steam that game files seems corrupt or missing
+ virtual uint32 GetInstalledDepots( AppId_t appID, DepotId_t *pvecDepots, uint32 cMaxDepots ) = 0; // return installed depots in mount order
+
+ // returns current app install folder for AppID, returns folder name length
+ virtual uint32 GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize ) = 0;
+ virtual bool BIsAppInstalled( AppId_t appID ) = 0; // returns true if that app is installed (not necessarily owned)
+
+ virtual CSteamID GetAppOwner() = 0; // returns the SteamID of the original owner. If different from current user, it's borrowed
+
+ // Returns the associated launch param if the game is run via steam://run///?param1=value1;param2=value2;param3=value3 etc.
+ // Parameter names starting with the character '@' are reserved for internal use and will always return and empty string.
+ // Parameter names starting with an underscore '_' are reserved for steam features -- they can be queried by the game,
+ // but it is advised that you not param names beginning with an underscore for your own features.
+ virtual const char *GetLaunchQueryParam( const char *pchKey ) = 0;
+
+#ifdef _PS3
+ // Result returned in a RegisterActivationCodeResponse_t callresult
+ virtual SteamAPICall_t RegisterActivationCode( const char *pchActivationCode ) = 0;
+#endif
+};
+
+#define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION006"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+//-----------------------------------------------------------------------------
+// Purpose: posted after the user gains ownership of DLC & that DLC is installed
+//-----------------------------------------------------------------------------
+struct DlcInstalled_t
+{
+ enum { k_iCallback = k_iSteamAppsCallbacks + 5 };
+ AppId_t m_nAppID; // AppID of the DLC
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: possible results when registering an activation code
+//-----------------------------------------------------------------------------
+enum ERegisterActivationCodeResult
+{
+ k_ERegisterActivationCodeResultOK = 0,
+ k_ERegisterActivationCodeResultFail = 1,
+ k_ERegisterActivationCodeResultAlreadyRegistered = 2,
+ k_ERegisterActivationCodeResultTimeout = 3,
+ k_ERegisterActivationCodeAlreadyOwned = 4,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: response to RegisterActivationCode()
+//-----------------------------------------------------------------------------
+struct RegisterActivationCodeResponse_t
+{
+ enum { k_iCallback = k_iSteamAppsCallbacks + 8 };
+ ERegisterActivationCodeResult m_eResult;
+ uint32 m_unPackageRegistered; // package that was registered. Only set on success
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: response to RegisterActivationCode()
+//-----------------------------------------------------------------------------
+struct AppProofOfPurchaseKeyResponse_t
+{
+ enum { k_iCallback = k_iSteamAppsCallbacks + 13 };
+ EResult m_eResult;
+ uint32 m_nAppID;
+ char m_rgchKey[ k_cubAppProofOfPurchaseKeyMax ];
+};
+
+//---------------------------------------------------------------------------------
+// Purpose: posted after the user gains executes a steam url with query parameters
+// such as steam://run///?param1=value1;param2=value2;param3=value3; etc
+// while the game is already running. The new params can be queried
+// with GetLaunchQueryParam.
+//---------------------------------------------------------------------------------
+struct NewLaunchQueryParameters_t
+{
+ enum { k_iCallback = k_iSteamAppsCallbacks + 14 };
+};
+
+
+#pragma pack( pop )
+#endif // ISTEAMAPPS_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamappticket.h b/lsteamclient/steamworks_sdk_130x/isteamappticket.h
new file mode 100644
index 00000000..570dc450
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamappticket.h
@@ -0,0 +1,32 @@
+//====== Copyright 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: a private, but well versioned, interface to get at critical bits
+// of a steam3 appticket - consumed by the simple drm wrapper to let it
+// ask about ownership with greater confidence.
+//
+//=============================================================================
+
+#ifndef ISTEAMAPPTICKET_H
+#define ISTEAMAPPTICKET_H
+#ifdef WIN32
+#pragma once
+#endif
+
+#include "steamtypes.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: hand out a reasonable "future proof" view of an app ownership ticket
+// the raw (signed) buffer, and indices into that buffer where the appid and
+// steamid are located. the sizes of the appid and steamid are implicit in
+// (each version of) the interface - currently uin32 appid and uint64 steamid
+//-----------------------------------------------------------------------------
+class ISteamAppTicket
+{
+public:
+ virtual uint32 GetAppOwnershipTicketData( uint32 nAppID, void *pvBuffer, uint32 cbBufferLength, uint32 *piAppId, uint32 *piSteamId, uint32 *piSignature, uint32 *pcbSignature ) = 0;
+};
+
+#define STEAMAPPTICKET_INTERFACE_VERSION "STEAMAPPTICKET_INTERFACE_VERSION001"
+
+
+#endif // ISTEAMAPPTICKET_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamclient.h b/lsteamclient/steamworks_sdk_130x/isteamclient.h
new file mode 100644
index 00000000..a14948b6
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamclient.h
@@ -0,0 +1,493 @@
+//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: Main interface for loading and accessing Steamworks API's from the
+// Steam client.
+// For most uses, this code is wrapped inside of SteamAPI_Init()
+//=============================================================================
+
+#ifndef ISTEAMCLIENT_H
+#define ISTEAMCLIENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steamtypes.h"
+#include "steamclientpublic.h"
+
+// Define compile time assert macros to let us validate the structure sizes.
+#define VALVE_COMPILE_TIME_ASSERT( pred ) typedef char compile_time_assert_type[(pred) ? 1 : -1];
+
+#ifndef REFERENCE
+#define REFERENCE(arg) ((void)arg)
+#endif
+
+#if defined(__linux__) || defined(__APPLE__)
+// The 32-bit version of gcc has the alignment requirement for uint64 and double set to
+// 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
+// The 64-bit version of gcc has the alignment requirement for these types set to
+// 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
+// The 64-bit structure packing has to match the 32-bit structure packing for each platform.
+#define VALVE_CALLBACK_PACK_SMALL
+#else
+#define VALVE_CALLBACK_PACK_LARGE
+#endif
+
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error ???
+#endif
+
+typedef struct
+{
+ uint32 m_u32;
+ uint64 m_u64;
+ uint16 m_u16;
+ double m_d;
+} ValvePackingSentinel_t;
+
+#pragma pack( pop )
+
+
+#if defined(VALVE_CALLBACK_PACK_SMALL)
+VALVE_COMPILE_TIME_ASSERT( sizeof(ValvePackingSentinel_t) == 24 )
+#elif defined(VALVE_CALLBACK_PACK_LARGE)
+VALVE_COMPILE_TIME_ASSERT( sizeof(ValvePackingSentinel_t) == 32 )
+#else
+#error ???
+#endif
+
+
+// handle to a communication pipe to the Steam client
+typedef int32 HSteamPipe;
+// handle to single instance of a steam user
+typedef int32 HSteamUser;
+// function prototype
+#if defined( POSIX )
+#define __cdecl
+#endif
+extern "C" typedef void (__cdecl *SteamAPIWarningMessageHook_t)(int, const char *);
+extern "C" typedef void( *SteamAPI_PostAPIResultInProcess_t )(SteamAPICall_t callHandle, void *, uint32 unCallbackSize, int iCallbackNum);
+extern "C" typedef uint32 ( *SteamAPI_CheckCallbackRegistered_t )( int iCallbackNum );
+#if defined( __SNC__ )
+ #pragma diag_suppress=1700 // warning 1700: class "%s" has virtual functions but non-virtual destructor
+#endif
+
+// interface predec
+class ISteamUser;
+class ISteamGameServer;
+class ISteamFriends;
+class ISteamUtils;
+class ISteamMatchmaking;
+class ISteamContentServer;
+class ISteamMatchmakingServers;
+class ISteamUserStats;
+class ISteamApps;
+class ISteamNetworking;
+class ISteamRemoteStorage;
+class ISteamScreenshots;
+class ISteamMusic;
+class ISteamMusicRemote;
+class ISteamGameServerStats;
+class ISteamPS3OverlayRender;
+class ISteamHTTP;
+class ISteamUnifiedMessages;
+class ISteamController;
+class ISteamUGC;
+class ISteamAppList;
+class ISteamHTMLSurface;
+
+//-----------------------------------------------------------------------------
+// Purpose: Interface to creating a new steam instance, or to
+// connect to an existing steam instance, whether it's in a
+// different process or is local.
+//
+// For most scenarios this is all handled automatically via SteamAPI_Init().
+// You'll only need to use these interfaces if you have a more complex versioning scheme,
+// where you want to get different versions of the same interface in different dll's in your project.
+//-----------------------------------------------------------------------------
+class ISteamClient
+{
+public:
+ // Creates a communication pipe to the Steam client
+ virtual HSteamPipe CreateSteamPipe() = 0;
+
+ // Releases a previously created communications pipe
+ virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0;
+
+ // connects to an existing global user, failing if none exists
+ // used by the game to coordinate with the steamUI
+ virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0;
+
+ // used by game servers, create a steam user that won't be shared with anyone else
+ virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType ) = 0;
+
+ // removes an allocated user
+ virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0;
+
+ // retrieves the ISteamUser interface associated with the handle
+ virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // retrieves the ISteamGameServer interface associated with the handle
+ virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // set the local IP and Port to bind to
+ // this must be set before CreateLocalUser()
+ virtual void SetLocalIPBinding( uint32 unIP, uint16 usPort ) = 0;
+
+ // returns the ISteamFriends interface
+ virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // returns the ISteamUtils interface
+ virtual ISteamUtils *GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // returns the ISteamMatchmaking interface
+ virtual ISteamMatchmaking *GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // returns the ISteamMatchmakingServers interface
+ virtual ISteamMatchmakingServers *GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // returns the a generic interface
+ virtual void *GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // returns the ISteamUserStats interface
+ virtual ISteamUserStats *GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // returns the ISteamGameServerStats interface
+ virtual ISteamGameServerStats *GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // returns apps interface
+ virtual ISteamApps *GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // networking
+ virtual ISteamNetworking *GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // remote storage
+ virtual ISteamRemoteStorage *GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // user screenshots
+ virtual ISteamScreenshots *GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // this needs to be called every frame to process matchmaking results
+ // redundant if you're already calling SteamAPI_RunCallbacks()
+ virtual void RunFrame() = 0;
+
+ // returns the number of IPC calls made since the last time this function was called
+ // Used for perf debugging so you can understand how many IPC calls your game makes per frame
+ // Every IPC call is at minimum a thread context switch if not a process one so you want to rate
+ // control how often you do them.
+ virtual uint32 GetIPCCallCount() = 0;
+
+ // API warning handling
+ // 'int' is the severity; 0 for msg, 1 for warning
+ // 'const char *' is the text of the message
+ // callbacks will occur directly after the API function is called that generated the warning or message
+ virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0;
+
+ // Trigger global shutdown for the DLL
+ virtual bool BShutdownIfAllPipesClosed() = 0;
+
+#ifdef _PS3
+ virtual ISteamPS3OverlayRender *GetISteamPS3OverlayRender() = 0;
+#endif
+
+ // Expose HTTP interface
+ virtual ISteamHTTP *GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // Exposes the ISteamUnifiedMessages interface
+ virtual ISteamUnifiedMessages *GetISteamUnifiedMessages( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // Exposes the ISteamController interface
+ virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // Exposes the ISteamUGC interface
+ virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // returns app list interface, only available on specially registered apps
+ virtual ISteamAppList *GetISteamAppList( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // Music Player
+ virtual ISteamMusic *GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+ // Music Player Remote
+ virtual ISteamMusicRemote *GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0;
+
+ // html page display
+ virtual ISteamHTMLSurface *GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) = 0;
+
+ // Helper functions for internal Steam usage
+ virtual void Set_SteamAPI_CPostAPIResultInProcess( SteamAPI_PostAPIResultInProcess_t func ) = 0;
+ virtual void Remove_SteamAPI_CPostAPIResultInProcess( SteamAPI_PostAPIResultInProcess_t func ) = 0;
+ virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func ) = 0;
+};
+
+#define STEAMCLIENT_INTERFACE_VERSION "SteamClient016"
+
+//-----------------------------------------------------------------------------
+// Purpose: Base values for callback identifiers, each callback must
+// have a unique ID.
+//-----------------------------------------------------------------------------
+enum { k_iSteamUserCallbacks = 100 };
+enum { k_iSteamGameServerCallbacks = 200 };
+enum { k_iSteamFriendsCallbacks = 300 };
+enum { k_iSteamBillingCallbacks = 400 };
+enum { k_iSteamMatchmakingCallbacks = 500 };
+enum { k_iSteamContentServerCallbacks = 600 };
+enum { k_iSteamUtilsCallbacks = 700 };
+enum { k_iClientFriendsCallbacks = 800 };
+enum { k_iClientUserCallbacks = 900 };
+enum { k_iSteamAppsCallbacks = 1000 };
+enum { k_iSteamUserStatsCallbacks = 1100 };
+enum { k_iSteamNetworkingCallbacks = 1200 };
+enum { k_iClientRemoteStorageCallbacks = 1300 };
+enum { k_iClientDepotBuilderCallbacks = 1400 };
+enum { k_iSteamGameServerItemsCallbacks = 1500 };
+enum { k_iClientUtilsCallbacks = 1600 };
+enum { k_iSteamGameCoordinatorCallbacks = 1700 };
+enum { k_iSteamGameServerStatsCallbacks = 1800 };
+enum { k_iSteam2AsyncCallbacks = 1900 };
+enum { k_iSteamGameStatsCallbacks = 2000 };
+enum { k_iClientHTTPCallbacks = 2100 };
+enum { k_iClientScreenshotsCallbacks = 2200 };
+enum { k_iSteamScreenshotsCallbacks = 2300 };
+enum { k_iClientAudioCallbacks = 2400 };
+enum { k_iClientUnifiedMessagesCallbacks = 2500 };
+enum { k_iSteamStreamLauncherCallbacks = 2600 };
+enum { k_iClientControllerCallbacks = 2700 };
+enum { k_iSteamControllerCallbacks = 2800 };
+enum { k_iClientParentalSettingsCallbacks = 2900 };
+enum { k_iClientDeviceAuthCallbacks = 3000 };
+enum { k_iClientNetworkDeviceManagerCallbacks = 3100 };
+enum { k_iClientMusicCallbacks = 3200 };
+enum { k_iClientRemoteClientManagerCallbacks = 3300 };
+enum { k_iClientUGCCallbacks = 3400 };
+enum { k_iSteamStreamClientCallbacks = 3500 };
+enum { k_IClientProductBuilderCallbacks = 3600 };
+enum { k_iClientShortcutsCallbacks = 3700 };
+enum { k_iClientRemoteControlManagerCallbacks = 3800 };
+enum { k_iSteamAppListCallbacks = 3900 };
+enum { k_iSteamMusicCallbacks = 4000 };
+enum { k_iSteamMusicRemoteCallbacks = 4100 };
+enum { k_iClientVRCallbacks = 4200 };
+enum { k_iClientReservedCallbacks = 4300 };
+enum { k_iSteamReservedCallbacks = 4400 };
+enum { k_iSteamHTMLSurfaceCallbacks = 4500 };
+enum { k_iClientVideoCallbacks = 4600 };
+
+//-----------------------------------------------------------------------------
+// The CALLBACK macros are for client side callback logging enabled with
+// log_callback
+// Do not change any of these.
+//-----------------------------------------------------------------------------
+
+struct SteamCallback_t
+{
+public:
+ SteamCallback_t() {}
+};
+
+#define DEFINE_CALLBACK( callbackname, callbackid ) \
+struct callbackname : SteamCallback_t { \
+ enum { k_iCallback = callbackid }; \
+ static callbackname *GetNullPointer() { return 0; } \
+ static const char *GetCallbackName() { return #callbackname; } \
+ static uint32 GetCallbackID() { return callbackname::k_iCallback; }
+
+#define CALLBACK_MEMBER( varidx, vartype, varname ) \
+ public: vartype varname ; \
+ static void GetMemberVar_##varidx( unsigned int &varOffset, unsigned int &varSize, uint32 &varCount, const char **pszName, const char **pszType ) { \
+ varOffset = (unsigned int)(size_t)&GetNullPointer()->varname; \
+ varSize = sizeof( vartype ); \
+ varCount = 1; \
+ *pszName = #varname; *pszType = #vartype; }
+
+#define CALLBACK_ARRAY( varidx, vartype, varname, varcount ) \
+ public: vartype varname [ varcount ]; \
+ static void GetMemberVar_##varidx( unsigned int &varOffset, unsigned int &varSize, uint32 &varCount, const char **pszName, const char **pszType ) { \
+ varOffset = (unsigned int)(size_t)&GetNullPointer()->varname[0]; \
+ varSize = sizeof( vartype ); \
+ varCount = varcount; \
+ *pszName = #varname; *pszType = #vartype; }
+
+
+#define END_CALLBACK_INTERNAL_BEGIN( numvars ) \
+ static uint32 GetNumMemberVariables() { return numvars; } \
+ static bool GetMemberVariable( uint32 index, uint32 &varOffset, uint32 &varSize, uint32 &varCount, const char **pszName, const char **pszType ) { \
+ switch ( index ) { default : return false;
+
+
+#define END_CALLBACK_INTERNAL_SWITCH( varidx ) case varidx : GetMemberVar_##varidx( varOffset, varSize, varCount, pszName, pszType ); return true;
+
+#define END_CALLBACK_INTERNAL_END() }; } };
+
+#define END_DEFINE_CALLBACK_0() \
+ static uint32 GetNumMemberVariables() { return 0; } \
+ static bool GetMemberVariable( uint32 index, uint32 &varOffset, uint32 &varSize, uint32 &varCount, const char **pszName, const char **pszType ) { REFERENCE( pszType ); REFERENCE( pszName ); REFERENCE( varCount ); REFERENCE( varSize ); REFERENCE( varOffset ); REFERENCE( index ); return false; } \
+ };
+
+
+#define END_DEFINE_CALLBACK_1() \
+ END_CALLBACK_INTERNAL_BEGIN( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_2() \
+ END_CALLBACK_INTERNAL_BEGIN( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_3() \
+ END_CALLBACK_INTERNAL_BEGIN( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_4() \
+ END_CALLBACK_INTERNAL_BEGIN( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_5() \
+ END_CALLBACK_INTERNAL_BEGIN( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_END()
+
+
+#define END_DEFINE_CALLBACK_6() \
+ END_CALLBACK_INTERNAL_BEGIN( 6 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_7() \
+ END_CALLBACK_INTERNAL_BEGIN( 7 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 6 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_8() \
+ END_CALLBACK_INTERNAL_BEGIN( 8 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 6 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 7 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_9() \
+ END_CALLBACK_INTERNAL_BEGIN( 9 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 6 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 7 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 8 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_10() \
+ END_CALLBACK_INTERNAL_BEGIN( 10 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 6 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 7 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 8 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 9 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_11() \
+ END_CALLBACK_INTERNAL_BEGIN( 11 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 6 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 7 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 8 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 9 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 10 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_12() \
+ END_CALLBACK_INTERNAL_BEGIN( 12 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 6 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 7 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 8 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 9 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 10 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 11 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_13() \
+ END_CALLBACK_INTERNAL_BEGIN( 13 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 6 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 7 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 8 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 9 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 10 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 11 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 12 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#define END_DEFINE_CALLBACK_14() \
+ END_CALLBACK_INTERNAL_BEGIN( 14 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 0 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 1 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 2 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 3 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 4 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 5 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 6 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 7 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 8 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 9 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 10 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 11 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 12 ) \
+ END_CALLBACK_INTERNAL_SWITCH( 13 ) \
+ END_CALLBACK_INTERNAL_END()
+
+#endif // ISTEAMCLIENT_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamcontroller.h b/lsteamclient/steamworks_sdk_130x/isteamcontroller.h
new file mode 100644
index 00000000..a00c76a9
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamcontroller.h
@@ -0,0 +1,91 @@
+//====== Copyright 1996-2013, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to valve controller
+//
+//=============================================================================
+
+#ifndef ISTEAMCONTROLLER_H
+#define ISTEAMCONTROLLER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "steamcontrollerpublic.h"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+#define MAX_STEAM_CONTROLLERS 16
+
+#pragma pack( pop )
+
+enum ESteamControllerPad
+{
+ k_ESteamControllerPad_Left,
+ k_ESteamControllerPad_Right
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Native Steam controller support API
+//-----------------------------------------------------------------------------
+class ISteamController
+{
+public:
+
+ //
+ // Native controller support API
+ //
+
+ // Must call init and shutdown when starting/ending use of the interface
+ virtual bool Init( const char *pchAbsolutePathToControllerConfigVDF ) = 0;
+ virtual bool Shutdown() = 0;
+
+ // Pump callback/callresult events, SteamAPI_RunCallbacks will do this for you,
+ // normally never need to call directly.
+ virtual void RunFrame() = 0;
+
+ // Get the state of the specified controller, returns false if that controller is not connected
+ virtual bool GetControllerState( uint32 unControllerIndex, SteamControllerState_t *pState ) = 0;
+
+ // Trigger a haptic pulse on the controller
+ virtual void TriggerHapticPulse( uint32 unControllerIndex, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ) = 0;
+
+ // Set the override mode which is used to choose to use different base/legacy bindings from your config file
+ virtual void SetOverrideMode( const char *pchMode ) = 0;
+};
+
+#define STEAMCONTROLLER_INTERFACE_VERSION "STEAMCONTROLLER_INTERFACE_VERSION"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+/*
+struct ControllerCallback_t
+{
+ enum { k_iCallback = k_iSteamControllerCallbacks + 1 };
+
+};
+*/
+
+
+#pragma pack( pop )
+
+
+#endif // ISTEAMCONTROLLER_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamfriends.h b/lsteamclient/steamworks_sdk_130x/isteamfriends.h
new file mode 100644
index 00000000..8e2136a9
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamfriends.h
@@ -0,0 +1,609 @@
+//====== Copyright (C) 1996-2008, Valve Corporation, All rights reserved. =====
+//
+// Purpose: interface to both friends list data and general information about users
+//
+//=============================================================================
+
+#ifndef ISTEAMFRIENDS_H
+#define ISTEAMFRIENDS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "steamclientpublic.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: set of relationships to other users
+//-----------------------------------------------------------------------------
+enum EFriendRelationship
+{
+ k_EFriendRelationshipNone = 0,
+ k_EFriendRelationshipBlocked = 1,
+ k_EFriendRelationshipRequestRecipient = 2,
+ k_EFriendRelationshipFriend = 3,
+ k_EFriendRelationshipRequestInitiator = 4,
+ k_EFriendRelationshipIgnored = 5,
+ k_EFriendRelationshipIgnoredFriend = 6,
+ k_EFriendRelationshipSuggested = 7,
+
+ // keep this updated
+ k_EFriendRelationshipMax = 8,
+};
+
+// maximum length of friend group name (not including terminating nul!)
+const int k_cchMaxFriendsGroupName = 64;
+
+// maximum number of groups a single user is allowed
+const int k_cFriendsGroupLimit = 100;
+
+const int k_cEnumerateFollowersMax = 50;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: list of states a friend can be in
+//-----------------------------------------------------------------------------
+enum EPersonaState
+{
+ k_EPersonaStateOffline = 0, // friend is not currently logged on
+ k_EPersonaStateOnline = 1, // friend is logged on
+ k_EPersonaStateBusy = 2, // user is on, but busy
+ k_EPersonaStateAway = 3, // auto-away feature
+ k_EPersonaStateSnooze = 4, // auto-away for a long time
+ k_EPersonaStateLookingToTrade = 5, // Online, trading
+ k_EPersonaStateLookingToPlay = 6, // Online, wanting to play
+ k_EPersonaStateMax,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: flags for enumerating friends list, or quickly checking a the relationship between users
+//-----------------------------------------------------------------------------
+enum EFriendFlags
+{
+ k_EFriendFlagNone = 0x00,
+ k_EFriendFlagBlocked = 0x01,
+ k_EFriendFlagFriendshipRequested = 0x02,
+ k_EFriendFlagImmediate = 0x04, // "regular" friend
+ k_EFriendFlagClanMember = 0x08,
+ k_EFriendFlagOnGameServer = 0x10,
+ // k_EFriendFlagHasPlayedWith = 0x20, // not currently used
+ // k_EFriendFlagFriendOfFriend = 0x40, // not currently used
+ k_EFriendFlagRequestingFriendship = 0x80,
+ k_EFriendFlagRequestingInfo = 0x100,
+ k_EFriendFlagIgnored = 0x200,
+ k_EFriendFlagIgnoredFriend = 0x400,
+ k_EFriendFlagSuggested = 0x800,
+ k_EFriendFlagAll = 0xFFFF,
+};
+
+
+// friend game played information
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+struct FriendGameInfo_t
+{
+ CGameID m_gameID;
+ uint32 m_unGameIP;
+ uint16 m_usGamePort;
+ uint16 m_usQueryPort;
+ CSteamID m_steamIDLobby;
+};
+#pragma pack( pop )
+
+// maximum number of characters in a user's name. Two flavors; one for UTF-8 and one for UTF-16.
+// The UTF-8 version has to be very generous to accomodate characters that get large when encoded
+// in UTF-8.
+enum
+{
+ k_cchPersonaNameMax = 128,
+ k_cwchPersonaNameMax = 32,
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: user restriction flags
+//-----------------------------------------------------------------------------
+enum EUserRestriction
+{
+ k_nUserRestrictionNone = 0, // no known chat/content restriction
+ k_nUserRestrictionUnknown = 1, // we don't know yet (user offline)
+ k_nUserRestrictionAnyChat = 2, // user is not allowed to (or can't) send/recv any chat
+ k_nUserRestrictionVoiceChat = 4, // user is not allowed to (or can't) send/recv voice chat
+ k_nUserRestrictionGroupChat = 8, // user is not allowed to (or can't) send/recv group chat
+ k_nUserRestrictionRating = 16, // user is too young according to rating in current region
+ k_nUserRestrictionGameInvites = 32, // user cannot send or recv game invites (e.g. mobile)
+ k_nUserRestrictionTrading = 64, // user cannot participate in trading (console, mobile)
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: information about user sessions
+//-----------------------------------------------------------------------------
+struct FriendSessionStateInfo_t
+{
+ uint32 m_uiOnlineSessionInstances;
+ uint8 m_uiPublishedToFriendsSessionInstance;
+};
+
+
+
+// size limit on chat room or member metadata
+const uint32 k_cubChatMetadataMax = 8192;
+
+// size limits on Rich Presence data
+enum { k_cchMaxRichPresenceKeys = 20 };
+enum { k_cchMaxRichPresenceKeyLength = 64 };
+enum { k_cchMaxRichPresenceValueLength = 256 };
+
+// These values are passed as parameters to the store
+enum EOverlayToStoreFlag
+{
+ k_EOverlayToStoreFlag_None = 0,
+ k_EOverlayToStoreFlag_AddToCart = 1,
+ k_EOverlayToStoreFlag_AddToCartAndShow = 2,
+};
+
+//-----------------------------------------------------------------------------
+// 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
+//-----------------------------------------------------------------------------
+class ISteamFriends
+{
+public:
+ // returns the local players name - guaranteed to not be NULL.
+ // this is the same name as on the users community profile page
+ // this is stored in UTF-8 format
+ // like all the other interface functions that return a char *, it's important that this pointer is not saved
+ // off; it will eventually be free'd or re-allocated
+ virtual const char *GetPersonaName() = 0;
+
+ // Sets the player name, stores it on the server and publishes the changes to all friends who are online.
+ // 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.
+ virtual SteamAPICall_t SetPersonaName( const char *pchPersonaName ) = 0;
+
+ // gets the status of the current user
+ virtual EPersonaState GetPersonaState() = 0;
+
+ // friend iteration
+ // takes a set of k_EFriendFlags, and returns the number of users the client knows about who meet that criteria
+ // then GetFriendByIndex() can then be used to return the id's of each of those users
+ virtual int GetFriendCount( int iFriendFlags ) = 0;
+
+ // returns the steamID of a user
+ // 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
+ virtual CSteamID GetFriendByIndex( int iFriend, int iFriendFlags ) = 0;
+
+ // returns a relationship to a user
+ virtual EFriendRelationship GetFriendRelationship( CSteamID steamIDFriend ) = 0;
+
+ // returns the current status of the specified user
+ // this will only be known by the local user if steamIDFriend is in their friends list; on the same game server; in a chat room or lobby; or in a small group with the local user
+ virtual EPersonaState GetFriendPersonaState( CSteamID steamIDFriend ) = 0;
+
+ // returns the name another user - guaranteed to not be NULL.
+ // same rules as GetFriendPersonaState() apply as to whether or not the user knowns the name of the other user
+ // note that on first joining a lobby, chat room or game server the local user will not known the name of the other users automatically; that information will arrive asyncronously
+ //
+ virtual const char *GetFriendPersonaName( CSteamID steamIDFriend ) = 0;
+
+ // returns true if the friend is actually in a game, and fills in pFriendGameInfo with an extra details
+ virtual bool GetFriendGamePlayed( CSteamID steamIDFriend, FriendGameInfo_t *pFriendGameInfo ) = 0;
+ // accesses old friends names - returns an empty string when their are no more items in the history
+ virtual const char *GetFriendPersonaNameHistory( CSteamID steamIDFriend, int iPersonaName ) = 0;
+
+ // Returns nickname the current user has set for the specified player. Returns NULL if the no nickname has been set for that player.
+ virtual const char *GetPlayerNickname( CSteamID steamIDPlayer ) = 0;
+
+ // returns true if the specified user meets any of the criteria specified in iFriendFlags
+ // iFriendFlags can be the union (binary or, |) of one or more k_EFriendFlags values
+ virtual bool HasFriend( CSteamID steamIDFriend, int iFriendFlags ) = 0;
+
+ // clan (group) iteration and access functions
+ virtual int GetClanCount() = 0;
+ virtual CSteamID GetClanByIndex( int iClan ) = 0;
+ virtual const char *GetClanName( CSteamID steamIDClan ) = 0;
+ virtual const char *GetClanTag( CSteamID steamIDClan ) = 0;
+ // returns the most recent information we have about what's happening in a clan
+ virtual bool GetClanActivityCounts( CSteamID steamIDClan, int *pnOnline, int *pnInGame, int *pnChatting ) = 0;
+ // 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
+ virtual SteamAPICall_t DownloadClanActivityCounts( CSteamID *psteamIDClans, int cClansToRequest ) = 0;
+
+ // iterators for getting users in a chat room, lobby, game server or clan
+ // note that large clans that cannot be iterated by the local user
+ // note that the current user must be in a lobby to retrieve CSteamIDs of other users in that lobby
+ // steamIDSource can be the steamID of a group, game server, lobby or chat room
+ virtual int GetFriendCountFromSource( CSteamID steamIDSource ) = 0;
+ virtual CSteamID GetFriendFromSourceByIndex( CSteamID steamIDSource, int iFriend ) = 0;
+
+ // returns true if the local user can see that steamIDUser is a member or in steamIDSource
+ virtual bool IsUserInSource( CSteamID steamIDUser, CSteamID steamIDSource ) = 0;
+
+ // User is in a game pressing the talk button (will suppress the microphone for all voice comms from the Steam friends UI)
+ virtual void SetInGameVoiceSpeaking( CSteamID steamIDUser, bool bSpeaking ) = 0;
+
+ // activates the game overlay, with an optional dialog to open
+ // valid options are "Friends", "Community", "Players", "Settings", "OfficialGameGroup", "Stats", "Achievements"
+ virtual void ActivateGameOverlay( const char *pchDialog ) = 0;
+
+ // activates game overlay to a specific place
+ // valid options are
+ // "steamid" - opens the overlay web browser to the specified user or groups profile
+ // "chat" - opens a chat window to the specified user, or joins the group chat
+ // "jointrade" - opens a window to a Steam Trading session that was started with the ISteamEconomy/StartTrade Web API
+ // "stats" - opens the overlay web browser to the specified user's stats
+ // "achievements" - opens the overlay web browser to the specified user's achievements
+ // "friendadd" - opens the overlay in minimal mode prompting the user to add the target user as a friend
+ // "friendremove" - opens the overlay in minimal mode prompting the user to remove the target friend
+ // "friendrequestaccept" - opens the overlay in minimal mode prompting the user to accept an incoming friend invite
+ // "friendrequestignore" - opens the overlay in minimal mode prompting the user to ignore an incoming friend invite
+ virtual void ActivateGameOverlayToUser( const char *pchDialog, CSteamID steamID ) = 0;
+
+ // activates game overlay web browser directly to the specified URL
+ // full address with protocol type is required, e.g. http://www.steamgames.com/
+ virtual void ActivateGameOverlayToWebPage( const char *pchURL ) = 0;
+
+ // activates game overlay to store page for app
+ virtual void ActivateGameOverlayToStore( AppId_t nAppID, EOverlayToStoreFlag eFlag ) = 0;
+
+ // Mark a target user as 'played with'. This is a client-side only feature that requires that the calling user is
+ // in game
+ virtual void SetPlayedWith( CSteamID steamIDUserPlayedWith ) = 0;
+
+ // activates game overlay to open the invite dialog. Invitations will be sent for the provided lobby.
+ virtual void ActivateGameOverlayInviteDialog( CSteamID steamIDLobby ) = 0;
+
+ // gets the small (32x32) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set
+ virtual int GetSmallFriendAvatar( CSteamID steamIDFriend ) = 0;
+
+ // gets the medium (64x64) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set
+ virtual int GetMediumFriendAvatar( CSteamID steamIDFriend ) = 0;
+
+ // gets the large (184x184) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set
+ // returns -1 if this image has yet to be loaded, in this case wait for a AvatarImageLoaded_t callback and then call this again
+ virtual int GetLargeFriendAvatar( CSteamID steamIDFriend ) = 0;
+
+ // requests information about a user - persona name & avatar
+ // if bRequireNameOnly is set, then the avatar of a user isn't downloaded
+ // - it's a lot slower to download avatars and churns the local cache, so if you don't need avatars, don't request them
+ // if returns true, it means that data is being requested, and a PersonaStateChanged_t callback will be posted when it's retrieved
+ // if returns false, it means that we already have all the details about that user, and functions can be called immediately
+ virtual bool RequestUserInformation( CSteamID steamIDUser, bool bRequireNameOnly ) = 0;
+
+ // requests information about a clan officer list
+ // 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
+ virtual SteamAPICall_t RequestClanOfficerList( CSteamID steamIDClan ) = 0;
+
+ // iteration of clan officers - can only be done when a RequestClanOfficerList() call has completed
+
+ // returns the steamID of the clan owner
+ virtual CSteamID GetClanOwner( CSteamID steamIDClan ) = 0;
+ // returns the number of officers in a clan (including the owner)
+ virtual int GetClanOfficerCount( CSteamID steamIDClan ) = 0;
+ // returns the steamID of a clan officer, by index, of range [0,GetClanOfficerCount)
+ virtual CSteamID GetClanOfficerByIndex( CSteamID steamIDClan, int iOfficer ) = 0;
+ // if current user is chat restricted, he can't send or receive any text/voice chat messages.
+ // the user can't see custom avatars. But the user can be online and send/recv game invites.
+ // a chat restricted user can't add friends or join any groups.
+ virtual uint32 GetUserRestrictions() = 0;
+
+ // Rich Presence data is automatically shared between friends who are in the same game
+ // Each user has a set of Key/Value pairs
+ // Up to 20 different keys can be set
+ // There are two magic keys:
+ // "status" - a UTF-8 string that will show up in the 'view game info' dialog in the Steam friends list
+ // "connect" - a UTF-8 string that contains the command-line for how a friend can connect to a game
+ // GetFriendRichPresence() returns an empty string "" if no value is set
+ // SetRichPresence() to a NULL or an empty string deletes the key
+ // You can iterate the current set of keys for a friend with GetFriendRichPresenceKeyCount()
+ // and GetFriendRichPresenceKeyByIndex() (typically only used for debugging)
+ virtual bool SetRichPresence( const char *pchKey, const char *pchValue ) = 0;
+ virtual void ClearRichPresence() = 0;
+ virtual const char *GetFriendRichPresence( CSteamID steamIDFriend, const char *pchKey ) = 0;
+ virtual int GetFriendRichPresenceKeyCount( CSteamID steamIDFriend ) = 0;
+ virtual const char *GetFriendRichPresenceKeyByIndex( CSteamID steamIDFriend, int iKey ) = 0;
+ // Requests rich presence for a specific user.
+ virtual void RequestFriendRichPresence( CSteamID steamIDFriend ) = 0;
+
+ // rich invite support
+ // if the target accepts the invite, the pchConnectString gets added to the command-line for launching the game
+ // if the game is already running, a GameRichPresenceJoinRequested_t callback is posted containing the connect string
+ // invites can only be sent to friends
+ virtual bool InviteUserToGame( CSteamID steamIDFriend, const char *pchConnectString ) = 0;
+
+ // recently-played-with friends iteration
+ // this iterates the entire list of users recently played with, across games
+ // GetFriendCoplayTime() returns as a unix time
+ virtual int GetCoplayFriendCount() = 0;
+ virtual CSteamID GetCoplayFriend( int iCoplayFriend ) = 0;
+ virtual int GetFriendCoplayTime( CSteamID steamIDFriend ) = 0;
+ virtual AppId_t GetFriendCoplayGame( CSteamID steamIDFriend ) = 0;
+
+ // chat interface for games
+ // 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
+ virtual SteamAPICall_t JoinClanChatRoom( CSteamID steamIDClan ) = 0;
+ virtual bool LeaveClanChatRoom( CSteamID steamIDClan ) = 0;
+ virtual int GetClanChatMemberCount( CSteamID steamIDClan ) = 0;
+ virtual CSteamID GetChatMemberByIndex( CSteamID steamIDClan, int iUser ) = 0;
+ virtual bool SendClanChatMessage( CSteamID steamIDClanChat, const char *pchText ) = 0;
+ virtual int GetClanChatMessage( CSteamID steamIDClanChat, int iMessage, void *prgchText, int cchTextMax, EChatEntryType *peChatEntryType, CSteamID *psteamidChatter ) = 0;
+ virtual bool IsClanChatAdmin( CSteamID steamIDClanChat, CSteamID steamIDUser ) = 0;
+
+ // interact with the Steam (game overlay / desktop)
+ virtual bool IsClanChatWindowOpenInSteam( CSteamID steamIDClanChat ) = 0;
+ virtual bool OpenClanChatWindowInSteam( CSteamID steamIDClanChat ) = 0;
+ virtual bool CloseClanChatWindowInSteam( CSteamID steamIDClanChat ) = 0;
+
+ // peer-to-peer chat interception
+ // this is so you can show P2P chats inline in the game
+ virtual bool SetListenForFriendsMessages( bool bInterceptEnabled ) = 0;
+ virtual bool ReplyToFriendMessage( CSteamID steamIDFriend, const char *pchMsgToSend ) = 0;
+ virtual int GetFriendMessage( CSteamID steamIDFriend, int iMessageID, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0;
+
+ // following apis
+ virtual SteamAPICall_t GetFollowerCount( CSteamID steamID ) = 0;
+ virtual SteamAPICall_t IsFollowing( CSteamID steamID ) = 0;
+ virtual SteamAPICall_t EnumerateFollowingList( uint32 unStartIndex ) = 0;
+};
+
+#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends014"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a friends' status changes
+//-----------------------------------------------------------------------------
+struct PersonaStateChange_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 4 };
+
+ uint64 m_ulSteamID; // steamID of the friend who changed
+ int m_nChangeFlags; // what's changed
+};
+
+
+// used in PersonaStateChange_t::m_nChangeFlags to describe what's changed about a user
+// these flags describe what the client has learned has changed recently, so on startup you'll see a name, avatar & relationship change for every friend
+enum EPersonaChange
+{
+ k_EPersonaChangeName = 0x0001,
+ k_EPersonaChangeStatus = 0x0002,
+ k_EPersonaChangeComeOnline = 0x0004,
+ k_EPersonaChangeGoneOffline = 0x0008,
+ k_EPersonaChangeGamePlayed = 0x0010,
+ k_EPersonaChangeGameServer = 0x0020,
+ k_EPersonaChangeAvatar = 0x0040,
+ k_EPersonaChangeJoinedSource= 0x0080,
+ k_EPersonaChangeLeftSource = 0x0100,
+ k_EPersonaChangeRelationshipChanged = 0x0200,
+ k_EPersonaChangeNameFirstSet = 0x0400,
+ k_EPersonaChangeFacebookInfo = 0x0800,
+ k_EPersonaChangeNickname = 0x1000,
+ k_EPersonaChangeSteamLevel = 0x2000,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: posted when game overlay activates or deactivates
+// the game can use this to be pause or resume single player games
+//-----------------------------------------------------------------------------
+struct GameOverlayActivated_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 31 };
+ uint8 m_bActive; // true if it's just been activated, false otherwise
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the user tries to join a different game server from their friends list
+// game client should attempt to connect to specified server when this is received
+//-----------------------------------------------------------------------------
+struct GameServerChangeRequested_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 32 };
+ char m_rgchServer[64]; // server address ("127.0.0.1:27015", "tf2.valvesoftware.com")
+ char m_rgchPassword[64]; // server password, if any
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the user tries to join a lobby from their friends list
+// game client should attempt to connect to specified lobby when this is received
+//-----------------------------------------------------------------------------
+struct GameLobbyJoinRequested_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 33 };
+ CSteamID m_steamIDLobby;
+
+ // The friend they did the join via (will be invalid if not directly via a friend)
+ //
+ // On PS3, the friend will be invalid if this was triggered by a PSN invite via the XMB, but
+ // the account type will be console user so you can tell at least that this was from a PSN friend
+ // rather than a Steam friend.
+ CSteamID m_steamIDFriend;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when an avatar is loaded in from a previous GetLargeFriendAvatar() call
+// if the image wasn't already available
+//-----------------------------------------------------------------------------
+struct AvatarImageLoaded_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 34 };
+ CSteamID m_steamID; // steamid the avatar has been loaded for
+ int m_iImage; // the image index of the now loaded image
+ int m_iWide; // width of the loaded image
+ int m_iTall; // height of the loaded image
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: marks the return of a request officer list call
+//-----------------------------------------------------------------------------
+struct ClanOfficerListResponse_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 35 };
+ CSteamID m_steamIDClan;
+ int m_cOfficers;
+ uint8 m_bSuccess;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: callback indicating updated data about friends rich presence information
+//-----------------------------------------------------------------------------
+struct FriendRichPresenceUpdate_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 36 };
+ CSteamID m_steamIDFriend; // friend who's rich presence has changed
+ AppId_t m_nAppID; // the appID of the game (should always be the current game)
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the user tries to join a game from their friends list
+// rich presence will have been set with the "connect" key which is set here
+//-----------------------------------------------------------------------------
+struct GameRichPresenceJoinRequested_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 37 };
+ CSteamID m_steamIDFriend; // the friend they did the join via (will be invalid if not directly via a friend)
+ char m_rgchConnect[k_cchMaxRichPresenceValueLength];
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a chat message has been received for a clan chat the game has joined
+//-----------------------------------------------------------------------------
+struct GameConnectedClanChatMsg_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 38 };
+ CSteamID m_steamIDClanChat;
+ CSteamID m_steamIDUser;
+ int m_iMessageID;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a user has joined a clan chat
+//-----------------------------------------------------------------------------
+struct GameConnectedChatJoin_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 39 };
+ CSteamID m_steamIDClanChat;
+ CSteamID m_steamIDUser;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a user has left the chat we're in
+//-----------------------------------------------------------------------------
+struct GameConnectedChatLeave_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 40 };
+ CSteamID m_steamIDClanChat;
+ CSteamID m_steamIDUser;
+ bool m_bKicked; // true if admin kicked
+ bool m_bDropped; // true if Steam connection dropped
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a DownloadClanActivityCounts() call has finished
+//-----------------------------------------------------------------------------
+struct DownloadClanActivityCountsResult_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 41 };
+ bool m_bSuccess;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a JoinClanChatRoom() call has finished
+//-----------------------------------------------------------------------------
+struct JoinClanChatRoomCompletionResult_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 42 };
+ CSteamID m_steamIDClanChat;
+ EChatRoomEnterResponse m_eChatRoomEnterResponse;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: a chat message has been received from a user
+//-----------------------------------------------------------------------------
+struct GameConnectedFriendChatMsg_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 43 };
+ CSteamID m_steamIDUser;
+ int m_iMessageID;
+};
+
+
+struct FriendsGetFollowerCount_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 44 };
+ EResult m_eResult;
+ CSteamID m_steamID;
+ int m_nCount;
+};
+
+
+struct FriendsIsFollowing_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 45 };
+ EResult m_eResult;
+ CSteamID m_steamID;
+ bool m_bIsFollowing;
+};
+
+
+struct FriendsEnumerateFollowingList_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 46 };
+ EResult m_eResult;
+ CSteamID m_rgSteamID[ k_cEnumerateFollowersMax ];
+ int32 m_nResultsReturned;
+ int32 m_nTotalResultCount;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: reports the result of an attempt to change the user's persona name
+//-----------------------------------------------------------------------------
+struct SetPersonaNameResponse_t
+{
+ enum { k_iCallback = k_iSteamFriendsCallbacks + 47 };
+
+ bool m_bSuccess; // true if name change succeeded completely.
+ bool m_bLocalSuccess; // true if name change was retained locally. (We might not have been able to communicate with Steam)
+ EResult m_result; // detailed result code
+};
+
+
+#pragma pack( pop )
+
+#endif // ISTEAMFRIENDS_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamgamecoordinator.h b/lsteamclient/steamworks_sdk_130x/isteamgamecoordinator.h
new file mode 100644
index 00000000..3a57f12d
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamgamecoordinator.h
@@ -0,0 +1,76 @@
+//====== Copyright ©, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to the game coordinator for this application
+//
+//=============================================================================
+
+#ifndef ISTEAMGAMECOORDINATOR
+#define ISTEAMGAMECOORDINATOR
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "steamtypes.h"
+#include "steamclientpublic.h"
+
+
+// list of possible return values from the ISteamGameCoordinator API
+enum EGCResults
+{
+ k_EGCResultOK = 0,
+ k_EGCResultNoMessage = 1, // There is no message in the queue
+ k_EGCResultBufferTooSmall = 2, // The buffer is too small for the requested message
+ k_EGCResultNotLoggedOn = 3, // The client is not logged onto Steam
+ k_EGCResultInvalidMessage = 4, // Something was wrong with the message being sent with SendMessage
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for sending and receiving messages from the Game Coordinator
+// for this application
+//-----------------------------------------------------------------------------
+class ISteamGameCoordinator
+{
+public:
+
+ // sends a message to the Game Coordinator
+ virtual EGCResults SendMessage( uint32 unMsgType, const void *pubData, uint32 cubData ) = 0;
+
+ // returns true if there is a message waiting from the game coordinator
+ virtual bool IsMessageAvailable( uint32 *pcubMsgSize ) = 0;
+
+ // fills the provided buffer with the first message in the queue and returns k_EGCResultOK or
+ // returns k_EGCResultNoMessage if there is no message waiting. pcubMsgSize is filled with the message size.
+ // If the provided buffer is not large enough to fit the entire message, k_EGCResultBufferTooSmall is returned
+ // and the message remains at the head of the queue.
+ virtual EGCResults RetrieveMessage( uint32 *punMsgType, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize ) = 0;
+
+};
+#define STEAMGAMECOORDINATOR_INTERFACE_VERSION "SteamGameCoordinator001"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+// callback notification - A new message is available for reading from the message queue
+struct GCMessageAvailable_t
+{
+ enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 1 };
+ uint32 m_nMessageSize;
+};
+
+// callback notification - A message failed to make it to the GC. It may be down temporarily
+struct GCMessageFailed_t
+{
+ enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 2 };
+};
+
+#pragma pack( pop )
+
+#endif // ISTEAMGAMECOORDINATOR
diff --git a/lsteamclient/steamworks_sdk_130x/isteamgameserver.h b/lsteamclient/steamworks_sdk_130x/isteamgameserver.h
new file mode 100644
index 00000000..c97ad6f5
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamgameserver.h
@@ -0,0 +1,384 @@
+//====== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam for game servers
+//
+//=============================================================================
+
+#ifndef ISTEAMGAMESERVER_H
+#define ISTEAMGAMESERVER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+#define MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE ((uint16)-1)
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for authenticating users via Steam to play on a game server
+//-----------------------------------------------------------------------------
+class ISteamGameServer
+{
+public:
+
+//
+// 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
+ virtual bool InitGameServer( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char *pchVersionString ) = 0;
+
+ /// Game product identifier. This is currently used by the master server for version checking purposes.
+ /// It's a required field, but will eventually will go away, and the AppID will be used for this purpose.
+ virtual void SetProduct( const char *pszProduct ) = 0;
+
+ /// Description of the game. This is a required field and is displayed in the steam server browser....for now.
+ /// This is a required field, but it will go away eventually, as the data should be determined from the AppID.
+ virtual void SetGameDescription( const char *pszGameDescription ) = 0;
+
+ /// If your game is a "mod," pass the string that identifies it. The default is an empty string, meaning
+ /// this application is the original game, not a mod.
+ ///
+ /// @see k_cbMaxGameServerGameDir
+ virtual void SetModDir( const char *pszModDir ) = 0;
+
+ /// Is this is a dedicated server? The default value is false.
+ virtual void SetDedicatedServer( bool bDedicated ) = 0;
+
+//
+// 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
+ virtual void LogOn( const char *pszToken ) = 0;
+
+ /// Login to a generic, anonymous account.
+ ///
+ /// Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init,
+ /// but this is no longer the case.
+ virtual void LogOnAnonymous() = 0;
+
+ /// Begin process of logging game server out of steam
+ virtual void LogOff() = 0;
+
+ // status functions
+ virtual bool BLoggedOn() = 0;
+ virtual bool BSecure() = 0;
+ virtual CSteamID GetSteamID() = 0;
+
+ /// Returns true if the master server has requested a restart.
+ /// Only returns true once per request.
+ virtual bool WasRestartRequested() = 0;
+
+//
+// Server state. These properties may be changed at any time.
+//
+
+ /// Max player count that will be reported to server browser and client queries
+ virtual void SetMaxPlayerCount( int cPlayersMax ) = 0;
+
+ /// Number of bots. Default value is zero
+ virtual void SetBotPlayerCount( int cBotplayers ) = 0;
+
+ /// Set the name of server as it will appear in the server browser
+ ///
+ /// @see k_cbMaxGameServerName
+ virtual void SetServerName( const char *pszServerName ) = 0;
+
+ /// Set name of map to report in the server browser
+ ///
+ /// @see k_cbMaxGameServerName
+ virtual void SetMapName( const char *pszMapName ) = 0;
+
+ /// Let people know if your server will require a password
+ virtual void SetPasswordProtected( bool bPasswordProtected ) = 0;
+
+ /// Spectator server. The default value is zero, meaning the service
+ /// is not used.
+ virtual void SetSpectatorPort( uint16 unSpectatorPort ) = 0;
+
+ /// Name of the spectator server. (Only used if spectator port is nonzero.)
+ ///
+ /// @see k_cbMaxGameServerMapName
+ virtual void SetSpectatorServerName( const char *pszSpectatorServerName ) = 0;
+
+ /// Call this to clear the whole list of key/values that are sent in rules queries.
+ virtual void ClearAllKeyValues() = 0;
+
+ /// Call this to add/update a key/value pair.
+ virtual void SetKeyValue( const char *pKey, const char *pValue ) = 0;
+
+ /// Sets a string defining the "gametags" for this server, this is optional, but if it is set
+ /// it allows users to filter in the matchmaking/server-browser interfaces based on the value
+ ///
+ /// @see k_cbMaxGameServerTags
+ virtual void SetGameTags( const char *pchGameTags ) = 0;
+
+ /// Sets a string defining the "gamedata" for this server, this is optional, but if it is set
+ /// it allows users to filter in the matchmaking/server-browser interfaces based on the value
+ /// don't set this unless it actually changes, its only uploaded to the master once (when
+ /// acknowledged)
+ ///
+ /// @see k_cbMaxGameServerGameData
+ virtual void SetGameData( const char *pchGameData ) = 0;
+
+ /// Region identifier. This is an optional field, the default value is empty, meaning the "world" region
+ virtual void SetRegion( const char *pszRegion ) = 0;
+
+//
+// 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)
+ virtual bool SendUserConnectAndAuthenticate( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0;
+
+ // Creates a fake user (ie, a bot) which will be listed as playing on the server, but skips validation.
+ //
+ // Return Value: Returns a SteamID for the user to be tracked with, you should call HandleUserDisconnect()
+ // when this user leaves the server just like you would for a real user.
+ virtual CSteamID CreateUnauthenticatedUserConnection() = 0;
+
+ // Should be called whenever a user leaves our game server, this lets Steam internally
+ // track which users are currently on which servers for the purposes of preventing a single
+ // account being logged into multiple servers, showing who is currently on a server, etc.
+ virtual void SendUserDisconnect( CSteamID steamIDUser ) = 0;
+
+ // Update the data to be displayed in the server browser and matchmaking interfaces for a user
+ // currently connected to the server. For regular users you must call this after you receive a
+ // GSUserValidationSuccess callback.
+ //
+ // Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player)
+ virtual bool BUpdateUserData( CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore ) = 0;
+
+ // New auth system APIs - do not mix with the old auth system APIs.
+ // ----------------------------------------------------------------
+
+ // Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ).
+ // pcbTicket retrieves the length of the actual ticket.
+ virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+
+ // Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused
+ // Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
+ virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0;
+
+ // Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
+ virtual void EndAuthSession( CSteamID steamID ) = 0;
+
+ // Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
+ virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0;
+
+ // After receiving a user's authentication data, and passing it to SendUserConnectAndAuthenticate, use this function
+ // to determine if the user owns downloadable content specified by the provided AppID.
+ virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0;
+
+ // Ask if a user in in the specified group, results returns async by GSUserGroupStatus_t
+ // returns false if we're not connected to the steam servers and thus cannot ask
+ virtual bool RequestUserGroupStatus( CSteamID steamIDUser, CSteamID steamIDGroup ) = 0;
+
+
+ // these two functions s are deprecated, and will not return results
+ // they will be removed in a future version of the SDK
+ virtual void GetGameplayStats( ) = 0;
+ virtual SteamAPICall_t GetServerReputation( ) = 0;
+
+ // Returns the public IP of the server according to Steam, useful when the server is
+ // behind NAT and you want to advertise its IP in a lobby for other clients to directly
+ // connect to
+ virtual uint32 GetPublicIP() = 0;
+
+// These are in GameSocketShare mode, where instead of ISteamGameServer creating its own
+// socket to talk to the master server on, it lets the game use its socket to forward messages
+// back and forth. This prevents us from requiring server ops to open up yet another port
+// in their firewalls.
+//
+// the IP address and port should be in host order, i.e 127.0.0.1 == 0x7f000001
+
+ // These are used when you've elected to multiplex the game server's UDP socket
+ // rather than having the master server updater use its own sockets.
+ //
+ // Source games use this to simplify the job of the server admins, so they
+ // don't have to open up more ports on their firewalls.
+
+ // Call this when a packet that starts with 0xFFFFFFFF comes in. That means
+ // it's for us.
+ virtual bool HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort ) = 0;
+
+ // AFTER calling HandleIncomingPacket for any packets that came in that frame, call this.
+ // This gets a packet that the master server updater needs to send out on UDP.
+ // It returns the length of the packet it wants to send, or 0 if there are no more packets to send.
+ // Call this each frame until it returns 0.
+ virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0;
+
+//
+// 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).
+ virtual void EnableHeartbeats( bool bActive ) = 0;
+
+ // You usually don't need to modify this.
+ // Pass -1 to use the default value for iHeartbeatInterval.
+ // Some mods change this.
+ virtual void SetHeartbeatInterval( int iHeartbeatInterval ) = 0;
+
+ // Force a heartbeat to steam at the next opportunity
+ virtual void ForceHeartbeat() = 0;
+
+ // associate this game server with this clan for the purposes of computing player compat
+ virtual SteamAPICall_t AssociateWithClan( CSteamID steamIDClan ) = 0;
+
+ // ask if any of the current players dont want to play with this new player - or vice versa
+ virtual SteamAPICall_t ComputeNewPlayerCompatibility( CSteamID steamIDNewPlayer ) = 0;
+
+};
+
+#define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer012"
+
+// game server flags
+const uint32 k_unServerFlagNone = 0x00;
+const uint32 k_unServerFlagActive = 0x01; // server has users playing
+const uint32 k_unServerFlagSecure = 0x02; // server wants to be secure
+const uint32 k_unServerFlagDedicated = 0x04; // server is dedicated
+const uint32 k_unServerFlagLinux = 0x08; // linux build
+const uint32 k_unServerFlagPassworded = 0x10; // password protected
+const uint32 k_unServerFlagPrivate = 0x20; // server shouldn't list on master server and
+ // won't enforce authentication of users that connect to the server.
+ // Useful when you run a server where the clients may not
+ // be connected to the internet but you want them to play (i.e LANs)
+
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+
+// client has been approved to connect to this game server
+struct GSClientApprove_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 1 };
+ CSteamID m_SteamID; // SteamID of approved player
+ CSteamID m_OwnerSteamID; // SteamID of original owner for game license
+};
+
+
+// client has been denied to connection to this game server
+struct GSClientDeny_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 2 };
+ CSteamID m_SteamID;
+ EDenyReason m_eDenyReason;
+ char m_rgchOptionalText[128];
+};
+
+
+// request the game server should kick the user
+struct GSClientKick_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 3 };
+ CSteamID m_SteamID;
+ EDenyReason m_eDenyReason;
+};
+
+// NOTE: callback values 4 and 5 are skipped because they are used for old deprecated callbacks,
+// do not reuse them here.
+
+
+// client achievement info
+struct GSClientAchievementStatus_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 6 };
+ uint64 m_SteamID;
+ char m_pchAchievement[128];
+ bool m_bUnlocked;
+};
+
+// received when the game server requests to be displayed as secure (VAC protected)
+// m_bSecure is true if the game server should display itself as secure to users, false otherwise
+struct GSPolicyResponse_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 15 };
+ uint8 m_bSecure;
+};
+
+// GS gameplay stats info
+struct GSGameplayStats_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 7 };
+ EResult m_eResult; // Result of the call
+ int32 m_nRank; // Overall rank of the server (0-based)
+ uint32 m_unTotalConnects; // Total number of clients who have ever connected to the server
+ uint32 m_unTotalMinutesPlayed; // Total number of minutes ever played on the server
+};
+
+// send as a reply to RequestUserGroupStatus()
+struct GSClientGroupStatus_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 8 };
+ CSteamID m_SteamIDUser;
+ CSteamID m_SteamIDGroup;
+ bool m_bMember;
+ bool m_bOfficer;
+};
+
+// Sent as a reply to GetServerReputation()
+struct GSReputation_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 9 };
+ EResult m_eResult; // Result of the call;
+ uint32 m_unReputationScore; // The reputation score for the game server
+ bool m_bBanned; // True if the server is banned from the Steam
+ // master servers
+
+ // The following members are only filled out if m_bBanned is true. They will all
+ // be set to zero otherwise. Master server bans are by IP so it is possible to be
+ // banned even when the score is good high if there is a bad server on another port.
+ // This information can be used to determine which server is bad.
+
+ uint32 m_unBannedIP; // The IP of the banned server
+ uint16 m_usBannedPort; // The port of the banned server
+ uint64 m_ulBannedGameID; // The game ID the banned server is serving
+ uint32 m_unBanExpires; // Time the ban expires, expressed in the Unix epoch (seconds since 1/1/1970)
+};
+
+// Sent as a reply to AssociateWithClan()
+struct AssociateWithClanResult_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 10 };
+ EResult m_eResult; // Result of the call;
+};
+
+// Sent as a reply to ComputeNewPlayerCompatibility()
+struct ComputeNewPlayerCompatibilityResult_t
+{
+ enum { k_iCallback = k_iSteamGameServerCallbacks + 11 };
+ EResult m_eResult; // Result of the call;
+ int m_cPlayersThatDontLikeCandidate;
+ int m_cPlayersThatCandidateDoesntLike;
+ int m_cClanPlayersThatDontLikeCandidate;
+ CSteamID m_SteamIDCandidate;
+};
+
+
+#pragma pack( pop )
+
+#endif // ISTEAMGAMESERVER_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamgameserverstats.h b/lsteamclient/steamworks_sdk_130x/isteamgameserverstats.h
new file mode 100644
index 00000000..2cd0d2d3
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamgameserverstats.h
@@ -0,0 +1,99 @@
+//====== Copyright © Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface for game servers to steam stats and achievements
+//
+//=============================================================================
+
+#ifndef ISTEAMGAMESERVERSTATS_H
+#define ISTEAMGAMESERVERSTATS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for authenticating users via Steam to play on a game server
+//-----------------------------------------------------------------------------
+class ISteamGameServerStats
+{
+public:
+ // downloads stats for the user
+ // returns a GSStatsReceived_t callback when completed
+ // if the user has no stats, GSStatsReceived_t.m_eResult will be set to k_EResultFail
+ // these stats will only be auto-updated for clients playing on the server. For other
+ // users you'll need to call RequestUserStats() again to refresh any data
+ virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0;
+
+ // requests stat information for a user, usable after a successful call to RequestUserStats()
+ virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0;
+ virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0;
+ virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0;
+
+ // Set / update stats and achievements.
+ // Note: These updates will work only on stats game servers are allowed to edit and only for
+ // game servers that have been declared as officially controlled by the game creators.
+ // Set the IP range of your official servers on the Steamworks page
+ virtual bool SetUserStat( CSteamID steamIDUser, const char *pchName, int32 nData ) = 0;
+ virtual bool SetUserStat( CSteamID steamIDUser, const char *pchName, float fData ) = 0;
+ virtual bool UpdateUserAvgRateStat( CSteamID steamIDUser, const char *pchName, float flCountThisSession, double dSessionLength ) = 0;
+
+ virtual bool SetUserAchievement( CSteamID steamIDUser, const char *pchName ) = 0;
+ virtual bool ClearUserAchievement( CSteamID steamIDUser, const char *pchName ) = 0;
+
+ // Store the current data on the server, will get a GSStatsStored_t callback when set.
+ //
+ // If the callback has a result of k_EResultInvalidParam, one or more stats
+ // uploaded has been rejected, either because they broke constraints
+ // or were out of date. In this case the server sends back updated values.
+ // The stats should be re-iterated to keep in sync.
+ virtual SteamAPICall_t StoreUserStats( CSteamID steamIDUser ) = 0;
+};
+
+#define STEAMGAMESERVERSTATS_INTERFACE_VERSION "SteamGameServerStats001"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the latests stats and achievements have been received
+// from the server
+//-----------------------------------------------------------------------------
+struct GSStatsReceived_t
+{
+ enum { k_iCallback = k_iSteamGameServerStatsCallbacks };
+ EResult m_eResult; // Success / error fetching the stats
+ CSteamID m_steamIDUser; // The user for whom the stats are retrieved for
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: result of a request to store the user stats for a game
+//-----------------------------------------------------------------------------
+struct GSStatsStored_t
+{
+ enum { k_iCallback = k_iSteamGameServerStatsCallbacks + 1 };
+ EResult m_eResult; // success / error
+ CSteamID m_steamIDUser; // The user for whom the stats were stored
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback indicating that a user's stats have been unloaded.
+// Call RequestUserStats again to access stats for this user
+//-----------------------------------------------------------------------------
+struct GSStatsUnloaded_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 };
+ CSteamID m_steamIDUser; // User whose stats have been unloaded
+};
+
+#pragma pack( pop )
+
+
+#endif // ISTEAMGAMESERVERSTATS_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamhtmlsurface.h b/lsteamclient/steamworks_sdk_130x/isteamhtmlsurface.h
new file mode 100644
index 00000000..156d5dde
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamhtmlsurface.h
@@ -0,0 +1,470 @@
+//====== Copyright 1996-2013, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to display html pages in a texture
+//
+//=============================================================================
+
+#ifndef ISTEAMHTMLSURFACE_H
+#define ISTEAMHTMLSURFACE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+typedef uint32 HHTMLBrowser;
+const uint32 INVALID_HTTMLBROWSER = 0;
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for displaying HTML pages and interacting with them
+//-----------------------------------------------------------------------------
+class ISteamHTMLSurface
+{
+public:
+ virtual ~ISteamHTMLSurface() {}
+
+ // Must call init and shutdown when starting/ending use of the interface
+ virtual bool Init() = 0;
+ virtual bool Shutdown() = 0;
+
+ // Create a browser object for display of a html page, when creation is complete the call handle
+ // will return a HTML_BrowserReady_t callback for the HHTMLBrowser of your new browser.
+ // The user agent string is a substring to be added to the general user agent string so you can
+ // identify your client on web servers.
+ // The userCSS string lets you apply a CSS style sheet to every displayed page, leave null if
+ // you do not require this functionality.
+ virtual SteamAPICall_t CreateBrowser( const char *pchUserAgent, const char *pchUserCSS ) = 0;
+
+ // Call this when you are done with a html surface, this lets us free the resources being used by it
+ virtual void RemoveBrowser( HHTMLBrowser unBrowserHandle ) = 0;
+
+ // Navigate to this URL, results in a HTML_StartRequest_t as the request commences
+ virtual void LoadURL( HHTMLBrowser unBrowserHandle, const char *pchURL, const char *pchPostData ) = 0;
+
+ // Tells the surface the size in pixels to display the surface
+ virtual void SetSize( HHTMLBrowser unBrowserHandle, uint32 unWidth, uint32 unHeight ) = 0;
+
+ // Stop the load of the current html page
+ virtual void StopLoad( HHTMLBrowser unBrowserHandle ) = 0;
+ // Reload (most likely from local cache) the current page
+ virtual void Reload( HHTMLBrowser unBrowserHandle ) = 0;
+ // navigate back in the page history
+ virtual void GoBack( HHTMLBrowser unBrowserHandle ) = 0;
+ // navigate forward in the page history
+ virtual void GoForward( HHTMLBrowser unBrowserHandle ) = 0;
+
+ // add this header to any url requests from this browser
+ virtual void AddHeader( HHTMLBrowser unBrowserHandle, const char *pchKey, const char *pchValue ) = 0;
+ // run this javascript script in the currently loaded page
+ virtual void ExecuteJavascript( HHTMLBrowser unBrowserHandle, const char *pchScript ) = 0;
+
+ enum EHTMLMouseButton
+ {
+ eHTMLMouseButton_Left = 0,
+ eHTMLMouseButton_Right = 1,
+ eHTMLMouseButton_Middle = 2,
+ };
+
+ // Mouse click and mouse movement commands
+ virtual void MouseUp( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0;
+ virtual void MouseDown( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0;
+ virtual void MouseDoubleClick( HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton ) = 0;
+ // x and y are relative to the HTML bounds
+ virtual void MouseMove( HHTMLBrowser unBrowserHandle, int x, int y ) = 0;
+ // nDelta is pixels of scroll
+ virtual void MouseWheel( HHTMLBrowser unBrowserHandle, int32 nDelta ) = 0;
+
+ enum EMouseCursor
+ {
+ dc_user = 0,
+ dc_none,
+ dc_arrow,
+ dc_ibeam,
+ dc_hourglass,
+ dc_waitarrow,
+ dc_crosshair,
+ dc_up,
+ dc_sizenw,
+ dc_sizese,
+ dc_sizene,
+ dc_sizesw,
+ dc_sizew,
+ dc_sizee,
+ dc_sizen,
+ dc_sizes,
+ dc_sizewe,
+ dc_sizens,
+ dc_sizeall,
+ dc_no,
+ dc_hand,
+ dc_blank, // don't show any custom cursor, just use your default
+ dc_middle_pan,
+ dc_north_pan,
+ dc_north_east_pan,
+ dc_east_pan,
+ dc_south_east_pan,
+ dc_south_pan,
+ dc_south_west_pan,
+ dc_west_pan,
+ dc_north_west_pan,
+ dc_alias,
+ dc_cell,
+ dc_colresize,
+ dc_copycur,
+ dc_verticaltext,
+ dc_rowresize,
+ dc_zoomin,
+ dc_zoomout,
+ dc_help,
+ dc_custom,
+
+ dc_last, // custom cursors start from this value and up
+ };
+
+ enum EHTMLKeyModifiers
+ {
+ eHTMLKeyModifier_None = 0,
+ eHTMLKeyModifier_AltDown = 1 << 0,
+ eHTMLKeyModifier_CrtlDown = 1 << 1,
+ eHTMLKeyModifier_ShiftDown = 1 << 2,
+ };
+
+ // keyboard interactions, native keycode is the virtual key code value from your OS
+ virtual void KeyDown( HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers ) = 0;
+ virtual void KeyUp( HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers ) = 0;
+ // cUnicodeChar is the unicode character point for this keypress (and potentially multiple chars per press)
+ virtual void KeyChar( HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, EHTMLKeyModifiers eHTMLKeyModifiers ) = 0;
+
+ // programmatically scroll this many pixels on the page
+ virtual void SetHorizontalScroll( HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll ) = 0;
+ virtual void SetVerticalScroll( HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll ) = 0;
+
+ // tell the html control if it has key focus currently, controls showing the I-beam cursor in text controls amongst other things
+ virtual void SetKeyFocus( HHTMLBrowser unBrowserHandle, bool bHasKeyFocus ) = 0;
+
+ // open the current pages html code in the local editor of choice, used for debugging
+ virtual void ViewSource( HHTMLBrowser unBrowserHandle ) = 0;
+ // copy the currently selected text on the html page to the local clipboard
+ virtual void CopyToClipboard( HHTMLBrowser unBrowserHandle ) = 0;
+ // paste from the local clipboard to the current html page
+ virtual void PasteFromClipboard( HHTMLBrowser unBrowserHandle ) = 0;
+
+ // find this string in the browser, if bCurrentlyInFind is true then instead cycle to the next matching element
+ virtual void Find( HHTMLBrowser unBrowserHandle, const char *pchSearchStr, bool bCurrentlyInFind, bool bReverse ) = 0;
+ // cancel a currently running find
+ virtual void StopFind( HHTMLBrowser unBrowserHandle ) = 0;
+
+ // return details about the link at position x,y on the current page
+ virtual void GetLinkAtPosition( HHTMLBrowser unBrowserHandle, int x, int y ) = 0;
+
+ // CALLBACKS
+ //
+ // These set of functions are used as responses to callback requests
+ //
+
+ // You MUST call this in response to a HTML_StartRequest_t callback
+ // Set bAllowed to true to allow this navigation, false to cancel it and stay
+ // on the current page. You can use this feature to limit the valid pages
+ // allowed in your HTML surface.
+ virtual void AllowStartRequest( HHTMLBrowser unBrowserHandle, bool bAllowed ) = 0;
+
+ // 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
+ virtual void JSDialogResponse( HHTMLBrowser unBrowserHandle, bool bResult ) = 0;
+
+ // You MUST call this in response to a HTML_FileOpenDialog_t callback
+ virtual void FileLoadDialogResponse( HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles ) = 0;
+};
+
+#define STEAMHTMLSURFACE_INTERFACE_VERSION "STEAMHTMLSURFACE_INTERFACE_VERSION_001"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The browser is ready for use
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_BrowserReady_t, k_iSteamHTMLSurfaceCallbacks + 1 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // this browser is now fully created and ready to navigate to pages
+END_DEFINE_CALLBACK_1()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: the browser has a pending paint
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK(HTML_NeedsPaint_t, k_iSteamHTMLSurfaceCallbacks + 2)
+CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the browser that needs the paint
+CALLBACK_MEMBER(1, const char *, pBGRA ) // a pointer to the B8G8R8A8 data for this surface, valid until SteamAPI_RunCallbacks is next called
+CALLBACK_MEMBER(2, uint32, unWide) // the total width of the pBGRA texture
+CALLBACK_MEMBER(3, uint32, unTall) // the total height of the pBGRA texture
+CALLBACK_MEMBER(4, uint32, unUpdateX) // the offset in X for the damage rect for this update
+CALLBACK_MEMBER(5, uint32, unUpdateY) // the offset in Y for the damage rect for this update
+CALLBACK_MEMBER(6, uint32, unUpdateWide) // the width of the damage rect for this update
+CALLBACK_MEMBER(7, uint32, unUpdateTall) // the height of the damage rect for this update
+CALLBACK_MEMBER(8, uint32, unScrollX) // the page scroll the browser was at when this texture was rendered
+CALLBACK_MEMBER(9, uint32, unScrollY) // the page scroll the browser was at when this texture was rendered
+CALLBACK_MEMBER(10, float, flPageScale) // the page scale factor on this page when rendered
+CALLBACK_MEMBER(11, uint32, unPageSerial) // incremented on each new page load, you can use this to reject draws while navigating to new pages
+END_DEFINE_CALLBACK_12()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The browser wanted to navigate to a new page
+// NOTE - you MUST call AllowStartRequest in response to this callback
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK(HTML_StartRequest_t, k_iSteamHTMLSurfaceCallbacks + 3)
+CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the handle of the surface navigating
+CALLBACK_MEMBER(1, const char *, pchURL) // the url they wish to navigate to
+CALLBACK_MEMBER(2, const char *, pchTarget) // the html link target type (i.e _blank, _self, _parent, _top )
+CALLBACK_MEMBER(3, const char *, pchPostData ) // any posted data for the request
+CALLBACK_MEMBER(4, bool, bIsRedirect) // true if this was a http/html redirect from the last load request
+END_DEFINE_CALLBACK_5()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The browser has been requested to close due to user interaction (usually from a javascript window.close() call)
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK(HTML_CloseBrowser_t, k_iSteamHTMLSurfaceCallbacks + 4)
+CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the handle of the surface
+END_DEFINE_CALLBACK_1()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: the browser is navigating to a new url
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_URLChanged_t, k_iSteamHTMLSurfaceCallbacks + 5 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface navigating
+CALLBACK_MEMBER( 1, const char *, pchURL ) // the url they wish to navigate to
+CALLBACK_MEMBER( 2, const char *, pchPostData ) // any posted data for the request
+CALLBACK_MEMBER( 3, bool, bIsRedirect ) // true if this was a http/html redirect from the last load request
+CALLBACK_MEMBER( 4, const char *, pchPageTitle ) // the title of the page
+CALLBACK_MEMBER( 5, bool, bNewNavigation ) // true if this was from a fresh tab and not a click on an existing page
+END_DEFINE_CALLBACK_6()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A page is finished loading
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_FinishedRequest_t, k_iSteamHTMLSurfaceCallbacks + 6 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchURL ) //
+CALLBACK_MEMBER( 2, const char *, pchPageTitle ) //
+END_DEFINE_CALLBACK_3()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a request to load this url in a new tab
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_OpenLinkInNewTab_t, k_iSteamHTMLSurfaceCallbacks + 7 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchURL ) //
+END_DEFINE_CALLBACK_2()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: the page has a new title now
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_ChangedTitle_t, k_iSteamHTMLSurfaceCallbacks + 8 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchTitle ) //
+END_DEFINE_CALLBACK_2()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: results from a search
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_SearchResults_t, k_iSteamHTMLSurfaceCallbacks + 9 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, uint32, unResults ) //
+CALLBACK_MEMBER( 2, uint32, unCurrentMatch ) //
+END_DEFINE_CALLBACK_3()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: page history status changed on the ability to go backwards and forward
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_CanGoBackAndForward_t, k_iSteamHTMLSurfaceCallbacks + 10 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, bool, bCanGoBack ) //
+CALLBACK_MEMBER( 2, bool, bCanGoForward ) //
+END_DEFINE_CALLBACK_3()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: details on the visibility and size of the horizontal scrollbar
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_HorizontalScroll_t, k_iSteamHTMLSurfaceCallbacks + 11 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, uint32, unScrollMax ) //
+CALLBACK_MEMBER( 2, uint32, unScrollCurrent ) //
+CALLBACK_MEMBER( 3, float, flPageScale ) //
+CALLBACK_MEMBER( 4, bool , bVisible ) //
+CALLBACK_MEMBER( 5, uint32, unPageSize ) //
+END_DEFINE_CALLBACK_6()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: details on the visibility and size of the vertical scrollbar
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_VerticalScroll_t, k_iSteamHTMLSurfaceCallbacks + 12 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, uint32, unScrollMax ) //
+CALLBACK_MEMBER( 2, uint32, unScrollCurrent ) //
+CALLBACK_MEMBER( 3, float, flPageScale ) //
+CALLBACK_MEMBER( 4, bool, bVisible ) //
+CALLBACK_MEMBER( 5, uint32, unPageSize ) //
+END_DEFINE_CALLBACK_6()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: response to GetLinkAtPosition call
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_LinkAtPosition_t, k_iSteamHTMLSurfaceCallbacks + 13 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, uint32, x ) //
+CALLBACK_MEMBER( 2, uint32, y ) //
+CALLBACK_MEMBER( 3, const char *, pchURL ) //
+CALLBACK_MEMBER( 4, bool, bInput ) //
+CALLBACK_MEMBER( 5, bool, bLiveLink ) //
+END_DEFINE_CALLBACK_6()
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: show a Javascript alert dialog, call JSDialogResponse
+// when the user dismisses this dialog (or right away to ignore it)
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_JSAlert_t, k_iSteamHTMLSurfaceCallbacks + 14 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchMessage ) //
+END_DEFINE_CALLBACK_2()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: show a Javascript confirmation dialog, call JSDialogResponse
+// when the user dismisses this dialog (or right away to ignore it)
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_JSConfirm_t, k_iSteamHTMLSurfaceCallbacks + 15 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchMessage ) //
+END_DEFINE_CALLBACK_2()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: show a Javascript confirmation dialog, call JSDialogResponse
+// when the user dismisses this dialog (or right away to ignore it)
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_FileOpenDialog_t, k_iSteamHTMLSurfaceCallbacks + 16 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchTitle ) //
+CALLBACK_MEMBER( 2, const char *, pchInitialFile ) //
+END_DEFINE_CALLBACK_3()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a popup item (i.e combo box) on the page needs rendering
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_ComboNeedsPaint_t, k_iSteamHTMLSurfaceCallbacks + 17 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pBGRA ) // a pointer to the B8G8R8A8 data for this surface, valid until SteamAPI_RunCallbacks is next called
+CALLBACK_MEMBER( 2, uint32, unWide ) // the total width of the pBGRA texture
+CALLBACK_MEMBER( 3, uint32, unTall ) // the total height of the pBGRA texture
+END_DEFINE_CALLBACK_4()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a popup (i.e combo box) wants to display
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_ShowPopup_t, k_iSteamHTMLSurfaceCallbacks + 18 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+END_DEFINE_CALLBACK_1()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a popup (i.e combo box) wants to hide
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_HidePopup_t, k_iSteamHTMLSurfaceCallbacks + 19 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+END_DEFINE_CALLBACK_1()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a popup (i.e combo box) wants to hide
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_SizePopup_t, k_iSteamHTMLSurfaceCallbacks + 20 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, uint32, unX ) // the x pos into the page to display the popup
+CALLBACK_MEMBER( 2, uint32, unY ) // the y pos into the page to display the popup
+CALLBACK_MEMBER( 3, uint32, unWide ) // the total width of the pBGRA texture
+CALLBACK_MEMBER( 4, uint32, unTall ) // the total height of the pBGRA texture
+END_DEFINE_CALLBACK_5()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a new html window has been created
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_NewWindow_t, k_iSteamHTMLSurfaceCallbacks + 21 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchURL ) // the page to load
+CALLBACK_MEMBER( 2, uint32, unX ) // the x pos into the page to display the popup
+CALLBACK_MEMBER( 3, uint32, unY ) // the y pos into the page to display the popup
+CALLBACK_MEMBER( 4, uint32, unWide ) // the total width of the pBGRA texture
+CALLBACK_MEMBER( 5, uint32, unTall ) // the total height of the pBGRA texture
+END_DEFINE_CALLBACK_6()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: change the cursor to display
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_SetCursor_t, k_iSteamHTMLSurfaceCallbacks + 22 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, uint32, eMouseCursor ) // the EMouseCursor to display
+END_DEFINE_CALLBACK_2()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: informational message from the browser
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_StatusText_t, k_iSteamHTMLSurfaceCallbacks + 23 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display
+END_DEFINE_CALLBACK_2()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: show a tooltip
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_ShowToolTip_t, k_iSteamHTMLSurfaceCallbacks + 24 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display
+END_DEFINE_CALLBACK_2()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: update the text of an existing tooltip
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_UpdateToolTip_t, k_iSteamHTMLSurfaceCallbacks + 25 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display
+END_DEFINE_CALLBACK_2()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: hide the tooltip you are showing
+//-----------------------------------------------------------------------------
+DEFINE_CALLBACK( HTML_HideToolTip_t, k_iSteamHTMLSurfaceCallbacks + 26 )
+CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface
+END_DEFINE_CALLBACK_1()
+
+
+#pragma pack( pop )
+
+
+#endif // ISTEAMHTMLSURFACE_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamhttp.h b/lsteamclient/steamworks_sdk_130x/isteamhttp.h
new file mode 100644
index 00000000..12a050d8
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamhttp.h
@@ -0,0 +1,176 @@
+//====== Copyright © 1996-2009, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to http client
+//
+//=============================================================================
+
+#ifndef ISTEAMHTTP_H
+#define ISTEAMHTTP_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "steamhttpenums.h"
+
+// Handle to a HTTP Request handle
+typedef uint32 HTTPRequestHandle;
+#define INVALID_HTTPREQUEST_HANDLE 0
+
+//-----------------------------------------------------------------------------
+// Purpose: interface to http client
+//-----------------------------------------------------------------------------
+class ISteamHTTP
+{
+public:
+
+ // Initializes a new HTTP request, returning a handle to use in further operations on it. Requires
+ // the method (GET or POST) and the absolute URL for the request. Only http requests (ie, not https) are
+ // currently supported, so this string must start with http:// or https:// and should look like http://store.steampowered.com/app/250/
+ // or such.
+ virtual HTTPRequestHandle CreateHTTPRequest( EHTTPMethod eHTTPRequestMethod, const char *pchAbsoluteURL ) = 0;
+
+ // Set a context value for the request, which will be returned in the HTTPRequestCompleted_t callback after
+ // sending the request. This is just so the caller can easily keep track of which callbacks go with which request data.
+ virtual bool SetHTTPRequestContextValue( HTTPRequestHandle hRequest, uint64 ulContextValue ) = 0;
+
+ // Set a timeout in seconds for the HTTP request, must be called prior to sending the request. Default
+ // timeout is 60 seconds if you don't call this. Returns false if the handle is invalid, or the request
+ // has already been sent.
+ virtual bool SetHTTPRequestNetworkActivityTimeout( HTTPRequestHandle hRequest, uint32 unTimeoutSeconds ) = 0;
+
+ // Set a request header value for the request, must be called prior to sending the request. Will
+ // return false if the handle is invalid or the request is already sent.
+ virtual bool SetHTTPRequestHeaderValue( HTTPRequestHandle hRequest, const char *pchHeaderName, const char *pchHeaderValue ) = 0;
+
+ // Set a GET or POST parameter value on the request, which is set will depend on the EHTTPMethod specified
+ // when creating the request. Must be called prior to sending the request. Will return false if the
+ // handle is invalid or the request is already sent.
+ virtual bool SetHTTPRequestGetOrPostParameter( HTTPRequestHandle hRequest, const char *pchParamName, const char *pchParamValue ) = 0;
+
+ // Sends the HTTP request, will return false on a bad handle, otherwise use SteamCallHandle to wait on
+ // asynchronous response via callback.
+ //
+ // Note: If the user is in offline mode in Steam, then this will add a only-if-cached cache-control
+ // header and only do a local cache lookup rather than sending any actual remote request.
+ virtual bool SendHTTPRequest( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle ) = 0;
+
+ // Sends the HTTP request, will return false on a bad handle, otherwise use SteamCallHandle to wait on
+ // asynchronous response via callback for completion, and listen for HTTPRequestHeadersReceived_t and
+ // HTTPRequestDataReceived_t callbacks while streaming.
+ virtual bool SendHTTPRequestAndStreamResponse( HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle ) = 0;
+
+ // Defers a request you have sent, the actual HTTP client code may have many requests queued, and this will move
+ // the specified request to the tail of the queue. Returns false on invalid handle, or if the request is not yet sent.
+ virtual bool DeferHTTPRequest( HTTPRequestHandle hRequest ) = 0;
+
+ // Prioritizes a request you have sent, the actual HTTP client code may have many requests queued, and this will move
+ // the specified request to the head of the queue. Returns false on invalid handle, or if the request is not yet sent.
+ virtual bool PrioritizeHTTPRequest( HTTPRequestHandle hRequest ) = 0;
+
+ // Checks if a response header is present in a HTTP response given a handle from HTTPRequestCompleted_t, also
+ // returns the size of the header value if present so the caller and allocate a correctly sized buffer for
+ // GetHTTPResponseHeaderValue.
+ virtual bool GetHTTPResponseHeaderSize( HTTPRequestHandle hRequest, const char *pchHeaderName, uint32 *unResponseHeaderSize ) = 0;
+
+ // Gets header values from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the
+ // header is not present or if your buffer is too small to contain it's value. You should first call
+ // BGetHTTPResponseHeaderSize to check for the presence of the header and to find out the size buffer needed.
+ virtual bool GetHTTPResponseHeaderValue( HTTPRequestHandle hRequest, const char *pchHeaderName, uint8 *pHeaderValueBuffer, uint32 unBufferSize ) = 0;
+
+ // Gets the size of the body data from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the
+ // handle is invalid.
+ virtual bool GetHTTPResponseBodySize( HTTPRequestHandle hRequest, uint32 *unBodySize ) = 0;
+
+ // Gets the body data from a HTTP response given a handle from HTTPRequestCompleted_t, will return false if the
+ // handle is invalid or is to a streaming response, or if the provided buffer is not the correct size. Use BGetHTTPResponseBodySize first to find out
+ // the correct buffer size to use.
+ virtual bool GetHTTPResponseBodyData( HTTPRequestHandle hRequest, uint8 *pBodyDataBuffer, uint32 unBufferSize ) = 0;
+
+ // Gets the body data from a streaming HTTP response given a handle from HTTPRequestDataReceived_t. Will return false if the
+ // handle is invalid or is to a non-streaming response (meaning it wasn't sent with SendHTTPRequestAndStreamResponse), or if the buffer size and offset
+ // do not match the size and offset sent in HTTPRequestDataReceived_t.
+ virtual bool GetHTTPStreamingResponseBodyData( HTTPRequestHandle hRequest, uint32 cOffset, uint8 *pBodyDataBuffer, uint32 unBufferSize ) = 0;
+
+ // Releases an HTTP response handle, should always be called to free resources after receiving a HTTPRequestCompleted_t
+ // callback and finishing using the response.
+ virtual bool ReleaseHTTPRequest( HTTPRequestHandle hRequest ) = 0;
+
+ // Gets progress on downloading the body for the request. This will be zero unless a response header has already been
+ // received which included a content-length field. For responses that contain no content-length it will report
+ // zero for the duration of the request as the size is unknown until the connection closes.
+ virtual bool GetHTTPDownloadProgressPct( HTTPRequestHandle hRequest, float *pflPercentOut ) = 0;
+
+ // Sets the body for an HTTP Post request. Will fail and return false on a GET request, and will fail if POST params
+ // have already been set for the request. Setting this raw body makes it the only contents for the post, the pchContentType
+ // parameter will set the content-type header for the request so the server may know how to interpret the body.
+ virtual bool SetHTTPRequestRawPostBody( HTTPRequestHandle hRequest, const char *pchContentType, uint8 *pubBody, uint32 unBodyLen ) = 0;
+};
+
+#define STEAMHTTP_INTERFACE_VERSION "STEAMHTTP_INTERFACE_VERSION002"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+struct HTTPRequestCompleted_t
+{
+ enum { k_iCallback = k_iClientHTTPCallbacks + 1 };
+
+ // Handle value for the request that has completed.
+ HTTPRequestHandle m_hRequest;
+
+ // Context value that the user defined on the request that this callback is associated with, 0 if
+ // no context value was set.
+ uint64 m_ulContextValue;
+
+ // This will be true if we actually got any sort of response from the server (even an error).
+ // It will be false if we failed due to an internal error or client side network failure.
+ bool m_bRequestSuccessful;
+
+ // Will be the HTTP status code value returned by the server, k_EHTTPStatusCode200OK is the normal
+ // OK response, if you get something else you probably need to treat it as a failure.
+ EHTTPStatusCode m_eStatusCode;
+};
+
+
+struct HTTPRequestHeadersReceived_t
+{
+ enum { k_iCallback = k_iClientHTTPCallbacks + 2 };
+
+ // Handle value for the request that has received headers.
+ HTTPRequestHandle m_hRequest;
+
+ // Context value that the user defined on the request that this callback is associated with, 0 if
+ // no context value was set.
+ uint64 m_ulContextValue;
+};
+
+struct HTTPRequestDataReceived_t
+{
+ enum { k_iCallback = k_iClientHTTPCallbacks + 3 };
+
+ // Handle value for the request that has received data.
+ HTTPRequestHandle m_hRequest;
+
+ // Context value that the user defined on the request that this callback is associated with, 0 if
+ // no context value was set.
+ uint64 m_ulContextValue;
+
+
+ // Offset to provide to GetHTTPStreamingResponseBodyData to get this chunk of data
+ uint32 m_cOffset;
+
+ // Size to provide to GetHTTPStreamingResponseBodyData to get this chunk of data
+ uint32 m_cBytesReceived;
+};
+
+
+#pragma pack( pop )
+
+#endif // ISTEAMHTTP_H
\ No newline at end of file
diff --git a/lsteamclient/steamworks_sdk_130x/isteammasterserverupdater.h b/lsteamclient/steamworks_sdk_130x/isteammasterserverupdater.h
new file mode 100644
index 00000000..19590019
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteammasterserverupdater.h
@@ -0,0 +1 @@
+#error "This file isn't used any more"
diff --git a/lsteamclient/steamworks_sdk_130x/isteammatchmaking.h b/lsteamclient/steamworks_sdk_130x/isteammatchmaking.h
new file mode 100644
index 00000000..0e54b1a3
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteammatchmaking.h
@@ -0,0 +1,747 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam managing game server/client match making
+//
+//=============================================================================
+
+#ifndef ISTEAMMATCHMAKING
+#define ISTEAMMATCHMAKING
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steamtypes.h"
+#include "steamclientpublic.h"
+#include "matchmakingtypes.h"
+#include "isteamclient.h"
+#include "isteamfriends.h"
+
+// lobby type description
+enum ELobbyType
+{
+ k_ELobbyTypePrivate = 0, // only way to join the lobby is to invite to someone else
+ k_ELobbyTypeFriendsOnly = 1, // shows for friends or invitees, but not in lobby list
+ k_ELobbyTypePublic = 2, // visible for friends and in lobby list
+ k_ELobbyTypeInvisible = 3, // returned by search, but not visible to other friends
+ // useful if you want a user in two lobbies, for example matching groups together
+ // a user can be in only one regular lobby, and up to two invisible lobbies
+};
+
+// lobby search filter tools
+enum ELobbyComparison
+{
+ k_ELobbyComparisonEqualToOrLessThan = -2,
+ k_ELobbyComparisonLessThan = -1,
+ k_ELobbyComparisonEqual = 0,
+ k_ELobbyComparisonGreaterThan = 1,
+ k_ELobbyComparisonEqualToOrGreaterThan = 2,
+ k_ELobbyComparisonNotEqual = 3,
+};
+
+// lobby search distance. Lobby results are sorted from closest to farthest.
+enum ELobbyDistanceFilter
+{
+ k_ELobbyDistanceFilterClose, // only lobbies in the same immediate region will be returned
+ k_ELobbyDistanceFilterDefault, // only lobbies in the same region or near by regions
+ k_ELobbyDistanceFilterFar, // for games that don't have many latency requirements, will return lobbies about half-way around the globe
+ k_ELobbyDistanceFilterWorldwide, // no filtering, will match lobbies as far as India to NY (not recommended, expect multiple seconds of latency between the clients)
+};
+
+// maximum number of characters a lobby metadata key can be
+#define k_nMaxLobbyKeyLength 255
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for match making services for clients to get to favorites
+// and to operate on game lobbies.
+//-----------------------------------------------------------------------------
+class ISteamMatchmaking
+{
+public:
+ // game server favorites storage
+ // saves basic details about a multiplayer game server locally
+
+ // returns the number of favorites servers the user has stored
+ virtual int GetFavoriteGameCount() = 0;
+
+ // returns the details of the game server
+ // iGame is of range [0,GetFavoriteGameCount())
+ // *pnIP, *pnConnPort are filled in the with IP:port of the game server
+ // *punFlags specify whether the game server was stored as an explicit favorite or in the history of connections
+ // *pRTime32LastPlayedOnServer is filled in the with the Unix time the favorite was added
+ virtual bool GetFavoriteGame( int iGame, AppId_t *pnAppID, uint32 *pnIP, uint16 *pnConnPort, uint16 *pnQueryPort, uint32 *punFlags, uint32 *pRTime32LastPlayedOnServer ) = 0;
+
+ // adds the game server to the local list; updates the time played of the server if it already exists in the list
+ virtual int AddFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer ) = 0;
+
+ // removes the game server from the local storage; returns true if one was removed
+ virtual bool RemoveFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags ) = 0;
+
+ ///////
+ // Game lobby functions
+
+ // Get a list of relevant lobbies
+ // this is an asynchronous request
+ // results will be returned by LobbyMatchList_t callback & call result, with the number of lobbies found
+ // this will never return lobbies that are full
+ // to add more filter, the filter calls below need to be call before each and every RequestLobbyList() call
+ // use the CCallResult<> object in steam_api.h to match the SteamAPICall_t call result to a function in an object, e.g.
+ /*
+ class CMyLobbyListManager
+ {
+ CCallResult m_CallResultLobbyMatchList;
+ void FindLobbies()
+ {
+ // SteamMatchmaking()->AddRequestLobbyListFilter*() functions would be called here, before RequestLobbyList()
+ SteamAPICall_t hSteamAPICall = SteamMatchmaking()->RequestLobbyList();
+ m_CallResultLobbyMatchList.Set( hSteamAPICall, this, &CMyLobbyListManager::OnLobbyMatchList );
+ }
+
+ void OnLobbyMatchList( LobbyMatchList_t *pLobbyMatchList, bool bIOFailure )
+ {
+ // lobby list has be retrieved from Steam back-end, use results
+ }
+ }
+ */
+ //
+ virtual SteamAPICall_t RequestLobbyList() = 0;
+ // filters for lobbies
+ // this needs to be called before RequestLobbyList() to take effect
+ // these are cleared on each call to RequestLobbyList()
+ virtual void AddRequestLobbyListStringFilter( const char *pchKeyToMatch, const char *pchValueToMatch, ELobbyComparison eComparisonType ) = 0;
+ // numerical comparison
+ virtual void AddRequestLobbyListNumericalFilter( const char *pchKeyToMatch, int nValueToMatch, ELobbyComparison eComparisonType ) = 0;
+ // returns results closest to the specified value. Multiple near filters can be added, with early filters taking precedence
+ virtual void AddRequestLobbyListNearValueFilter( const char *pchKeyToMatch, int nValueToBeCloseTo ) = 0;
+ // returns only lobbies with the specified number of slots available
+ virtual void AddRequestLobbyListFilterSlotsAvailable( int nSlotsAvailable ) = 0;
+ // sets the distance for which we should search for lobbies (based on users IP address to location map on the Steam backed)
+ virtual void AddRequestLobbyListDistanceFilter( ELobbyDistanceFilter eLobbyDistanceFilter ) = 0;
+ // sets how many results to return, the lower the count the faster it is to download the lobby results & details to the client
+ virtual void AddRequestLobbyListResultCountFilter( int cMaxResults ) = 0;
+
+ virtual void AddRequestLobbyListCompatibleMembersFilter( CSteamID steamIDLobby ) = 0;
+
+ // returns the CSteamID of a lobby, as retrieved by a RequestLobbyList call
+ // should only be called after a LobbyMatchList_t callback is received
+ // iLobby is of the range [0, LobbyMatchList_t::m_nLobbiesMatching)
+ // the returned CSteamID::IsValid() will be false if iLobby is out of range
+ virtual CSteamID GetLobbyByIndex( int iLobby ) = 0;
+
+ // Create a lobby on the Steam servers.
+ // If private, then the lobby will not be returned by any RequestLobbyList() call; the CSteamID
+ // of the lobby will need to be communicated via game channels or via InviteUserToLobby()
+ // this is an asynchronous request
+ // results will be returned by LobbyCreated_t callback and call result; lobby is joined & ready to use at this point
+ // a LobbyEnter_t callback will also be received (since the local user is joining their own lobby)
+ virtual SteamAPICall_t CreateLobby( ELobbyType eLobbyType, int cMaxMembers ) = 0;
+
+ // Joins an existing lobby
+ // this is an asynchronous request
+ // results will be returned by LobbyEnter_t callback & call result, check m_EChatRoomEnterResponse to see if was successful
+ // lobby metadata is available to use immediately on this call completing
+ virtual SteamAPICall_t JoinLobby( CSteamID steamIDLobby ) = 0;
+
+ // Leave a lobby; this will take effect immediately on the client side
+ // other users in the lobby will be notified by a LobbyChatUpdate_t callback
+ virtual void LeaveLobby( CSteamID steamIDLobby ) = 0;
+
+ // Invite another user to the lobby
+ // the target user will receive a LobbyInvite_t callback
+ // will return true if the invite is successfully sent, whether or not the target responds
+ // returns false if the local user is not connected to the Steam servers
+ // if the other user clicks the join link, a GameLobbyJoinRequested_t will be posted if the user is in-game,
+ // or if the game isn't running yet the game will be launched with the parameter +connect_lobby <64-bit lobby id>
+ virtual bool InviteUserToLobby( CSteamID steamIDLobby, CSteamID steamIDInvitee ) = 0;
+
+ // Lobby iteration, for viewing details of users in a lobby
+ // only accessible if the lobby user is a member of the specified lobby
+ // persona information for other lobby members (name, avatar, etc.) will be asynchronously received
+ // and accessible via ISteamFriends interface
+
+ // returns the number of users in the specified lobby
+ virtual int GetNumLobbyMembers( CSteamID steamIDLobby ) = 0;
+ // returns the CSteamID of a user in the lobby
+ // iMember is of range [0,GetNumLobbyMembers())
+ // note that the current user must be in a lobby to retrieve CSteamIDs of other users in that lobby
+ virtual CSteamID GetLobbyMemberByIndex( CSteamID steamIDLobby, int iMember ) = 0;
+
+ // Get data associated with this lobby
+ // takes a simple key, and returns the string associated with it
+ // "" will be returned if no value is set, or if steamIDLobby is invalid
+ virtual const char *GetLobbyData( CSteamID steamIDLobby, const char *pchKey ) = 0;
+ // Sets a key/value pair in the lobby metadata
+ // each user in the lobby will be broadcast this new value, and any new users joining will receive any existing data
+ // this can be used to set lobby names, map, etc.
+ // to reset a key, just set it to ""
+ // other users in the lobby will receive notification of the lobby data change via a LobbyDataUpdate_t callback
+ virtual bool SetLobbyData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue ) = 0;
+
+ // returns the number of metadata keys set on the specified lobby
+ virtual int GetLobbyDataCount( CSteamID steamIDLobby ) = 0;
+
+ // returns a lobby metadata key/values pair by index, of range [0, GetLobbyDataCount())
+ virtual bool GetLobbyDataByIndex( CSteamID steamIDLobby, int iLobbyData, char *pchKey, int cchKeyBufferSize, char *pchValue, int cchValueBufferSize ) = 0;
+
+ // removes a metadata key from the lobby
+ virtual bool DeleteLobbyData( CSteamID steamIDLobby, const char *pchKey ) = 0;
+
+ // Gets per-user metadata for someone in this lobby
+ virtual const char *GetLobbyMemberData( CSteamID steamIDLobby, CSteamID steamIDUser, const char *pchKey ) = 0;
+ // Sets per-user metadata (for the local user implicitly)
+ virtual void SetLobbyMemberData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue ) = 0;
+
+ // Broadcasts a chat message to the all the users in the lobby
+ // users in the lobby (including the local user) will receive a LobbyChatMsg_t callback
+ // returns true if the message is successfully sent
+ // pvMsgBody can be binary or text data, up to 4k
+ // if pvMsgBody is text, cubMsgBody should be strlen( text ) + 1, to include the null terminator
+ virtual bool SendLobbyChatMsg( CSteamID steamIDLobby, const void *pvMsgBody, int cubMsgBody ) = 0;
+ // Get a chat message as specified in a LobbyChatMsg_t callback
+ // iChatID is the LobbyChatMsg_t::m_iChatID value in the callback
+ // *pSteamIDUser is filled in with the CSteamID of the member
+ // *pvData is filled in with the message itself
+ // return value is the number of bytes written into the buffer
+ virtual int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, CSteamID *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0;
+
+ // Refreshes metadata for a lobby you're not necessarily in right now
+ // you never do this for lobbies you're a member of, only if your
+ // this will send down all the metadata associated with a lobby
+ // this is an asynchronous call
+ // returns false if the local user is not connected to the Steam servers
+ // results will be returned by a LobbyDataUpdate_t callback
+ // if the specified lobby doesn't exist, LobbyDataUpdate_t::m_bSuccess will be set to false
+ virtual bool RequestLobbyData( CSteamID steamIDLobby ) = 0;
+
+ // sets the game server associated with the lobby
+ // usually at this point, the users will join the specified game server
+ // either the IP/Port or the steamID of the game server has to be valid, depending on how you want the clients to be able to connect
+ virtual void SetLobbyGameServer( CSteamID steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, CSteamID steamIDGameServer ) = 0;
+ // returns the details of a game server set in a lobby - returns false if there is no game server set, or that lobby doesn't exist
+ virtual bool GetLobbyGameServer( CSteamID steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, CSteamID *psteamIDGameServer ) = 0;
+
+ // set the limit on the # of users who can join the lobby
+ virtual bool SetLobbyMemberLimit( CSteamID steamIDLobby, int cMaxMembers ) = 0;
+ // returns the current limit on the # of users who can join the lobby; returns 0 if no limit is defined
+ virtual int GetLobbyMemberLimit( CSteamID steamIDLobby ) = 0;
+
+ // updates which type of lobby it is
+ // only lobbies that are k_ELobbyTypePublic or k_ELobbyTypeInvisible, and are set to joinable, will be returned by RequestLobbyList() calls
+ virtual bool SetLobbyType( CSteamID steamIDLobby, ELobbyType eLobbyType ) = 0;
+
+ // sets whether or not a lobby is joinable - defaults to true for a new lobby
+ // if set to false, no user can join, even if they are a friend or have been invited
+ virtual bool SetLobbyJoinable( CSteamID steamIDLobby, bool bLobbyJoinable ) = 0;
+
+ // returns the current lobby owner
+ // you must be a member of the lobby to access this
+ // there always one lobby owner - if the current owner leaves, another user will become the owner
+ // it is possible (bur rare) to join a lobby just as the owner is leaving, thus entering a lobby with self as the owner
+ virtual CSteamID GetLobbyOwner( CSteamID steamIDLobby ) = 0;
+
+ // changes who the lobby owner is
+ // you must be the lobby owner for this to succeed, and steamIDNewOwner must be in the lobby
+ // after completion, the local user will no longer be the owner
+ virtual bool SetLobbyOwner( CSteamID steamIDLobby, CSteamID steamIDNewOwner ) = 0;
+
+ // link two lobbies for the purposes of checking player compatibility
+ // you must be the lobby owner of both lobbies
+ virtual bool SetLinkedLobby( CSteamID steamIDLobby, CSteamID steamIDLobbyDependent ) = 0;
+
+#ifdef _PS3
+ // changes who the lobby owner is
+ // you must be the lobby owner for this to succeed, and steamIDNewOwner must be in the lobby
+ // after completion, the local user will no longer be the owner
+ virtual void CheckForPSNGameBootInvite( unsigned int iGameBootAttributes ) = 0;
+#endif
+};
+#define STEAMMATCHMAKING_INTERFACE_VERSION "SteamMatchMaking009"
+
+
+//-----------------------------------------------------------------------------
+// Callback interfaces for server list functions (see ISteamMatchmakingServers below)
+//
+// The idea here is that your game code implements objects that implement these
+// interfaces to receive callback notifications after calling asynchronous functions
+// inside the ISteamMatchmakingServers() interface below.
+//
+// This is different than normal Steam callback handling due to the potentially
+// large size of server lists.
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Typedef for handle type you will receive when requesting server list.
+//-----------------------------------------------------------------------------
+typedef void* HServerListRequest;
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after a server list refresh
+// or an individual server update.
+//
+// Since you get these callbacks after requesting full list refreshes you will
+// usually implement this interface inside an object like CServerBrowser. If that
+// object is getting destructed you should use ISteamMatchMakingServers()->CancelQuery()
+// to cancel any in-progress queries so you don't get a callback into the destructed
+// object and crash.
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingServerListResponse
+{
+public:
+ // Server has responded ok with updated data
+ virtual void ServerResponded( HServerListRequest hRequest, int iServer ) = 0;
+
+ // Server has failed to respond
+ virtual void ServerFailedToRespond( HServerListRequest hRequest, int iServer ) = 0;
+
+ // A list refresh you had initiated is now 100% completed
+ virtual void RefreshComplete( HServerListRequest hRequest, EMatchMakingServerResponse response ) = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after pinging an individual server
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->PingServer() call below. If you are
+// destructing an object that implements this interface then you should call
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress. Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingPingResponse
+{
+public:
+ // Server has responded successfully and has updated data
+ virtual void ServerResponded( gameserveritem_t &server ) = 0;
+
+ // Server failed to respond to the ping request
+ virtual void ServerFailedToRespond() = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after requesting details on
+// who is playing on a particular server.
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->PlayerDetails() call below. If you are
+// destructing an object that implements this interface then you should call
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress. Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingPlayersResponse
+{
+public:
+ // Got data on a new player on the server -- you'll get this callback once per player
+ // on the server which you have requested player data on.
+ virtual void AddPlayerToList( const char *pchName, int nScore, float flTimePlayed ) = 0;
+
+ // The server failed to respond to the request for player details
+ virtual void PlayersFailedToRespond() = 0;
+
+ // The server has finished responding to the player details request
+ // (ie, you won't get anymore AddPlayerToList callbacks)
+ virtual void PlayersRefreshComplete() = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after requesting rules
+// details on a particular server.
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->ServerRules() call below. If you are
+// destructing an object that implements this interface then you should call
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress. Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingRulesResponse
+{
+public:
+ // Got data on a rule on the server -- you'll get one of these per rule defined on
+ // the server you are querying
+ virtual void RulesResponded( const char *pchRule, const char *pchValue ) = 0;
+
+ // The server failed to respond to the request for rule details
+ virtual void RulesFailedToRespond() = 0;
+
+ // The server has finished responding to the rule details request
+ // (ie, you won't get anymore RulesResponded callbacks)
+ virtual void RulesRefreshComplete() = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Typedef for handle type you will receive when querying details on an individual server.
+//-----------------------------------------------------------------------------
+typedef int HServerQuery;
+const int HSERVERQUERY_INVALID = 0xffffffff;
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for match making services for clients to get to game lists and details
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingServers
+{
+public:
+ // Request a new list of servers of a particular type. These calls each correspond to one of the EMatchMakingType values.
+ // Each call allocates a new asynchronous request object.
+ // Request object must be released by calling ReleaseRequest( hServerListRequest )
+ virtual HServerListRequest RequestInternetServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+ virtual HServerListRequest RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+ virtual HServerListRequest RequestFriendsServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+ virtual HServerListRequest RequestFavoritesServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+ virtual HServerListRequest RequestHistoryServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+ virtual HServerListRequest RequestSpectatorServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+
+ // Releases the asynchronous request object and cancels any pending query on it if there's a pending query in progress.
+ // RefreshComplete callback is not posted when request is released.
+ virtual void ReleaseRequest( HServerListRequest hServerListRequest ) = 0;
+
+ /* the filter operation codes that go in the key part of MatchMakingKeyValuePair_t should be one of these:
+
+ "map"
+ - Server passes the filter if the server is playing the specified map.
+ "gamedataand"
+ - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) contains all of the
+ specified strings. The value field is a comma-delimited list of strings to match.
+ "gamedataor"
+ - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) contains at least one of the
+ specified strings. The value field is a comma-delimited list of strings to match.
+ "gamedatanor"
+ - Server passes the filter if the server's game data (ISteamGameServer::SetGameData) does not contain any
+ of the specified strings. The value field is a comma-delimited list of strings to check.
+ "gametagsand"
+ - Server passes the filter if the server's game tags (ISteamGameServer::SetGameTags) contains all
+ of the specified strings. The value field is a comma-delimited list of strings to check.
+ "gametagsnor"
+ - Server passes the filter if the server's game tags (ISteamGameServer::SetGameTags) does not contain any
+ of the specified strings. The value field is a comma-delimited list of strings to check.
+ "and" (x1 && x2 && ... && xn)
+ "or" (x1 || x2 || ... || xn)
+ "nand" !(x1 && x2 && ... && xn)
+ "nor" !(x1 || x2 || ... || xn)
+ - Performs Boolean operation on the following filters. The operand to this filter specifies
+ the "size" of the Boolean inputs to the operation, in Key/value pairs. (The keyvalue
+ pairs must immediately follow, i.e. this is a prefix logical operator notation.)
+ In the simplest case where Boolean expressions are not nested, this is simply
+ the number of operands.
+
+ For example, to match servers on a particular map or with a particular tag, would would
+ use these filters.
+
+ ( server.map == "cp_dustbowl" || server.gametags.contains("payload") )
+ "or", "2"
+ "map", "cp_dustbowl"
+ "gametagsand", "payload"
+
+ If logical inputs are nested, then the operand specifies the size of the entire
+ "length" of its operands, not the number of immediate children.
+
+ ( server.map == "cp_dustbowl" || ( server.gametags.contains("payload") && !server.gametags.contains("payloadrace") ) )
+ "or", "4"
+ "map", "cp_dustbowl"
+ "and", "2"
+ "gametagsand", "payload"
+ "gametagsnor", "payloadrace"
+
+ Unary NOT can be achieved using either "nand" or "nor" with a single operand.
+
+ "addr"
+ - Server passes the filter if the server's query address matches the specified IP or IP:port.
+ "gameaddr"
+ - Server passes the filter if the server's game address matches the specified IP or IP:port.
+
+ The following filter operations ignore the "value" part of MatchMakingKeyValuePair_t
+
+ "dedicated"
+ - Server passes the filter if it passed true to SetDedicatedServer.
+ "secure"
+ - Server passes the filter if the server is VAC-enabled.
+ "notfull"
+ - Server passes the filter if the player count is less than the reported max player count.
+ "hasplayers"
+ - Server passes the filter if the player count is greater than zero.
+ "noplayers"
+ - Server passes the filter if it doesn't have any players.
+ "linux"
+ - Server passes the filter if it's a linux server
+ */
+
+ // Get details on a given server in the list, you can get the valid range of index
+ // values by calling GetServerCount(). You will also receive index values in
+ // ISteamMatchmakingServerListResponse::ServerResponded() callbacks
+ virtual gameserveritem_t *GetServerDetails( HServerListRequest hRequest, int iServer ) = 0;
+
+ // Cancel an request which is operation on the given list type. You should call this to cancel
+ // any in-progress requests before destructing a callback object that may have been passed
+ // to one of the above list request calls. Not doing so may result in a crash when a callback
+ // occurs on the destructed object.
+ // Canceling a query does not release the allocated request handle.
+ // The request handle must be released using ReleaseRequest( hRequest )
+ virtual void CancelQuery( HServerListRequest hRequest ) = 0;
+
+ // Ping every server in your list again but don't update the list of servers
+ // Query callback installed when the server list was requested will be used
+ // again to post notifications and RefreshComplete, so the callback must remain
+ // valid until another RefreshComplete is called on it or the request
+ // is released with ReleaseRequest( hRequest )
+ virtual void RefreshQuery( HServerListRequest hRequest ) = 0;
+
+ // Returns true if the list is currently refreshing its server list
+ virtual bool IsRefreshing( HServerListRequest hRequest ) = 0;
+
+ // How many servers in the given list, GetServerDetails above takes 0... GetServerCount() - 1
+ virtual int GetServerCount( HServerListRequest hRequest ) = 0;
+
+ // Refresh a single server inside of a query (rather than all the servers )
+ virtual void RefreshServer( HServerListRequest hRequest, int iServer ) = 0;
+
+
+ //-----------------------------------------------------------------------------
+ // Queries to individual servers directly via IP/Port
+ //-----------------------------------------------------------------------------
+
+ // Request updated ping time and other details from a single server
+ virtual HServerQuery PingServer( uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse ) = 0;
+
+ // Request the list of players currently playing on a server
+ virtual HServerQuery PlayerDetails( uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse ) = 0;
+
+ // Request the list of rules that the server is running (See ISteamGameServer::SetKeyValue() to set the rules server side)
+ virtual HServerQuery ServerRules( uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse ) = 0;
+
+ // Cancel an outstanding Ping/Players/Rules query from above. You should call this to cancel
+ // any in-progress requests before destructing a callback object that may have been passed
+ // to one of the above calls to avoid crashing when callbacks occur.
+ virtual void CancelServerQuery( HServerQuery hServerQuery ) = 0;
+};
+#define STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION "SteamMatchMakingServers002"
+
+// game server flags
+const uint32 k_unFavoriteFlagNone = 0x00;
+const uint32 k_unFavoriteFlagFavorite = 0x01; // this game favorite entry is for the favorites list
+const uint32 k_unFavoriteFlagHistory = 0x02; // this game favorite entry is for the history list
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Used in ChatInfo messages - fields specific to a chat member - must fit in a uint32
+//-----------------------------------------------------------------------------
+enum EChatMemberStateChange
+{
+ // Specific to joining / leaving the chatroom
+ k_EChatMemberStateChangeEntered = 0x0001, // This user has joined or is joining the chat room
+ k_EChatMemberStateChangeLeft = 0x0002, // This user has left or is leaving the chat room
+ k_EChatMemberStateChangeDisconnected = 0x0004, // User disconnected without leaving the chat first
+ k_EChatMemberStateChangeKicked = 0x0008, // User kicked
+ k_EChatMemberStateChangeBanned = 0x0010, // User kicked and banned
+};
+
+// returns true of the flags indicate that a user has been removed from the chat
+#define BChatMemberStateChangeRemoved( rgfChatMemberStateChangeFlags ) ( rgfChatMemberStateChangeFlags & ( k_EChatMemberStateChangeDisconnected | k_EChatMemberStateChangeLeft | k_EChatMemberStateChangeKicked | k_EChatMemberStateChangeBanned ) )
+
+
+//-----------------------------------------------------------------------------
+// Callbacks for ISteamMatchmaking (which go through the regular Steam callback registration system)
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: a server was added/removed from the favorites list, you should refresh now
+//-----------------------------------------------------------------------------
+struct FavoritesListChanged_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 2 };
+ uint32 m_nIP; // an IP of 0 means reload the whole list, any other value means just one server
+ uint32 m_nQueryPort;
+ uint32 m_nConnPort;
+ uint32 m_nAppID;
+ uint32 m_nFlags;
+ bool m_bAdd; // true if this is adding the entry, otherwise it is a remove
+ AccountID_t m_unAccountId;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Someone has invited you to join a Lobby
+// normally you don't need to do anything with this, since
+// the Steam UI will also display a ' has invited you to the lobby, join?' dialog
+//
+// if the user outside a game chooses to join, your game will be launched with the parameter "+connect_lobby <64-bit lobby id>",
+// or with the callback GameLobbyJoinRequested_t if they're already in-game
+//-----------------------------------------------------------------------------
+struct LobbyInvite_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 3 };
+
+ uint64 m_ulSteamIDUser; // Steam ID of the person making the invite
+ uint64 m_ulSteamIDLobby; // Steam ID of the Lobby
+ uint64 m_ulGameID; // GameID of the Lobby
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sent on entering a lobby, or on failing to enter
+// m_EChatRoomEnterResponse will be set to k_EChatRoomEnterResponseSuccess on success,
+// or a higher value on failure (see enum EChatRoomEnterResponse)
+//-----------------------------------------------------------------------------
+struct LobbyEnter_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 4 };
+
+ uint64 m_ulSteamIDLobby; // SteamID of the Lobby you have entered
+ uint32 m_rgfChatPermissions; // Permissions of the current user
+ bool m_bLocked; // If true, then only invited users may join
+ uint32 m_EChatRoomEnterResponse; // EChatRoomEnterResponse
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The lobby metadata has changed
+// if m_ulSteamIDMember is the steamID of a lobby member, use GetLobbyMemberData() to access per-user details
+// if m_ulSteamIDMember == m_ulSteamIDLobby, use GetLobbyData() to access lobby metadata
+//-----------------------------------------------------------------------------
+struct LobbyDataUpdate_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 5 };
+
+ uint64 m_ulSteamIDLobby; // steamID of the Lobby
+ uint64 m_ulSteamIDMember; // steamID of the member whose data changed, or the room itself
+ uint8 m_bSuccess; // true if we lobby data was successfully changed;
+ // will only be false if RequestLobbyData() was called on a lobby that no longer exists
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The lobby chat room state has changed
+// this is usually sent when a user has joined or left the lobby
+//-----------------------------------------------------------------------------
+struct LobbyChatUpdate_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 6 };
+
+ uint64 m_ulSteamIDLobby; // Lobby ID
+ uint64 m_ulSteamIDUserChanged; // user who's status in the lobby just changed - can be recipient
+ uint64 m_ulSteamIDMakingChange; // Chat member who made the change (different from SteamIDUserChange if kicking, muting, etc.)
+ // for example, if one user kicks another from the lobby, this will be set to the id of the user who initiated the kick
+ uint32 m_rgfChatMemberStateChange; // bitfield of EChatMemberStateChange values
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A chat message for this lobby has been sent
+// use GetLobbyChatEntry( m_iChatID ) to retrieve the contents of this message
+//-----------------------------------------------------------------------------
+struct LobbyChatMsg_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 7 };
+
+ uint64 m_ulSteamIDLobby; // the lobby id this is in
+ uint64 m_ulSteamIDUser; // steamID of the user who has sent this message
+ uint8 m_eChatEntryType; // type of message
+ uint32 m_iChatID; // index of the chat entry to lookup
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A game created a game for all the members of the lobby to join,
+// as triggered by a SetLobbyGameServer()
+// it's up to the individual clients to take action on this; the usual
+// game behavior is to leave the lobby and connect to the specified game server
+//-----------------------------------------------------------------------------
+struct LobbyGameCreated_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 9 };
+
+ uint64 m_ulSteamIDLobby; // the lobby we were in
+ uint64 m_ulSteamIDGameServer; // the new game server that has been created or found for the lobby members
+ uint32 m_unIP; // IP & Port of the game server (if any)
+ uint16 m_usPort;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Number of matching lobbies found
+// iterate the returned lobbies with GetLobbyByIndex(), from values 0 to m_nLobbiesMatching-1
+//-----------------------------------------------------------------------------
+struct LobbyMatchList_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 10 };
+ uint32 m_nLobbiesMatching; // Number of lobbies that matched search criteria and we have SteamIDs for
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: posted if a user is forcefully removed from a lobby
+// can occur if a user loses connection to Steam
+//-----------------------------------------------------------------------------
+struct LobbyKicked_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 12 };
+ uint64 m_ulSteamIDLobby; // Lobby
+ uint64 m_ulSteamIDAdmin; // User who kicked you - possibly the ID of the lobby itself
+ uint8 m_bKickedDueToDisconnect; // true if you were kicked from the lobby due to the user losing connection to Steam (currently always true)
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Result of our request to create a Lobby
+// m_eResult == k_EResultOK on success
+// at this point, the lobby has been joined and is ready for use
+// a LobbyEnter_t callback will also be received (since the local user is joining their own lobby)
+//-----------------------------------------------------------------------------
+struct LobbyCreated_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 13 };
+
+ EResult m_eResult; // k_EResultOK - the lobby was successfully created
+ // k_EResultNoConnection - your Steam client doesn't have a connection to the back-end
+ // k_EResultTimeout - you the message to the Steam servers, but it didn't respond
+ // k_EResultFail - the server responded, but with an unknown internal error
+ // k_EResultAccessDenied - your game isn't set to allow lobbies, or your client does haven't rights to play the game
+ // k_EResultLimitExceeded - your game client has created too many lobbies
+
+ uint64 m_ulSteamIDLobby; // chat room, zero if failed
+};
+
+// used by now obsolete RequestFriendsLobbiesResponse_t
+// enum { k_iCallback = k_iSteamMatchmakingCallbacks + 14 };
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Result of CheckForPSNGameBootInvite
+// m_eResult == k_EResultOK on success
+// at this point, the local user may not have finishing joining this lobby;
+// game code should wait until the subsequent LobbyEnter_t callback is received
+//-----------------------------------------------------------------------------
+struct PSNGameBootInviteResult_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 15 };
+
+ bool m_bGameBootInviteExists;
+ CSteamID m_steamIDLobby; // Should be valid if m_bGameBootInviteExists == true
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Result of our request to create a Lobby
+// m_eResult == k_EResultOK on success
+// at this point, the lobby has been joined and is ready for use
+// a LobbyEnter_t callback will also be received (since the local user is joining their own lobby)
+//-----------------------------------------------------------------------------
+struct FavoritesListAccountsUpdated_t
+{
+ enum { k_iCallback = k_iSteamMatchmakingCallbacks + 16 };
+
+ EResult m_eResult;
+};
+
+#pragma pack( pop )
+
+
+#endif // ISTEAMMATCHMAKING
diff --git a/lsteamclient/steamworks_sdk_130x/isteammusic.h b/lsteamclient/steamworks_sdk_130x/isteammusic.h
new file mode 100644
index 00000000..0d956bf6
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteammusic.h
@@ -0,0 +1,67 @@
+//============ Copyright (c) Valve Corporation, All rights reserved. ============
+
+#ifndef ISTEAMMUSIC_H
+#define ISTEAMMUSIC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+enum AudioPlayback_Status
+{
+ AudioPlayback_Undefined = 0,
+ AudioPlayback_Playing = 1,
+ AudioPlayback_Paused = 2,
+ AudioPlayback_Idle = 3
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions to control music playback in the steam client
+//-----------------------------------------------------------------------------
+class ISteamMusic
+{
+public:
+ virtual bool BIsEnabled() = 0;
+ virtual bool BIsPlaying() = 0;
+
+ virtual AudioPlayback_Status GetPlaybackStatus() = 0;
+
+ virtual void Play() = 0;
+ virtual void Pause() = 0;
+ virtual void PlayPrevious() = 0;
+ virtual void PlayNext() = 0;
+
+ // volume is between 0.0 and 1.0
+ virtual void SetVolume( float flVolume ) = 0;
+ virtual float GetVolume() = 0;
+
+};
+
+#define STEAMMUSIC_INTERFACE_VERSION "STEAMMUSIC_INTERFACE_VERSION001"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+
+DEFINE_CALLBACK( PlaybackStatusHasChanged_t, k_iSteamMusicCallbacks + 1 )
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( VolumeHasChanged_t, k_iSteamMusicCallbacks + 2 )
+ CALLBACK_MEMBER( 0, float, m_flNewVolume )
+END_DEFINE_CALLBACK_1()
+
+#pragma pack( pop )
+
+
+#endif // #define ISTEAMMUSIC_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteammusicremote.h b/lsteamclient/steamworks_sdk_130x/isteammusicremote.h
new file mode 100644
index 00000000..da838b2a
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteammusicremote.h
@@ -0,0 +1,126 @@
+//============ Copyright (c) Valve Corporation, All rights reserved. ============
+
+#ifndef ISTEAMMUSICREMOTE_H
+#define ISTEAMMUSICREMOTE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "isteammusic.h"
+
+#define k_SteamMusicNameMaxLength 255
+#define k_SteamMusicPNGMaxLength 65535
+
+
+class ISteamMusicRemote
+{
+public:
+ // Service Definition
+ virtual bool RegisterSteamMusicRemote( const char *pchName ) = 0;
+ virtual bool DeregisterSteamMusicRemote() = 0;
+ virtual bool BIsCurrentMusicRemote() = 0;
+ virtual bool BActivationSuccess( bool bValue ) = 0;
+
+ virtual bool SetDisplayName( const char *pchDisplayName ) = 0;
+ virtual bool SetPNGIcon_64x64( void *pvBuffer, uint32 cbBufferLength ) = 0;
+
+ // Abilities for the user interface
+ virtual bool EnablePlayPrevious(bool bValue) = 0;
+ virtual bool EnablePlayNext( bool bValue ) = 0;
+ virtual bool EnableShuffled( bool bValue ) = 0;
+ virtual bool EnableLooped( bool bValue ) = 0;
+ virtual bool EnableQueue( bool bValue ) = 0;
+ virtual bool EnablePlaylists( bool bValue ) = 0;
+
+ // Status
+ virtual bool UpdatePlaybackStatus( AudioPlayback_Status nStatus ) = 0;
+ virtual bool UpdateShuffled( bool bValue ) = 0;
+ virtual bool UpdateLooped( bool bValue ) = 0;
+ virtual bool UpdateVolume( float flValue ) = 0; // volume is between 0.0 and 1.0
+
+ // Current Entry
+ virtual bool CurrentEntryWillChange() = 0;
+ virtual bool CurrentEntryIsAvailable( bool bAvailable ) = 0;
+ virtual bool UpdateCurrentEntryText( const char *pchText ) = 0;
+ virtual bool UpdateCurrentEntryElapsedSeconds( int nValue ) = 0;
+ virtual bool UpdateCurrentEntryCoverArt( void *pvBuffer, uint32 cbBufferLength ) = 0;
+ virtual bool CurrentEntryDidChange() = 0;
+
+ // Queue
+ virtual bool QueueWillChange() = 0;
+ virtual bool ResetQueueEntries() = 0;
+ virtual bool SetQueueEntry( int nID, int nPosition, const char *pchEntryText ) = 0;
+ virtual bool SetCurrentQueueEntry( int nID ) = 0;
+ virtual bool QueueDidChange() = 0;
+
+ // Playlist
+ virtual bool PlaylistWillChange() = 0;
+ virtual bool ResetPlaylistEntries() = 0;
+ virtual bool SetPlaylistEntry( int nID, int nPosition, const char *pchEntryText ) = 0;
+ virtual bool SetCurrentPlaylistEntry( int nID ) = 0;
+ virtual bool PlaylistDidChange() = 0;
+};
+
+#define STEAMMUSICREMOTE_INTERFACE_VERSION "STEAMMUSICREMOTE_INTERFACE_VERSION001"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+
+DEFINE_CALLBACK( MusicPlayerRemoteWillActivate_t, k_iSteamMusicRemoteCallbacks + 1)
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( MusicPlayerRemoteWillDeactivate_t, k_iSteamMusicRemoteCallbacks + 2 )
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( MusicPlayerRemoteToFront_t, k_iSteamMusicRemoteCallbacks + 3 )
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( MusicPlayerWillQuit_t, k_iSteamMusicRemoteCallbacks + 4 )
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( MusicPlayerWantsPlay_t, k_iSteamMusicRemoteCallbacks + 5 )
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( MusicPlayerWantsPause_t, k_iSteamMusicRemoteCallbacks + 6 )
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( MusicPlayerWantsPlayPrevious_t, k_iSteamMusicRemoteCallbacks + 7 )
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( MusicPlayerWantsPlayNext_t, k_iSteamMusicRemoteCallbacks + 8 )
+END_DEFINE_CALLBACK_0()
+
+DEFINE_CALLBACK( MusicPlayerWantsShuffled_t, k_iSteamMusicRemoteCallbacks + 9 )
+ CALLBACK_MEMBER( 0, bool, m_bShuffled )
+END_DEFINE_CALLBACK_1()
+
+DEFINE_CALLBACK( MusicPlayerWantsLooped_t, k_iSteamMusicRemoteCallbacks + 10 )
+ CALLBACK_MEMBER(0, bool, m_bLooped )
+END_DEFINE_CALLBACK_1()
+
+DEFINE_CALLBACK( MusicPlayerWantsVolume_t, k_iSteamMusicCallbacks + 11 )
+ CALLBACK_MEMBER(0, float, m_flNewVolume)
+END_DEFINE_CALLBACK_1()
+
+DEFINE_CALLBACK( MusicPlayerSelectsQueueEntry_t, k_iSteamMusicCallbacks + 12 )
+ CALLBACK_MEMBER(0, int, nID )
+END_DEFINE_CALLBACK_1()
+
+DEFINE_CALLBACK( MusicPlayerSelectsPlaylistEntry_t, k_iSteamMusicCallbacks + 13 )
+ CALLBACK_MEMBER(0, int, nID )
+END_DEFINE_CALLBACK_1()
+
+
+#pragma pack( pop )
+
+
+
+#endif // #define ISTEAMMUSICREMOTE_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamnetworking.h b/lsteamclient/steamworks_sdk_130x/isteamnetworking.h
new file mode 100644
index 00000000..f733cc88
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamnetworking.h
@@ -0,0 +1,306 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam managing network connections between game clients & servers
+//
+//=============================================================================
+
+#ifndef ISTEAMNETWORKING
+#define ISTEAMNETWORKING
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steamtypes.h"
+#include "steamclientpublic.h"
+
+
+// list of possible errors returned by SendP2PPacket() API
+// these will be posted in the P2PSessionConnectFail_t callback
+enum EP2PSessionError
+{
+ k_EP2PSessionErrorNone = 0,
+ k_EP2PSessionErrorNotRunningApp = 1, // target is not running the same game
+ k_EP2PSessionErrorNoRightsToApp = 2, // local user doesn't own the app that is running
+ k_EP2PSessionErrorDestinationNotLoggedIn = 3, // target user isn't connected to Steam
+ k_EP2PSessionErrorTimeout = 4, // target isn't responding, perhaps not calling AcceptP2PSessionWithUser()
+ // corporate firewalls can also block this (NAT traversal is not firewall traversal)
+ // make sure that UDP ports 3478, 4379, and 4380 are open in an outbound direction
+ k_EP2PSessionErrorMax = 5
+};
+
+// SendP2PPacket() send types
+// Typically k_EP2PSendUnreliable is what you want for UDP-like packets, k_EP2PSendReliable for TCP-like packets
+enum EP2PSend
+{
+ // Basic UDP send. Packets can't be bigger than 1200 bytes (your typical MTU size). Can be lost, or arrive out of order (rare).
+ // The sending API does have some knowledge of the underlying connection, so if there is no NAT-traversal accomplished or
+ // there is a recognized adjustment happening on the connection, the packet will be batched until the connection is open again.
+ k_EP2PSendUnreliable = 0,
+
+ // As above, but if the underlying p2p connection isn't yet established the packet will just be thrown away. Using this on the first
+ // packet sent to a remote host almost guarantees the packet will be dropped.
+ // This is only really useful for kinds of data that should never buffer up, i.e. voice payload packets
+ k_EP2PSendUnreliableNoDelay = 1,
+
+ // Reliable message send. Can send up to 1MB of data in a single message.
+ // Does fragmentation/re-assembly of messages under the hood, as well as a sliding window for efficient sends of large chunks of data.
+ k_EP2PSendReliable = 2,
+
+ // As above, but applies the Nagle algorithm to the send - sends will accumulate
+ // until the current MTU size (typically ~1200 bytes, but can change) or ~200ms has passed (Nagle algorithm).
+ // Useful if you want to send a set of smaller messages but have the coalesced into a single packet
+ // Since the reliable stream is all ordered, you can do several small message sends with k_EP2PSendReliableWithBuffering and then
+ // do a normal k_EP2PSendReliable to force all the buffered data to be sent.
+ k_EP2PSendReliableWithBuffering = 3,
+
+};
+
+
+// connection state to a specified user, returned by GetP2PSessionState()
+// this is under-the-hood info about what's going on with a SendP2PPacket(), shouldn't be needed except for debuggin
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+struct P2PSessionState_t
+{
+ uint8 m_bConnectionActive; // true if we've got an active open connection
+ uint8 m_bConnecting; // true if we're currently trying to establish a connection
+ uint8 m_eP2PSessionError; // last error recorded (see enum above)
+ uint8 m_bUsingRelay; // true if it's going through a relay server (TURN)
+ int32 m_nBytesQueuedForSend;
+ int32 m_nPacketsQueuedForSend;
+ uint32 m_nRemoteIP; // potential IP:Port of remote host. Could be TURN server.
+ uint16 m_nRemotePort; // Only exists for compatibility with older authentication api's
+};
+#pragma pack( pop )
+
+
+// handle to a socket
+typedef uint32 SNetSocket_t; // CreateP2PConnectionSocket()
+typedef uint32 SNetListenSocket_t; // CreateListenSocket()
+
+// connection progress indicators, used by CreateP2PConnectionSocket()
+enum ESNetSocketState
+{
+ k_ESNetSocketStateInvalid = 0,
+
+ // communication is valid
+ k_ESNetSocketStateConnected = 1,
+
+ // states while establishing a connection
+ k_ESNetSocketStateInitiated = 10, // the connection state machine has started
+
+ // p2p connections
+ k_ESNetSocketStateLocalCandidatesFound = 11, // we've found our local IP info
+ k_ESNetSocketStateReceivedRemoteCandidates = 12,// we've received information from the remote machine, via the Steam back-end, about their IP info
+
+ // direct connections
+ k_ESNetSocketStateChallengeHandshake = 15, // we've received a challenge packet from the server
+
+ // failure states
+ k_ESNetSocketStateDisconnecting = 21, // the API shut it down, and we're in the process of telling the other end
+ k_ESNetSocketStateLocalDisconnect = 22, // the API shut it down, and we've completed shutdown
+ k_ESNetSocketStateTimeoutDuringConnect = 23, // we timed out while trying to creating the connection
+ k_ESNetSocketStateRemoteEndDisconnected = 24, // the remote end has disconnected from us
+ k_ESNetSocketStateConnectionBroken = 25, // connection has been broken; either the other end has disappeared or our local network connection has broke
+
+};
+
+// describes how the socket is currently connected
+enum ESNetSocketConnectionType
+{
+ k_ESNetSocketConnectionTypeNotConnected = 0,
+ k_ESNetSocketConnectionTypeUDP = 1,
+ k_ESNetSocketConnectionTypeUDPRelay = 2,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for making connections and sending data between clients,
+// traversing NAT's where possible
+//-----------------------------------------------------------------------------
+class ISteamNetworking
+{
+public:
+ ////////////////////////////////////////////////////////////////////////////////////////////
+ // Session-less connection functions
+ // automatically establishes NAT-traversing or Relay server connections
+
+ // Sends a P2P packet to the specified user
+ // UDP-like, unreliable and a max packet size of 1200 bytes
+ // the first packet send may be delayed as the NAT-traversal code runs
+ // if we can't get through to the user, an error will be posted via the callback P2PSessionConnectFail_t
+ // see EP2PSend enum above for the descriptions of the different ways of sending packets
+ //
+ // nChannel is a routing number you can use to help route message to different systems - you'll have to call ReadP2PPacket()
+ // with the same channel number in order to retrieve the data on the other end
+ // using different channels to talk to the same user will still use the same underlying p2p connection, saving on resources
+ virtual bool SendP2PPacket( CSteamID steamIDRemote, const void *pubData, uint32 cubData, EP2PSend eP2PSendType, int nChannel = 0 ) = 0;
+
+ // returns true if any data is available for read, and the amount of data that will need to be read
+ virtual bool IsP2PPacketAvailable( uint32 *pcubMsgSize, int nChannel = 0 ) = 0;
+
+ // reads in a packet that has been sent from another user via SendP2PPacket()
+ // returns the size of the message and the steamID of the user who sent it in the last two parameters
+ // if the buffer passed in is too small, the message will be truncated
+ // this call is not blocking, and will return false if no data is available
+ virtual bool ReadP2PPacket( void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, CSteamID *psteamIDRemote, int nChannel = 0 ) = 0;
+
+ // AcceptP2PSessionWithUser() should only be called in response to a P2PSessionRequest_t callback
+ // P2PSessionRequest_t will be posted if another user tries to send you a packet that you haven't talked to yet
+ // if you don't want to talk to the user, just ignore the request
+ // if the user continues to send you packets, another P2PSessionRequest_t will be posted periodically
+ // this may be called multiple times for a single user
+ // (if you've called SendP2PPacket() on the other user, this implicitly accepts the session request)
+ virtual bool AcceptP2PSessionWithUser( CSteamID steamIDRemote ) = 0;
+
+ // call CloseP2PSessionWithUser() when you're done talking to a user, will free up resources under-the-hood
+ // if the remote user tries to send data to you again, another P2PSessionRequest_t callback will be posted
+ virtual bool CloseP2PSessionWithUser( CSteamID steamIDRemote ) = 0;
+
+ // call CloseP2PChannelWithUser() when you're done talking to a user on a specific channel. Once all channels
+ // open channels to a user have been closed, the open session to the user will be closed and new data from this
+ // user will trigger a P2PSessionRequest_t callback
+ virtual bool CloseP2PChannelWithUser( CSteamID steamIDRemote, int nChannel ) = 0;
+
+ // fills out P2PSessionState_t structure with details about the underlying connection to the user
+ // should only needed for debugging purposes
+ // returns false if no connection exists to the specified user
+ virtual bool GetP2PSessionState( CSteamID steamIDRemote, P2PSessionState_t *pConnectionState ) = 0;
+
+ // Allow P2P connections to fall back to being relayed through the Steam servers if a direct connection
+ // or NAT-traversal cannot be established. Only applies to connections created after setting this value,
+ // or to existing connections that need to automatically reconnect after this value is set.
+ //
+ // P2P packet relay is allowed by default
+ virtual bool AllowP2PPacketRelay( bool bAllow ) = 0;
+
+
+ ////////////////////////////////////////////////////////////////////////////////////////////
+ // LISTEN / CONNECT style interface functions
+ //
+ // This is an older set of functions designed around the Berkeley TCP sockets model
+ // it's preferential that you use the above P2P functions, they're more robust
+ // and these older functions will be removed eventually
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ // creates a socket and listens others to connect
+ // will trigger a SocketStatusCallback_t callback on another client connecting
+ // nVirtualP2PPort is the unique ID that the client will connect to, in case you have multiple ports
+ // this can usually just be 0 unless you want multiple sets of connections
+ // unIP is the local IP address to bind to
+ // pass in 0 if you just want the default local IP
+ // unPort is the port to use
+ // pass in 0 if you don't want users to be able to connect via IP/Port, but expect to be always peer-to-peer connections only
+ virtual SNetListenSocket_t CreateListenSocket( int nVirtualP2PPort, uint32 nIP, uint16 nPort, bool bAllowUseOfPacketRelay ) = 0;
+
+ // creates a socket and begin connection to a remote destination
+ // can connect via a known steamID (client or game server), or directly to an IP
+ // on success will trigger a SocketStatusCallback_t callback
+ // on failure or timeout will trigger a SocketStatusCallback_t callback with a failure code in m_eSNetSocketState
+ virtual SNetSocket_t CreateP2PConnectionSocket( CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay ) = 0;
+ virtual SNetSocket_t CreateConnectionSocket( uint32 nIP, uint16 nPort, int nTimeoutSec ) = 0;
+
+ // disconnects the connection to the socket, if any, and invalidates the handle
+ // any unread data on the socket will be thrown away
+ // if bNotifyRemoteEnd is set, socket will not be completely destroyed until the remote end acknowledges the disconnect
+ virtual bool DestroySocket( SNetSocket_t hSocket, bool bNotifyRemoteEnd ) = 0;
+ // destroying a listen socket will automatically kill all the regular sockets generated from it
+ virtual bool DestroyListenSocket( SNetListenSocket_t hSocket, bool bNotifyRemoteEnd ) = 0;
+
+ // sending data
+ // must be a handle to a connected socket
+ // data is all sent via UDP, and thus send sizes are limited to 1200 bytes; after this, many routers will start dropping packets
+ // use the reliable flag with caution; although the resend rate is pretty aggressive,
+ // it can still cause stalls in receiving data (like TCP)
+ virtual bool SendDataOnSocket( SNetSocket_t hSocket, void *pubData, uint32 cubData, bool bReliable ) = 0;
+
+ // receiving data
+ // returns false if there is no data remaining
+ // fills out *pcubMsgSize with the size of the next message, in bytes
+ virtual bool IsDataAvailableOnSocket( SNetSocket_t hSocket, uint32 *pcubMsgSize ) = 0;
+
+ // fills in pubDest with the contents of the message
+ // messages are always complete, of the same size as was sent (i.e. packetized, not streaming)
+ // if *pcubMsgSize < cubDest, only partial data is written
+ // returns false if no data is available
+ virtual bool RetrieveDataFromSocket( SNetSocket_t hSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize ) = 0;
+
+ // checks for data from any socket that has been connected off this listen socket
+ // returns false if there is no data remaining
+ // fills out *pcubMsgSize with the size of the next message, in bytes
+ // fills out *phSocket with the socket that data is available on
+ virtual bool IsDataAvailable( SNetListenSocket_t hListenSocket, uint32 *pcubMsgSize, SNetSocket_t *phSocket ) = 0;
+
+ // retrieves data from any socket that has been connected off this listen socket
+ // fills in pubDest with the contents of the message
+ // messages are always complete, of the same size as was sent (i.e. packetized, not streaming)
+ // if *pcubMsgSize < cubDest, only partial data is written
+ // returns false if no data is available
+ // fills out *phSocket with the socket that data is available on
+ virtual bool RetrieveData( SNetListenSocket_t hListenSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, SNetSocket_t *phSocket ) = 0;
+
+ // returns information about the specified socket, filling out the contents of the pointers
+ virtual bool GetSocketInfo( SNetSocket_t hSocket, CSteamID *pSteamIDRemote, int *peSocketStatus, uint32 *punIPRemote, uint16 *punPortRemote ) = 0;
+
+ // returns which local port the listen socket is bound to
+ // *pnIP and *pnPort will be 0 if the socket is set to listen for P2P connections only
+ virtual bool GetListenSocketInfo( SNetListenSocket_t hListenSocket, uint32 *pnIP, uint16 *pnPort ) = 0;
+
+ // returns true to describe how the socket ended up connecting
+ virtual ESNetSocketConnectionType GetSocketConnectionType( SNetSocket_t hSocket ) = 0;
+
+ // max packet size, in bytes
+ virtual int GetMaxPacketSize( SNetSocket_t hSocket ) = 0;
+};
+#define STEAMNETWORKING_INTERFACE_VERSION "SteamNetworking005"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+// callback notification - a user wants to talk to us over the P2P channel via the SendP2PPacket() API
+// in response, a call to AcceptP2PPacketsFromUser() needs to be made, if you want to talk with them
+struct P2PSessionRequest_t
+{
+ enum { k_iCallback = k_iSteamNetworkingCallbacks + 2 };
+ CSteamID m_steamIDRemote; // user who wants to talk to us
+};
+
+
+// callback notification - packets can't get through to the specified user via the SendP2PPacket() API
+// all packets queued packets unsent at this point will be dropped
+// further attempts to send will retry making the connection (but will be dropped if we fail again)
+struct P2PSessionConnectFail_t
+{
+ enum { k_iCallback = k_iSteamNetworkingCallbacks + 3 };
+ CSteamID m_steamIDRemote; // user we were sending packets to
+ uint8 m_eP2PSessionError; // EP2PSessionError indicating why we're having trouble
+};
+
+
+// callback notification - status of a socket has changed
+// used as part of the CreateListenSocket() / CreateP2PConnectionSocket()
+struct SocketStatusCallback_t
+{
+ enum { k_iCallback = k_iSteamNetworkingCallbacks + 1 };
+ SNetSocket_t m_hSocket; // the socket used to send/receive data to the remote host
+ SNetListenSocket_t m_hListenSocket; // this is the server socket that we were listening on; NULL if this was an outgoing connection
+ CSteamID m_steamIDRemote; // remote steamID we have connected to, if it has one
+ int m_eSNetSocketState; // socket state, ESNetSocketState
+};
+
+#pragma pack( pop )
+
+#endif // ISTEAMNETWORKING
diff --git a/lsteamclient/steamworks_sdk_130x/isteamps3overlayrenderer.h b/lsteamclient/steamworks_sdk_130x/isteamps3overlayrenderer.h
new file mode 100644
index 00000000..2cbb757d
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamps3overlayrenderer.h
@@ -0,0 +1,91 @@
+//====== Copyright © 1996-2010, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface the game must provide Steam with on PS3 in order for the
+// Steam overlay to render.
+//
+//=============================================================================
+
+#ifndef ISTEAMPS3OVERLAYRENDERER_H
+#define ISTEAMPS3OVERLAYRENDERER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cell/pad.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Enum for supported gradient directions
+//-----------------------------------------------------------------------------
+enum EOverlayGradientDirection
+{
+ k_EOverlayGradientHorizontal = 1,
+ k_EOverlayGradientVertical = 2,
+ k_EOverlayGradientNone = 3,
+};
+
+// Helpers for fetching individual color components from ARGB packed DWORD colors Steam PS3 overlay renderer uses.
+#define STEAM_COLOR_RED( color ) \
+ (int)(((color)>>16)&0xff)
+
+#define STEAM_COLOR_GREEN( color ) \
+ (int)(((color)>>8)&0xff)
+
+#define STEAM_COLOR_BLUE( color ) \
+ (int)((color)&0xff)
+
+#define STEAM_COLOR_ALPHA( color ) \
+ (int)(((color)>>24)&0xff)
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Interface the game must expose to Steam for rendering
+//-----------------------------------------------------------------------------
+class ISteamPS3OverlayRenderHost
+{
+public:
+
+ // Interface for game engine to implement which Steam requires to render.
+
+ // Draw a textured rect. This may use only part of the texture and will pass texture coords, it will also possibly request a gradient and will specify colors for vertexes.
+ virtual void DrawTexturedRect( int x0, int y0, int x1, int y1, float u0, float v0, float u1, float v1, int32 iTextureID, DWORD colorStart, DWORD colorEnd, EOverlayGradientDirection eDirection ) = 0;
+
+ // Load a RGBA texture for Steam, or update a previously loaded one. Updates may be partial. You must not evict or remove this texture once Steam has uploaded it.
+ virtual void LoadOrUpdateTexture( int32 iTextureID, bool bIsFullTexture, int x0, int y0, uint32 uWidth, uint32 uHeight, int32 iBytes, char *pData ) = 0;
+
+ // Delete a texture Steam previously uploaded
+ virtual void DeleteTexture( int32 iTextureID ) = 0;
+
+ // Delete all previously uploaded textures
+ virtual void DeleteAllTextures() = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Interface Steam exposes for the game to tell it when to render, etc.
+//-----------------------------------------------------------------------------
+class ISteamPS3OverlayRender
+{
+public:
+
+ // Call once at startup to initialize the Steam overlay and pass it your host interface ptr
+ virtual bool BHostInitialize( uint32 unScreenWidth, uint32 unScreenHeight, uint32 unRefreshRate, ISteamPS3OverlayRenderHost *pRenderHost, void *CellFontLib ) = 0;
+
+ // Call this once a frame when you are ready for the Steam overlay to render (ie, right before flipping buffers, after all your rendering)
+ virtual void Render() = 0;
+
+ // Call this everytime you read input on PS3.
+ //
+ // If this returns true, then the overlay is active and has consumed the input, your game
+ // should then ignore all the input until BHandleCellPadData once again returns false, which
+ // will mean the overlay is deactivated.
+ virtual bool BHandleCellPadData( const CellPadData &padData ) = 0;
+
+ // Call this if you detect no controllers connected or that the XMB is intercepting input
+ //
+ // This is important to clear input state for the overlay, so keys left down during XMB activation
+ // are not continued to be processed.
+ virtual bool BResetInputState() = 0;
+};
+
+
+#endif // ISTEAMPS3OVERLAYRENDERER_H
\ No newline at end of file
diff --git a/lsteamclient/steamworks_sdk_130x/isteamremotestorage.h b/lsteamclient/steamworks_sdk_130x/isteamremotestorage.h
new file mode 100644
index 00000000..db34eee7
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamremotestorage.h
@@ -0,0 +1,648 @@
+//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: public interface to user remote file storage in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMREMOTESTORAGE_H
+#define ISTEAMREMOTESTORAGE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Defines the largest allowed file size. Cloud files cannot be written
+// in a single chunk over 100MB (and cannot be over 200MB total.)
+//-----------------------------------------------------------------------------
+const uint32 k_unMaxCloudFileChunkSize = 100 * 1024 * 1024;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Structure that contains an array of const char * strings and the number of those strings
+//-----------------------------------------------------------------------------
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+struct SteamParamStringArray_t
+{
+ const char ** m_ppStrings;
+ int32 m_nNumStrings;
+};
+#pragma pack( pop )
+
+// A handle to a piece of user generated content
+typedef uint64 UGCHandle_t;
+typedef uint64 PublishedFileUpdateHandle_t;
+typedef uint64 PublishedFileId_t;
+const PublishedFileId_t k_PublishedFileIdInvalid = 0;
+const UGCHandle_t k_UGCHandleInvalid = 0xffffffffffffffffull;
+const PublishedFileUpdateHandle_t k_PublishedFileUpdateHandleInvalid = 0xffffffffffffffffull;
+
+// Handle for writing to Steam Cloud
+typedef uint64 UGCFileWriteStreamHandle_t;
+const UGCFileWriteStreamHandle_t k_UGCFileStreamHandleInvalid = 0xffffffffffffffffull;
+
+const uint32 k_cchPublishedDocumentTitleMax = 128 + 1;
+const uint32 k_cchPublishedDocumentDescriptionMax = 8000;
+const uint32 k_cchPublishedDocumentChangeDescriptionMax = 8000;
+const uint32 k_unEnumeratePublishedFilesMaxResults = 50;
+const uint32 k_cchTagListMax = 1024 + 1;
+const uint32 k_cchFilenameMax = 260;
+const uint32 k_cchPublishedFileURLMax = 256;
+
+// Ways to handle a synchronization conflict
+enum EResolveConflict
+{
+ k_EResolveConflictKeepClient = 1, // The local version of each file will be used to overwrite the server version
+ k_EResolveConflictKeepServer = 2, // The server version of each file will be used to overwrite the local version
+};
+
+enum ERemoteStoragePlatform
+{
+ k_ERemoteStoragePlatformNone = 0,
+ k_ERemoteStoragePlatformWindows = (1 << 0),
+ k_ERemoteStoragePlatformOSX = (1 << 1),
+ k_ERemoteStoragePlatformPS3 = (1 << 2),
+ k_ERemoteStoragePlatformLinux = (1 << 3),
+ k_ERemoteStoragePlatformReserved2 = (1 << 4),
+
+ k_ERemoteStoragePlatformAll = 0xffffffff
+};
+
+enum ERemoteStoragePublishedFileVisibility
+{
+ k_ERemoteStoragePublishedFileVisibilityPublic = 0,
+ k_ERemoteStoragePublishedFileVisibilityFriendsOnly = 1,
+ k_ERemoteStoragePublishedFileVisibilityPrivate = 2,
+};
+
+
+enum EWorkshopFileType
+{
+ k_EWorkshopFileTypeFirst = 0,
+
+ k_EWorkshopFileTypeCommunity = 0,
+ k_EWorkshopFileTypeMicrotransaction = 1,
+ k_EWorkshopFileTypeCollection = 2,
+ k_EWorkshopFileTypeArt = 3,
+ k_EWorkshopFileTypeVideo = 4,
+ k_EWorkshopFileTypeScreenshot = 5,
+ k_EWorkshopFileTypeGame = 6,
+ k_EWorkshopFileTypeSoftware = 7,
+ k_EWorkshopFileTypeConcept = 8,
+ k_EWorkshopFileTypeWebGuide = 9,
+ k_EWorkshopFileTypeIntegratedGuide = 10,
+ k_EWorkshopFileTypeMerch = 11,
+ k_EWorkshopFileTypeControllerBinding = 12,
+ k_EWorkshopFileTypeSteamworksAccessInvite = 13,
+ k_EWorkshopFileTypeSteamVideo = 14,
+
+ // Update k_EWorkshopFileTypeMax if you add values.
+ k_EWorkshopFileTypeMax = 15
+
+};
+
+enum EWorkshopVote
+{
+ k_EWorkshopVoteUnvoted = 0,
+ k_EWorkshopVoteFor = 1,
+ k_EWorkshopVoteAgainst = 2,
+};
+
+enum EWorkshopFileAction
+{
+ k_EWorkshopFileActionPlayed = 0,
+ k_EWorkshopFileActionCompleted = 1,
+};
+
+enum EWorkshopEnumerationType
+{
+ k_EWorkshopEnumerationTypeRankedByVote = 0,
+ k_EWorkshopEnumerationTypeRecent = 1,
+ k_EWorkshopEnumerationTypeTrending = 2,
+ k_EWorkshopEnumerationTypeFavoritesOfFriends = 3,
+ k_EWorkshopEnumerationTypeVotedByFriends = 4,
+ k_EWorkshopEnumerationTypeContentByFriends = 5,
+ k_EWorkshopEnumerationTypeRecentFromFollowedUsers = 6,
+};
+
+enum EWorkshopVideoProvider
+{
+ k_EWorkshopVideoProviderNone = 0,
+ k_EWorkshopVideoProviderYoutube = 1
+};
+
+
+enum EUGCReadAction
+{
+ // Keeps the file handle open unless the last byte is read. You can use this when reading large files (over 100MB) in sequential chunks.
+ // If the last byte is read, this will behave the same as k_EUGCRead_Close. Otherwise, it behaves the same as k_EUGCRead_ContinueReading.
+ // This value maintains the same behavior as before the EUGCReadAction parameter was introduced.
+ k_EUGCRead_ContinueReadingUntilFinished = 0,
+
+ // Keeps the file handle open. Use this when using UGCRead to seek to different parts of the file.
+ // When you are done seeking around the file, make a final call with k_EUGCRead_Close to close it.
+ k_EUGCRead_ContinueReading = 1,
+
+ // Frees the file handle. Use this when you're done reading the content.
+ // To read the file from Steam again you will need to call UGCDownload again.
+ k_EUGCRead_Close = 2,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing, reading and writing files stored remotely
+// and cached locally
+//-----------------------------------------------------------------------------
+class ISteamRemoteStorage
+{
+ public:
+ // NOTE
+ //
+ // Filenames are case-insensitive, and will be converted to lowercase automatically.
+ // So "foo.bar" and "Foo.bar" are the same file, and if you write "Foo.bar" then
+ // iterate the files, the filename returned will be "foo.bar".
+ //
+
+ // file operations
+ virtual bool FileWrite( const char *pchFile, const void *pvData, int32 cubData ) = 0;
+ virtual int32 FileRead( const char *pchFile, void *pvData, int32 cubDataToRead ) = 0;
+ virtual bool FileForget( const char *pchFile ) = 0;
+ virtual bool FileDelete( const char *pchFile ) = 0;
+ virtual SteamAPICall_t FileShare( const char *pchFile ) = 0;
+ virtual bool SetSyncPlatforms( const char *pchFile, ERemoteStoragePlatform eRemoteStoragePlatform ) = 0;
+
+ // file operations that cause network IO
+ virtual UGCFileWriteStreamHandle_t FileWriteStreamOpen( const char *pchFile ) = 0;
+ virtual bool FileWriteStreamWriteChunk( UGCFileWriteStreamHandle_t writeHandle, const void *pvData, int32 cubData ) = 0;
+ virtual bool FileWriteStreamClose( UGCFileWriteStreamHandle_t writeHandle ) = 0;
+ virtual bool FileWriteStreamCancel( UGCFileWriteStreamHandle_t writeHandle ) = 0;
+
+ // file information
+ virtual bool FileExists( const char *pchFile ) = 0;
+ virtual bool FilePersisted( const char *pchFile ) = 0;
+ virtual int32 GetFileSize( const char *pchFile ) = 0;
+ virtual int64 GetFileTimestamp( const char *pchFile ) = 0;
+ virtual ERemoteStoragePlatform GetSyncPlatforms( const char *pchFile ) = 0;
+
+ // iteration
+ virtual int32 GetFileCount() = 0;
+ virtual const char *GetFileNameAndSize( int iFile, int32 *pnFileSizeInBytes ) = 0;
+
+ // configuration management
+ virtual bool GetQuota( int32 *pnTotalBytes, int32 *puAvailableBytes ) = 0;
+ virtual bool IsCloudEnabledForAccount() = 0;
+ virtual bool IsCloudEnabledForApp() = 0;
+ virtual void SetCloudEnabledForApp( bool bEnabled ) = 0;
+
+ // user generated content
+
+ // Downloads a UGC file. A priority value of 0 will download the file immediately,
+ // otherwise it will wait to download the file until all downloads with a lower priority
+ // value are completed. Downloads with equal priority will occur simultaneously.
+ virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent, uint32 unPriority ) = 0;
+
+ // Gets the amount of data downloaded so far for a piece of content. pnBytesExpected can be 0 if function returns false
+ // or if the transfer hasn't started yet, so be careful to check for that before dividing to get a percentage
+ virtual bool GetUGCDownloadProgress( UGCHandle_t hContent, int32 *pnBytesDownloaded, int32 *pnBytesExpected ) = 0;
+
+ // Gets metadata for a file after it has been downloaded. This is the same metadata given in the RemoteStorageDownloadUGCResult_t call result
+ virtual bool GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner ) = 0;
+
+ // After download, gets the content of the file.
+ // Small files can be read all at once by calling this function with an offset of 0 and cubDataToRead equal to the size of the file.
+ // Larger files can be read in chunks to reduce memory usage (since both sides of the IPC client and the game itself must allocate
+ // enough memory for each chunk). Once the last byte is read, the file is implicitly closed and further calls to UGCRead will fail
+ // unless UGCDownload is called again.
+ // For especially large files (anything over 100MB) it is a requirement that the file is read in chunks.
+ virtual int32 UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead, uint32 cOffset, EUGCReadAction eAction ) = 0;
+
+ // Functions to iterate through UGC that has finished downloading but has not yet been read via UGCRead()
+ virtual int32 GetCachedUGCCount() = 0;
+ virtual UGCHandle_t GetCachedUGCHandle( int32 iCachedContent ) = 0;
+
+ // The following functions are only necessary on the Playstation 3. On PC & Mac, the Steam client will handle these operations for you
+ // On Playstation 3, the game controls which files are stored in the cloud, via FilePersist, FileFetch, and FileForget.
+
+#if defined(_PS3) || defined(_SERVER)
+ // Connect to Steam and get a list of files in the Cloud - results in a RemoteStorageAppSyncStatusCheck_t callback
+ virtual void GetFileListFromServer() = 0;
+ // Indicate this file should be downloaded in the next sync
+ virtual bool FileFetch( const char *pchFile ) = 0;
+ // Indicate this file should be persisted in the next sync
+ virtual bool FilePersist( const char *pchFile ) = 0;
+ // Pull any requested files down from the Cloud - results in a RemoteStorageAppSyncedClient_t callback
+ virtual bool SynchronizeToClient() = 0;
+ // Upload any requested files to the Cloud - results in a RemoteStorageAppSyncedServer_t callback
+ virtual bool SynchronizeToServer() = 0;
+ // Reset any fetch/persist/etc requests
+ virtual bool ResetFileRequestState() = 0;
+#endif
+
+ // publishing UGC
+ virtual SteamAPICall_t PublishWorkshopFile( const char *pchFile, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags, EWorkshopFileType eWorkshopFileType ) = 0;
+ virtual PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest( PublishedFileId_t unPublishedFileId ) = 0;
+ virtual bool UpdatePublishedFileFile( PublishedFileUpdateHandle_t updateHandle, const char *pchFile ) = 0;
+ virtual bool UpdatePublishedFilePreviewFile( PublishedFileUpdateHandle_t updateHandle, const char *pchPreviewFile ) = 0;
+ virtual bool UpdatePublishedFileTitle( PublishedFileUpdateHandle_t updateHandle, const char *pchTitle ) = 0;
+ virtual bool UpdatePublishedFileDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchDescription ) = 0;
+ virtual bool UpdatePublishedFileVisibility( PublishedFileUpdateHandle_t updateHandle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0;
+ virtual bool UpdatePublishedFileTags( PublishedFileUpdateHandle_t updateHandle, SteamParamStringArray_t *pTags ) = 0;
+ virtual SteamAPICall_t CommitPublishedFileUpdate( PublishedFileUpdateHandle_t updateHandle ) = 0;
+ // Gets published file details for the given publishedfileid. If unMaxSecondsOld is greater than 0,
+ // cached data may be returned, depending on how long ago it was cached. A value of 0 will force a refresh.
+ // A value of k_WorkshopForceLoadPublishedFileDetailsFromCache will use cached data if it exists, no matter how old it is.
+ virtual SteamAPICall_t GetPublishedFileDetails( PublishedFileId_t unPublishedFileId, uint32 unMaxSecondsOld ) = 0;
+ virtual SteamAPICall_t DeletePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+ // enumerate the files that the current user published with this app
+ virtual SteamAPICall_t EnumerateUserPublishedFiles( uint32 unStartIndex ) = 0;
+ virtual SteamAPICall_t SubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+ virtual SteamAPICall_t EnumerateUserSubscribedFiles( uint32 unStartIndex ) = 0;
+ virtual SteamAPICall_t UnsubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+ virtual bool UpdatePublishedFileSetChangeDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchChangeDescription ) = 0;
+ virtual SteamAPICall_t GetPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId ) = 0;
+ virtual SteamAPICall_t UpdateUserPublishedItemVote( PublishedFileId_t unPublishedFileId, bool bVoteUp ) = 0;
+ virtual SteamAPICall_t GetUserPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId ) = 0;
+ virtual SteamAPICall_t EnumerateUserSharedWorkshopFiles( CSteamID steamId, uint32 unStartIndex, SteamParamStringArray_t *pRequiredTags, SteamParamStringArray_t *pExcludedTags ) = 0;
+ virtual SteamAPICall_t PublishVideo( EWorkshopVideoProvider eVideoProvider, const char *pchVideoAccount, const char *pchVideoIdentifier, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags ) = 0;
+ virtual SteamAPICall_t SetUserPublishedFileAction( PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction ) = 0;
+ virtual SteamAPICall_t EnumeratePublishedFilesByUserAction( EWorkshopFileAction eAction, uint32 unStartIndex ) = 0;
+ // this method enumerates the public view of workshop files
+ virtual SteamAPICall_t EnumeratePublishedWorkshopFiles( EWorkshopEnumerationType eEnumerationType, uint32 unStartIndex, uint32 unCount, uint32 unDays, SteamParamStringArray_t *pTags, SteamParamStringArray_t *pUserTags ) = 0;
+
+ virtual SteamAPICall_t UGCDownloadToLocation( UGCHandle_t hContent, const char *pchLocation, uint32 unPriority ) = 0;
+};
+
+#define STEAMREMOTESTORAGE_INTERFACE_VERSION "STEAMREMOTESTORAGE_INTERFACE_VERSION012"
+
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: sent when the local file cache is fully synced with the server for an app
+// That means that an application can be started and has all latest files
+//-----------------------------------------------------------------------------
+struct RemoteStorageAppSyncedClient_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 1 };
+ AppId_t m_nAppID;
+ EResult m_eResult;
+ int m_unNumDownloads;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: sent when the server is fully synced with the local file cache for an app
+// That means that we can shutdown Steam and our data is stored on the server
+//-----------------------------------------------------------------------------
+struct RemoteStorageAppSyncedServer_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 2 };
+ AppId_t m_nAppID;
+ EResult m_eResult;
+ int m_unNumUploads;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Status of up and downloads during a sync session
+//
+//-----------------------------------------------------------------------------
+struct RemoteStorageAppSyncProgress_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 3 };
+ char m_rgchCurrentFile[k_cchFilenameMax]; // Current file being transferred
+ AppId_t m_nAppID; // App this info relates to
+ uint32 m_uBytesTransferredThisChunk; // Bytes transferred this chunk
+ double m_dAppPercentComplete; // Percent complete that this app's transfers are
+ bool m_bUploading; // if false, downloading
+};
+
+//
+// IMPORTANT! k_iClientRemoteStorageCallbacks + 4 is used, see iclientremotestorage.h
+//
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sent after we've determined the list of files that are out of sync
+// with the server.
+//-----------------------------------------------------------------------------
+struct RemoteStorageAppSyncStatusCheck_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 5 };
+ AppId_t m_nAppID;
+ EResult m_eResult;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Sent after a conflict resolution attempt.
+//-----------------------------------------------------------------------------
+struct RemoteStorageConflictResolution_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 6 };
+ AppId_t m_nAppID;
+ EResult m_eResult;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to FileShare()
+//-----------------------------------------------------------------------------
+struct RemoteStorageFileShareResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 7 };
+ EResult m_eResult; // The result of the operation
+ UGCHandle_t m_hFile; // The handle that can be shared with users and features
+ char m_rgchFilename[k_cchFilenameMax]; // The name of the file that was shared
+};
+
+
+// k_iClientRemoteStorageCallbacks + 8 is deprecated! Do not reuse
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to PublishFile()
+//-----------------------------------------------------------------------------
+struct RemoteStoragePublishFileResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 9 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId;
+ bool m_bUserNeedsToAcceptWorkshopLegalAgreement;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to DeletePublishedFile()
+//-----------------------------------------------------------------------------
+struct RemoteStorageDeletePublishedFileResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 11 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to EnumerateUserPublishedFiles()
+//-----------------------------------------------------------------------------
+struct RemoteStorageEnumerateUserPublishedFilesResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 12 };
+ EResult m_eResult; // The result of the operation.
+ int32 m_nResultsReturned;
+ int32 m_nTotalResultCount;
+ PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ];
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to SubscribePublishedFile()
+//-----------------------------------------------------------------------------
+struct RemoteStorageSubscribePublishedFileResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 13 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to EnumerateSubscribePublishedFiles()
+//-----------------------------------------------------------------------------
+struct RemoteStorageEnumerateUserSubscribedFilesResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 14 };
+ EResult m_eResult; // The result of the operation.
+ int32 m_nResultsReturned;
+ int32 m_nTotalResultCount;
+ PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ];
+ uint32 m_rgRTimeSubscribed[ k_unEnumeratePublishedFilesMaxResults ];
+};
+
+#if defined(VALVE_CALLBACK_PACK_SMALL)
+ VALVE_COMPILE_TIME_ASSERT( sizeof( RemoteStorageEnumerateUserSubscribedFilesResult_t ) == (1 + 1 + 1 + 50 + 100) * 4 );
+#elif defined(VALVE_CALLBACK_PACK_LARGE)
+ VALVE_COMPILE_TIME_ASSERT( sizeof( RemoteStorageEnumerateUserSubscribedFilesResult_t ) == (1 + 1 + 1 + 50 + 100) * 4 + 4 );
+#else
+#warning You must first include isteamclient.h
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to UnsubscribePublishedFile()
+//-----------------------------------------------------------------------------
+struct RemoteStorageUnsubscribePublishedFileResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 15 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to CommitPublishedFileUpdate()
+//-----------------------------------------------------------------------------
+struct RemoteStorageUpdatePublishedFileResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 16 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId;
+ bool m_bUserNeedsToAcceptWorkshopLegalAgreement;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to UGCDownload()
+//-----------------------------------------------------------------------------
+struct RemoteStorageDownloadUGCResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 17 };
+ EResult m_eResult; // The result of the operation.
+ UGCHandle_t m_hFile; // The handle to the file that was attempted to be downloaded.
+ AppId_t m_nAppID; // ID of the app that created this file.
+ int32 m_nSizeInBytes; // The size of the file that was downloaded, in bytes.
+ char m_pchFileName[k_cchFilenameMax]; // The name of the file that was downloaded.
+ uint64 m_ulSteamIDOwner; // Steam ID of the user who created this content.
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to GetPublishedFileDetails()
+//-----------------------------------------------------------------------------
+struct RemoteStorageGetPublishedFileDetailsResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 18 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId;
+ AppId_t m_nCreatorAppID; // ID of the app that created this file.
+ AppId_t m_nConsumerAppID; // ID of the app that will consume this file.
+ char m_rgchTitle[k_cchPublishedDocumentTitleMax]; // title of document
+ char m_rgchDescription[k_cchPublishedDocumentDescriptionMax]; // description of document
+ UGCHandle_t m_hFile; // The handle of the primary file
+ UGCHandle_t m_hPreviewFile; // The handle of the preview file
+ uint64 m_ulSteamIDOwner; // Steam ID of the user who created this content.
+ uint32 m_rtimeCreated; // time when the published file was created
+ uint32 m_rtimeUpdated; // time when the published file was last updated
+ ERemoteStoragePublishedFileVisibility m_eVisibility;
+ bool m_bBanned;
+ char m_rgchTags[k_cchTagListMax]; // comma separated list of all tags associated with this file
+ bool m_bTagsTruncated; // whether the list of tags was too long to be returned in the provided buffer
+ char m_pchFileName[k_cchFilenameMax]; // The name of the primary file
+ int32 m_nFileSize; // Size of the primary file
+ int32 m_nPreviewFileSize; // Size of the preview file
+ char m_rgchURL[k_cchPublishedFileURLMax]; // URL (for a video or a website)
+ EWorkshopFileType m_eFileType; // Type of the file
+ bool m_bAcceptedForUse; // developer has specifically flagged this item as accepted in the Workshop
+};
+
+
+struct RemoteStorageEnumerateWorkshopFilesResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 19 };
+ EResult m_eResult;
+ int32 m_nResultsReturned;
+ int32 m_nTotalResultCount;
+ PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ];
+ float m_rgScore[ k_unEnumeratePublishedFilesMaxResults ];
+ AppId_t m_nAppId;
+ uint32 m_unStartIndex;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of GetPublishedItemVoteDetails
+//-----------------------------------------------------------------------------
+struct RemoteStorageGetPublishedItemVoteDetailsResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 20 };
+ EResult m_eResult;
+ PublishedFileId_t m_unPublishedFileId;
+ int32 m_nVotesFor;
+ int32 m_nVotesAgainst;
+ int32 m_nReports;
+ float m_fScore;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: User subscribed to a file for the app (from within the app or on the web)
+//-----------------------------------------------------------------------------
+struct RemoteStoragePublishedFileSubscribed_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 21 };
+ PublishedFileId_t m_nPublishedFileId; // The published file id
+ AppId_t m_nAppID; // ID of the app that will consume this file.
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: User unsubscribed from a file for the app (from within the app or on the web)
+//-----------------------------------------------------------------------------
+struct RemoteStoragePublishedFileUnsubscribed_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 22 };
+ PublishedFileId_t m_nPublishedFileId; // The published file id
+ AppId_t m_nAppID; // ID of the app that will consume this file.
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Published file that a user owns was deleted (from within the app or the web)
+//-----------------------------------------------------------------------------
+struct RemoteStoragePublishedFileDeleted_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 23 };
+ PublishedFileId_t m_nPublishedFileId; // The published file id
+ AppId_t m_nAppID; // ID of the app that will consume this file.
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to UpdateUserPublishedItemVote()
+//-----------------------------------------------------------------------------
+struct RemoteStorageUpdateUserPublishedItemVoteResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 24 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId; // The published file id
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to GetUserPublishedItemVoteDetails()
+//-----------------------------------------------------------------------------
+struct RemoteStorageUserVoteDetails_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 25 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId; // The published file id
+ EWorkshopVote m_eVote; // what the user voted
+};
+
+struct RemoteStorageEnumerateUserSharedWorkshopFilesResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 26 };
+ EResult m_eResult; // The result of the operation.
+ int32 m_nResultsReturned;
+ int32 m_nTotalResultCount;
+ PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ];
+};
+
+struct RemoteStorageSetUserPublishedFileActionResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 27 };
+ EResult m_eResult; // The result of the operation.
+ PublishedFileId_t m_nPublishedFileId; // The published file id
+ EWorkshopFileAction m_eAction; // the action that was attempted
+};
+
+struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 28 };
+ EResult m_eResult; // The result of the operation.
+ EWorkshopFileAction m_eAction; // the action that was filtered on
+ int32 m_nResultsReturned;
+ int32 m_nTotalResultCount;
+ PublishedFileId_t m_rgPublishedFileId[ k_unEnumeratePublishedFilesMaxResults ];
+ uint32 m_rgRTimeUpdated[ k_unEnumeratePublishedFilesMaxResults ];
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called periodically while a PublishWorkshopFile is in progress
+//-----------------------------------------------------------------------------
+struct RemoteStoragePublishFileProgress_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 29 };
+ double m_dPercentFile;
+ bool m_bPreview;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when the content for a published file is updated
+//-----------------------------------------------------------------------------
+struct RemoteStoragePublishedFileUpdated_t
+{
+ enum { k_iCallback = k_iClientRemoteStorageCallbacks + 30 };
+ PublishedFileId_t m_nPublishedFileId; // The published file id
+ AppId_t m_nAppID; // ID of the app that will consume this file.
+ UGCHandle_t m_hFile; // The new content
+};
+
+
+
+#pragma pack( pop )
+
+
+#endif // ISTEAMREMOTESTORAGE_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamscreenshots.h b/lsteamclient/steamworks_sdk_130x/isteamscreenshots.h
new file mode 100644
index 00000000..ce8fb06e
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamscreenshots.h
@@ -0,0 +1,96 @@
+//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: public interface to user remote file storage in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMSCREENSHOTS_H
+#define ISTEAMSCREENSHOTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+const uint32 k_nScreenshotMaxTaggedUsers = 32;
+const uint32 k_nScreenshotMaxTaggedPublishedFiles = 32;
+const int k_cubUFSTagTypeMax = 255;
+const int k_cubUFSTagValueMax = 255;
+
+// Required with of a thumbnail provided to AddScreenshotToLibrary. If you do not provide a thumbnail
+// one will be generated.
+const int k_ScreenshotThumbWidth = 200;
+
+// Handle is valid for the lifetime of your process and no longer
+typedef uint32 ScreenshotHandle;
+#define INVALID_SCREENSHOT_HANDLE 0
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for adding screenshots to the user's screenshot library
+//-----------------------------------------------------------------------------
+class ISteamScreenshots
+{
+public:
+ // Writes a screenshot to the user's screenshot library given the raw image data, which must be in RGB format.
+ // The return value is a handle that is valid for the duration of the game process and can be used to apply tags.
+ virtual ScreenshotHandle WriteScreenshot( void *pubRGB, uint32 cubRGB, int nWidth, int nHeight ) = 0;
+
+ // Adds a screenshot to the user's screenshot library from disk. If a thumbnail is provided, it must be 200 pixels wide and the same aspect ratio
+ // as the screenshot, otherwise a thumbnail will be generated if the user uploads the screenshot. The screenshots must be in either JPEG or TGA format.
+ // The return value is a handle that is valid for the duration of the game process and can be used to apply tags.
+ // JPEG, TGA, and PNG formats are supported.
+ virtual ScreenshotHandle AddScreenshotToLibrary( const char *pchFilename, const char *pchThumbnailFilename, int nWidth, int nHeight ) = 0;
+
+ // Causes the Steam overlay to take a screenshot. If screenshots are being hooked by the game then a ScreenshotRequested_t callback is sent back to the game instead.
+ virtual void TriggerScreenshot() = 0;
+
+ // Toggles whether the overlay handles screenshots when the user presses the screenshot hotkey, or the game handles them. If the game is hooking screenshots,
+ // then the ScreenshotRequested_t callback will be sent if the user presses the hotkey, and the game is expected to call WriteScreenshot or AddScreenshotToLibrary
+ // in response.
+ virtual void HookScreenshots( bool bHook ) = 0;
+
+ // Sets metadata about a screenshot's location (for example, the name of the map)
+ virtual bool SetLocation( ScreenshotHandle hScreenshot, const char *pchLocation ) = 0;
+
+ // Tags a user as being visible in the screenshot
+ virtual bool TagUser( ScreenshotHandle hScreenshot, CSteamID steamID ) = 0;
+
+ // Tags a published file as being visible in the screenshot
+ virtual bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID ) = 0;
+};
+
+#define STEAMSCREENSHOTS_INTERFACE_VERSION "STEAMSCREENSHOTS_INTERFACE_VERSION002"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+//-----------------------------------------------------------------------------
+// Purpose: Screenshot successfully written or otherwise added to the library
+// and can now be tagged
+//-----------------------------------------------------------------------------
+struct ScreenshotReady_t
+{
+ enum { k_iCallback = k_iSteamScreenshotsCallbacks + 1 };
+ ScreenshotHandle m_hLocal;
+ EResult m_eResult;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Screenshot has been requested by the user. Only sent if
+// HookScreenshots() has been called, in which case Steam will not take
+// the screenshot itself.
+//-----------------------------------------------------------------------------
+struct ScreenshotRequested_t
+{
+ enum { k_iCallback = k_iSteamScreenshotsCallbacks + 2 };
+};
+
+#pragma pack( pop )
+
+
+#endif // ISTEAMSCREENSHOTS_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamugc.h b/lsteamclient/steamworks_sdk_130x/isteamugc.h
new file mode 100644
index 00000000..e89f0940
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamugc.h
@@ -0,0 +1,270 @@
+//====== Copyright 1996-2013, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam ugc
+//
+//=============================================================================
+
+#ifndef ISTEAMUGC_H
+#define ISTEAMUGC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+
+typedef uint64 UGCQueryHandle_t;
+typedef uint64 UGCUpdateHandle_t;
+
+
+const UGCQueryHandle_t k_UGCQueryHandleInvalid = 0xffffffffffffffffull;
+const UGCUpdateHandle_t k_UGCUpdateHandleInvalid = 0xffffffffffffffffull;
+
+
+// Matching UGC types for queries
+enum EUGCMatchingUGCType
+{
+ k_EUGCMatchingUGCType_Items = 0, // both mtx items and ready-to-use items
+ k_EUGCMatchingUGCType_Items_Mtx = 1,
+ k_EUGCMatchingUGCType_Items_ReadyToUse = 2,
+ k_EUGCMatchingUGCType_Collections = 3,
+ k_EUGCMatchingUGCType_Artwork = 4,
+ k_EUGCMatchingUGCType_Videos = 5,
+ k_EUGCMatchingUGCType_Screenshots = 6,
+ k_EUGCMatchingUGCType_AllGuides = 7, // both web guides and integrated guides
+ k_EUGCMatchingUGCType_WebGuides = 8,
+ k_EUGCMatchingUGCType_IntegratedGuides = 9,
+ k_EUGCMatchingUGCType_UsableInGame = 10, // ready-to-use items and integrated guides
+ k_EUGCMatchingUGCType_ControllerBindings = 11,
+};
+
+// Different lists of published UGC for a user.
+// If the current logged in user is different than the specified user, then some options may not be allowed.
+enum EUserUGCList
+{
+ k_EUserUGCList_Published,
+ k_EUserUGCList_VotedOn,
+ k_EUserUGCList_VotedUp,
+ k_EUserUGCList_VotedDown,
+ k_EUserUGCList_WillVoteLater,
+ k_EUserUGCList_Favorited,
+ k_EUserUGCList_Subscribed,
+ k_EUserUGCList_UsedOrPlayed,
+ k_EUserUGCList_Followed,
+};
+
+// Sort order for user published UGC lists (defaults to creation order descending)
+enum EUserUGCListSortOrder
+{
+ k_EUserUGCListSortOrder_CreationOrderDesc,
+ k_EUserUGCListSortOrder_CreationOrderAsc,
+ k_EUserUGCListSortOrder_TitleAsc,
+ k_EUserUGCListSortOrder_LastUpdatedDesc,
+ k_EUserUGCListSortOrder_SubscriptionDateDesc,
+ k_EUserUGCListSortOrder_VoteScoreDesc,
+ k_EUserUGCListSortOrder_ForModeration,
+};
+
+// Combination of sorting and filtering for queries across all UGC
+enum EUGCQuery
+{
+ k_EUGCQuery_RankedByVote = 0,
+ k_EUGCQuery_RankedByPublicationDate = 1,
+ k_EUGCQuery_AcceptedForGameRankedByAcceptanceDate = 2,
+ k_EUGCQuery_RankedByTrend = 3,
+ k_EUGCQuery_FavoritedByFriendsRankedByPublicationDate = 4,
+ k_EUGCQuery_CreatedByFriendsRankedByPublicationDate = 5,
+ k_EUGCQuery_RankedByNumTimesReported = 6,
+ k_EUGCQuery_CreatedByFollowedUsersRankedByPublicationDate = 7,
+ k_EUGCQuery_NotYetRated = 8,
+ k_EUGCQuery_RankedByTotalVotesAsc = 9,
+ k_EUGCQuery_RankedByVotesUp = 10,
+ k_EUGCQuery_RankedByTextSearch = 11,
+};
+
+enum EItemUpdateStatus
+{
+ k_EItemUpdateStatusInvalid = 0, // The item update handle was invalid, job might be finished, listen too SubmitItemUpdateResult_t
+ k_EItemUpdateStatusPreparingConfig = 1, // The item update is processing configuration data
+ k_EItemUpdateStatusPreparingContent = 2, // The item update is reading and processing content files
+ k_EItemUpdateStatusUploadingContent = 3, // The item update is uploading content changes to Steam
+ k_EItemUpdateStatusUploadingPreviewFile = 4, // The item update is uploading new preview file image
+ k_EItemUpdateStatusCommittingChanges = 5 // The item update is committing all changes
+};
+
+
+const uint32 kNumUGCResultsPerPage = 50;
+
+// Details for a single published file/UGC
+struct SteamUGCDetails_t
+{
+ PublishedFileId_t m_nPublishedFileId;
+ EResult m_eResult; // The result of the operation.
+ EWorkshopFileType m_eFileType; // Type of the file
+ AppId_t m_nCreatorAppID; // ID of the app that created this file.
+ AppId_t m_nConsumerAppID; // ID of the app that will consume this file.
+ char m_rgchTitle[k_cchPublishedDocumentTitleMax]; // title of document
+ char m_rgchDescription[k_cchPublishedDocumentDescriptionMax]; // description of document
+ uint64 m_ulSteamIDOwner; // Steam ID of the user who created this content.
+ uint32 m_rtimeCreated; // time when the published file was created
+ uint32 m_rtimeUpdated; // time when the published file was last updated
+ uint32 m_rtimeAddedToUserList; // time when the user added the published file to their list (not always applicable)
+ ERemoteStoragePublishedFileVisibility m_eVisibility; // visibility
+ bool m_bBanned; // whether the file was banned
+ bool m_bAcceptedForUse; // developer has specifically flagged this item as accepted in the Workshop
+ bool m_bTagsTruncated; // whether the list of tags was too long to be returned in the provided buffer
+ char m_rgchTags[k_cchTagListMax]; // comma separated list of all tags associated with this file
+ // file/url information
+ UGCHandle_t m_hFile; // The handle of the primary file
+ UGCHandle_t m_hPreviewFile; // The handle of the preview file
+ char m_pchFileName[k_cchFilenameMax]; // The cloud filename of the primary file
+ int32 m_nFileSize; // Size of the primary file
+ int32 m_nPreviewFileSize; // Size of the preview file
+ char m_rgchURL[k_cchPublishedFileURLMax]; // URL (for a video or a website)
+ // voting information
+ uint32 m_unVotesUp; // number of votes up
+ uint32 m_unVotesDown; // number of votes down
+ float m_flScore; // calculated score
+ uint32 m_unNumChildren; // if m_eFileType == k_EWorkshopFileTypeCollection, then this number will be the number of children contained within the collection
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Steam UGC support API
+//-----------------------------------------------------------------------------
+class ISteamUGC
+{
+public:
+
+ // Query UGC associated with a user. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
+ virtual UGCQueryHandle_t CreateQueryUserUGCRequest( AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
+
+ // Query for all matching UGC. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
+ virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
+
+ // Send the query to Steam
+ virtual SteamAPICall_t SendQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
+
+ // Retrieve an individual result after receiving the callback for querying UGC
+ virtual bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails ) = 0;
+
+ // Release the request to free up memory, after retrieving results
+ virtual bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
+
+ // Options to set for querying UGC
+ virtual bool AddRequiredTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+ virtual bool AddExcludedTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+ virtual bool SetReturnLongDescription( UGCQueryHandle_t handle, bool bReturnLongDescription ) = 0;
+ virtual bool SetReturnTotalOnly( UGCQueryHandle_t handle, bool bReturnTotalOnly ) = 0;
+ virtual bool SetAllowCachedResponse( UGCQueryHandle_t handle, uint32 unMaxAgeSeconds ) = 0;
+
+ // Options only for querying user UGC
+ virtual bool SetCloudFileNameFilter( UGCQueryHandle_t handle, const char *pMatchCloudFileName ) = 0;
+
+ // Options only for querying all UGC
+ virtual bool SetMatchAnyTag( UGCQueryHandle_t handle, bool bMatchAnyTag ) = 0;
+ virtual bool SetSearchText( UGCQueryHandle_t handle, const char *pSearchText ) = 0;
+ virtual bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint32 unDays ) = 0;
+
+ // Request full details for one piece of UGC
+ virtual SteamAPICall_t RequestUGCDetails( PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds ) = 0;
+
+ // Steam Workshop Creator API
+ virtual SteamAPICall_t CreateItem( AppId_t nConsumerAppId, EWorkshopFileType eFileType ) = 0; // create new item for this app with no content attached yet
+
+ virtual UGCUpdateHandle_t StartItemUpdate( AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID ) = 0; // start an UGC item update. Set changed properties before commiting update with CommitItemUpdate()
+
+ virtual bool SetItemTitle( UGCUpdateHandle_t handle, const char *pchTitle ) = 0; // change the title of an UGC item
+ virtual bool SetItemDescription( UGCUpdateHandle_t handle, const char *pchDescription ) = 0; // change the description of an UGC item
+ virtual bool SetItemVisibility( UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0; // change the visibility of an UGC item
+ virtual bool SetItemTags( UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t *pTags ) = 0; // change the tags of an UGC item
+ virtual bool SetItemContent( UGCUpdateHandle_t handle, const char *pszContentFolder ) = 0; // update item content from this local folder
+ virtual bool SetItemPreview( UGCUpdateHandle_t handle, const char *pszPreviewFile ) = 0; // change preview image file for this item. pszPreviewFile points to local image file
+
+ virtual SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) = 0; // commit update process started with StartItemUpdate()
+ virtual EItemUpdateStatus GetItemUpdateProgress( UGCUpdateHandle_t handle, uint64 *punBytesProcessed, uint64* punBytesTotal ) = 0;
+
+ // Steam Workshop Consumer API
+ virtual SteamAPICall_t SubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // subscript to this item, will be installed ASAP
+ virtual SteamAPICall_t UnsubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // unsubscribe from this item, will be uninstalled after game quits
+ virtual uint32 GetNumSubscribedItems() = 0; // number of subscribed items
+ virtual uint32 GetSubscribedItems( PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0; // all subscribed item PublishFileIDs
+
+ // Get info about the item on disk. If you are supporting items published through the legacy RemoteStorage APIs then *pbLegacyItem will be set to true
+ // and pchFolder will contain the full path to the file rather than the containing folder.
+ virtual bool GetItemInstallInfo( PublishedFileId_t nPublishedFileID, uint64 *punSizeOnDisk, char *pchFolder, uint32 cchFolderSize, bool *pbLegacyItem ) = 0; // returns true if item is installed
+ virtual bool GetItemUpdateInfo( PublishedFileId_t nPublishedFileID, bool *pbNeedsUpdate, bool *pbIsDownloading, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0;
+};
+
+#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION003"
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback for querying UGC
+//-----------------------------------------------------------------------------
+struct SteamUGCQueryCompleted_t
+{
+ enum { k_iCallback = k_iClientUGCCallbacks + 1 };
+ UGCQueryHandle_t m_handle;
+ EResult m_eResult;
+ uint32 m_unNumResultsReturned;
+ uint32 m_unTotalMatchingResults;
+ bool m_bCachedData; // indicates whether this data was retrieved from the local on-disk cache
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback for requesting details on one piece of UGC
+//-----------------------------------------------------------------------------
+struct SteamUGCRequestUGCDetailsResult_t
+{
+ enum { k_iCallback = k_iClientUGCCallbacks + 2 };
+ SteamUGCDetails_t m_details;
+ bool m_bCachedData; // indicates whether this data was retrieved from the local on-disk cache
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: result for ISteamUGC::CreateItem()
+//-----------------------------------------------------------------------------
+struct CreateItemResult_t
+{
+ enum { k_iCallback = k_iClientUGCCallbacks + 3 };
+ EResult m_eResult;
+ PublishedFileId_t m_nPublishedFileId; // new item got this UGC PublishFileID
+ bool m_bUserNeedsToAcceptWorkshopLegalAgreement;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: result for ISteamUGC::SubmitItemUpdate()
+//-----------------------------------------------------------------------------
+struct SubmitItemUpdateResult_t
+{
+ enum { k_iCallback = k_iClientUGCCallbacks + 4 };
+ EResult m_eResult;
+ bool m_bUserNeedsToAcceptWorkshopLegalAgreement;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a new Workshop item has been installed
+//-----------------------------------------------------------------------------
+struct ItemInstalled_t
+{
+ enum { k_iCallback = k_iClientUGCCallbacks + 5 };
+ AppId_t m_unAppID;
+ PublishedFileId_t m_nPublishedFileId;
+};
+
+
+#pragma pack( pop )
+
+#endif // ISTEAMUGC_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamunifiedmessages.h b/lsteamclient/steamworks_sdk_130x/isteamunifiedmessages.h
new file mode 100644
index 00000000..493611d5
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamunifiedmessages.h
@@ -0,0 +1,63 @@
+//====== Copyright � 1996-2007, Valve Corporation, All rights reserved. =======
+//
+// Purpose: Interface to unified messages client
+//
+// You should not need to use this interface except if your product is using a language other than C++.
+// Contact your Steam Tech contact for more details.
+//
+//=============================================================================
+
+#ifndef ISTEAMUNIFIEDMESSAGES_H
+#define ISTEAMUNIFIEDMESSAGES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef uint64 ClientUnifiedMessageHandle;
+
+class ISteamUnifiedMessages
+{
+public:
+ static const ClientUnifiedMessageHandle k_InvalidUnifiedMessageHandle = 0;
+
+ // Sends a service method (in binary serialized form) using the Steam Client.
+ // Returns a unified message handle (k_InvalidUnifiedMessageHandle if could not send the message).
+ virtual ClientUnifiedMessageHandle SendMethod( const char *pchServiceMethod, const void *pRequestBuffer, uint32 unRequestBufferSize, uint64 unContext ) = 0;
+
+ // Gets the size of the response and the EResult. Returns false if the response is not ready yet.
+ virtual bool GetMethodResponseInfo( ClientUnifiedMessageHandle hHandle, uint32 *punResponseSize, EResult *peResult ) = 0;
+
+ // Gets a response in binary serialized form (and optionally release the corresponding allocated memory).
+ virtual bool GetMethodResponseData( ClientUnifiedMessageHandle hHandle, void *pResponseBuffer, uint32 unResponseBufferSize, bool bAutoRelease ) = 0;
+
+ // Releases the message and its corresponding allocated memory.
+ virtual bool ReleaseMethod( ClientUnifiedMessageHandle hHandle ) = 0;
+
+ // Sends a service notification (in binary serialized form) using the Steam Client.
+ // Returns true if the notification was sent successfully.
+ virtual bool SendNotification( const char *pchServiceNotification, const void *pNotificationBuffer, uint32 unNotificationBufferSize ) = 0;
+};
+
+#define STEAMUNIFIEDMESSAGES_INTERFACE_VERSION "STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+struct SteamUnifiedMessagesSendMethodResult_t
+{
+ enum { k_iCallback = k_iClientUnifiedMessagesCallbacks + 1 };
+ ClientUnifiedMessageHandle m_hHandle; // The handle returned by SendMethod().
+ uint64 m_unContext; // Context provided when calling SendMethod().
+ EResult m_eResult; // The result of the method call.
+ uint32 m_unResponseSize; // The size of the response.
+};
+
+#pragma pack( pop )
+
+#endif // ISTEAMUNIFIEDMESSAGES_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamuser.h b/lsteamclient/steamworks_sdk_130x/isteamuser.h
new file mode 100644
index 00000000..0b73178d
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamuser.h
@@ -0,0 +1,348 @@
+//====== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to user account information in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMUSER_H
+#define ISTEAMUSER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+// structure that contains client callback data
+// see callbacks documentation for more details
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+struct CallbackMsg_t
+{
+ HSteamUser m_hSteamUser;
+ int m_iCallback;
+ uint8 *m_pubParam;
+ int m_cubParam;
+};
+#pragma pack( pop )
+
+// reference to a steam call, to filter results by
+typedef int32 HSteamCall;
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing and manipulating a steam account
+// associated with one client instance
+//-----------------------------------------------------------------------------
+class ISteamUser
+{
+public:
+ // returns the HSteamUser this interface represents
+ // this is only used internally by the API, and by a few select interfaces that support multi-user
+ virtual HSteamUser GetHSteamUser() = 0;
+
+ // returns true if the Steam client current has a live connection to the Steam servers.
+ // If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
+ // The Steam client will automatically be trying to recreate the connection as often as possible.
+ virtual bool BLoggedOn() = 0;
+
+ // returns the CSteamID of the account currently logged into the Steam client
+ // a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
+ virtual CSteamID GetSteamID() = 0;
+
+ // Multiplayer Authentication functions
+
+ // InitiateGameConnection() starts the state machine for authenticating the game client with the game server
+ // It is the client portion of a three-way handshake between the client, the game server, and the steam servers
+ //
+ // Parameters:
+ // void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token.
+ // int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes.
+ // CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
+ // CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( )
+ // uint32 unIPServer, uint16 usPortServer - the IP address of the game server
+ // bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running)
+ //
+ // return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed
+ // The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process.
+ virtual int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0;
+
+ // notify of disconnect
+ // needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
+ virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
+
+ // Legacy functions
+
+ // used by only a few games to track usage events
+ virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0;
+
+ // get the local storage folder for current Steam account to write application data, e.g. save games, configs etc.
+ // this will usually be something like "C:\Progam Files\Steam\userdata\\\local"
+ virtual bool GetUserDataFolder( char *pchBuffer, int cubBuffer ) = 0;
+
+ // Starts voice recording. Once started, use GetVoice() to get the data
+ virtual void StartVoiceRecording( ) = 0;
+
+ // Stops voice recording. Because people often release push-to-talk keys early, the system will keep recording for
+ // a little bit after this function is called. GetVoice() should continue to be called until it returns
+ // k_eVoiceResultNotRecording
+ virtual void StopVoiceRecording( ) = 0;
+
+ // Determine the amount of captured audio data that is available in bytes.
+ // This provides both the compressed and uncompressed data. Please note that the uncompressed
+ // data is not the raw feed from the microphone: data may only be available if audible
+ // levels of speech are detected.
+ // nUncompressedVoiceDesiredSampleRate is necessary to know the number of bytes to return in pcbUncompressed - can be set to 0 if you don't need uncompressed (the usual case)
+ // If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nUncompressedVoiceDesiredSampleRate
+ virtual EVoiceResult GetAvailableVoice( uint32 *pcbCompressed, uint32 *pcbUncompressed, uint32 nUncompressedVoiceDesiredSampleRate ) = 0;
+
+ // Gets the latest voice data from the microphone. Compressed data is an arbitrary format, and is meant to be handed back to
+ // DecompressVoice() for playback later as a binary blob. Uncompressed data is 16-bit, signed integer, 11025Hz PCM format.
+ // Please note that the uncompressed data is not the raw feed from the microphone: data may only be available if audible
+ // levels of speech are detected, and may have passed through denoising filters, etc.
+ // This function should be called as often as possible once recording has started; once per frame at least.
+ // nBytesWritten is set to the number of bytes written to pDestBuffer.
+ // nUncompressedBytesWritten is set to the number of bytes written to pUncompressedDestBuffer.
+ // You must grab both compressed and uncompressed here at the same time, if you want both.
+ // Matching data that is not read during this call will be thrown away.
+ // GetAvailableVoice() can be used to determine how much data is actually available.
+ // If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nUncompressedVoiceDesiredSampleRate
+ virtual EVoiceResult GetVoice( bool bWantCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, bool bWantUncompressed, void *pUncompressedDestBuffer, uint32 cbUncompressedDestBufferSize, uint32 *nUncompressBytesWritten, uint32 nUncompressedVoiceDesiredSampleRate ) = 0;
+
+ // Decompresses a chunk of compressed data produced by GetVoice().
+ // nBytesWritten is set to the number of bytes written to pDestBuffer unless the return value is k_EVoiceResultBufferTooSmall.
+ // In that case, nBytesWritten is set to the size of the buffer required to decompress the given
+ // data. The suggested buffer size for the destination buffer is 22 kilobytes.
+ // The output format of the data is 16-bit signed at the requested samples per second.
+ // If you're upgrading from an older Steamworks API, you'll want to pass in 11025 to nDesiredSampleRate
+ virtual EVoiceResult DecompressVoice( const void *pCompressed, uint32 cbCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, uint32 nDesiredSampleRate ) = 0;
+
+ // This returns the frequency of the voice data as it's stored internally; calling DecompressVoice() with this size will yield the best results
+ virtual uint32 GetVoiceOptimalSampleRate() = 0;
+
+ // Retrieve ticket to be sent to the entity who wishes to authenticate you.
+ // pcbTicket retrieves the length of the actual ticket.
+ virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+
+ // Authenticate ticket from entity steamID to be sure it is valid and isnt reused
+ // Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
+ virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0;
+
+ // Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
+ virtual void EndAuthSession( CSteamID steamID ) = 0;
+
+ // Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
+ virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0;
+
+ // After receiving a user's authentication data, and passing it to BeginAuthSession, use this function
+ // to determine if the user owns downloadable content specified by the provided AppID.
+ virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0;
+
+ // returns true if this users looks like they are behind a NAT device. Only valid once the user has connected to steam
+ // (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT.
+ virtual bool BIsBehindNAT() = 0;
+
+ // set data to be replicated to friends so that they can join your game
+ // CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
+ // uint32 unIPServer, uint16 usPortServer - the IP address of the game server
+ virtual void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer ) = 0;
+
+ // Requests a ticket encrypted with an app specific shared key
+ // pDataToInclude, cbDataToInclude will be encrypted into the ticket
+ // ( This is asynchronous, you must wait for the ticket to be completed by the server )
+ virtual SteamAPICall_t RequestEncryptedAppTicket( void *pDataToInclude, int cbDataToInclude ) = 0;
+
+ // retrieve a finished ticket
+ virtual bool GetEncryptedAppTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+
+ // Trading Card badges data access
+ // if you only have one set of cards, the series will be 1
+ // the user has can have two different badges for a series; the regular (max level 5) and the foil (max level 1)
+ virtual int GetGameBadgeLevel( int nSeries, bool bFoil ) = 0;
+
+ // gets the Steam Level of the user, as shown on their profile
+ virtual int GetPlayerSteamLevel() = 0;
+
+#ifdef _PS3
+ // Initiates PS3 Logon request using just PSN ticket.
+ //
+ // PARAMS: bInteractive - If set tells Steam to go ahead and show the PS3 NetStart dialog if needed to
+ // prompt the user for network setup/PSN logon before initiating the Steam side of the logon.
+ //
+ // Listen for SteamServersConnected_t or SteamServerConnectFailure_t for status. SteamServerConnectFailure_t
+ // may return with EResult k_EResultExternalAccountUnlinked if the PSN account is unknown to Steam. You should
+ // then call LogOnAndLinkSteamAccountToPSN() after prompting the user for credentials to establish a link.
+ // Future calls to LogOn() after the one time link call should succeed as long as the user is connected to PSN.
+ virtual void LogOn( bool bInteractive ) = 0;
+
+ // Initiates a request to logon with a specific steam username/password and create a PSN account link at
+ // the same time. Should call this only if LogOn() has failed and indicated the PSN account is unlinked.
+ //
+ // PARAMS: bInteractive - If set tells Steam to go ahead and show the PS3 NetStart dialog if needed to
+ // prompt the user for network setup/PSN logon before initiating the Steam side of the logon. pchUserName
+ // should be the users Steam username, and pchPassword should be the users Steam password.
+ //
+ // Listen for SteamServersConnected_t or SteamServerConnectFailure_t for status. SteamServerConnectFailure_t
+ // may return with EResult k_EResultOtherAccountAlreadyLinked if already linked to another account.
+ virtual void LogOnAndLinkSteamAccountToPSN( bool bInteractive, const char *pchUserName, const char *pchPassword ) = 0;
+
+ // Final logon option for PS3, this logs into an existing account if already linked, but if not already linked
+ // creates a new account using the info in the PSN ticket to generate a unique account name. The new account is
+ // then linked to the PSN ticket. This is the faster option for new users who don't have an existing Steam account
+ // to get into multiplayer.
+ //
+ // PARAMS: bInteractive - If set tells Steam to go ahead and show the PS3 NetStart dialog if needed to
+ // prompt the user for network setup/PSN logon before initiating the Steam side of the logon.
+ virtual void LogOnAndCreateNewSteamAccountIfNeeded( bool bInteractive ) = 0;
+
+ // Returns a special SteamID that represents the user's PSN information. Can be used to query the user's PSN avatar,
+ // online name, etc. through the standard Steamworks interfaces.
+ virtual CSteamID GetConsoleSteamID() = 0;
+#endif
+
+};
+
+#define STEAMUSER_INTERFACE_VERSION "SteamUser017"
+
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a connections to the Steam back-end has been established
+// this means the Steam client now has a working connection to the Steam servers
+// usually this will have occurred before the game has launched, and should
+// only be seen if the user has dropped connection due to a networking issue
+// or a Steam server update
+//-----------------------------------------------------------------------------
+struct SteamServersConnected_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 1 };
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a connection attempt has failed
+// this will occur periodically if the Steam client is not connected,
+// and has failed in it's retry to establish a connection
+//-----------------------------------------------------------------------------
+struct SteamServerConnectFailure_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 2 };
+ EResult m_eResult;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called if the client has lost connection to the Steam servers
+// real-time services will be disabled until a matching SteamServersConnected_t has been posted
+//-----------------------------------------------------------------------------
+struct SteamServersDisconnected_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 3 };
+ EResult m_eResult;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sent by the Steam server to the client telling it to disconnect from the specified game server,
+// which it may be in the process of or already connected to.
+// The game client should immediately disconnect upon receiving this message.
+// This can usually occur if the user doesn't have rights to play on the game server.
+//-----------------------------------------------------------------------------
+struct ClientGameServerDeny_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 13 };
+
+ uint32 m_uAppID;
+ uint32 m_unGameServerIP;
+ uint16 m_usGameServerPort;
+ uint16 m_bSecure;
+ uint32 m_uReason;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the callback system for this client is in an error state (and has flushed pending callbacks)
+// When getting this message the client should disconnect from Steam, reset any stored Steam state and reconnect.
+// This usually occurs in the rare event the Steam client has some kind of fatal error.
+//-----------------------------------------------------------------------------
+struct IPCFailure_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 17 };
+ enum EFailureType
+ {
+ k_EFailureFlushedCallbackQueue,
+ k_EFailurePipeFail,
+ };
+ uint8 m_eFailureType;
+};
+
+
+//-----------------------------------------------------------------------------
+// callback for BeginAuthSession
+//-----------------------------------------------------------------------------
+struct ValidateAuthTicketResponse_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 43 };
+ CSteamID m_SteamID;
+ EAuthSessionResponse m_eAuthSessionResponse;
+ CSteamID m_OwnerSteamID; // different from m_SteamID if borrowed
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a user has responded to a microtransaction authorization request
+//-----------------------------------------------------------------------------
+struct MicroTxnAuthorizationResponse_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 52 };
+
+ uint32 m_unAppID; // AppID for this microtransaction
+ uint64 m_ulOrderID; // OrderID provided for the microtransaction
+ uint8 m_bAuthorized; // if user authorized transaction
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Result from RequestEncryptedAppTicket
+//-----------------------------------------------------------------------------
+struct EncryptedAppTicketResponse_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 54 };
+
+ EResult m_eResult;
+};
+
+//-----------------------------------------------------------------------------
+// callback for GetAuthSessionTicket
+//-----------------------------------------------------------------------------
+struct GetAuthSessionTicketResponse_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 63 };
+ HAuthTicket m_hAuthTicket;
+ EResult m_eResult;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: sent to your game in response to a steam://gamewebcallback/ command
+//-----------------------------------------------------------------------------
+struct GameWebCallback_t
+{
+ enum { k_iCallback = k_iSteamUserCallbacks + 64 };
+ char m_szURL[256];
+};
+
+
+#pragma pack( pop )
+
+#endif // ISTEAMUSER_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamuserstats.h b/lsteamclient/steamworks_sdk_130x/isteamuserstats.h
new file mode 100644
index 00000000..595ec356
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamuserstats.h
@@ -0,0 +1,463 @@
+//====== Copyright � 1996-2009, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to stats, achievements, and leaderboards
+//
+//=============================================================================
+
+#ifndef ISTEAMUSERSTATS_H
+#define ISTEAMUSERSTATS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "isteamremotestorage.h"
+
+// size limit on stat or achievement name (UTF-8 encoded)
+enum { k_cchStatNameMax = 128 };
+
+// maximum number of bytes for a leaderboard name (UTF-8 encoded)
+enum { k_cchLeaderboardNameMax = 128 };
+
+// maximum number of details int32's storable for a single leaderboard entry
+enum { k_cLeaderboardDetailsMax = 64 };
+
+// handle to a single leaderboard
+typedef uint64 SteamLeaderboard_t;
+
+// handle to a set of downloaded entries in a leaderboard
+typedef uint64 SteamLeaderboardEntries_t;
+
+// type of data request, when downloading leaderboard entries
+enum ELeaderboardDataRequest
+{
+ k_ELeaderboardDataRequestGlobal = 0,
+ k_ELeaderboardDataRequestGlobalAroundUser = 1,
+ k_ELeaderboardDataRequestFriends = 2,
+ k_ELeaderboardDataRequestUsers = 3
+};
+
+// the sort order of a leaderboard
+enum ELeaderboardSortMethod
+{
+ k_ELeaderboardSortMethodNone = 0,
+ k_ELeaderboardSortMethodAscending = 1, // top-score is lowest number
+ k_ELeaderboardSortMethodDescending = 2, // top-score is highest number
+};
+
+// the display type (used by the Steam Community web site) for a leaderboard
+enum ELeaderboardDisplayType
+{
+ k_ELeaderboardDisplayTypeNone = 0,
+ k_ELeaderboardDisplayTypeNumeric = 1, // simple numerical score
+ k_ELeaderboardDisplayTypeTimeSeconds = 2, // the score represents a time, in seconds
+ k_ELeaderboardDisplayTypeTimeMilliSeconds = 3, // the score represents a time, in milliseconds
+};
+
+enum ELeaderboardUploadScoreMethod
+{
+ k_ELeaderboardUploadScoreMethodNone = 0,
+ k_ELeaderboardUploadScoreMethodKeepBest = 1, // Leaderboard will keep user's best score
+ k_ELeaderboardUploadScoreMethodForceUpdate = 2, // Leaderboard will always replace score with specified
+};
+
+// a single entry in a leaderboard, as returned by GetDownloadedLeaderboardEntry()
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+struct LeaderboardEntry_t
+{
+ CSteamID m_steamIDUser; // user with the entry - use SteamFriends()->GetFriendPersonaName() & SteamFriends()->GetFriendAvatar() to get more info
+ int32 m_nGlobalRank; // [1..N], where N is the number of users with an entry in the leaderboard
+ int32 m_nScore; // score as set in the leaderboard
+ int32 m_cDetails; // number of int32 details available for this entry
+ UGCHandle_t m_hUGC; // handle for UGC attached to the entry
+};
+
+#pragma pack( pop )
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing stats, achievements, and leaderboard information
+//-----------------------------------------------------------------------------
+class ISteamUserStats
+{
+public:
+ // Ask the server to send down this user's data and achievements for this game
+ virtual bool RequestCurrentStats() = 0;
+
+ // Data accessors
+ virtual bool GetStat( const char *pchName, int32 *pData ) = 0;
+ virtual bool GetStat( const char *pchName, float *pData ) = 0;
+
+ // Set / update data
+ virtual bool SetStat( const char *pchName, int32 nData ) = 0;
+ virtual bool SetStat( const char *pchName, float fData ) = 0;
+ virtual bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength ) = 0;
+
+ // Achievement flag accessors
+ virtual bool GetAchievement( const char *pchName, bool *pbAchieved ) = 0;
+ virtual bool SetAchievement( const char *pchName ) = 0;
+ virtual bool ClearAchievement( const char *pchName ) = 0;
+
+ // Get the achievement status, and the time it was unlocked if unlocked.
+ // If the return value is true, but the unlock time is zero, that means it was unlocked before Steam
+ // began tracking achievement unlock times (December 2009). Time is seconds since January 1, 1970.
+ virtual bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0;
+
+ // Store the current data on the server, will get a callback when set
+ // And one callback for every new achievement
+ //
+ // If the callback has a result of k_EResultInvalidParam, one or more stats
+ // uploaded has been rejected, either because they broke constraints
+ // or were out of date. In this case the server sends back updated values.
+ // The stats should be re-iterated to keep in sync.
+ virtual bool StoreStats() = 0;
+
+ // Achievement / GroupAchievement metadata
+
+ // Gets the icon of the achievement, which is a handle to be used in ISteamUtils::GetImageRGBA(), or 0 if none set.
+ // A return value of 0 may indicate we are still fetching data, and you can wait for the UserAchievementIconFetched_t callback
+ // which will notify you when the bits are ready. If the callback still returns zero, then there is no image set for the
+ // specified achievement.
+ virtual int GetAchievementIcon( const char *pchName ) = 0;
+
+ // Get general attributes for an achievement. Accepts the following keys:
+ // - "name" and "desc" for retrieving the localized achievement name and description (returned in UTF8)
+ // - "hidden" for retrieving if an achievement is hidden (returns "0" when not hidden, "1" when hidden)
+ virtual const char *GetAchievementDisplayAttribute( const char *pchName, const char *pchKey ) = 0;
+
+ // Achievement progress - triggers an AchievementProgress callback, that is all.
+ // Calling this w/ N out of N progress will NOT set the achievement, the game must still do that.
+ virtual bool IndicateAchievementProgress( const char *pchName, uint32 nCurProgress, uint32 nMaxProgress ) = 0;
+
+ // Used for iterating achievements. In general games should not need these functions because they should have a
+ // list of existing achievements compiled into them
+ virtual uint32 GetNumAchievements() = 0;
+ // Get achievement name iAchievement in [0,GetNumAchievements)
+ virtual const char *GetAchievementName( uint32 iAchievement ) = 0;
+
+ // Friends stats & achievements
+
+ // downloads stats for the user
+ // returns a UserStatsReceived_t received when completed
+ // if the other user has no stats, UserStatsReceived_t.m_eResult will be set to k_EResultFail
+ // these stats won't be auto-updated; you'll need to call RequestUserStats() again to refresh any data
+ virtual SteamAPICall_t RequestUserStats( CSteamID steamIDUser ) = 0;
+
+ // requests stat information for a user, usable after a successful call to RequestUserStats()
+ virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0;
+ virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0;
+ virtual bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved ) = 0;
+ // See notes for GetAchievementAndUnlockTime above
+ virtual bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime ) = 0;
+
+ // Reset stats
+ virtual bool ResetAllStats( bool bAchievementsToo ) = 0;
+
+ // Leaderboard functions
+
+ // asks the Steam back-end for a leaderboard by name, and will create it if it's not yet
+ // This call is asynchronous, with the result returned in LeaderboardFindResult_t
+ virtual SteamAPICall_t FindOrCreateLeaderboard( const char *pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) = 0;
+
+ // as above, but won't create the leaderboard if it's not found
+ // This call is asynchronous, with the result returned in LeaderboardFindResult_t
+ virtual SteamAPICall_t FindLeaderboard( const char *pchLeaderboardName ) = 0;
+
+ // returns the name of a leaderboard
+ virtual const char *GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) = 0;
+
+ // returns the total number of entries in a leaderboard, as of the last request
+ virtual int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) = 0;
+
+ // returns the sort method of the leaderboard
+ virtual ELeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) = 0;
+
+ // returns the display type of the leaderboard
+ virtual ELeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) = 0;
+
+ // Asks the Steam back-end for a set of rows in the leaderboard.
+ // This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t
+ // LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below)
+ // You can ask for more entries than exist, and it will return as many as do exist.
+ // k_ELeaderboardDataRequestGlobal requests rows in the leaderboard from the full table, with nRangeStart & nRangeEnd in the range [1, TotalEntries]
+ // k_ELeaderboardDataRequestGlobalAroundUser requests rows around the current user, nRangeStart being negate
+ // e.g. DownloadLeaderboardEntries( hLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -3, 3 ) will return 7 rows, 3 before the user, 3 after
+ // k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user
+ virtual SteamAPICall_t DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) = 0;
+ // as above, but downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers
+ // if a user doesn't have a leaderboard entry, they won't be included in the result
+ // a max of 100 users can be downloaded at a time, with only one outstanding call at a time
+ virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, CSteamID *prgUsers, int cUsers ) = 0;
+
+ // Returns data about a single leaderboard entry
+ // use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries
+ // e.g.
+ // void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded )
+ // {
+ // for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ )
+ // {
+ // LeaderboardEntry_t leaderboardEntry;
+ // int32 details[3]; // we know this is how many we've stored previously
+ // GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 );
+ // assert( leaderboardEntry.m_cDetails == 3 );
+ // ...
+ // }
+ // once you've accessed all the entries, the data will be free'd, and the SteamLeaderboardEntries_t handle will become invalid
+ virtual bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) = 0;
+
+ // Uploads a user score to the Steam back-end.
+ // This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t
+ // Details are extra game-defined information regarding how the user got that score
+ // pScoreDetails points to an array of int32's, cScoreDetailsCount is the number of int32's in the list
+ virtual SteamAPICall_t UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 *pScoreDetails, int cScoreDetailsCount ) = 0;
+
+ // Attaches a piece of user generated content the user's entry on a leaderboard.
+ // hContent is a handle to a piece of user generated content that was shared using ISteamUserRemoteStorage::FileShare().
+ // This call is asynchronous, with the result returned in LeaderboardUGCSet_t.
+ virtual SteamAPICall_t AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) = 0;
+
+ // Retrieves the number of players currently playing your game (online + offline)
+ // This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t
+ virtual SteamAPICall_t GetNumberOfCurrentPlayers() = 0;
+
+ // Requests that Steam fetch data on the percentage of players who have received each achievement
+ // for the game globally.
+ // This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t.
+ virtual SteamAPICall_t RequestGlobalAchievementPercentages() = 0;
+
+ // Get the info on the most achieved achievement for the game, returns an iterator index you can use to fetch
+ // the next most achieved afterwards. Will return -1 if there is no data on achievement
+ // percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback).
+ virtual int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0;
+
+ // Get the info on the next most achieved achievement for the game. Call this after GetMostAchievedAchievementInfo or another
+ // GetNextMostAchievedAchievementInfo call passing the iterator from the previous call. Returns -1 after the last
+ // achievement has been iterated.
+ virtual int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) = 0;
+
+ // Returns the percentage of users who have achieved the specified achievement.
+ virtual bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent ) = 0;
+
+ // Requests global stats data, which is available for stats marked as "aggregated".
+ // This call is asynchronous, with the results returned in GlobalStatsReceived_t.
+ // nHistoryDays specifies how many days of day-by-day history to retrieve in addition
+ // to the overall totals. The limit is 60.
+ virtual SteamAPICall_t RequestGlobalStats( int nHistoryDays ) = 0;
+
+ // Gets the lifetime totals for an aggregated stat
+ virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0;
+ virtual bool GetGlobalStat( const char *pchStatName, double *pData ) = 0;
+
+ // Gets history for an aggregated stat. pData will be filled with daily values, starting with today.
+ // So when called, pData[0] will be today, pData[1] will be yesterday, and pData[2] will be two days ago,
+ // etc. cubData is the size in bytes of the pubData buffer. Returns the number of
+ // elements actually set.
+ virtual int32 GetGlobalStatHistory( const char *pchStatName, int64 *pData, uint32 cubData ) = 0;
+ virtual int32 GetGlobalStatHistory( const char *pchStatName, double *pData, uint32 cubData ) = 0;
+
+#ifdef _PS3
+ // Call to kick off installation of the PS3 trophies. This call is asynchronous, and the results will be returned in a PS3TrophiesInstalled_t
+ // callback.
+ virtual bool InstallPS3Trophies() = 0;
+
+ // Returns the amount of space required at boot to install trophies. This value can be used when comparing the amount of space needed
+ // by the game to the available space value passed to the game at boot. The value is set during InstallPS3Trophies().
+ virtual uint64 GetTrophySpaceRequiredBeforeInstall() = 0;
+
+ // On PS3, user stats & achievement progress through Steam must be stored with the user's saved game data.
+ // At startup, before calling RequestCurrentStats(), you must pass the user's stats data to Steam via this method.
+ // If you do not have any user data, call this function with pvData = NULL and cubData = 0
+ virtual bool SetUserStatsData( const void *pvData, uint32 cubData ) = 0;
+
+ // Call to get the user's current stats data. You should retrieve this data after receiving successful UserStatsReceived_t & UserStatsStored_t
+ // callbacks, and store the data with the user's save game data. You can call this method with pvData = NULL and cubData = 0 to get the required
+ // buffer size.
+ virtual bool GetUserStatsData( void *pvData, uint32 cubData, uint32 *pcubWritten ) = 0;
+#endif
+};
+
+#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION011"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the latests stats and achievements have been received
+// from the server
+//-----------------------------------------------------------------------------
+struct UserStatsReceived_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 1 };
+ uint64 m_nGameID; // Game these stats are for
+ EResult m_eResult; // Success / error fetching the stats
+ CSteamID m_steamIDUser; // The user for whom the stats are retrieved for
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: result of a request to store the user stats for a game
+//-----------------------------------------------------------------------------
+struct UserStatsStored_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 2 };
+ uint64 m_nGameID; // Game these stats are for
+ EResult m_eResult; // success / error
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: result of a request to store the achievements for a game, or an
+// "indicate progress" call. If both m_nCurProgress and m_nMaxProgress
+// are zero, that means the achievement has been fully unlocked.
+//-----------------------------------------------------------------------------
+struct UserAchievementStored_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 3 };
+
+ uint64 m_nGameID; // Game this is for
+ bool m_bGroupAchievement; // if this is a "group" achievement
+ char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement
+ uint32 m_nCurProgress; // current progress towards the achievement
+ uint32 m_nMaxProgress; // "out of" this many
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: call result for finding a leaderboard, returned as a result of FindOrCreateLeaderboard() or FindLeaderboard()
+// use CCallResult<> to map this async result to a member function
+//-----------------------------------------------------------------------------
+struct LeaderboardFindResult_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 4 };
+ SteamLeaderboard_t m_hSteamLeaderboard; // handle to the leaderboard serarched for, 0 if no leaderboard found
+ uint8 m_bLeaderboardFound; // 0 if no leaderboard found
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: call result indicating scores for a leaderboard have been downloaded and are ready to be retrieved, returned as a result of DownloadLeaderboardEntries()
+// use CCallResult<> to map this async result to a member function
+//-----------------------------------------------------------------------------
+struct LeaderboardScoresDownloaded_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 5 };
+ SteamLeaderboard_t m_hSteamLeaderboard;
+ SteamLeaderboardEntries_t m_hSteamLeaderboardEntries; // the handle to pass into GetDownloadedLeaderboardEntries()
+ int m_cEntryCount; // the number of entries downloaded
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: call result indicating scores has been uploaded, returned as a result of UploadLeaderboardScore()
+// use CCallResult<> to map this async result to a member function
+//-----------------------------------------------------------------------------
+struct LeaderboardScoreUploaded_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 6 };
+ uint8 m_bSuccess; // 1 if the call was successful
+ SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was
+ int32 m_nScore; // the score that was attempted to set
+ uint8 m_bScoreChanged; // true if the score in the leaderboard change, false if the existing score was better
+ int m_nGlobalRankNew; // the new global rank of the user in this leaderboard
+ int m_nGlobalRankPrevious; // the previous global rank of the user in this leaderboard; 0 if the user had no existing entry in the leaderboard
+};
+
+struct NumberOfCurrentPlayers_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 7 };
+ uint8 m_bSuccess; // 1 if the call was successful
+ int32 m_cPlayers; // Number of players currently playing
+};
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback indicating that a user's stats have been unloaded.
+// Call RequestUserStats again to access stats for this user
+//-----------------------------------------------------------------------------
+struct UserStatsUnloaded_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 8 };
+ CSteamID m_steamIDUser; // User whose stats have been unloaded
+};
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback indicating that an achievement icon has been fetched
+//-----------------------------------------------------------------------------
+struct UserAchievementIconFetched_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 9 };
+
+ CGameID m_nGameID; // Game this is for
+ char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement
+ bool m_bAchieved; // Is the icon for the achieved or not achieved version?
+ int m_nIconHandle; // Handle to the image, which can be used in SteamUtils()->GetImageRGBA(), 0 means no image is set for the achievement
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback indicating that global achievement percentages are fetched
+//-----------------------------------------------------------------------------
+struct GlobalAchievementPercentagesReady_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 10 };
+
+ uint64 m_nGameID; // Game this is for
+ EResult m_eResult; // Result of the operation
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: call result indicating UGC has been uploaded, returned as a result of SetLeaderboardUGC()
+//-----------------------------------------------------------------------------
+struct LeaderboardUGCSet_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 11 };
+ EResult m_eResult; // The result of the operation
+ SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: callback indicating that PS3 trophies have been installed
+//-----------------------------------------------------------------------------
+struct PS3TrophiesInstalled_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 };
+ uint64 m_nGameID; // Game these stats are for
+ EResult m_eResult; // The result of the operation
+ uint64 m_ulRequiredDiskSpace; // If m_eResult is k_EResultDiskFull, will contain the amount of space needed to install trophies
+
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: callback indicating global stats have been received.
+// Returned as a result of RequestGlobalStats()
+//-----------------------------------------------------------------------------
+struct GlobalStatsReceived_t
+{
+ enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 };
+ uint64 m_nGameID; // Game global stats were requested for
+ EResult m_eResult; // The result of the request
+};
+
+#pragma pack( pop )
+
+
+#endif // ISTEAMUSER_H
diff --git a/lsteamclient/steamworks_sdk_130x/isteamutils.h b/lsteamclient/steamworks_sdk_130x/isteamutils.h
new file mode 100644
index 00000000..2e302b9e
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/isteamutils.h
@@ -0,0 +1,307 @@
+//====== Copyright � 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to utility functions in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMUTILS_H
+#define ISTEAMUTILS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+
+// Steam API call failure results
+enum ESteamAPICallFailure
+{
+ k_ESteamAPICallFailureNone = -1, // no failure
+ k_ESteamAPICallFailureSteamGone = 0, // the local Steam process has gone away
+ k_ESteamAPICallFailureNetworkFailure = 1, // the network connection to Steam has been broken, or was already broken
+ // SteamServersDisconnected_t callback will be sent around the same time
+ // SteamServersConnected_t will be sent when the client is able to talk to the Steam servers again
+ k_ESteamAPICallFailureInvalidHandle = 2, // the SteamAPICall_t handle passed in no longer exists
+ k_ESteamAPICallFailureMismatchedCallback = 3,// GetAPICallResult() was called with the wrong callback type for this API call
+};
+
+
+// Input modes for the Big Picture gamepad text entry
+enum EGamepadTextInputMode
+{
+ k_EGamepadTextInputModeNormal = 0,
+ k_EGamepadTextInputModePassword = 1
+};
+
+
+// Controls number of allowed lines for the Big Picture gamepad text entry
+enum EGamepadTextInputLineMode
+{
+ k_EGamepadTextInputLineModeSingleLine = 0,
+ k_EGamepadTextInputLineModeMultipleLines = 1
+};
+
+
+// function prototype for warning message hook
+#if defined( POSIX )
+#define __cdecl
+#endif
+extern "C" typedef void (__cdecl *SteamAPIWarningMessageHook_t)(int, const char *);
+
+//-----------------------------------------------------------------------------
+// Purpose: interface to user independent utility functions
+//-----------------------------------------------------------------------------
+class ISteamUtils
+{
+public:
+ // return the number of seconds since the user
+ virtual uint32 GetSecondsSinceAppActive() = 0;
+ virtual uint32 GetSecondsSinceComputerActive() = 0;
+
+ // the universe this client is connecting to
+ virtual EUniverse GetConnectedUniverse() = 0;
+
+ // Steam server time - in PST, number of seconds since January 1, 1970 (i.e unix time)
+ virtual uint32 GetServerRealTime() = 0;
+
+ // returns the 2 digit ISO 3166-1-alpha-2 format country code this client is running in (as looked up via an IP-to-location database)
+ // e.g "US" or "UK".
+ virtual const char *GetIPCountry() = 0;
+
+ // returns true if the image exists, and valid sizes were filled out
+ virtual bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) = 0;
+
+ // returns true if the image exists, and the buffer was successfully filled out
+ // results are returned in RGBA format
+ // the destination buffer size should be 4 * height * width * sizeof(char)
+ virtual bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) = 0;
+
+ // returns the IP of the reporting server for valve - currently only used in Source engine games
+ virtual bool GetCSERIPPort( uint32 *unIP, uint16 *usPort ) = 0;
+
+ // return the amount of battery power left in the current system in % [0..100], 255 for being on AC power
+ virtual uint8 GetCurrentBatteryPower() = 0;
+
+ // returns the appID of the current process
+ virtual uint32 GetAppID() = 0;
+
+ // Sets the position where the overlay instance for the currently calling game should show notifications.
+ // This position is per-game and if this function is called from outside of a game context it will do nothing.
+ virtual void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition ) = 0;
+
+ // API asynchronous call results
+ // can be used directly, but more commonly used via the callback dispatch API (see steam_api.h)
+ virtual bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, bool *pbFailed ) = 0;
+ virtual ESteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall ) = 0;
+ virtual bool GetAPICallResult( SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed ) = 0;
+
+ // this needs to be called every frame to process matchmaking results
+ // redundant if you're already calling SteamAPI_RunCallbacks()
+ virtual void RunFrame() = 0;
+
+ // returns the number of IPC calls made since the last time this function was called
+ // Used for perf debugging so you can understand how many IPC calls your game makes per frame
+ // Every IPC call is at minimum a thread context switch if not a process one so you want to rate
+ // control how often you do them.
+ virtual uint32 GetIPCCallCount() = 0;
+
+ // API warning handling
+ // 'int' is the severity; 0 for msg, 1 for warning
+ // 'const char *' is the text of the message
+ // callbacks will occur directly after the API function is called that generated the warning or message
+ virtual void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction ) = 0;
+
+ // Returns true if the overlay is running & the user can access it. The overlay process could take a few seconds to
+ // start & hook the game process, so this function will initially return false while the overlay is loading.
+ virtual bool IsOverlayEnabled() = 0;
+
+ // Normally this call is unneeded if your game has a constantly running frame loop that calls the
+ // D3D Present API, or OGL SwapBuffers API every frame.
+ //
+ // However, if you have a game that only refreshes the screen on an event driven basis then that can break
+ // the overlay, as it uses your Present/SwapBuffers calls to drive it's internal frame loop and it may also
+ // need to Present() to the screen any time an even needing a notification happens or when the overlay is
+ // brought up over the game by a user. You can use this API to ask the overlay if it currently need a present
+ // in that case, and then you can check for this periodically (roughly 33hz is desirable) and make sure you
+ // refresh the screen with Present or SwapBuffers to allow the overlay to do it's work.
+ virtual bool BOverlayNeedsPresent() = 0;
+
+#ifndef _PS3
+ // Asynchronous call to check if an executable file has been signed using the public key set on the signing tab
+ // of the partner site, for example to refuse to load modified executable files.
+ // The result is returned in CheckFileSignature_t.
+ // k_ECheckFileSignatureNoSignaturesFoundForThisApp - This app has not been configured on the signing tab of the partner site to enable this function.
+ // k_ECheckFileSignatureNoSignaturesFoundForThisFile - This file is not listed on the signing tab for the partner site.
+ // k_ECheckFileSignatureFileNotFound - The file does not exist on disk.
+ // k_ECheckFileSignatureInvalidSignature - The file exists, and the signing tab has been set for this file, but the file is either not signed or the signature does not match.
+ // k_ECheckFileSignatureValidSignature - The file is signed and the signature is valid.
+ virtual SteamAPICall_t CheckFileSignature( const char *szFileName ) = 0;
+#endif
+
+#ifdef _PS3
+ virtual void PostPS3SysutilCallback( uint64_t status, uint64_t param, void* userdata ) = 0;
+ virtual bool BIsReadyToShutdown() = 0;
+ virtual bool BIsPSNOnline() = 0;
+
+ // Call this with localized strings for the language the game is running in, otherwise default english
+ // strings will be used by Steam.
+ virtual void SetPSNGameBootInviteStrings( const char *pchSubject, const char *pchBody ) = 0;
+#endif
+
+ // Activates the Big Picture text input dialog which only supports gamepad input
+ virtual bool ShowGamepadTextInput( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32 unCharMax, const char *pchExistingText ) = 0;
+
+ // Returns previously entered text & length
+ virtual uint32 GetEnteredGamepadTextLength() = 0;
+ virtual bool GetEnteredGamepadTextInput( char *pchText, uint32 cchText ) = 0;
+
+ // returns the language the steam client is running in, you probably want ISteamApps::GetCurrentGameLanguage instead, this is for very special usage cases
+ virtual const char *GetSteamUILanguage() = 0;
+
+ // returns true if Steam itself is running in VR mode
+ virtual bool IsSteamRunningInVR() = 0;
+};
+
+#define STEAMUTILS_INTERFACE_VERSION "SteamUtils007"
+
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: The country of the user changed
+//-----------------------------------------------------------------------------
+struct IPCountry_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 1 };
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fired when running on a laptop and less than 10 minutes of battery is left, fires then every minute
+//-----------------------------------------------------------------------------
+struct LowBatteryPower_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 2 };
+ uint8 m_nMinutesBatteryLeft;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a SteamAsyncCall_t has completed (or failed)
+//-----------------------------------------------------------------------------
+struct SteamAPICallCompleted_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 3 };
+ SteamAPICall_t m_hAsyncCall;
+};
+
+
+//-----------------------------------------------------------------------------
+// called when Steam wants to shutdown
+//-----------------------------------------------------------------------------
+struct SteamShutdown_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 4 };
+};
+
+//-----------------------------------------------------------------------------
+// results for CheckFileSignature
+//-----------------------------------------------------------------------------
+enum ECheckFileSignature
+{
+ k_ECheckFileSignatureInvalidSignature = 0,
+ k_ECheckFileSignatureValidSignature = 1,
+ k_ECheckFileSignatureFileNotFound = 2,
+ k_ECheckFileSignatureNoSignaturesFoundForThisApp = 3,
+ k_ECheckFileSignatureNoSignaturesFoundForThisFile = 4,
+};
+
+//-----------------------------------------------------------------------------
+// callback for CheckFileSignature
+//-----------------------------------------------------------------------------
+struct CheckFileSignature_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 5 };
+ ECheckFileSignature m_eCheckFileSignature;
+};
+
+#ifdef _PS3
+//-----------------------------------------------------------------------------
+// callback for NetCtlNetStartDialog finishing on PS3
+//-----------------------------------------------------------------------------
+struct NetStartDialogFinished_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 6 };
+};
+
+//-----------------------------------------------------------------------------
+// callback for NetCtlNetStartDialog unloaded on PS3
+//-----------------------------------------------------------------------------
+struct NetStartDialogUnloaded_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 7 };
+};
+
+//-----------------------------------------------------------------------------
+// callback for system menu closing on PS3 - should trigger resyncronizing friends list, etc.
+//-----------------------------------------------------------------------------
+struct PS3SystemMenuClosed_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 8 };
+};
+
+//-----------------------------------------------------------------------------
+// callback for NP message being selected by user on PS3 - should trigger handling of message if it's a lobby invite, etc.
+//-----------------------------------------------------------------------------
+struct PS3NPMessageSelected_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 9 };
+ uint32 dataid;
+};
+
+//-----------------------------------------------------------------------------
+// callback for when the PS3 keyboard dialog closes
+//-----------------------------------------------------------------------------
+struct PS3KeyboardDialogFinished_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 10 };
+};
+
+// k_iSteamUtilsCallbacks + 11 is taken
+
+//-----------------------------------------------------------------------------
+// callback for PSN status changing on PS3
+//-----------------------------------------------------------------------------
+struct PS3PSNStatusChange_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 12 };
+ bool m_bPSNOnline;
+};
+
+#endif
+
+// k_iSteamUtilsCallbacks + 13 is taken
+
+
+//-----------------------------------------------------------------------------
+// Big Picture gamepad text input has been closed
+//-----------------------------------------------------------------------------
+struct GamepadTextInputDismissed_t
+{
+ enum { k_iCallback = k_iSteamUtilsCallbacks + 14 };
+ bool m_bSubmitted; // true if user entered & accepted text (Call ISteamUtils::GetEnteredGamepadTextInput() for text), false if canceled input
+ uint32 m_unSubmittedText;
+};
+
+// k_iSteamUtilsCallbacks + 15 is taken
+
+#pragma pack( pop )
+
+#endif // ISTEAMUTILS_H
diff --git a/lsteamclient/steamworks_sdk_130x/matchmakingtypes.h b/lsteamclient/steamworks_sdk_130x/matchmakingtypes.h
new file mode 100644
index 00000000..28c58500
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/matchmakingtypes.h
@@ -0,0 +1,249 @@
+//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef MATCHMAKINGTYPES_H
+#define MATCHMAKINGTYPES_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#ifdef POSIX
+#ifndef _snprintf
+#define _snprintf snprintf
+#endif
+#endif
+
+#include
+#include
+
+//
+// Max size (in bytes of UTF-8 data, not in characters) of server fields, including null terminator.
+// WARNING: These cannot be changed easily, without breaking clients using old interfaces.
+//
+const int k_cbMaxGameServerGameDir = 32;
+const int k_cbMaxGameServerMapName = 32;
+const int k_cbMaxGameServerGameDescription = 64;
+const int k_cbMaxGameServerName = 64;
+const int k_cbMaxGameServerTags = 128;
+const int k_cbMaxGameServerGameData = 2048;
+
+/// Store key/value pair used in matchmaking queries.
+///
+/// Actually, the name Key/Value is a bit misleading. The "key" is better
+/// understood as "filter operation code" and the "value" is the operand to this
+/// filter operation. The meaning of the operand depends upon the filter.
+struct MatchMakingKeyValuePair_t
+{
+ MatchMakingKeyValuePair_t() { m_szKey[0] = m_szValue[0] = 0; }
+ MatchMakingKeyValuePair_t( const char *pchKey, const char *pchValue )
+ {
+ strncpy( m_szKey, pchKey, sizeof(m_szKey) ); // this is a public header, use basic c library string funcs only!
+ m_szKey[ sizeof( m_szKey ) - 1 ] = '\0';
+ strncpy( m_szValue, pchValue, sizeof(m_szValue) );
+ m_szValue[ sizeof( m_szValue ) - 1 ] = '\0';
+ }
+ char m_szKey[ 256 ];
+ char m_szValue[ 256 ];
+};
+
+
+enum EMatchMakingServerResponse
+{
+ eServerResponded = 0,
+ eServerFailedToRespond,
+ eNoServersListedOnMasterServer // for the Internet query type, returned in response callback if no servers of this type match
+};
+
+// servernetadr_t is all the addressing info the serverbrowser needs to know about a game server,
+// namely: its IP, its connection port, and its query port.
+class servernetadr_t
+{
+public:
+
+ void Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort );
+#ifdef NETADR_H
+ netadr_t GetIPAndQueryPort();
+#endif
+
+ // Access the query port.
+ uint16 GetQueryPort() const;
+ void SetQueryPort( uint16 usPort );
+
+ // Access the connection port.
+ uint16 GetConnectionPort() const;
+ void SetConnectionPort( uint16 usPort );
+
+ // Access the IP
+ uint32 GetIP() const;
+ void SetIP( uint32 );
+
+ // This gets the 'a.b.c.d:port' string with the connection port (instead of the query port).
+ const char *GetConnectionAddressString() const;
+ const char *GetQueryAddressString() const;
+
+ // Comparison operators and functions.
+ bool operator<(const servernetadr_t &netadr) const;
+ void operator=( const servernetadr_t &that )
+ {
+ m_usConnectionPort = that.m_usConnectionPort;
+ m_usQueryPort = that.m_usQueryPort;
+ m_unIP = that.m_unIP;
+ }
+
+
+private:
+ const char *ToString( uint32 unIP, uint16 usPort ) const;
+ uint16 m_usConnectionPort; // (in HOST byte order)
+ uint16 m_usQueryPort;
+ uint32 m_unIP;
+};
+
+
+inline void servernetadr_t::Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort )
+{
+ m_unIP = ip;
+ m_usQueryPort = usQueryPort;
+ m_usConnectionPort = usConnectionPort;
+}
+
+#ifdef NETADR_H
+inline netadr_t servernetadr_t::GetIPAndQueryPort()
+{
+ return netadr_t( m_unIP, m_usQueryPort );
+}
+#endif
+
+inline uint16 servernetadr_t::GetQueryPort() const
+{
+ return m_usQueryPort;
+}
+
+inline void servernetadr_t::SetQueryPort( uint16 usPort )
+{
+ m_usQueryPort = usPort;
+}
+
+inline uint16 servernetadr_t::GetConnectionPort() const
+{
+ return m_usConnectionPort;
+}
+
+inline void servernetadr_t::SetConnectionPort( uint16 usPort )
+{
+ m_usConnectionPort = usPort;
+}
+
+inline uint32 servernetadr_t::GetIP() const
+{
+ return m_unIP;
+}
+
+inline void servernetadr_t::SetIP( uint32 unIP )
+{
+ m_unIP = unIP;
+}
+
+inline const char *servernetadr_t::ToString( uint32 unIP, uint16 usPort ) const
+{
+ static char s[4][64];
+ static int nBuf = 0;
+ unsigned char *ipByte = (unsigned char *)&unIP;
+#ifdef VALVE_BIG_ENDIAN
+ _snprintf (s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[0]), (int)(ipByte[1]), (int)(ipByte[2]), (int)(ipByte[3]), usPort );
+#else
+ _snprintf (s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[3]), (int)(ipByte[2]), (int)(ipByte[1]), (int)(ipByte[0]), usPort );
+#endif
+ const char *pchRet = s[nBuf];
+ ++nBuf;
+ nBuf %= ( (sizeof(s)/sizeof(s[0])) );
+ return pchRet;
+}
+
+inline const char* servernetadr_t::GetConnectionAddressString() const
+{
+ return ToString( m_unIP, m_usConnectionPort );
+}
+
+inline const char* servernetadr_t::GetQueryAddressString() const
+{
+ return ToString( m_unIP, m_usQueryPort );
+}
+
+inline bool servernetadr_t::operator<(const servernetadr_t &netadr) const
+{
+ return ( m_unIP < netadr.m_unIP ) || ( m_unIP == netadr.m_unIP && m_usQueryPort < netadr.m_usQueryPort );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Data describing a single server
+//-----------------------------------------------------------------------------
+class gameserveritem_t
+{
+public:
+ gameserveritem_t();
+
+ const char* GetName() const;
+ void SetName( const char *pName );
+
+public:
+ servernetadr_t m_NetAdr; ///< IP/Query Port/Connection Port for this server
+ int m_nPing; ///< current ping time in milliseconds
+ bool m_bHadSuccessfulResponse; ///< server has responded successfully in the past
+ bool m_bDoNotRefresh; ///< server is marked as not responding and should no longer be refreshed
+ char m_szGameDir[k_cbMaxGameServerGameDir]; ///< current game directory
+ char m_szMap[k_cbMaxGameServerMapName]; ///< current map
+ char m_szGameDescription[k_cbMaxGameServerGameDescription]; ///< game description
+ uint32 m_nAppID; ///< Steam App ID of this server
+ int m_nPlayers; ///< total number of players currently on the server. INCLUDES BOTS!!
+ int m_nMaxPlayers; ///< Maximum players that can join this server
+ int m_nBotPlayers; ///< Number of bots (i.e simulated players) on this server
+ bool m_bPassword; ///< true if this server needs a password to join
+ bool m_bSecure; ///< Is this server protected by VAC
+ uint32 m_ulTimeLastPlayed; ///< time (in unix time) when this server was last played on (for favorite/history servers)
+ int m_nServerVersion; ///< server version as reported to Steam
+
+private:
+
+ /// Game server name
+ char m_szServerName[k_cbMaxGameServerName];
+
+ // For data added after SteamMatchMaking001 add it here
+public:
+ /// the tags this server exposes
+ char m_szGameTags[k_cbMaxGameServerTags];
+
+ /// steamID of the game server - invalid if it's doesn't have one (old server, or not connected to Steam)
+ CSteamID m_steamID;
+};
+
+
+inline gameserveritem_t::gameserveritem_t()
+{
+ m_szGameDir[0] = m_szMap[0] = m_szGameDescription[0] = m_szServerName[0] = 0;
+ m_bHadSuccessfulResponse = m_bDoNotRefresh = m_bPassword = m_bSecure = false;
+ m_nPing = m_nAppID = m_nPlayers = m_nMaxPlayers = m_nBotPlayers = m_ulTimeLastPlayed = m_nServerVersion = 0;
+ m_szGameTags[0] = 0;
+}
+
+inline const char* gameserveritem_t::GetName() const
+{
+ // Use the IP address as the name if nothing is set yet.
+ if ( m_szServerName[0] == 0 )
+ return m_NetAdr.GetConnectionAddressString();
+ else
+ return m_szServerName;
+}
+
+inline void gameserveritem_t::SetName( const char *pName )
+{
+ strncpy( m_szServerName, pName, sizeof( m_szServerName ) );
+ m_szServerName[ sizeof( m_szServerName ) - 1 ] = '\0';
+}
+
+
+#endif // MATCHMAKINGTYPES_H
diff --git a/lsteamclient/steamworks_sdk_130x/steam_api.h b/lsteamclient/steamworks_sdk_130x/steam_api.h
new file mode 100644
index 00000000..2890cb15
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steam_api.h
@@ -0,0 +1,583 @@
+//====== Copyright 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAM_API_H
+#define STEAM_API_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "isteamuser.h"
+#include "isteamfriends.h"
+#include "isteamutils.h"
+#include "isteammatchmaking.h"
+#include "isteamuserstats.h"
+#include "isteamapps.h"
+#include "isteamnetworking.h"
+#include "isteamremotestorage.h"
+#include "isteamscreenshots.h"
+#include "isteammusic.h"
+#include "isteammusicremote.h"
+#include "isteamhttp.h"
+#include "isteamunifiedmessages.h"
+#include "isteamcontroller.h"
+#include "isteamugc.h"
+#include "isteamapplist.h"
+#include "isteamhtmlsurface.h"
+
+#if defined( _PS3 )
+#include "steamps3params.h"
+#endif
+
+// Steam API export macro
+#if defined( _WIN32 ) && !defined( _X360 )
+ #if defined( STEAM_API_EXPORTS )
+ #define S_API extern "C" __declspec( dllexport )
+ #elif defined( STEAM_API_NODLL )
+ #define S_API extern "C"
+ #else
+ #define S_API extern "C" __declspec( dllimport )
+ #endif // STEAM_API_EXPORTS
+#elif defined( GNUC )
+ #if defined( STEAM_API_EXPORTS )
+ #define S_API extern "C" __attribute__ ((visibility("default")))
+ #else
+ #define S_API extern "C"
+ #endif // STEAM_API_EXPORTS
+#else // !WIN32
+ #if defined( STEAM_API_EXPORTS )
+ #define S_API extern "C"
+ #else
+ #define S_API extern "C"
+ #endif // STEAM_API_EXPORTS
+#endif
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// Steam API setup & shutdown
+//
+// These functions manage loading, initializing and shutdown of the steamclient.dll
+//
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+// S_API void SteamAPI_Init(); (see below)
+S_API void S_CALLTYPE SteamAPI_Shutdown();
+
+// checks if a local Steam client is running
+S_API bool S_CALLTYPE SteamAPI_IsSteamRunning();
+
+// Detects if your executable was launched through the Steam client, and restarts your game through
+// the client if necessary. The Steam client will be started if it is not running.
+//
+// Returns: true if your executable was NOT launched through the Steam client. This function will
+// then start your application through the client. Your current process should exit.
+//
+// false if your executable was started through the Steam client or a steam_appid.txt file
+// is present in your game's directory (for development). Your current process should continue.
+//
+// NOTE: This function should be used only if you are using CEG or not using Steam's DRM. Once applied
+// to your executable, Steam's DRM will handle restarting through Steam if necessary.
+S_API bool S_CALLTYPE SteamAPI_RestartAppIfNecessary( uint32 unOwnAppID );
+
+// crash dump recording functions
+S_API void S_CALLTYPE SteamAPI_WriteMiniDump( uint32 uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID );
+S_API void S_CALLTYPE SteamAPI_SetMiniDumpComment( const char *pchMsg );
+
+// interface pointers, configured by SteamAPI_Init()
+S_API ISteamClient *S_CALLTYPE SteamClient();
+
+
+//
+// VERSION_SAFE_STEAM_API_INTERFACES is usually not necessary, but it provides safety against releasing
+// new steam_api.dll's without recompiling/rereleasing modules that use it.
+//
+// If you use VERSION_SAFE_STEAM_API_INTERFACES, then you should call SteamAPI_InitSafe(). Also, to get the
+// Steam interfaces, you must create and Init() a CSteamAPIContext (below) and use the interfaces in there.
+//
+// If you don't use VERSION_SAFE_STEAM_API_INTERFACES, then you can use SteamAPI_Init() and the SteamXXXX()
+// functions below to get at the Steam interfaces.
+//
+#ifdef VERSION_SAFE_STEAM_API_INTERFACES
+S_API bool S_CALLTYPE SteamAPI_InitSafe();
+#else
+
+#if defined(_PS3)
+S_API bool S_CALLTYPE SteamAPI_Init( SteamPS3Params_t *pParams );
+#else
+S_API bool S_CALLTYPE SteamAPI_Init();
+#endif
+
+S_API ISteamUser *S_CALLTYPE SteamUser();
+S_API ISteamFriends *S_CALLTYPE SteamFriends();
+S_API ISteamUtils *S_CALLTYPE SteamUtils();
+S_API ISteamMatchmaking *S_CALLTYPE SteamMatchmaking();
+S_API ISteamUserStats *S_CALLTYPE SteamUserStats();
+S_API ISteamApps *S_CALLTYPE SteamApps();
+S_API ISteamNetworking *S_CALLTYPE SteamNetworking();
+S_API ISteamMatchmakingServers *S_CALLTYPE SteamMatchmakingServers();
+S_API ISteamRemoteStorage *S_CALLTYPE SteamRemoteStorage();
+S_API ISteamScreenshots *S_CALLTYPE SteamScreenshots();
+S_API ISteamHTTP *S_CALLTYPE SteamHTTP();
+S_API ISteamUnifiedMessages *S_CALLTYPE SteamUnifiedMessages();
+S_API ISteamController *S_CALLTYPE SteamController();
+S_API ISteamUGC *S_CALLTYPE SteamUGC();
+S_API ISteamAppList *S_CALLTYPE SteamAppList();
+S_API ISteamMusic *S_CALLTYPE SteamMusic();
+S_API ISteamMusicRemote *S_CALLTYPE SteamMusicRemote();
+S_API ISteamHTMLSurface *S_CALLTYPE SteamHTMLSurface();
+#ifdef _PS3
+S_API ISteamPS3OverlayRender *S_CALLTYPE SteamPS3OverlayRender();
+#endif
+#endif // VERSION_SAFE_STEAM_API_INTERFACES
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// steam callback helper functions
+//
+// The following classes/macros are used to be able to easily multiplex callbacks
+// from the Steam API into various objects in the app in a thread-safe manner
+//
+// These functors are triggered via the SteamAPI_RunCallbacks() function, mapping the callback
+// to as many functions/objects as are registered to it
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+S_API void S_CALLTYPE SteamAPI_RunCallbacks();
+
+
+
+// functions used by the utility CCallback objects to receive callbacks
+S_API void S_CALLTYPE SteamAPI_RegisterCallback( class CCallbackBase *pCallback, int iCallback );
+S_API void S_CALLTYPE SteamAPI_UnregisterCallback( class CCallbackBase *pCallback );
+// functions used by the utility CCallResult objects to receive async call results
+S_API void S_CALLTYPE SteamAPI_RegisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
+S_API void S_CALLTYPE SteamAPI_UnregisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: base for callbacks,
+// used only by CCallback, shouldn't be used directly
+//-----------------------------------------------------------------------------
+class CCallbackBase
+{
+public:
+ CCallbackBase() { m_nCallbackFlags = 0; m_iCallback = 0; }
+ // don't add a virtual destructor because we export this binary interface across dll's
+ virtual void Run( void *pvParam ) = 0;
+ virtual void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall ) = 0;
+ int GetICallback() { return m_iCallback; }
+ virtual int GetCallbackSizeBytes() = 0;
+
+protected:
+ enum { k_ECallbackFlagsRegistered = 0x01, k_ECallbackFlagsGameServer = 0x02 };
+ uint8 m_nCallbackFlags;
+ int m_iCallback;
+ friend class CCallbackMgr;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: maps a steam async call result to a class member function
+// template params: T = local class, P = parameter struct
+//-----------------------------------------------------------------------------
+template< class T, class P >
+class CCallResult : private CCallbackBase
+{
+public:
+ typedef void (T::*func_t)( P*, bool );
+
+ CCallResult()
+ {
+ m_hAPICall = k_uAPICallInvalid;
+ m_pObj = NULL;
+ m_Func = NULL;
+ m_iCallback = P::k_iCallback;
+ }
+
+ void Set( SteamAPICall_t hAPICall, T *p, func_t func )
+ {
+ if ( m_hAPICall )
+ SteamAPI_UnregisterCallResult( this, m_hAPICall );
+
+ m_hAPICall = hAPICall;
+ m_pObj = p;
+ m_Func = func;
+
+ if ( hAPICall )
+ SteamAPI_RegisterCallResult( this, hAPICall );
+ }
+
+ bool IsActive() const
+ {
+ return ( m_hAPICall != k_uAPICallInvalid );
+ }
+
+ void Cancel()
+ {
+ if ( m_hAPICall != k_uAPICallInvalid )
+ {
+ SteamAPI_UnregisterCallResult( this, m_hAPICall );
+ m_hAPICall = k_uAPICallInvalid;
+ }
+
+ }
+
+ ~CCallResult()
+ {
+ Cancel();
+ }
+
+ void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
+private:
+ virtual void Run( void *pvParam )
+ {
+ m_hAPICall = k_uAPICallInvalid; // caller unregisters for us
+ (m_pObj->*m_Func)( (P *)pvParam, false );
+ }
+ void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall )
+ {
+ if ( hSteamAPICall == m_hAPICall )
+ {
+ m_hAPICall = k_uAPICallInvalid; // caller unregisters for us
+ (m_pObj->*m_Func)( (P *)pvParam, bIOFailure );
+ }
+ }
+ int GetCallbackSizeBytes()
+ {
+ return sizeof( P );
+ }
+
+ SteamAPICall_t m_hAPICall;
+ T *m_pObj;
+ func_t m_Func;
+};
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: maps a steam callback to a class member function
+// template params: T = local class, P = parameter struct
+//-----------------------------------------------------------------------------
+template< class T, class P, bool bGameServer >
+class CCallback : protected CCallbackBase
+{
+public:
+ typedef void (T::*func_t)( P* );
+
+ // If you can't support constructing a callback with the correct parameters
+ // then uncomment the empty constructor below and manually call
+ // ::Register() for your object
+ // Or, just call the regular constructor with (NULL, NULL)
+ // CCallback() {}
+
+ // constructor for initializing this object in owner's constructor
+ CCallback( T *pObj, func_t func ) : m_pObj( pObj ), m_Func( func )
+ {
+ if ( pObj && func )
+ Register( pObj, func );
+ }
+
+ ~CCallback()
+ {
+ if ( m_nCallbackFlags & k_ECallbackFlagsRegistered )
+ Unregister();
+ }
+
+ // manual registration of the callback
+ void Register( T *pObj, func_t func )
+ {
+ if ( !pObj || !func )
+ return;
+
+ if ( m_nCallbackFlags & k_ECallbackFlagsRegistered )
+ Unregister();
+
+ if ( bGameServer )
+ {
+ m_nCallbackFlags |= k_ECallbackFlagsGameServer;
+ }
+ m_pObj = pObj;
+ m_Func = func;
+ // SteamAPI_RegisterCallback sets k_ECallbackFlagsRegistered
+ SteamAPI_RegisterCallback( this, P::k_iCallback );
+ }
+
+ void Unregister()
+ {
+ // SteamAPI_UnregisterCallback removes k_ECallbackFlagsRegistered
+ SteamAPI_UnregisterCallback( this );
+ }
+
+ void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
+protected:
+ virtual void Run( void *pvParam )
+ {
+ (m_pObj->*m_Func)( (P *)pvParam );
+ }
+ virtual void Run( void *pvParam, bool, SteamAPICall_t )
+ {
+ (m_pObj->*m_Func)( (P *)pvParam );
+ }
+ int GetCallbackSizeBytes()
+ {
+ return sizeof( P );
+ }
+
+ T *m_pObj;
+ func_t m_Func;
+};
+
+// Allows you to defer registration of the callback
+template< class T, class P, bool bGameServer >
+class CCallbackManual : public CCallback< T, P, bGameServer >
+{
+public:
+ CCallbackManual() : CCallback< T, P, bGameServer >( NULL, NULL ) {}
+};
+
+// utility macro for declaring the function and callback object together
+#define STEAM_CALLBACK( thisclass, func, param, var ) CCallback< thisclass, param, false > var; void func( param *pParam )
+
+// same as above, but lets you defer the callback binding by calling Register later
+#define STEAM_CALLBACK_MANUAL( thisclass, func, param, var ) CCallbackManual< thisclass, param, false > var; void func( param *pParam )
+
+
+#ifdef _WIN32
+// disable this warning; this pattern need for steam callback registration
+#pragma warning( disable: 4355 ) // 'this' : used in base member initializer list
+#endif
+
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// 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
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+// pumps out all the steam messages, calling the register callback
+S_API void Steam_RunCallbacks( HSteamPipe hSteamPipe, bool bGameServerCallbacks );
+
+// register the callback funcs to use to interact with the steam dll
+S_API void Steam_RegisterInterfaceFuncs( void *hModule );
+
+// returns the HSteamUser of the last user to dispatch a callback
+S_API HSteamUser Steam_GetHSteamUserCurrent();
+
+// returns the filename path of the current running Steam process, used if you need to load an explicit steam dll by name
+S_API const char *SteamAPI_GetSteamInstallPath();
+
+// returns the pipe we are communicating to Steam with
+S_API HSteamPipe SteamAPI_GetHSteamPipe();
+
+// sets whether or not Steam_RunCallbacks() should do a try {} catch (...) {} around calls to issuing callbacks
+S_API void SteamAPI_SetTryCatchCallbacks( bool bTryCatchCallbacks );
+
+// backwards compat export, passes through to SteamAPI_ variants
+S_API HSteamPipe GetHSteamPipe();
+S_API HSteamUser GetHSteamUser();
+
+#ifdef VERSION_SAFE_STEAM_API_INTERFACES
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// VERSION_SAFE_STEAM_API_INTERFACES uses CSteamAPIContext to provide interfaces to each module in a way that
+// lets them each specify the interface versions they are compiled with.
+//
+// It's important that these stay inlined in the header so the calling module specifies the interface versions
+// for whatever Steam API version it has.
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+S_API HSteamUser SteamAPI_GetHSteamUser();
+
+class CSteamAPIContext
+{
+public:
+ CSteamAPIContext();
+ void Clear();
+
+ bool Init();
+
+ ISteamUser* SteamUser() { return m_pSteamUser; }
+ ISteamFriends* SteamFriends() { return m_pSteamFriends; }
+ ISteamUtils* SteamUtils() { return m_pSteamUtils; }
+ ISteamMatchmaking* SteamMatchmaking() { return m_pSteamMatchmaking; }
+ ISteamUserStats* SteamUserStats() { return m_pSteamUserStats; }
+ ISteamApps* SteamApps() { return m_pSteamApps; }
+ ISteamMatchmakingServers* SteamMatchmakingServers() { return m_pSteamMatchmakingServers; }
+ ISteamNetworking* SteamNetworking() { return m_pSteamNetworking; }
+ ISteamRemoteStorage* SteamRemoteStorage() { return m_pSteamRemoteStorage; }
+ ISteamScreenshots* SteamScreenshots() { return m_pSteamScreenshots; }
+ ISteamHTTP* SteamHTTP() { return m_pSteamHTTP; }
+ ISteamUnifiedMessages* SteamUnifiedMessages() { return m_pSteamUnifiedMessages; }
+ ISteamController* SteamController() { return m_pController; }
+ ISteamUGC* SteamUGC() { return m_pSteamUGC; }
+ ISteamAppList* SteamAppList() { return m_pSteamAppList; }
+ ISteamMusic* SteamMusic() { return m_pSteamMusic; }
+ ISteamMusicRemote* SteamMusicRemote() { return m_pSteamMusicRemote; }
+ ISteamHTMLSurface* SteamHTMLSurface() { return m_pSteamHTMLSurface; }
+#ifdef _PS3
+ ISteamPS3OverlayRender* SteamPS3OverlayRender() { return m_pSteamPS3OverlayRender; }
+#endif
+
+private:
+ ISteamUser *m_pSteamUser;
+ ISteamFriends *m_pSteamFriends;
+ ISteamUtils *m_pSteamUtils;
+ ISteamMatchmaking *m_pSteamMatchmaking;
+ ISteamUserStats *m_pSteamUserStats;
+ ISteamApps *m_pSteamApps;
+ ISteamMatchmakingServers *m_pSteamMatchmakingServers;
+ ISteamNetworking *m_pSteamNetworking;
+ ISteamRemoteStorage *m_pSteamRemoteStorage;
+ ISteamScreenshots *m_pSteamScreenshots;
+ ISteamHTTP *m_pSteamHTTP;
+ ISteamUnifiedMessages*m_pSteamUnifiedMessages;
+ ISteamController *m_pController;
+ ISteamUGC *m_pSteamUGC;
+ ISteamAppList *m_pSteamAppList;
+ ISteamMusic *m_pSteamMusic;
+ ISteamMusicRemote *m_pSteamMusicRemote;
+ ISteamHTMLSurface *m_pSteamHTMLSurface;
+#ifdef _PS3
+ ISteamPS3OverlayRender *m_pSteamPS3OverlayRender;
+#endif
+};
+
+inline CSteamAPIContext::CSteamAPIContext()
+{
+ Clear();
+}
+
+inline void CSteamAPIContext::Clear()
+{
+ m_pSteamUser = NULL;
+ m_pSteamFriends = NULL;
+ m_pSteamUtils = NULL;
+ m_pSteamMatchmaking = NULL;
+ m_pSteamUserStats = NULL;
+ m_pSteamApps = NULL;
+ m_pSteamMatchmakingServers = NULL;
+ m_pSteamNetworking = NULL;
+ m_pSteamRemoteStorage = NULL;
+ m_pSteamHTTP = NULL;
+ m_pSteamScreenshots = NULL;
+ m_pSteamMusic = NULL;
+ m_pSteamUnifiedMessages = NULL;
+ m_pController = NULL;
+ m_pSteamUGC = NULL;
+ m_pSteamAppList = NULL;
+ m_pSteamMusic = NULL;
+ m_pSteamMusicRemote= NULL;
+ m_pSteamHTMLSurface = NULL;
+#ifdef _PS3
+ m_pSteamPS3OverlayRender = NULL;
+#endif
+}
+
+// This function must be inlined so the module using steam_api.dll gets the version names they want.
+inline bool CSteamAPIContext::Init()
+{
+ if ( !SteamClient() )
+ return false;
+
+ HSteamUser hSteamUser = SteamAPI_GetHSteamUser();
+ HSteamPipe hSteamPipe = SteamAPI_GetHSteamPipe();
+
+ m_pSteamUser = SteamClient()->GetISteamUser( hSteamUser, hSteamPipe, STEAMUSER_INTERFACE_VERSION );
+ if ( !m_pSteamUser )
+ return false;
+
+ m_pSteamFriends = SteamClient()->GetISteamFriends( hSteamUser, hSteamPipe, STEAMFRIENDS_INTERFACE_VERSION );
+ if ( !m_pSteamFriends )
+ return false;
+
+ m_pSteamUtils = SteamClient()->GetISteamUtils( hSteamPipe, STEAMUTILS_INTERFACE_VERSION );
+ if ( !m_pSteamUtils )
+ return false;
+
+ m_pSteamMatchmaking = SteamClient()->GetISteamMatchmaking( hSteamUser, hSteamPipe, STEAMMATCHMAKING_INTERFACE_VERSION );
+ if ( !m_pSteamMatchmaking )
+ return false;
+
+ m_pSteamMatchmakingServers = SteamClient()->GetISteamMatchmakingServers( hSteamUser, hSteamPipe, STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION );
+ if ( !m_pSteamMatchmakingServers )
+ return false;
+
+ m_pSteamUserStats = SteamClient()->GetISteamUserStats( hSteamUser, hSteamPipe, STEAMUSERSTATS_INTERFACE_VERSION );
+ if ( !m_pSteamUserStats )
+ return false;
+
+ m_pSteamApps = SteamClient()->GetISteamApps( hSteamUser, hSteamPipe, STEAMAPPS_INTERFACE_VERSION );
+ if ( !m_pSteamApps )
+ return false;
+
+ m_pSteamNetworking = SteamClient()->GetISteamNetworking( hSteamUser, hSteamPipe, STEAMNETWORKING_INTERFACE_VERSION );
+ if ( !m_pSteamNetworking )
+ return false;
+
+ m_pSteamRemoteStorage = SteamClient()->GetISteamRemoteStorage( hSteamUser, hSteamPipe, STEAMREMOTESTORAGE_INTERFACE_VERSION );
+ if ( !m_pSteamRemoteStorage )
+ return false;
+
+ m_pSteamScreenshots = SteamClient()->GetISteamScreenshots( hSteamUser, hSteamPipe, STEAMSCREENSHOTS_INTERFACE_VERSION );
+ if ( !m_pSteamScreenshots )
+ return false;
+
+ m_pSteamHTTP = SteamClient()->GetISteamHTTP( hSteamUser, hSteamPipe, STEAMHTTP_INTERFACE_VERSION );
+ if ( !m_pSteamHTTP )
+ return false;
+
+ m_pSteamUnifiedMessages = SteamClient()->GetISteamUnifiedMessages( hSteamUser, hSteamPipe, STEAMUNIFIEDMESSAGES_INTERFACE_VERSION );
+ if ( !m_pSteamUnifiedMessages )
+ return false;
+
+ m_pController = SteamClient()->GetISteamController( hSteamUser, hSteamPipe, STEAMCONTROLLER_INTERFACE_VERSION );
+ if ( !m_pController )
+ return false;
+
+ m_pSteamUGC = SteamClient()->GetISteamUGC( hSteamUser, hSteamPipe, STEAMUGC_INTERFACE_VERSION );
+ if ( !m_pSteamUGC )
+ return false;
+
+ m_pSteamAppList = SteamClient()->GetISteamAppList( hSteamUser, hSteamPipe, STEAMAPPLIST_INTERFACE_VERSION );
+ if ( !m_pSteamAppList )
+ return false;
+
+ m_pSteamMusic = SteamClient()->GetISteamMusic( hSteamUser, hSteamPipe, STEAMMUSIC_INTERFACE_VERSION );
+ if ( !m_pSteamMusic )
+ {
+ return false;
+ }
+
+ m_pSteamMusicRemote = SteamClient()->GetISteamMusicRemote( hSteamUser, hSteamPipe, STEAMMUSICREMOTE_INTERFACE_VERSION );
+ if ( !m_pSteamMusicRemote )
+ {
+ return false;
+ }
+
+ m_pSteamHTMLSurface = SteamClient()->GetISteamHTMLSurface( hSteamUser, hSteamPipe, STEAMHTMLSURFACE_INTERFACE_VERSION );
+ if ( !m_pSteamHTMLSurface )
+ {
+ return false;
+ }
+
+#ifdef _PS3
+ m_pSteamPS3OverlayRender = SteamClient()->GetISteamPS3OverlayRender();
+#endif
+
+ return true;
+}
+
+#endif // VERSION_SAFE_STEAM_API_INTERFACES
+
+#if defined(USE_BREAKPAD_HANDLER) || defined(STEAM_API_EXPORTS)
+// this should be called before the game initialized the steam APIs
+// pchDate should be of the format "Mmm dd yyyy" (such as from the __DATE__ macro )
+// pchTime should be of the format "hh:mm:ss" (such as from the __TIME__ macro )
+// bFullMemoryDumps (Win32 only) -- writes out a uuid-full.dmp in the client/dumps folder
+// pvContext-- can be NULL, will be the void * context passed into m_pfnPreMinidumpCallback
+// PFNPreMinidumpCallback m_pfnPreMinidumpCallback -- optional callback which occurs just before a .dmp file is written during a crash. Applications can hook this to allow adding additional information into the .dmp comment stream.
+S_API void S_CALLTYPE SteamAPI_UseBreakpadCrashHandler( char const *pchVersion, char const *pchDate, char const *pchTime, bool bFullMemoryDumps, void *pvContext, PFNPreMinidumpCallback m_pfnPreMinidumpCallback );
+S_API void S_CALLTYPE SteamAPI_SetBreakpadAppID( uint32 unAppID );
+#endif
+
+#endif // STEAM_API_H
diff --git a/lsteamclient/steamworks_sdk_130x/steam_gameserver.h b/lsteamclient/steamworks_sdk_130x/steam_gameserver.h
new file mode 100644
index 00000000..2d384894
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steam_gameserver.h
@@ -0,0 +1,163 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAM_GAMESERVER_H
+#define STEAM_GAMESERVER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steam_api.h"
+#include "isteamgameserver.h"
+#include "isteamgameserverstats.h"
+
+enum EServerMode
+{
+ eServerModeInvalid = 0, // DO NOT USE
+ eServerModeNoAuthentication = 1, // Don't authenticate user logins and don't list on the server list
+ eServerModeAuthentication = 2, // Authenticate users, list on the server list, don't run VAC on clients that connect
+ eServerModeAuthenticationAndSecure = 3, // Authenticate users, list on the server list and VAC protect clients
+};
+
+// 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.)
+#ifndef _PS3
+
+#ifdef VERSION_SAFE_STEAM_API_INTERFACES
+S_API bool SteamGameServer_InitSafe( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );
+#else
+S_API bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );
+#endif
+
+#else
+
+#ifdef VERSION_SAFE_STEAM_API_INTERFACES
+S_API bool SteamGameServer_InitSafe( const SteamPS3Params_t *ps3Params, uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );
+#else
+S_API bool SteamGameServer_Init( const SteamPS3Params_t *ps3Params, uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );
+#endif
+
+#endif
+
+#ifndef VERSION_SAFE_STEAM_API_INTERFACES
+S_API ISteamGameServer *SteamGameServer();
+S_API ISteamUtils *SteamGameServerUtils();
+S_API ISteamNetworking *SteamGameServerNetworking();
+S_API ISteamGameServerStats *SteamGameServerStats();
+S_API ISteamHTTP *SteamGameServerHTTP();
+#endif
+
+S_API void SteamGameServer_Shutdown();
+S_API void SteamGameServer_RunCallbacks();
+
+S_API bool SteamGameServer_BSecure();
+S_API uint64 SteamGameServer_GetSteamID();
+
+#define STEAM_GAMESERVER_CALLBACK( thisclass, func, param, var ) CCallback< thisclass, param, true > var; void func( param *pParam )
+
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// 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
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+S_API HSteamPipe SteamGameServer_GetHSteamPipe();
+
+#ifdef VERSION_SAFE_STEAM_API_INTERFACES
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// VERSION_SAFE_STEAM_API_INTERFACES uses CSteamAPIContext to provide interfaces to each module in a way that
+// lets them each specify the interface versions they are compiled with.
+//
+// It's important that these stay inlined in the header so the calling module specifies the interface versions
+// for whatever Steam API version it has.
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+S_API HSteamUser SteamGameServer_GetHSteamUser();
+
+class CSteamGameServerAPIContext
+{
+public:
+ CSteamGameServerAPIContext();
+ void Clear();
+
+ bool Init();
+
+ ISteamGameServer *SteamGameServer() { return m_pSteamGameServer; }
+ ISteamUtils *SteamGameServerUtils() { return m_pSteamGameServerUtils; }
+ ISteamNetworking *SteamGameServerNetworking() { return m_pSteamGameServerNetworking; }
+ ISteamGameServerStats *SteamGameServerStats() { return m_pSteamGameServerStats; }
+ ISteamHTTP *SteamHTTP() { return m_pSteamHTTP; }
+
+private:
+ ISteamGameServer *m_pSteamGameServer;
+ ISteamUtils *m_pSteamGameServerUtils;
+ ISteamNetworking *m_pSteamGameServerNetworking;
+ ISteamGameServerStats *m_pSteamGameServerStats;
+ ISteamHTTP *m_pSteamHTTP;
+};
+
+inline CSteamGameServerAPIContext::CSteamGameServerAPIContext()
+{
+ Clear();
+}
+
+inline void CSteamGameServerAPIContext::Clear()
+{
+ m_pSteamGameServer = NULL;
+ m_pSteamGameServerUtils = NULL;
+ m_pSteamGameServerNetworking = NULL;
+ m_pSteamGameServerStats = NULL;
+ m_pSteamHTTP = NULL;
+}
+
+S_API ISteamClient *g_pSteamClientGameServer;
+// This function must be inlined so the module using steam_api.dll gets the version names they want.
+inline bool CSteamGameServerAPIContext::Init()
+{
+ if ( !g_pSteamClientGameServer )
+ return false;
+
+ HSteamUser hSteamUser = SteamGameServer_GetHSteamUser();
+ HSteamPipe hSteamPipe = SteamGameServer_GetHSteamPipe();
+
+ m_pSteamGameServer = g_pSteamClientGameServer->GetISteamGameServer( hSteamUser, hSteamPipe, STEAMGAMESERVER_INTERFACE_VERSION );
+ if ( !m_pSteamGameServer )
+ return false;
+
+ m_pSteamGameServerUtils = g_pSteamClientGameServer->GetISteamUtils( hSteamPipe, STEAMUTILS_INTERFACE_VERSION );
+ if ( !m_pSteamGameServerUtils )
+ return false;
+
+ m_pSteamGameServerNetworking = g_pSteamClientGameServer->GetISteamNetworking( hSteamUser, hSteamPipe, STEAMNETWORKING_INTERFACE_VERSION );
+ if ( !m_pSteamGameServerNetworking )
+ return false;
+
+ m_pSteamGameServerStats = g_pSteamClientGameServer->GetISteamGameServerStats( hSteamUser, hSteamPipe, STEAMGAMESERVERSTATS_INTERFACE_VERSION );
+ if ( !m_pSteamGameServerStats )
+ return false;
+
+ m_pSteamHTTP = g_pSteamClientGameServer->GetISteamHTTP( hSteamUser, hSteamPipe, STEAMHTTP_INTERFACE_VERSION );
+ if ( !m_pSteamHTTP )
+ return false;
+
+ return true;
+}
+
+#endif // VERSION_SAFE_STEAM_API_INTERFACES
+
+
+#endif // STEAM_GAMESERVER_H
diff --git a/lsteamclient/steamworks_sdk_130x/steamclientpublic.h b/lsteamclient/steamworks_sdk_130x/steamclientpublic.h
new file mode 100644
index 00000000..1620520b
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steamclientpublic.h
@@ -0,0 +1,1102 @@
+//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAMCLIENTPUBLIC_H
+#define STEAMCLIENTPUBLIC_H
+#ifdef _WIN32
+#pragma once
+#endif
+//lint -save -e1931 -e1927 -e1924 -e613 -e726
+
+// This header file defines the interface between the calling application and the code that
+// knows how to communicate with the connection manager (CM) from the Steam service
+
+// This header file is intended to be portable; ideally this 1 header file plus a lib or dll
+// is all you need to integrate the client library into some other tree. So please avoid
+// including or requiring other header files if possible. This header should only describe the
+// interface layer, no need to include anything about the implementation.
+
+#include "steamtypes.h"
+#include "steamuniverse.h"
+
+// General result codes
+enum EResult
+{
+ k_EResultOK = 1, // success
+ k_EResultFail = 2, // generic failure
+ k_EResultNoConnection = 3, // no/failed network connection
+// k_EResultNoConnectionRetry = 4, // OBSOLETE - removed
+ k_EResultInvalidPassword = 5, // password/ticket is invalid
+ k_EResultLoggedInElsewhere = 6, // same user logged in elsewhere
+ k_EResultInvalidProtocolVer = 7, // protocol version is incorrect
+ k_EResultInvalidParam = 8, // a parameter is incorrect
+ k_EResultFileNotFound = 9, // file was not found
+ k_EResultBusy = 10, // called method busy - action not taken
+ k_EResultInvalidState = 11, // called object was in an invalid state
+ k_EResultInvalidName = 12, // name is invalid
+ k_EResultInvalidEmail = 13, // email is invalid
+ k_EResultDuplicateName = 14, // name is not unique
+ k_EResultAccessDenied = 15, // access is denied
+ k_EResultTimeout = 16, // operation timed out
+ k_EResultBanned = 17, // VAC2 banned
+ k_EResultAccountNotFound = 18, // account not found
+ k_EResultInvalidSteamID = 19, // steamID is invalid
+ k_EResultServiceUnavailable = 20, // The requested service is currently unavailable
+ k_EResultNotLoggedOn = 21, // The user is not logged on
+ k_EResultPending = 22, // Request is pending (may be in process, or waiting on third party)
+ k_EResultEncryptionFailure = 23, // Encryption or Decryption failed
+ k_EResultInsufficientPrivilege = 24, // Insufficient privilege
+ k_EResultLimitExceeded = 25, // Too much of a good thing
+ k_EResultRevoked = 26, // Access has been revoked (used for revoked guest passes)
+ k_EResultExpired = 27, // License/Guest pass the user is trying to access is expired
+ k_EResultAlreadyRedeemed = 28, // Guest pass has already been redeemed by account, cannot be acked again
+ k_EResultDuplicateRequest = 29, // The request is a duplicate and the action has already occurred in the past, ignored this time
+ k_EResultAlreadyOwned = 30, // All the games in this guest pass redemption request are already owned by the user
+ k_EResultIPNotFound = 31, // IP address not found
+ k_EResultPersistFailed = 32, // failed to write change to the data store
+ k_EResultLockingFailed = 33, // failed to acquire access lock for this operation
+ k_EResultLogonSessionReplaced = 34,
+ k_EResultConnectFailed = 35,
+ k_EResultHandshakeFailed = 36,
+ k_EResultIOFailure = 37,
+ k_EResultRemoteDisconnect = 38,
+ k_EResultShoppingCartNotFound = 39, // failed to find the shopping cart requested
+ k_EResultBlocked = 40, // a user didn't allow it
+ k_EResultIgnored = 41, // target is ignoring sender
+ k_EResultNoMatch = 42, // nothing matching the request found
+ k_EResultAccountDisabled = 43,
+ k_EResultServiceReadOnly = 44, // this service is not accepting content changes right now
+ k_EResultAccountNotFeatured = 45, // account doesn't have value, so this feature isn't available
+ k_EResultAdministratorOK = 46, // allowed to take this action, but only because requester is admin
+ k_EResultContentVersion = 47, // A Version mismatch in content transmitted within the Steam protocol.
+ k_EResultTryAnotherCM = 48, // The current CM can't service the user making a request, user should try another.
+ k_EResultPasswordRequiredToKickSession = 49,// You are already logged in elsewhere, this cached credential login has failed.
+ k_EResultAlreadyLoggedInElsewhere = 50, // You are already logged in elsewhere, you must wait
+ k_EResultSuspended = 51, // Long running operation (content download) suspended/paused
+ k_EResultCancelled = 52, // Operation canceled (typically by user: content download)
+ k_EResultDataCorruption = 53, // Operation canceled because data is ill formed or unrecoverable
+ k_EResultDiskFull = 54, // Operation canceled - not enough disk space.
+ k_EResultRemoteCallFailed = 55, // an remote call or IPC call failed
+ k_EResultPasswordUnset = 56, // Password could not be verified as it's unset server side
+ k_EResultExternalAccountUnlinked = 57, // External account (PSN, Facebook...) is not linked to a Steam account
+ k_EResultPSNTicketInvalid = 58, // PSN ticket was invalid
+ k_EResultExternalAccountAlreadyLinked = 59, // External account (PSN, Facebook...) is already linked to some other account, must explicitly request to replace/delete the link first
+ k_EResultRemoteFileConflict = 60, // The sync cannot resume due to a conflict between the local and remote files
+ k_EResultIllegalPassword = 61, // The requested new password is not legal
+ k_EResultSameAsPreviousValue = 62, // new value is the same as the old one ( secret question and answer )
+ k_EResultAccountLogonDenied = 63, // account login denied due to 2nd factor authentication failure
+ k_EResultCannotUseOldPassword = 64, // The requested new password is not legal
+ k_EResultInvalidLoginAuthCode = 65, // account login denied due to auth code invalid
+ k_EResultAccountLogonDeniedNoMail = 66, // account login denied due to 2nd factor auth failure - and no mail has been sent
+ k_EResultHardwareNotCapableOfIPT = 67, //
+ k_EResultIPTInitError = 68, //
+ k_EResultParentalControlRestricted = 69, // operation failed due to parental control restrictions for current user
+ k_EResultFacebookQueryError = 70, // Facebook query returned an error
+ k_EResultExpiredLoginAuthCode = 71, // account login denied due to auth code expired
+ k_EResultIPLoginRestrictionFailed = 72,
+ k_EResultAccountLockedDown = 73,
+ k_EResultAccountLogonDeniedVerifiedEmailRequired = 74,
+ k_EResultNoMatchingURL = 75,
+ k_EResultBadResponse = 76, // parse failure, missing field, etc.
+ k_EResultRequirePasswordReEntry = 77, // The user cannot complete the action until they re-enter their password
+ k_EResultValueOutOfRange = 78, // the value entered is outside the acceptable range
+ k_EResultUnexpectedError = 79, // something happened that we didn't expect to ever happen
+ k_EResultDisabled = 80, // The requested service has been configured to be unavailable
+ k_EResultInvalidCEGSubmission = 81, // The set of files submitted to the CEG server are not valid !
+ k_EResultRestrictedDevice = 82, // The device being used is not allowed to perform this action
+ k_EResultRegionLocked = 83, // The action could not be complete because it is region restricted
+ k_EResultRateLimitExceeded = 84, // Temporary rate limit exceeded, try again later, different from k_EResultLimitExceeded which may be permanent
+ k_EResultAccountLoginDeniedNeedTwoFactor = 85, // Need two-factor code to login
+ k_EResultItemDeleted = 86, // The thing we're trying to access has been deleted
+ k_EResultAccountLoginDeniedThrottle = 87, // login attempt failed, try to throttle response to possible attacker
+ k_EResultTwoFactorCodeMismatch = 88, // two factor code mismatch
+ k_EResultTwoFactorActivationCodeMismatch = 89, // activation code for two-factor didn't match
+};
+
+// Error codes for use with the voice functions
+enum EVoiceResult
+{
+ k_EVoiceResultOK = 0,
+ k_EVoiceResultNotInitialized = 1,
+ k_EVoiceResultNotRecording = 2,
+ k_EVoiceResultNoData = 3,
+ k_EVoiceResultBufferTooSmall = 4,
+ k_EVoiceResultDataCorrupted = 5,
+ k_EVoiceResultRestricted = 6,
+ k_EVoiceResultUnsupportedCodec = 7,
+
+};
+
+// Result codes to GSHandleClientDeny/Kick
+typedef enum
+{
+ k_EDenyInvalid = 0,
+ k_EDenyInvalidVersion = 1,
+ k_EDenyGeneric = 2,
+ k_EDenyNotLoggedOn = 3,
+ k_EDenyNoLicense = 4,
+ k_EDenyCheater = 5,
+ k_EDenyLoggedInElseWhere = 6,
+ k_EDenyUnknownText = 7,
+ k_EDenyIncompatibleAnticheat = 8,
+ k_EDenyMemoryCorruption = 9,
+ k_EDenyIncompatibleSoftware = 10,
+ k_EDenySteamConnectionLost = 11,
+ k_EDenySteamConnectionError = 12,
+ k_EDenySteamResponseTimedOut = 13,
+ k_EDenySteamValidationStalled = 14,
+ k_EDenySteamOwnerLeftGuestUser = 15,
+} EDenyReason;
+
+// return type of GetAuthSessionTicket
+typedef uint32 HAuthTicket;
+const HAuthTicket k_HAuthTicketInvalid = 0;
+
+// results from BeginAuthSession
+typedef enum
+{
+ k_EBeginAuthSessionResultOK = 0, // Ticket is valid for this game and this steamID.
+ k_EBeginAuthSessionResultInvalidTicket = 1, // Ticket is not valid.
+ k_EBeginAuthSessionResultDuplicateRequest = 2, // A ticket has already been submitted for this steamID
+ k_EBeginAuthSessionResultInvalidVersion = 3, // Ticket is from an incompatible interface version
+ k_EBeginAuthSessionResultGameMismatch = 4, // Ticket is not for this game
+ k_EBeginAuthSessionResultExpiredTicket = 5, // Ticket has expired
+} EBeginAuthSessionResult;
+
+// Callback values for callback ValidateAuthTicketResponse_t which is a response to BeginAuthSession
+typedef enum
+{
+ k_EAuthSessionResponseOK = 0, // Steam has verified the user is online, the ticket is valid and ticket has not been reused.
+ k_EAuthSessionResponseUserNotConnectedToSteam = 1, // The user in question is not connected to steam
+ k_EAuthSessionResponseNoLicenseOrExpired = 2, // The license has expired.
+ k_EAuthSessionResponseVACBanned = 3, // The user is VAC banned for this game.
+ k_EAuthSessionResponseLoggedInElseWhere = 4, // The user account has logged in elsewhere and the session containing the game instance has been disconnected.
+ k_EAuthSessionResponseVACCheckTimedOut = 5, // VAC has been unable to perform anti-cheat checks on this user
+ k_EAuthSessionResponseAuthTicketCanceled = 6, // The ticket has been canceled by the issuer
+ k_EAuthSessionResponseAuthTicketInvalidAlreadyUsed = 7, // This ticket has already been used, it is not valid.
+ k_EAuthSessionResponseAuthTicketInvalid = 8, // This ticket is not from a user instance currently connected to steam.
+ k_EAuthSessionResponsePublisherIssuedBan = 9, // The user is banned for this game. The ban came via the web api and not VAC
+} EAuthSessionResponse;
+
+// results from UserHasLicenseForApp
+typedef enum
+{
+ k_EUserHasLicenseResultHasLicense = 0, // User has a license for specified app
+ k_EUserHasLicenseResultDoesNotHaveLicense = 1, // User does not have a license for the specified app
+ k_EUserHasLicenseResultNoAuth = 2, // User has not been authenticated
+} EUserHasLicenseForAppResult;
+
+
+// Steam account types
+enum EAccountType
+{
+ k_EAccountTypeInvalid = 0,
+ k_EAccountTypeIndividual = 1, // single user account
+ k_EAccountTypeMultiseat = 2, // multiseat (e.g. cybercafe) account
+ k_EAccountTypeGameServer = 3, // game server account
+ k_EAccountTypeAnonGameServer = 4, // anonymous game server account
+ k_EAccountTypePending = 5, // pending
+ k_EAccountTypeContentServer = 6, // content server
+ k_EAccountTypeClan = 7,
+ k_EAccountTypeChat = 8,
+ k_EAccountTypeConsoleUser = 9, // Fake SteamID for local PSN account on PS3 or Live account on 360, etc.
+ k_EAccountTypeAnonUser = 10,
+
+ // Max of 16 items in this field
+ k_EAccountTypeMax
+};
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+enum EAppReleaseState
+{
+ k_EAppReleaseState_Unknown = 0, // unknown, required appinfo or license info is missing
+ k_EAppReleaseState_Unavailable = 1, // even if user 'just' owns it, can see game at all
+ k_EAppReleaseState_Prerelease = 2, // can be purchased and is visible in games list, nothing else. Common appInfo section released
+ k_EAppReleaseState_PreloadOnly = 3, // owners can preload app, not play it. AppInfo fully released.
+ k_EAppReleaseState_Released = 4, // owners can download and play app.
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+enum EAppOwnershipFlags
+{
+ k_EAppOwnershipFlags_None = 0x0000, // unknown
+ k_EAppOwnershipFlags_OwnsLicense = 0x0001, // owns license for this game
+ k_EAppOwnershipFlags_FreeLicense = 0x0002, // not paid for game
+ k_EAppOwnershipFlags_RegionRestricted = 0x0004, // owns app, but not allowed to play in current region
+ k_EAppOwnershipFlags_LowViolence = 0x0008, // only low violence version
+ k_EAppOwnershipFlags_InvalidPlatform = 0x0010, // app not supported on current platform
+ k_EAppOwnershipFlags_SharedLicense = 0x0020, // license was granted by authorized local device
+ k_EAppOwnershipFlags_FreeWeekend = 0x0040, // owned by a free weekend licenses
+ k_EAppOwnershipFlags_RetailLicense = 0x0080, // has a retail license for game, (CD-Key etc)
+ k_EAppOwnershipFlags_LicenseLocked = 0x0100, // shared license is locked (in use) by other user
+ k_EAppOwnershipFlags_LicensePending = 0x0200, // owns app, but transaction is still pending. Can't install or play
+ k_EAppOwnershipFlags_LicenseExpired = 0x0400, // doesn't own app anymore since license expired
+ k_EAppOwnershipFlags_LicensePermanent = 0x0800, // permanent license, not borrowed, or guest or freeweekend etc
+ k_EAppOwnershipFlags_LicenseRecurring = 0x1000, // Recurring license, user is charged periodically
+ k_EAppOwnershipFlags_LicenseCanceled = 0x2000, // Mark as canceled, but might be still active if recurring
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: designed as flags to allow filters masks
+//-----------------------------------------------------------------------------
+enum EAppType
+{
+ k_EAppType_Invalid = 0x000, // unknown / invalid
+ k_EAppType_Game = 0x001, // playable game, default type
+ k_EAppType_Application = 0x002, // software application
+ k_EAppType_Tool = 0x004, // SDKs, editors & dedicated servers
+ k_EAppType_Demo = 0x008, // game demo
+ k_EAppType_Media_DEPRECATED = 0x010, // legacy - was used for game trailers, which are now just videos on the web
+ k_EAppType_DLC = 0x020, // down loadable content
+ k_EAppType_Guide = 0x040, // game guide, PDF etc
+ k_EAppType_Driver = 0x080, // hardware driver updater (ATI, Razor etc)
+ k_EAppType_Config = 0x100, // hidden app used to config Steam features (backpack, sales, etc)
+ k_EAppType_Film = 0x200, // A Movie (feature film)
+ k_EAppType_TVSeries = 0x400, // A TV or other video series which will have episodes and perhaps seasons
+ k_EAppType_Video = 0x800, // A video component of either a Film or TVSeries (may be the feature, an episode, preview, making-of, etc)
+ k_EAppType_Plugin = 0x1000, // Plug-in types for other Apps
+ k_EAppType_Music = 0x2000, // Music files
+
+ k_EAppType_Shortcut = 0x40000000, // just a shortcut, client side only
+ k_EAppType_DepotOnly = 0x80000000, // placeholder since depots and apps share the same namespace
+};
+
+
+
+//-----------------------------------------------------------------------------
+// types of user game stats fields
+// WARNING: DO NOT RENUMBER EXISTING VALUES - STORED IN DATABASE
+//-----------------------------------------------------------------------------
+enum ESteamUserStatType
+{
+ k_ESteamUserStatTypeINVALID = 0,
+ k_ESteamUserStatTypeINT = 1,
+ k_ESteamUserStatTypeFLOAT = 2,
+ // Read as FLOAT, set with count / session length
+ k_ESteamUserStatTypeAVGRATE = 3,
+ k_ESteamUserStatTypeACHIEVEMENTS = 4,
+ k_ESteamUserStatTypeGROUPACHIEVEMENTS = 5,
+
+ // max, for sanity checks
+ k_ESteamUserStatTypeMAX
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Chat Entry Types (previously was only friend-to-friend message types)
+//-----------------------------------------------------------------------------
+enum EChatEntryType
+{
+ k_EChatEntryTypeInvalid = 0,
+ k_EChatEntryTypeChatMsg = 1, // Normal text message from another user
+ k_EChatEntryTypeTyping = 2, // Another user is typing (not used in multi-user chat)
+ k_EChatEntryTypeInviteGame = 3, // Invite from other user into that users current game
+ k_EChatEntryTypeEmote = 4, // text emote message (deprecated, should be treated as ChatMsg)
+ //k_EChatEntryTypeLobbyGameStart = 5, // lobby game is starting (dead - listen for LobbyGameCreated_t callback instead)
+ k_EChatEntryTypeLeftConversation = 6, // user has left the conversation ( closed chat window )
+ // Above are previous FriendMsgType entries, now merged into more generic chat entry types
+ k_EChatEntryTypeEntered = 7, // user has entered the conversation (used in multi-user chat and group chat)
+ k_EChatEntryTypeWasKicked = 8, // user was kicked (data: 64-bit steamid of actor performing the kick)
+ k_EChatEntryTypeWasBanned = 9, // user was banned (data: 64-bit steamid of actor performing the ban)
+ k_EChatEntryTypeDisconnected = 10, // user disconnected
+ k_EChatEntryTypeHistoricalChat = 11, // a chat message from user's chat history or offilne message
+ k_EChatEntryTypeReserved1 = 12,
+ k_EChatEntryTypeReserved2 = 13,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Chat Room Enter Responses
+//-----------------------------------------------------------------------------
+enum EChatRoomEnterResponse
+{
+ k_EChatRoomEnterResponseSuccess = 1, // Success
+ k_EChatRoomEnterResponseDoesntExist = 2, // Chat doesn't exist (probably closed)
+ k_EChatRoomEnterResponseNotAllowed = 3, // General Denied - You don't have the permissions needed to join the chat
+ k_EChatRoomEnterResponseFull = 4, // Chat room has reached its maximum size
+ k_EChatRoomEnterResponseError = 5, // Unexpected Error
+ k_EChatRoomEnterResponseBanned = 6, // You are banned from this chat room and may not join
+ k_EChatRoomEnterResponseLimited = 7, // Joining this chat is not allowed because you are a limited user (no value on account)
+ k_EChatRoomEnterResponseClanDisabled = 8, // Attempt to join a clan chat when the clan is locked or disabled
+ k_EChatRoomEnterResponseCommunityBan = 9, // Attempt to join a chat when the user has a community lock on their account
+ k_EChatRoomEnterResponseMemberBlockedYou = 10, // Join failed - some member in the chat has blocked you from joining
+ k_EChatRoomEnterResponseYouBlockedMember = 11, // Join failed - you have blocked some member already in the chat
+ // k_EChatRoomEnterResponseNoRankingDataLobby = 12, // No longer used
+ // k_EChatRoomEnterResponseNoRankingDataUser = 13, // No longer used
+ // k_EChatRoomEnterResponseRankOutOfRange = 14, // No longer used
+};
+
+
+typedef void (*PFNLegacyKeyRegistration)( const char *pchCDKey, const char *pchInstallPath );
+typedef bool (*PFNLegacyKeyInstalled)();
+
+const unsigned int k_unSteamAccountIDMask = 0xFFFFFFFF;
+const unsigned int k_unSteamAccountInstanceMask = 0x000FFFFF;
+// we allow 3 simultaneous user account instances right now, 1= desktop, 2 = console, 4 = web, 0 = all
+const unsigned int k_unSteamUserDesktopInstance = 1;
+const unsigned int k_unSteamUserConsoleInstance = 2;
+const unsigned int k_unSteamUserWebInstance = 4;
+
+// Special flags for Chat accounts - they go in the top 8 bits
+// of the steam ID's "instance", leaving 12 for the actual instances
+enum EChatSteamIDInstanceFlags
+{
+ k_EChatAccountInstanceMask = 0x00000FFF, // top 8 bits are flags
+
+ k_EChatInstanceFlagClan = ( k_unSteamAccountInstanceMask + 1 ) >> 1, // top bit
+ k_EChatInstanceFlagLobby = ( k_unSteamAccountInstanceMask + 1 ) >> 2, // next one down, etc
+ k_EChatInstanceFlagMMSLobby = ( k_unSteamAccountInstanceMask + 1 ) >> 3, // next one down, etc
+
+ // Max of 8 flags
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Marketing message flags that change how a client should handle them
+//-----------------------------------------------------------------------------
+enum EMarketingMessageFlags
+{
+ k_EMarketingMessageFlagsNone = 0,
+ k_EMarketingMessageFlagsHighPriority = 1 << 0,
+ k_EMarketingMessageFlagsPlatformWindows = 1 << 1,
+ k_EMarketingMessageFlagsPlatformMac = 1 << 2,
+ k_EMarketingMessageFlagsPlatformLinux = 1 << 3,
+
+ //aggregate flags
+ k_EMarketingMessageFlagsPlatformRestrictions =
+ k_EMarketingMessageFlagsPlatformWindows |
+ k_EMarketingMessageFlagsPlatformMac |
+ k_EMarketingMessageFlagsPlatformLinux,
+};
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Possible positions to tell the overlay to show notifications in
+//-----------------------------------------------------------------------------
+enum ENotificationPosition
+{
+ k_EPositionTopLeft = 0,
+ k_EPositionTopRight = 1,
+ k_EPositionBottomLeft = 2,
+ k_EPositionBottomRight = 3,
+};
+
+
+#pragma pack( push, 1 )
+
+#define CSTEAMID_DEFINED
+
+// Steam ID structure (64 bits total)
+class CSteamID
+{
+public:
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Constructor
+ //-----------------------------------------------------------------------------
+ CSteamID()
+ {
+ m_steamid.m_comp.m_unAccountID = 0;
+ m_steamid.m_comp.m_EAccountType = k_EAccountTypeInvalid;
+ m_steamid.m_comp.m_EUniverse = k_EUniverseInvalid;
+ m_steamid.m_comp.m_unAccountInstance = 0;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Constructor
+ // Input : unAccountID - 32-bit account ID
+ // eUniverse - Universe this account belongs to
+ // eAccountType - Type of account
+ //-----------------------------------------------------------------------------
+ CSteamID( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType )
+ {
+ Set( unAccountID, eUniverse, eAccountType );
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Constructor
+ // Input : unAccountID - 32-bit account ID
+ // unAccountInstance - instance
+ // eUniverse - Universe this account belongs to
+ // eAccountType - Type of account
+ //-----------------------------------------------------------------------------
+ CSteamID( uint32 unAccountID, unsigned int unAccountInstance, EUniverse eUniverse, EAccountType eAccountType )
+ {
+#if defined(_SERVER) && defined(Assert)
+ Assert( ! ( ( k_EAccountTypeIndividual == eAccountType ) && ( unAccountInstance > k_unSteamUserWebInstance ) ) ); // enforce that for individual accounts, instance is always 1
+#endif // _SERVER
+ InstancedSet( unAccountID, unAccountInstance, eUniverse, 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.
+ //-----------------------------------------------------------------------------
+ CSteamID( uint64 ulSteamID )
+ {
+ SetFromUint64( ulSteamID );
+ }
+#ifdef INT64_DIFFERENT_FROM_INT64_T
+ CSteamID( uint64_t ulSteamID )
+ {
+ SetFromUint64( (uint64)ulSteamID );
+ }
+#endif
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Sets parameters for steam ID
+ // Input : unAccountID - 32-bit account ID
+ // eUniverse - Universe this account belongs to
+ // eAccountType - Type of account
+ //-----------------------------------------------------------------------------
+ void Set( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType )
+ {
+ m_steamid.m_comp.m_unAccountID = unAccountID;
+ m_steamid.m_comp.m_EUniverse = eUniverse;
+ m_steamid.m_comp.m_EAccountType = eAccountType;
+
+ if ( eAccountType == k_EAccountTypeClan || eAccountType == k_EAccountTypeGameServer )
+ {
+ m_steamid.m_comp.m_unAccountInstance = 0;
+ }
+ else
+ {
+ // by default we pick the desktop instance
+ m_steamid.m_comp.m_unAccountInstance = k_unSteamUserDesktopInstance;
+ }
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Sets parameters for steam ID
+ // Input : unAccountID - 32-bit account ID
+ // eUniverse - Universe this account belongs to
+ // eAccountType - Type of account
+ //-----------------------------------------------------------------------------
+ void InstancedSet( uint32 unAccountID, uint32 unInstance, EUniverse eUniverse, EAccountType eAccountType )
+ {
+ m_steamid.m_comp.m_unAccountID = unAccountID;
+ m_steamid.m_comp.m_EUniverse = eUniverse;
+ m_steamid.m_comp.m_EAccountType = eAccountType;
+ m_steamid.m_comp.m_unAccountInstance = unInstance;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Initializes a steam ID from its 52 bit parts and universe/type
+ // Input : ulIdentifier - 52 bits of goodness
+ //-----------------------------------------------------------------------------
+ void FullSet( uint64 ulIdentifier, EUniverse eUniverse, EAccountType eAccountType )
+ {
+ m_steamid.m_comp.m_unAccountID = ( ulIdentifier & k_unSteamAccountIDMask ); // account ID is low 32 bits
+ m_steamid.m_comp.m_unAccountInstance = ( ( ulIdentifier >> 32 ) & k_unSteamAccountInstanceMask ); // account instance is next 20 bits
+ m_steamid.m_comp.m_EUniverse = eUniverse;
+ m_steamid.m_comp.m_EAccountType = eAccountType;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Initializes a steam ID from its 64-bit representation
+ // Input : ulSteamID - 64-bit representation of a Steam ID
+ //-----------------------------------------------------------------------------
+ void SetFromUint64( uint64 ulSteamID )
+ {
+ m_steamid.m_unAll64Bits = ulSteamID;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Clear all fields, leaving an invalid ID.
+ //-----------------------------------------------------------------------------
+ void Clear()
+ {
+ m_steamid.m_comp.m_unAccountID = 0;
+ m_steamid.m_comp.m_EAccountType = k_EAccountTypeInvalid;
+ m_steamid.m_comp.m_EUniverse = k_EUniverseInvalid;
+ m_steamid.m_comp.m_unAccountInstance = 0;
+ }
+
+
+#if defined( INCLUDED_STEAM2_USERID_STRUCTS )
+ //-----------------------------------------------------------------------------
+ // Purpose: Initializes a steam ID from a Steam2 ID structure
+ // Input: pTSteamGlobalUserID - Steam2 ID to convert
+ // eUniverse - universe this ID belongs to
+ //-----------------------------------------------------------------------------
+ void SetFromSteam2( TSteamGlobalUserID *pTSteamGlobalUserID, EUniverse eUniverse )
+ {
+ m_steamid.m_comp.m_unAccountID = pTSteamGlobalUserID->m_SteamLocalUserID.Split.Low32bits * 2 +
+ pTSteamGlobalUserID->m_SteamLocalUserID.Split.High32bits;
+ m_steamid.m_comp.m_EUniverse = eUniverse; // set the universe
+ m_steamid.m_comp.m_EAccountType = k_EAccountTypeIndividual; // Steam 2 accounts always map to account type of individual
+ m_steamid.m_comp.m_unAccountInstance = k_unSteamUserDesktopInstance; // Steam2 only knew desktop instances
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Fills out a Steam2 ID structure
+ // Input: pTSteamGlobalUserID - Steam2 ID to write to
+ //-----------------------------------------------------------------------------
+ void ConvertToSteam2( TSteamGlobalUserID *pTSteamGlobalUserID ) const
+ {
+ // only individual accounts have any meaning in Steam 2, only they can be mapped
+ // Assert( m_steamid.m_comp.m_EAccountType == k_EAccountTypeIndividual );
+
+ pTSteamGlobalUserID->m_SteamInstanceID = 0;
+ pTSteamGlobalUserID->m_SteamLocalUserID.Split.High32bits = m_steamid.m_comp.m_unAccountID % 2;
+ pTSteamGlobalUserID->m_SteamLocalUserID.Split.Low32bits = m_steamid.m_comp.m_unAccountID / 2;
+ }
+#endif // defined( INCLUDED_STEAM_COMMON_STEAMCOMMON_H )
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Converts steam ID to its 64-bit representation
+ // Output : 64-bit representation of a Steam ID
+ //-----------------------------------------------------------------------------
+ uint64 ConvertToUint64() const
+ {
+ return m_steamid.m_unAll64Bits;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // 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
+ //-----------------------------------------------------------------------------
+ uint64 GetStaticAccountKey() const
+ {
+ // note we do NOT include the account instance (which is a dynamic property) in the static account key
+ return (uint64) ( ( ( (uint64) m_steamid.m_comp.m_EUniverse ) << 56 ) + ((uint64) m_steamid.m_comp.m_EAccountType << 52 ) + m_steamid.m_comp.m_unAccountID );
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: create an anonymous game server login to be filled in by the AM
+ //-----------------------------------------------------------------------------
+ void CreateBlankAnonLogon( EUniverse eUniverse )
+ {
+ m_steamid.m_comp.m_unAccountID = 0;
+ m_steamid.m_comp.m_EAccountType = k_EAccountTypeAnonGameServer;
+ m_steamid.m_comp.m_EUniverse = eUniverse;
+ m_steamid.m_comp.m_unAccountInstance = 0;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: create an anonymous game server login to be filled in by the AM
+ //-----------------------------------------------------------------------------
+ void CreateBlankAnonUserLogon( EUniverse eUniverse )
+ {
+ m_steamid.m_comp.m_unAccountID = 0;
+ m_steamid.m_comp.m_EAccountType = k_EAccountTypeAnonUser;
+ m_steamid.m_comp.m_EUniverse = eUniverse;
+ m_steamid.m_comp.m_unAccountInstance = 0;
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this an anonymous game server login that will be filled in?
+ //-----------------------------------------------------------------------------
+ bool BBlankAnonAccount() const
+ {
+ return m_steamid.m_comp.m_unAccountID == 0 && BAnonAccount() && m_steamid.m_comp.m_unAccountInstance == 0;
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this a game server account id? (Either persistent or anonymous)
+ //-----------------------------------------------------------------------------
+ bool BGameServerAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeGameServer || m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonGameServer;
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this a persistent (not anonymous) game server account id?
+ //-----------------------------------------------------------------------------
+ bool BPersistentGameServerAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeGameServer;
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this an anonymous game server account id?
+ //-----------------------------------------------------------------------------
+ bool BAnonGameServerAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonGameServer;
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this a content server account id?
+ //-----------------------------------------------------------------------------
+ bool BContentServerAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeContentServer;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this a clan account id?
+ //-----------------------------------------------------------------------------
+ bool BClanAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeClan;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this a chat account id?
+ //-----------------------------------------------------------------------------
+ bool BChatAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeChat;
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this a chat account id?
+ //-----------------------------------------------------------------------------
+ bool IsLobby() const
+ {
+ return ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeChat )
+ && ( m_steamid.m_comp.m_unAccountInstance & k_EChatInstanceFlagLobby );
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this an individual user account id?
+ //-----------------------------------------------------------------------------
+ bool BIndividualAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeIndividual || m_steamid.m_comp.m_EAccountType == k_EAccountTypeConsoleUser;
+ }
+
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this an anonymous account?
+ //-----------------------------------------------------------------------------
+ bool BAnonAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonUser || m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonGameServer;
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this an anonymous user account? ( used to create an account or reset a password )
+ //-----------------------------------------------------------------------------
+ bool BAnonUserAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonUser;
+ }
+
+ //-----------------------------------------------------------------------------
+ // Purpose: Is this a faked up Steam ID for a PSN friend account?
+ //-----------------------------------------------------------------------------
+ bool BConsoleUserAccount() const
+ {
+ return m_steamid.m_comp.m_EAccountType == k_EAccountTypeConsoleUser;
+ }
+
+ // simple accessors
+ void SetAccountID( uint32 unAccountID ) { m_steamid.m_comp.m_unAccountID = unAccountID; }
+ void SetAccountInstance( uint32 unInstance ){ m_steamid.m_comp.m_unAccountInstance = unInstance; }
+ void ClearIndividualInstance() { if ( BIndividualAccount() ) m_steamid.m_comp.m_unAccountInstance = 0; }
+ bool HasNoIndividualInstance() const { return BIndividualAccount() && (m_steamid.m_comp.m_unAccountInstance==0); }
+ AccountID_t GetAccountID() const { return m_steamid.m_comp.m_unAccountID; }
+ uint32 GetUnAccountInstance() const { return m_steamid.m_comp.m_unAccountInstance; }
+ EAccountType GetEAccountType() const { return ( EAccountType ) m_steamid.m_comp.m_EAccountType; }
+ EUniverse GetEUniverse() const { return m_steamid.m_comp.m_EUniverse; }
+ void SetEUniverse( EUniverse eUniverse ) { m_steamid.m_comp.m_EUniverse = eUniverse; }
+ bool IsValid() const;
+
+ // this set of functions is hidden, will be moved out of class
+ explicit CSteamID( const char *pchSteamID, EUniverse eDefaultUniverse = k_EUniverseInvalid );
+ const char * Render() const; // renders this steam ID to string
+ static const char * Render( uint64 ulSteamID ); // static method to render a uint64 representation of a steam ID to a string
+
+ void SetFromString( const char *pchSteamID, EUniverse eDefaultUniverse );
+ // SetFromString allows many partially-correct strings, constraining how
+ // we might be able to change things in the future.
+ // SetFromStringStrict requires the exact string forms that we support
+ // and is preferred when the caller knows it's safe to be strict.
+ // Returns whether the string parsed correctly.
+ bool SetFromStringStrict( const char *pchSteamID, EUniverse eDefaultUniverse );
+ bool SetFromSteam2String( const char *pchSteam2ID, EUniverse eUniverse );
+
+ inline bool operator==( const CSteamID &val ) const { return m_steamid.m_unAll64Bits == val.m_steamid.m_unAll64Bits; }
+ inline bool operator!=( const CSteamID &val ) const { return !operator==( val ); }
+ inline bool operator<( const CSteamID &val ) const { return m_steamid.m_unAll64Bits < val.m_steamid.m_unAll64Bits; }
+ inline bool operator>( const CSteamID &val ) const { return m_steamid.m_unAll64Bits > val.m_steamid.m_unAll64Bits; }
+
+ // DEBUG function
+ bool BValidExternalSteamID() const;
+
+private:
+ // These are defined here to prevent accidental implicit conversion of a u32AccountID to a CSteamID.
+ // If you get a compiler error about an ambiguous constructor/function then it may be because you're
+ // passing a 32-bit int to a function that takes a CSteamID. You should explicitly create the SteamID
+ // using the correct Universe and account Type/Instance values.
+ CSteamID( uint32 );
+ CSteamID( int32 );
+
+ // 64 bits total
+ union SteamID_t
+ {
+ struct SteamIDComponent_t
+ {
+#ifdef VALVE_BIG_ENDIAN
+ EUniverse m_EUniverse : 8; // universe this account belongs to
+ unsigned int m_EAccountType : 4; // type of account - can't show as EAccountType, due to signed / unsigned difference
+ unsigned int m_unAccountInstance : 20; // dynamic instance ID
+ uint32 m_unAccountID : 32; // unique account identifier
+#else
+ uint32 m_unAccountID : 32; // unique account identifier
+ unsigned int m_unAccountInstance : 20; // dynamic instance ID
+ unsigned int m_EAccountType : 4; // type of account - can't show as EAccountType, due to signed / unsigned difference
+ EUniverse m_EUniverse : 8; // universe this account belongs to
+#endif
+ } m_comp;
+
+ uint64 m_unAll64Bits;
+ } m_steamid;
+};
+
+inline bool CSteamID::IsValid() const
+{
+ if ( m_steamid.m_comp.m_EAccountType <= k_EAccountTypeInvalid || m_steamid.m_comp.m_EAccountType >= k_EAccountTypeMax )
+ return false;
+
+ if ( m_steamid.m_comp.m_EUniverse <= k_EUniverseInvalid || m_steamid.m_comp.m_EUniverse >= k_EUniverseMax )
+ return false;
+
+ if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeIndividual )
+ {
+ if ( m_steamid.m_comp.m_unAccountID == 0 || m_steamid.m_comp.m_unAccountInstance > k_unSteamUserWebInstance )
+ return false;
+ }
+
+ if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeClan )
+ {
+ if ( m_steamid.m_comp.m_unAccountID == 0 || m_steamid.m_comp.m_unAccountInstance != 0 )
+ return false;
+ }
+
+ if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeGameServer )
+ {
+ if ( m_steamid.m_comp.m_unAccountID == 0 )
+ return false;
+ // Any limit on instances? We use them for local users and bots
+ }
+ return true;
+}
+
+// generic invalid CSteamID
+#define k_steamIDNil CSteamID()
+
+// This steamID comes from a user game connection to an out of date GS that hasnt implemented the protocol
+// to provide its steamID
+#define k_steamIDOutofDateGS CSteamID( 0, 0, k_EUniverseInvalid, k_EAccountTypeInvalid )
+// This steamID comes from a user game connection to an sv_lan GS
+#define k_steamIDLanModeGS CSteamID( 0, 0, k_EUniversePublic, k_EAccountTypeInvalid )
+// This steamID can come from a user game connection to a GS that has just booted but hasnt yet even initialized
+// its steam3 component and started logging on.
+#define k_steamIDNotInitYetGS CSteamID( 1, 0, k_EUniverseInvalid, k_EAccountTypeInvalid )
+// This steamID can come from a user game connection to a GS that isn't using the steam authentication system but still
+// wants to support the "Join Game" option in the friends list
+#define k_steamIDNonSteamGS CSteamID( 2, 0, k_EUniverseInvalid, k_EAccountTypeInvalid )
+
+
+#ifdef STEAM
+// Returns the matching chat steamID, with the default instance of 0
+// If the steamID passed in is already of type k_EAccountTypeChat it will be returned with the same instance
+CSteamID ChatIDFromSteamID( const CSteamID &steamID );
+// Returns the matching clan steamID, with the default instance of 0
+// If the steamID passed in is already of type k_EAccountTypeClan it will be returned with the same instance
+CSteamID ClanIDFromSteamID( const CSteamID &steamID );
+// Asserts steamID type before conversion
+CSteamID ChatIDFromClanID( const CSteamID &steamIDClan );
+// Asserts steamID type before conversion
+CSteamID ClanIDFromChatID( const CSteamID &steamIDChat );
+
+#endif // _STEAM
+
+
+//-----------------------------------------------------------------------------
+// Purpose: encapsulates an appID/modID pair
+//-----------------------------------------------------------------------------
+class CGameID
+{
+public:
+
+ CGameID()
+ {
+ m_gameID.m_nType = k_EGameIDTypeApp;
+ m_gameID.m_nAppID = k_uAppIdInvalid;
+ m_gameID.m_nModID = 0;
+ }
+
+ explicit CGameID( uint64 ulGameID )
+ {
+ m_ulGameID = ulGameID;
+ }
+#ifdef INT64_DIFFERENT_FROM_INT64_T
+ CGameID( uint64_t ulGameID )
+ {
+ m_ulGameID = (uint64)ulGameID;
+ }
+#endif
+
+ explicit CGameID( int32 nAppID )
+ {
+ m_ulGameID = 0;
+ m_gameID.m_nAppID = nAppID;
+ }
+
+ explicit CGameID( uint32 nAppID )
+ {
+ m_ulGameID = 0;
+ m_gameID.m_nAppID = nAppID;
+ }
+
+ CGameID( uint32 nAppID, uint32 nModID )
+ {
+ m_ulGameID = 0;
+ m_gameID.m_nAppID = nAppID;
+ m_gameID.m_nModID = nModID;
+ m_gameID.m_nType = k_EGameIDTypeGameMod;
+ }
+
+ // Hidden functions used only by Steam
+ explicit CGameID( const char *pchGameID );
+ const char *Render() const; // render this Game ID to string
+ static const char *Render( uint64 ulGameID ); // static method to render a uint64 representation of a Game ID to a string
+
+ // must include checksum_crc.h first to get this functionality
+#if defined( CHECKSUM_CRC_H )
+ CGameID( uint32 nAppID, const char *pchModPath )
+ {
+ m_ulGameID = 0;
+ m_gameID.m_nAppID = nAppID;
+ m_gameID.m_nType = k_EGameIDTypeGameMod;
+
+ char rgchModDir[MAX_PATH];
+ Q_FileBase( pchModPath, rgchModDir, sizeof( rgchModDir ) );
+ CRC32_t crc32;
+ CRC32_Init( &crc32 );
+ CRC32_ProcessBuffer( &crc32, rgchModDir, Q_strlen( rgchModDir ) );
+ CRC32_Final( &crc32 );
+
+ // set the high-bit on the mod-id
+ // reduces crc32 to 31bits, but lets us use the modID as a guaranteed unique
+ // replacement for appID's
+ m_gameID.m_nModID = crc32 | (0x80000000);
+ }
+
+ CGameID( const char *pchExePath, const char *pchAppName )
+ {
+ m_ulGameID = 0;
+ m_gameID.m_nAppID = k_uAppIdInvalid;
+ m_gameID.m_nType = k_EGameIDTypeShortcut;
+
+ CRC32_t crc32;
+ CRC32_Init( &crc32 );
+ CRC32_ProcessBuffer( &crc32, pchExePath, Q_strlen( pchExePath ) );
+ CRC32_ProcessBuffer( &crc32, pchAppName, Q_strlen( pchAppName ) );
+ CRC32_Final( &crc32 );
+
+ // set the high-bit on the mod-id
+ // reduces crc32 to 31bits, but lets us use the modID as a guaranteed unique
+ // replacement for appID's
+ m_gameID.m_nModID = crc32 | (0x80000000);
+ }
+
+#if defined( VSTFILEID_H )
+
+ CGameID( VstFileID vstFileID )
+ {
+ m_ulGameID = 0;
+ m_gameID.m_nAppID = k_uAppIdInvalid;
+ m_gameID.m_nType = k_EGameIDTypeP2P;
+
+ CRC32_t crc32;
+ CRC32_Init( &crc32 );
+ const char *pchFileId = vstFileID.Render();
+ CRC32_ProcessBuffer( &crc32, pchFileId, Q_strlen( pchFileId ) );
+ CRC32_Final( &crc32 );
+
+ // set the high-bit on the mod-id
+ // reduces crc32 to 31bits, but lets us use the modID as a guaranteed unique
+ // replacement for appID's
+ m_gameID.m_nModID = crc32 | (0x80000000);
+ }
+
+#endif /* VSTFILEID_H */
+
+#endif /* CHECKSUM_CRC_H */
+
+
+ uint64 ToUint64() const
+ {
+ return m_ulGameID;
+ }
+
+ uint64 *GetUint64Ptr()
+ {
+ return &m_ulGameID;
+ }
+
+ void Set( uint64 ulGameID )
+ {
+ m_ulGameID = ulGameID;
+ }
+
+ bool IsMod() const
+ {
+ return ( m_gameID.m_nType == k_EGameIDTypeGameMod );
+ }
+
+ bool IsShortcut() const
+ {
+ return ( m_gameID.m_nType == k_EGameIDTypeShortcut );
+ }
+
+ bool IsP2PFile() const
+ {
+ return ( m_gameID.m_nType == k_EGameIDTypeP2P );
+ }
+
+ bool IsSteamApp() const
+ {
+ return ( m_gameID.m_nType == k_EGameIDTypeApp );
+ }
+
+ uint32 ModID() const
+ {
+ return m_gameID.m_nModID;
+ }
+
+ uint32 AppID() const
+ {
+ return m_gameID.m_nAppID;
+ }
+
+ bool operator == ( const CGameID &rhs ) const
+ {
+ return m_ulGameID == rhs.m_ulGameID;
+ }
+
+ bool operator != ( const CGameID &rhs ) const
+ {
+ return !(*this == rhs);
+ }
+
+ bool operator < ( const CGameID &rhs ) const
+ {
+ return ( m_ulGameID < rhs.m_ulGameID );
+ }
+
+ bool IsValid() const
+ {
+ // each type has it's own invalid fixed point:
+ switch( m_gameID.m_nType )
+ {
+ case k_EGameIDTypeApp:
+ return m_gameID.m_nAppID != k_uAppIdInvalid;
+
+ case k_EGameIDTypeGameMod:
+ return m_gameID.m_nAppID != k_uAppIdInvalid && m_gameID.m_nModID & 0x80000000;
+
+ case k_EGameIDTypeShortcut:
+ return (m_gameID.m_nModID & 0x80000000) != 0;
+
+ case k_EGameIDTypeP2P:
+ return m_gameID.m_nAppID == k_uAppIdInvalid && m_gameID.m_nModID & 0x80000000;
+
+ default:
+#if defined(Assert)
+ Assert(false);
+#endif
+ return false;
+ }
+
+ }
+
+ void Reset()
+ {
+ m_ulGameID = 0;
+ }
+
+
+
+private:
+
+ enum EGameIDType
+ {
+ k_EGameIDTypeApp = 0,
+ k_EGameIDTypeGameMod = 1,
+ k_EGameIDTypeShortcut = 2,
+ k_EGameIDTypeP2P = 3,
+ };
+
+ struct GameID_t
+ {
+#ifdef VALVE_BIG_ENDIAN
+ unsigned int m_nModID : 32;
+ unsigned int m_nType : 8;
+ unsigned int m_nAppID : 24;
+#else
+ unsigned int m_nAppID : 24;
+ unsigned int m_nType : 8;
+ unsigned int m_nModID : 32;
+#endif
+ };
+
+ union
+ {
+ uint64 m_ulGameID;
+ GameID_t m_gameID;
+ };
+};
+
+#pragma pack( pop )
+
+const int k_cchGameExtraInfoMax = 64;
+
+
+//-----------------------------------------------------------------------------
+// Constants used for query ports.
+//-----------------------------------------------------------------------------
+
+#define QUERY_PORT_NOT_INITIALIZED 0xFFFF // We haven't asked the GS for this query port's actual value yet.
+#define QUERY_PORT_ERROR 0xFFFE // We were unable to get the query port for this server.
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Passed as argument to SteamAPI_UseBreakpadCrashHandler to enable optional callback
+// just before minidump file is captured after a crash has occurred. (Allows app to append additional comment data to the dump, etc.)
+//-----------------------------------------------------------------------------
+typedef void (*PFNPreMinidumpCallback)(void *context);
+
+//-----------------------------------------------------------------------------
+// Purpose: Used by ICrashHandler interfaces to reference particular installed crash handlers
+//-----------------------------------------------------------------------------
+typedef void *BREAKPAD_HANDLE;
+#define BREAKPAD_INVALID_HANDLE (BREAKPAD_HANDLE)0
+
+#endif // STEAMCLIENTPUBLIC_H
diff --git a/lsteamclient/steamworks_sdk_130x/steamcontrollerpublic.h b/lsteamclient/steamworks_sdk_130x/steamcontrollerpublic.h
new file mode 100644
index 00000000..ad06f0e8
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steamcontrollerpublic.h
@@ -0,0 +1,79 @@
+//========= Copyright © 1996-2013, Valve LLC, All rights reserved. ============
+//
+// Purpose: Controller related public types/constants
+//
+//=============================================================================
+
+#ifndef STEAMCONTROLLERPUBLIC_H
+#define STEAMCONTROLLERPUBLIC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#if defined( STEAM ) || defined( ISTEAMCONTROLLER_H )
+// This file should only be included by the Steam build or directly from
+// isteamcontroller.h.
+#include "steamtypes.h"
+#else
+#include
+typedef uint32_t uint32;
+#ifdef __C51__
+typedef uint8_t uint64[8];
+#else
+typedef uint64_t uint64;
+#endif
+#endif
+
+#pragma pack(1)
+
+// Safe to add new bitfields at the end of this list for new buttons/actions,
+// but never re-use or re-number an existing flag as old client code will be
+// confused.
+#define STEAM_RIGHT_TRIGGER_MASK 0x0000000000000001l
+#define STEAM_LEFT_TRIGGER_MASK 0x0000000000000002l
+#define STEAM_RIGHT_BUMPER_MASK 0x0000000000000004l
+#define STEAM_LEFT_BUMPER_MASK 0x0000000000000008l
+#define STEAM_BUTTON_0_MASK 0x0000000000000010l
+#define STEAM_BUTTON_1_MASK 0x0000000000000020l
+#define STEAM_BUTTON_2_MASK 0x0000000000000040l
+#define STEAM_BUTTON_3_MASK 0x0000000000000080l
+#define STEAM_TOUCH_0_MASK 0x0000000000000100l
+#define STEAM_TOUCH_1_MASK 0x0000000000000200l
+#define STEAM_TOUCH_2_MASK 0x0000000000000400l
+#define STEAM_TOUCH_3_MASK 0x0000000000000800l
+#define STEAM_BUTTON_MENU_MASK 0x0000000000001000l
+#define STEAM_BUTTON_STEAM_MASK 0x0000000000002000l
+#define STEAM_BUTTON_ESCAPE_MASK 0x0000000000004000l
+#define STEAM_BUTTON_BACK_LEFT_MASK 0x0000000000008000l
+#define STEAM_BUTTON_BACK_RIGHT_MASK 0x0000000000010000l
+#define STEAM_BUTTON_LEFTPAD_CLICKED_MASK 0x0000000000020000l
+#define STEAM_BUTTON_RIGHTPAD_CLICKED_MASK 0x0000000000040000l
+#define STEAM_LEFTPAD_FINGERDOWN_MASK 0x0000000000080000l
+#define STEAM_RIGHTPAD_FINGERDOWN_MASK 0x0000000000100000l
+
+// Only add fields to the end of this struct, or if you need to change it in a larger
+// way add a new message id and new struct completely so as to not break old clients.
+typedef struct
+{
+ // If packet num matches that on your prior call, then the controller state hasn't been changed since
+ // your last call and there is no need to process it
+ uint32 unPacketNum;
+
+ // bit flags for each of the buttons
+ uint64 ulButtons;
+
+ // Left pad coordinates
+ short sLeftPadX;
+ short sLeftPadY;
+
+ // Right pad coordinates
+ short sRightPadX;
+ short sRightPadY;
+
+} SteamControllerState_t;
+
+#pragma pack()
+
+#endif // STEAMCONTROLLERPUBLIC_H
+
diff --git a/lsteamclient/steamworks_sdk_130x/steamencryptedappticket.h b/lsteamclient/steamworks_sdk_130x/steamencryptedappticket.h
new file mode 100644
index 00000000..0331c139
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steamencryptedappticket.h
@@ -0,0 +1,32 @@
+//========= Copyright © 1996-2010, Valve LLC, All rights reserved. ============
+//
+// Purpose: utilities to decode/decrypt a ticket from the
+// ISteamUser::RequestEncryptedAppTicket, ISteamUser::GetEncryptedAppTicket API
+//
+// To use: declare CSteamEncryptedAppTicket, then call BDecryptTicket
+// if BDecryptTicket returns true, other accessors are valid
+//
+//=============================================================================
+
+#include "steam_api.h"
+
+static const int k_nSteamEncryptedAppTicketSymmetricKeyLen = 32;
+
+
+S_API bool SteamEncryptedAppTicket_BDecryptTicket( const uint8 *rgubTicketEncrypted, uint32 cubTicketEncrypted,
+ uint8 *rgubTicketDecrypted, uint32 *pcubTicketDecrypted,
+ const uint8 rgubKey[k_nSteamEncryptedAppTicketSymmetricKeyLen], int cubKey );
+
+S_API bool SteamEncryptedAppTicket_BIsTicketForApp( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, AppId_t nAppID );
+
+S_API RTime32 SteamEncryptedAppTicket_GetTicketIssueTime( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted );
+
+S_API void SteamEncryptedAppTicket_GetTicketSteamID( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, CSteamID *psteamID );
+
+S_API AppId_t SteamEncryptedAppTicket_GetTicketAppID( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted );
+
+S_API bool SteamEncryptedAppTicket_BUserOwnsAppInTicket( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, AppId_t nAppID );
+
+S_API bool SteamEncryptedAppTicket_BUserIsVacBanned( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted );
+
+S_API const uint8 *SteamEncryptedAppTicket_GetUserVariableData( uint8 *rgubTicketDecrypted, uint32 cubTicketDecrypted, uint32 *pcubUserData );
\ No newline at end of file
diff --git a/lsteamclient/steamworks_sdk_130x/steamhttpenums.h b/lsteamclient/steamworks_sdk_130x/steamhttpenums.h
new file mode 100644
index 00000000..155fe770
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steamhttpenums.h
@@ -0,0 +1,95 @@
+//====== Copyright © 1996-2010, Valve Corporation, All rights reserved. =======
+//
+// Purpose: HTTP related enums, stuff that is shared by both clients and servers, and our
+// UI projects goes here.
+//
+//=============================================================================
+
+#ifndef STEAMHTTPENUMS_H
+#define STEAMHTTPENUMS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// HTTP related types
+
+// This enum is used in client API methods, do not re-number existing values.
+enum EHTTPMethod
+{
+ k_EHTTPMethodInvalid = 0,
+ k_EHTTPMethodGET,
+ k_EHTTPMethodHEAD,
+ k_EHTTPMethodPOST,
+ k_EHTTPMethodPUT,
+ k_EHTTPMethodDELETE,
+ k_EHTTPMethodOPTIONS,
+
+ // The remaining HTTP methods are not yet supported, per rfc2616 section 5.1.1 only GET and HEAD are required for
+ // a compliant general purpose server. We'll likely add more as we find uses for them.
+
+ // k_EHTTPMethodTRACE,
+ // k_EHTTPMethodCONNECT
+};
+
+
+// HTTP Status codes that the server can send in response to a request, see rfc2616 section 10.3 for descriptions
+// of each of these.
+enum EHTTPStatusCode
+{
+ // Invalid status code (this isn't defined in HTTP, used to indicate unset in our code)
+ k_EHTTPStatusCodeInvalid = 0,
+
+ // Informational codes
+ k_EHTTPStatusCode100Continue = 100,
+ k_EHTTPStatusCode101SwitchingProtocols = 101,
+
+ // Success codes
+ k_EHTTPStatusCode200OK = 200,
+ k_EHTTPStatusCode201Created = 201,
+ k_EHTTPStatusCode202Accepted = 202,
+ k_EHTTPStatusCode203NonAuthoritative = 203,
+ k_EHTTPStatusCode204NoContent = 204,
+ k_EHTTPStatusCode205ResetContent = 205,
+ k_EHTTPStatusCode206PartialContent = 206,
+
+ // Redirection codes
+ k_EHTTPStatusCode300MultipleChoices = 300,
+ k_EHTTPStatusCode301MovedPermanently = 301,
+ k_EHTTPStatusCode302Found = 302,
+ k_EHTTPStatusCode303SeeOther = 303,
+ k_EHTTPStatusCode304NotModified = 304,
+ k_EHTTPStatusCode305UseProxy = 305,
+ //k_EHTTPStatusCode306Unused = 306, (used in old HTTP spec, now unused in 1.1)
+ k_EHTTPStatusCode307TemporaryRedirect = 307,
+
+ // Error codes
+ k_EHTTPStatusCode400BadRequest = 400,
+ k_EHTTPStatusCode401Unauthorized = 401,
+ k_EHTTPStatusCode402PaymentRequired = 402, // This is reserved for future HTTP specs, not really supported by clients
+ k_EHTTPStatusCode403Forbidden = 403,
+ k_EHTTPStatusCode404NotFound = 404,
+ k_EHTTPStatusCode405MethodNotAllowed = 405,
+ k_EHTTPStatusCode406NotAcceptable = 406,
+ k_EHTTPStatusCode407ProxyAuthRequired = 407,
+ k_EHTTPStatusCode408RequestTimeout = 408,
+ k_EHTTPStatusCode409Conflict = 409,
+ k_EHTTPStatusCode410Gone = 410,
+ k_EHTTPStatusCode411LengthRequired = 411,
+ k_EHTTPStatusCode412PreconditionFailed = 412,
+ k_EHTTPStatusCode413RequestEntityTooLarge = 413,
+ k_EHTTPStatusCode414RequestURITooLong = 414,
+ k_EHTTPStatusCode415UnsupportedMediaType = 415,
+ k_EHTTPStatusCode416RequestedRangeNotSatisfiable = 416,
+ k_EHTTPStatusCode417ExpectationFailed = 417,
+ k_EHTTPStatusCode429TooManyRequests = 429,
+
+ // Server error codes
+ k_EHTTPStatusCode500InternalServerError = 500,
+ k_EHTTPStatusCode501NotImplemented = 501,
+ k_EHTTPStatusCode502BadGateway = 502,
+ k_EHTTPStatusCode503ServiceUnavailable = 503,
+ k_EHTTPStatusCode504GatewayTimeout = 504,
+ k_EHTTPStatusCode505HTTPVersionNotSupported = 505,
+};
+
+#endif // STEAMHTTPENUMS_H
\ No newline at end of file
diff --git a/lsteamclient/steamworks_sdk_130x/steamps3params.h b/lsteamclient/steamworks_sdk_130x/steamps3params.h
new file mode 100644
index 00000000..c7a659dc
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steamps3params.h
@@ -0,0 +1,112 @@
+//====== Copyright 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAMPS3PARAMS_H
+#define STEAMPS3PARAMS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// PlayStation 3 initialization parameters
+//
+// The following structure must be passed to when loading steam_api_ps3.prx
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+#define STEAM_PS3_PATH_MAX 1055
+#define STEAM_PS3_SERVICE_ID_MAX 32
+#define STEAM_PS3_COMMUNICATION_ID_MAX 10
+#define STEAM_PS3_COMMUNICATION_SIG_MAX 160
+#define STEAM_PS3_LANGUAGE_MAX 64
+#define STEAM_PS3_REGION_CODE_MAX 16
+#define STEAM_PS3_CURRENT_PARAMS_VER 2
+struct SteamPS3Params_t
+{
+ uint32 m_unVersion; // set to STEAM_PS3_CURRENT_PARAMS_VER
+
+ void *pReserved;
+ uint32 m_nAppId; // set to your game's appid
+
+ char m_rgchInstallationPath[ STEAM_PS3_PATH_MAX ]; // directory containing latest steam prx's and sdata. Can be read only (BDVD)
+ char m_rgchSystemCache[ STEAM_PS3_PATH_MAX ]; // temp working cache, not persistent
+ char m_rgchGameData[ STEAM_PS3_PATH_MAX ]; // persistent game data path for storing user data
+ char m_rgchNpServiceID[ STEAM_PS3_SERVICE_ID_MAX ];
+ char m_rgchNpCommunicationID[ STEAM_PS3_COMMUNICATION_ID_MAX ];
+ char m_rgchNpCommunicationSig[ STEAM_PS3_COMMUNICATION_SIG_MAX ];
+
+ // Language should be one of the following. must be zero terminated
+ // danish
+ // dutch
+ // english
+ // finnish
+ // french
+ // german
+ // italian
+ // korean
+ // norwegian
+ // polish
+ // portuguese
+ // russian
+ // schinese
+ // spanish
+ // swedish
+ // tchinese
+ char m_rgchSteamLanguage[ STEAM_PS3_LANGUAGE_MAX ];
+
+ // region codes are "SCEA", "SCEE", "SCEJ". must be zero terminated
+ char m_rgchRegionCode[ STEAM_PS3_REGION_CODE_MAX ];
+
+ // Should be SYS_TTYP3 through SYS_TTYP10, if it's 0 then Steam won't spawn a
+ // thread to read console input at all. Using this let's you use Steam console commands
+ // like: profile_on, profile_off, profile_dump, mem_stats, mem_validate.
+ unsigned int m_cSteamInputTTY;
+
+ struct Ps3netInit_t
+ {
+ bool m_bNeedInit;
+ void *m_pMemory;
+ int m_nMemorySize;
+ int m_flags;
+ } m_sysNetInitInfo;
+
+ struct Ps3jpgInit_t
+ {
+ bool m_bNeedInit;
+ } m_sysJpgInitInfo;
+
+ struct Ps3pngInit_t
+ {
+ bool m_bNeedInit;
+ } m_sysPngInitInfo;
+
+ struct Ps3sysutilUserInfo_t
+ {
+ bool m_bNeedInit;
+ } m_sysSysUtilUserInfo;
+
+ bool m_bIncludeNewsPage;
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// PlayStation 3 memory structure
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+#define STEAMPS3_MALLOC_INUSE 0x53D04A51
+#define STEAMPS3_MALLOC_SYSTEM 0x0D102C48
+#define STEAMPS3_MALLOC_OK 0xFFD04A51
+struct SteamPS3Memory_t
+{
+ bool m_bSingleAllocation; // If true, Steam will request one 6MB allocation and use the returned memory for all future allocations
+ // If false, Steam will make call malloc for each allocation
+
+ // required function pointers
+ void* (*m_pfMalloc)(size_t);
+ void* (*m_pfRealloc)(void *, size_t);
+ void (*m_pfFree)(void *);
+ size_t (*m_pUsable_size)(void*);
+};
+
+
+#endif // STEAMPS3PARAMS_H
diff --git a/lsteamclient/steamworks_sdk_130x/steamtypes.h b/lsteamclient/steamworks_sdk_130x/steamtypes.h
new file mode 100644
index 00000000..cc14fbf6
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steamtypes.h
@@ -0,0 +1,157 @@
+//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAMTYPES_H
+#define STEAMTYPES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define S_CALLTYPE __cdecl
+
+// Steam-specific types. Defined here so this header file can be included in other code bases.
+#ifndef WCHARTYPES_H
+typedef unsigned char uint8;
+#endif
+
+#if defined( __GNUC__ ) && !defined(POSIX)
+ #if __GNUC__ < 4
+ #error "Steamworks requires GCC 4.X (4.2 or 4.4 have been tested)"
+ #endif
+ #define POSIX 1
+#endif
+
+#if defined(__x86_64__) || defined(_WIN64)
+#define X64BITS
+#endif
+
+// Make sure VALVE_BIG_ENDIAN gets set on PS3, may already be set previously in Valve internal code.
+#if !defined(VALVE_BIG_ENDIAN) && defined(_PS3)
+#define VALVE_BIG_ENDIAN
+#endif
+
+typedef unsigned char uint8;
+typedef signed char int8;
+
+#if defined( _WIN32 )
+
+typedef __int16 int16;
+typedef unsigned __int16 uint16;
+typedef __int32 int32;
+typedef unsigned __int32 uint32;
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+
+typedef int64 lint64;
+typedef uint64 ulint64;
+
+#ifdef X64BITS
+typedef __int64 intp; // intp is an integer that can accomodate a pointer
+typedef unsigned __int64 uintp; // (ie, sizeof(intp) >= sizeof(int) && sizeof(intp) >= sizeof(void *)
+#else
+typedef __int32 intp;
+typedef unsigned __int32 uintp;
+#endif
+
+#else // _WIN32
+
+typedef short int16;
+typedef unsigned short uint16;
+typedef int int32;
+typedef unsigned int uint32;
+typedef long long int64;
+typedef unsigned long long uint64;
+
+// [u]int64 are actually defined as 'long long' and gcc 64-bit
+// doesn't automatically consider them the same as 'long int'.
+// Changing the types for [u]int64 is complicated by
+// there being many definitions, so we just
+// define a 'long int' here and use it in places that would
+// otherwise confuse the compiler.
+typedef long int lint64;
+typedef unsigned long int ulint64;
+
+#ifdef X64BITS
+typedef long long intp;
+typedef unsigned long long uintp;
+#else
+typedef int intp;
+typedef unsigned int uintp;
+#endif
+
+#endif // else _WIN32
+
+const int k_cubSaltSize = 8;
+typedef uint8 Salt_t[ k_cubSaltSize ];
+
+//-----------------------------------------------------------------------------
+// GID (GlobalID) stuff
+// This is a globally unique identifier. It's guaranteed to be unique across all
+// racks and servers for as long as a given universe persists.
+//-----------------------------------------------------------------------------
+// NOTE: for GID parsing/rendering and other utils, see gid.h
+typedef uint64 GID_t;
+
+const GID_t k_GIDNil = 0xffffffffffffffffull;
+
+// For convenience, we define a number of types that are just new names for GIDs
+typedef GID_t JobID_t; // Each Job has a unique ID
+typedef GID_t TxnID_t; // Each financial transaction has a unique ID
+
+const GID_t k_TxnIDNil = k_GIDNil;
+const GID_t k_TxnIDUnknown = 0;
+
+
+// this is baked into client messages and interfaces as an int,
+// make sure we never break this.
+typedef uint32 PackageId_t;
+const PackageId_t k_uPackageIdFreeSub = 0x0;
+const PackageId_t k_uPackageIdInvalid = 0xFFFFFFFF;
+
+
+// this is baked into client messages and interfaces as an int,
+// make sure we never break this.
+typedef uint32 AppId_t;
+const AppId_t k_uAppIdInvalid = 0x0;
+
+typedef uint64 AssetClassId_t;
+const AssetClassId_t k_ulAssetClassIdInvalid = 0x0;
+
+typedef uint32 PhysicalItemId_t;
+const PhysicalItemId_t k_uPhysicalItemIdInvalid = 0x0;
+
+
+// this is baked into client messages and interfaces as an int,
+// make sure we never break this. AppIds and DepotIDs also presently
+// share the same namespace, but since we'd like to change that in the future
+// I've defined it seperately here.
+typedef uint32 DepotId_t;
+const DepotId_t k_uDepotIdInvalid = 0x0;
+
+// RTime32
+// We use this 32 bit time representing real world time.
+// It offers 1 second resolution beginning on January 1, 1970 (Unix time)
+typedef uint32 RTime32;
+
+typedef uint32 CellID_t;
+const CellID_t k_uCellIDInvalid = 0xFFFFFFFF;
+
+// handle to a Steam API call
+typedef uint64 SteamAPICall_t;
+const SteamAPICall_t k_uAPICallInvalid = 0x0;
+
+typedef uint32 AccountID_t;
+
+typedef uint32 PartnerId_t;
+const PartnerId_t k_uPartnerIdInvalid = 0;
+
+// ID for a depot content manifest
+typedef uint64 ManifestId_t;
+const ManifestId_t k_uManifestIdInvalid = 0;
+
+
+
+#endif // STEAMTYPES_H
diff --git a/lsteamclient/steamworks_sdk_130x/steamuniverse.h b/lsteamclient/steamworks_sdk_130x/steamuniverse.h
new file mode 100644
index 00000000..2318935f
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steamuniverse.h
@@ -0,0 +1,27 @@
+//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAMUNIVERSE_H
+#define STEAMUNIVERSE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+// Steam universes. Each universe is a self-contained Steam instance.
+enum EUniverse
+{
+ k_EUniverseInvalid = 0,
+ k_EUniversePublic = 1,
+ k_EUniverseBeta = 2,
+ k_EUniverseInternal = 3,
+ k_EUniverseDev = 4,
+ // k_EUniverseRC = 5, // no such universe anymore
+ k_EUniverseMax
+};
+
+
+#endif // STEAMUNIVERSE_H
diff --git a/lsteamclient/steamworks_sdk_130x/steamvr.h b/lsteamclient/steamworks_sdk_130x/steamvr.h
new file mode 100644
index 00000000..cfbbdb16
--- /dev/null
+++ b/lsteamclient/steamworks_sdk_130x/steamvr.h
@@ -0,0 +1,261 @@
+#pragma once
+
+#include
+
+namespace vr
+{
+
+#if defined(__linux__) || defined(__APPLE__)
+ // The 32-bit version of gcc has the alignment requirement for uint64 and double set to
+ // 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
+ // The 64-bit version of gcc has the alignment requirement for these types set to
+ // 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
+ // The 64-bit structure packing has to match the 32-bit structure packing for each platform.
+#pragma pack( push, 4 )
+#else
+#pragma pack( push, 8 )
+#endif
+
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is meters
+struct HmdMatrix34_t
+{
+ float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+ float m[4][4];
+};
+
+
+/** Used to return the post-distortion UVs for each color channel.
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+ float rfRed[2];
+ float rfGreen[2];
+ float rfBlue[2];
+};
+
+
+enum Hmd_Eye
+{
+ Eye_Left = 0,
+ Eye_Right = 1
+};
+
+enum GraphicsAPIConvention
+{
+ API_DirectX = 0, // Normalized Z goes from 0 at the viewer to 1 at the far clip plane
+ API_OpenGL = 1, // Normalized Z goes from 1 at the viewer to -1 at the far clip plane
+};
+
+enum HmdTrackingResult
+{
+ TrackingResult_Uninitialized = 1,
+
+ TrackingResult_Calibrating_InProgress = 100,
+ TrackingResult_Calibrating_OutOfRange = 101,
+
+ TrackingResult_Running_OK = 200,
+ TrackingResult_Running_OutOfRange = 201,
+};
+
+class IHmd
+{
+public:
+
+
+ // ------------------------------------
+ // Display Methods
+ // ------------------------------------
+
+ /** Size and position that the window needs to be on the VR display. */
+ virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+ /** Suggested size for the intermediate render target that the distortion pulls from. */
+ virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+ /** Gets the viewport in the frame buffer to draw the output of the distortion into */
+ virtual void GetEyeOutputViewport( Hmd_Eye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+ /** The projection matrix for the specified eye */
+ virtual HmdMatrix44_t GetProjectionMatrix( Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType ) = 0;
+
+ /** The components necessary to build your own projection matrix in case your
+ * application is doing something fancy like infinite Z */
+ virtual void GetProjectionRaw( Hmd_Eye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
+
+ /** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
+ * the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. */
+ virtual DistortionCoordinates_t ComputeDistortion( Hmd_Eye eEye, float fU, float fV ) = 0;
+
+ /** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+ * space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection.
+ * Normally View and Eye^-1 will be multiplied together and treated as View in your application.
+ */
+ virtual HmdMatrix34_t GetHeadFromEyePose( Hmd_Eye eEye ) = 0;
+
+ /** For use in simple VR apps, this method returns the concatenation of the
+ * tracking pose and the eye matrix to get a full view matrix for each eye.
+ * This is ( GetEyeMatrix() ) * (GetWorldFromHeadPose() ^ -1 ) */
+ virtual bool GetViewMatrix( float fSecondsFromNow, HmdMatrix44_t *pMatLeftView, HmdMatrix44_t *pMatRightView, HmdTrackingResult *peResult ) = 0;
+
+ /** [D3D9 Only]
+ * Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+ * a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+ */
+ virtual int32_t GetD3D9AdapterIndex() = 0;
+
+ /** [D3D10/11 Only]
+ * Returns the adapter index and output index that the user should pass into EnumAdapters adn EnumOutputs
+ * to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+ */
+ virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) = 0;
+
+ /** [Windows Only]
+ * Notifies the system that the VR output will appear in a particular window.
+ */
+ virtual void AttachToWindow( void *hWnd ) = 0;
+
+ // ------------------------------------
+ // Tracking Methods
+ // ------------------------------------
+
+ /** The pose that the tracker thinks that the HMD will be in at the specified
+ * number of seconds into the future. Pass 0 to get the current state.
+ *
+ * This is roughly analogous to the inverse of the view matrix in most applications, though
+ * many games will need to do some additional rotation or translation on top of the rotation
+ * and translation provided by the head pose.
+ *
+ * If this function returns true the pose has been populated with a pose that can be used by the application.
+ * Check peResult for details about the pose, including messages that should be displayed to the user.
+ */
+ virtual bool GetTrackerFromHeadPose( float fPredictedSecondsFromNow, HmdMatrix34_t *pmPose, HmdTrackingResult *peResult ) = 0;
+
+ /** Passes back the pose matrix from the last successful call to GetWorldFromHeadPose(). Returns true if that matrix is
+ * valid (because there has been a previous successful pose.) */
+ virtual bool GetLastTrackerFromHeadPose( HmdMatrix34_t *pmPose ) = 0;
+
+ /** Returns true if the tracker for this HMD will drift the Yaw component of its pose over time regardless of
+ * actual head motion. This is true for gyro-based trackers with no ground truth. */
+ virtual bool WillDriftInYaw() = 0;
+
+ /** Sets the zero pose for the tracker coordinate system. After this call all WorldFromHead poses will be relative
+ * to the pose whenever this was called. The new zero coordinate system will not change the fact that the Y axis is
+ * up in the real world, so the next pose returned from GetWorldFromHeadPose after a call to ZeroTracker may not be
+ * exactly an identity matrix. */
+ virtual void ZeroTracker() = 0;
+
+ /** Returns the zero pose for the tracker coordinate system. If the tracker has never had a valid pose, this
+ * will be an identity matrix. */
+ virtual HmdMatrix34_t GetTrackerZeroPose() = 0;
+
+ // ------------------------------------
+ // Administrative methods
+ // ------------------------------------
+
+ /** The ID of the driver this HMD uses as a UTF-8 string. Returns the length of the ID in bytes. If
+ * the buffer is not large enough to fit the ID an empty string will be returned. In general, 128 bytes
+ * will be enough to fit any ID. */
+ virtual uint32_t GetDriverId( char *pchBuffer, uint32_t unBufferLen ) = 0;
+
+ /** The ID of this display within its driver this HMD uses as a UTF-8 string. Returns the length of the ID in bytes. If
+ * the buffer is not large enough to fit the ID an empty string will be returned. In general, 128 bytes
+ * will be enough to fit any ID. */
+ virtual uint32_t GetDisplayId( char *pchBuffer, uint32_t unBufferLen ) = 0;
+};
+
+static const char * const IHmd_Version = "IHmd_005";
+
+/** error codes returned by Vr_Init */
+enum HmdError
+{
+ HmdError_None = 0,
+
+ HmdError_Init_InstallationNotFound = 100,
+ HmdError_Init_InstallationCorrupt = 101,
+ HmdError_Init_VRClientDLLNotFound = 102,
+ HmdError_Init_FileNotFound = 103,
+ HmdError_Init_FactoryNotFound = 104,
+ HmdError_Init_InterfaceNotFound = 105,
+ HmdError_Init_InvalidInterface = 106,
+ HmdError_Init_UserConfigDirectoryInvalid = 107,
+ HmdError_Init_HmdNotFound = 108,
+ HmdError_Init_NotInitialized = 109,
+
+ HmdError_Driver_Failed = 200,
+ HmdError_Driver_Unknown = 201,
+ HmdError_Driver_HmdUnknown = 202,
+ HmdError_Driver_NotLoaded = 203,
+
+ HmdError_IPC_ServerInitFailed = 300,
+ HmdError_IPC_ConnectFailed = 301,
+ HmdError_IPC_SharedStateInitFailed = 302,
+
+ HmdError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+
+};
+
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec( dllexport )
+#else
+#define VR_INTERFACE extern "C" __declspec( dllimport )
+#endif
+
+#elif defined(GNUC) || defined(COMPILER_GCC)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C"
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+
+
+
+/** Finds the active installation of the VR API and initializes it. The priority for figuring
+* out where to load vrclient from are:
+* 1. The convar "VR_OVERRIDE", which should contain an absolute path to the root of
+* an vr API directory.
+* 2. The pchVROverride argument. This should be an absolute path or a path relative to
+* the current executable.
+* 3. The path "./vr" relative to the current executable's path.
+*
+* Each of these paths are to the "root" of the VR API install. That's the directory with
+* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+*/
+VR_INTERFACE IHmd *VR_Init( HmdError *peError );
+
+/** unloads vrclient.dll. Any interface pointers from the interface are
+* invalid after this point */
+VR_INTERFACE void VR_Shutdown( );
+
+/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+* to know if initializing VR is a possibility but isn't ready to take that step yet.
+*/
+VR_INTERFACE bool VR_IsHmdPresent();
+
+/** Returns the string version of an HMD error. This function may be called outside of VR_Init()/VR_Shutdown(). */
+VR_INTERFACE const char *VR_GetStringForHmdError( HmdError error );
+
+#pragma pack( pop )
+
+
+}
\ No newline at end of file
diff --git a/lsteamclient/struct_converters_130x.cpp b/lsteamclient/struct_converters_130x.cpp
new file mode 100644
index 00000000..0ea4e287
--- /dev/null
+++ b/lsteamclient/struct_converters_130x.cpp
@@ -0,0 +1,134 @@
+#include "steam_defs.h"
+#include "steamworks_sdk_130x/steam_api.h"
+#include "steamworks_sdk_130x/isteamgameserver.h"
+#include "steamworks_sdk_130x/isteamgameserverstats.h"
+#include "steamworks_sdk_130x/isteamgamecoordinator.h"
+#include "steamclient_private.h"
+extern "C" {
+#pragma pack( push, 8 )
+struct winLeaderboardEntry_t_130x {
+ CSteamID m_steamIDUser;
+ int32 m_nGlobalRank;
+ int32 m_nScore;
+ int32 m_cDetails;
+ UGCHandle_t m_hUGC;
+} __attribute__ ((ms_struct));
+#pragma pack( pop )
+void win_to_lin_struct_LeaderboardEntry_t_130x(const void *w, void *l)
+{
+ LeaderboardEntry_t *lin = (LeaderboardEntry_t *)l;
+ struct winLeaderboardEntry_t_130x *win = (struct winLeaderboardEntry_t_130x *)w;
+ lin->m_steamIDUser = win->m_steamIDUser;
+ lin->m_nGlobalRank = win->m_nGlobalRank;
+ lin->m_nScore = win->m_nScore;
+ lin->m_cDetails = win->m_cDetails;
+ lin->m_hUGC = win->m_hUGC;
+}
+
+void lin_to_win_struct_LeaderboardEntry_t_130x(const void *l, void *w)
+{
+ LeaderboardEntry_t *lin = (LeaderboardEntry_t *)l;
+ struct winLeaderboardEntry_t_130x *win = (struct winLeaderboardEntry_t_130x *)w;
+ win->m_steamIDUser = lin->m_steamIDUser;
+ win->m_nGlobalRank = lin->m_nGlobalRank;
+ win->m_nScore = lin->m_nScore;
+ win->m_cDetails = lin->m_cDetails;
+ win->m_hUGC = lin->m_hUGC;
+}
+
+#pragma pack( push, 8 )
+struct winSteamUGCDetails_t_130x {
+ PublishedFileId_t m_nPublishedFileId;
+ EResult m_eResult;
+ EWorkshopFileType m_eFileType;
+ AppId_t m_nCreatorAppID;
+ AppId_t m_nConsumerAppID;
+ char m_rgchTitle[129];
+ char m_rgchDescription[8000];
+ uint64 m_ulSteamIDOwner;
+ uint32 m_rtimeCreated;
+ uint32 m_rtimeUpdated;
+ uint32 m_rtimeAddedToUserList;
+ ERemoteStoragePublishedFileVisibility m_eVisibility;
+ bool m_bBanned;
+ bool m_bAcceptedForUse;
+ bool m_bTagsTruncated;
+ char m_rgchTags[1025];
+ UGCHandle_t m_hFile;
+ UGCHandle_t m_hPreviewFile;
+ char m_pchFileName[260];
+ int32 m_nFileSize;
+ int32 m_nPreviewFileSize;
+ char m_rgchURL[256];
+ uint32 m_unVotesUp;
+ uint32 m_unVotesDown;
+ float m_flScore;
+ uint32 m_unNumChildren;
+} __attribute__ ((ms_struct));
+#pragma pack( pop )
+void win_to_lin_struct_SteamUGCDetails_t_130x(const void *w, void *l)
+{
+ SteamUGCDetails_t *lin = (SteamUGCDetails_t *)l;
+ struct winSteamUGCDetails_t_130x *win = (struct winSteamUGCDetails_t_130x *)w;
+ lin->m_nPublishedFileId = win->m_nPublishedFileId;
+ lin->m_eResult = win->m_eResult;
+ lin->m_eFileType = win->m_eFileType;
+ lin->m_nCreatorAppID = win->m_nCreatorAppID;
+ lin->m_nConsumerAppID = win->m_nConsumerAppID;
+ memcpy(lin->m_rgchTitle, win->m_rgchTitle, sizeof(lin->m_rgchTitle));
+ memcpy(lin->m_rgchDescription, win->m_rgchDescription, sizeof(lin->m_rgchDescription));
+ lin->m_ulSteamIDOwner = win->m_ulSteamIDOwner;
+ lin->m_rtimeCreated = win->m_rtimeCreated;
+ lin->m_rtimeUpdated = win->m_rtimeUpdated;
+ lin->m_rtimeAddedToUserList = win->m_rtimeAddedToUserList;
+ lin->m_eVisibility = win->m_eVisibility;
+ lin->m_bBanned = win->m_bBanned;
+ lin->m_bAcceptedForUse = win->m_bAcceptedForUse;
+ lin->m_bTagsTruncated = win->m_bTagsTruncated;
+ memcpy(lin->m_rgchTags, win->m_rgchTags, sizeof(lin->m_rgchTags));
+ lin->m_hFile = win->m_hFile;
+ lin->m_hPreviewFile = win->m_hPreviewFile;
+ memcpy(lin->m_pchFileName, win->m_pchFileName, sizeof(lin->m_pchFileName));
+ lin->m_nFileSize = win->m_nFileSize;
+ lin->m_nPreviewFileSize = win->m_nPreviewFileSize;
+ memcpy(lin->m_rgchURL, win->m_rgchURL, sizeof(lin->m_rgchURL));
+ lin->m_unVotesUp = win->m_unVotesUp;
+ lin->m_unVotesDown = win->m_unVotesDown;
+ lin->m_flScore = win->m_flScore;
+ lin->m_unNumChildren = win->m_unNumChildren;
+}
+
+void lin_to_win_struct_SteamUGCDetails_t_130x(const void *l, void *w)
+{
+ SteamUGCDetails_t *lin = (SteamUGCDetails_t *)l;
+ struct winSteamUGCDetails_t_130x *win = (struct winSteamUGCDetails_t_130x *)w;
+ win->m_nPublishedFileId = lin->m_nPublishedFileId;
+ win->m_eResult = lin->m_eResult;
+ win->m_eFileType = lin->m_eFileType;
+ win->m_nCreatorAppID = lin->m_nCreatorAppID;
+ win->m_nConsumerAppID = lin->m_nConsumerAppID;
+ memcpy(win->m_rgchTitle, lin->m_rgchTitle, sizeof(win->m_rgchTitle));
+ memcpy(win->m_rgchDescription, lin->m_rgchDescription, sizeof(win->m_rgchDescription));
+ win->m_ulSteamIDOwner = lin->m_ulSteamIDOwner;
+ win->m_rtimeCreated = lin->m_rtimeCreated;
+ win->m_rtimeUpdated = lin->m_rtimeUpdated;
+ win->m_rtimeAddedToUserList = lin->m_rtimeAddedToUserList;
+ win->m_eVisibility = lin->m_eVisibility;
+ win->m_bBanned = lin->m_bBanned;
+ win->m_bAcceptedForUse = lin->m_bAcceptedForUse;
+ win->m_bTagsTruncated = lin->m_bTagsTruncated;
+ memcpy(win->m_rgchTags, lin->m_rgchTags, sizeof(win->m_rgchTags));
+ win->m_hFile = lin->m_hFile;
+ win->m_hPreviewFile = lin->m_hPreviewFile;
+ memcpy(win->m_pchFileName, lin->m_pchFileName, sizeof(win->m_pchFileName));
+ win->m_nFileSize = lin->m_nFileSize;
+ win->m_nPreviewFileSize = lin->m_nPreviewFileSize;
+ memcpy(win->m_rgchURL, lin->m_rgchURL, sizeof(win->m_rgchURL));
+ win->m_unVotesUp = lin->m_unVotesUp;
+ win->m_unVotesDown = lin->m_unVotesDown;
+ win->m_flScore = lin->m_flScore;
+ win->m_unNumChildren = lin->m_unNumChildren;
+}
+
+
+}
diff --git a/lsteamclient/struct_converters_130x.h b/lsteamclient/struct_converters_130x.h
new file mode 100644
index 00000000..5bd87961
--- /dev/null
+++ b/lsteamclient/struct_converters_130x.h
@@ -0,0 +1,6 @@
+extern void win_to_lin_struct_LeaderboardEntry_t_130x(const void *w, void *l);
+extern void lin_to_win_struct_LeaderboardEntry_t_130x(const void *l, void *w);
+
+extern void win_to_lin_struct_SteamUGCDetails_t_130x(const void *w, void *l);
+extern void lin_to_win_struct_SteamUGCDetails_t_130x(const void *l, void *w);
+
diff --git a/lsteamclient/winISteamHTMLSurface.c b/lsteamclient/winISteamHTMLSurface.c
index d5da3b15..2bb0fa52 100644
--- a/lsteamclient/winISteamHTMLSurface.c
+++ b/lsteamclient/winISteamHTMLSurface.c
@@ -955,3 +955,293 @@ winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_002 *create_winISteamHTM
return r;
}
+#include "cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001.h"
+
+typedef struct __winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 {
+ vtable_ptr *vtable;
+ void *linux_side;
+} winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001;
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_destructor, 4)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_destructor(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this)
+{/* never called */}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Init, 4)
+bool __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Init(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this)
+{
+ TRACE("%p\n", _this);
+ return cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Init(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Shutdown, 4)
+bool __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Shutdown(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this)
+{
+ TRACE("%p\n", _this);
+ return cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Shutdown(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CreateBrowser, 12)
+SteamAPICall_t __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CreateBrowser(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, const char * pchUserAgent, const char * pchUserCSS)
+{
+ TRACE("%p\n", _this);
+ return cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CreateBrowser(_this->linux_side, pchUserAgent, pchUserCSS);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_RemoveBrowser, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_RemoveBrowser(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_RemoveBrowser(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_LoadURL, 16)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_LoadURL(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, const char * pchURL, const char * pchPostData)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_LoadURL(_this->linux_side, unBrowserHandle, pchURL, pchPostData);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetSize, 16)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetSize(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, uint32 unWidth, uint32 unHeight)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetSize(_this->linux_side, unBrowserHandle, unWidth, unHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopLoad, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopLoad(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopLoad(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Reload, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Reload(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Reload(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoBack, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoBack(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoBack(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoForward, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoForward(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoForward(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AddHeader, 16)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AddHeader(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, const char * pchKey, const char * pchValue)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AddHeader(_this->linux_side, unBrowserHandle, pchKey, pchValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ExecuteJavascript, 12)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ExecuteJavascript(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, const char * pchScript)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ExecuteJavascript(_this->linux_side, unBrowserHandle, pchScript);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseUp, 12)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseUp(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseUp(_this->linux_side, unBrowserHandle, eMouseButton);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDown, 12)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDown(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDown(_this->linux_side, unBrowserHandle, eMouseButton);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDoubleClick, 12)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDoubleClick(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDoubleClick(_this->linux_side, unBrowserHandle, eMouseButton);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseMove, 16)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseMove(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, int x, int y)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseMove(_this->linux_side, unBrowserHandle, x, y);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseWheel, 12)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseWheel(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, int32 nDelta)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseWheel(_this->linux_side, unBrowserHandle, nDelta);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyDown, 16)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyDown(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyDown(_this->linux_side, unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyUp, 16)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyUp(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyUp(_this->linux_side, unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyChar, 16)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyChar(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, EHTMLKeyModifiers eHTMLKeyModifiers)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyChar(_this->linux_side, unBrowserHandle, cUnicodeChar, eHTMLKeyModifiers);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetHorizontalScroll, 12)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetHorizontalScroll(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetHorizontalScroll(_this->linux_side, unBrowserHandle, nAbsolutePixelScroll);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetVerticalScroll, 12)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetVerticalScroll(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetVerticalScroll(_this->linux_side, unBrowserHandle, nAbsolutePixelScroll);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetKeyFocus, 9)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetKeyFocus(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, bool bHasKeyFocus)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetKeyFocus(_this->linux_side, unBrowserHandle, bHasKeyFocus);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ViewSource, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ViewSource(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ViewSource(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CopyToClipboard, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CopyToClipboard(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CopyToClipboard(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_PasteFromClipboard, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_PasteFromClipboard(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_PasteFromClipboard(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Find, 14)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Find(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, const char * pchSearchStr, bool bCurrentlyInFind, bool bReverse)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Find(_this->linux_side, unBrowserHandle, pchSearchStr, bCurrentlyInFind, bReverse);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopFind, 8)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopFind(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopFind(_this->linux_side, unBrowserHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GetLinkAtPosition, 16)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GetLinkAtPosition(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, int x, int y)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GetLinkAtPosition(_this->linux_side, unBrowserHandle, x, y);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AllowStartRequest, 9)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AllowStartRequest(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, bool bAllowed)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AllowStartRequest(_this->linux_side, unBrowserHandle, bAllowed);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_JSDialogResponse, 9)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_JSDialogResponse(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, bool bResult)
+{
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_JSDialogResponse(_this->linux_side, unBrowserHandle, bResult);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_FileLoadDialogResponse, 12)
+void __thiscall winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_FileLoadDialogResponse(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *_this, HHTMLBrowser unBrowserHandle, const char ** pchSelectedFiles)
+{
+ const char **lin_pchSelectedFiles = steamclient_dos_to_unix_stringlist(pchSelectedFiles);
+ TRACE("%p\n", _this);
+ cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_FileLoadDialogResponse(_this->linux_side, unBrowserHandle, pchSelectedFiles ? lin_pchSelectedFiles : NULL);
+ steamclient_free_stringlist(lin_pchSelectedFiles);
+}
+
+extern vtable_ptr winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+ __ASM_VTABLE(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001,
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_destructor)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Init)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Shutdown)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CreateBrowser)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_RemoveBrowser)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_LoadURL)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetSize)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopLoad)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Reload)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoBack)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GoForward)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AddHeader)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ExecuteJavascript)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseUp)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDown)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseDoubleClick)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseMove)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_MouseWheel)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyDown)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyUp)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_KeyChar)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetHorizontalScroll)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetVerticalScroll)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_SetKeyFocus)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_ViewSource)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_CopyToClipboard)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_PasteFromClipboard)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_Find)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_StopFind)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_GetLinkAtPosition)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_AllowStartRequest)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_JSDialogResponse)
+ VTABLE_ADD_FUNC(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_FileLoadDialogResponse)
+ );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *create_winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001(void *linux_side)
+{
+ winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001));
+ TRACE("-> %p\n", r);
+ r->vtable = &winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001_vtable;
+ r->linux_side = linux_side;
+ return r;
+}
+
diff --git a/lsteamclient/win_constructors.h b/lsteamclient/win_constructors.h
index 67175f97..b012c00c 100644
--- a/lsteamclient/win_constructors.h
+++ b/lsteamclient/win_constructors.h
@@ -50,6 +50,7 @@ extern void *create_winISteamClient_SteamClient016(void *);
extern void *create_winISteamUser_SteamUser017(void *);
extern void *create_winISteamFriends_SteamFriends014(void *);
extern void *create_winISteamApps_STEAMAPPS_INTERFACE_VERSION006(void *);
+extern void *create_winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001(void *);
extern void *create_winISteamClient_SteamClient015(void *);
extern void *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION002(void *);
extern void *create_winISteamClient_SteamClient014(void *);
diff --git a/lsteamclient/win_constructors_table.dat b/lsteamclient/win_constructors_table.dat
index 4b758c67..fcaf074e 100644
--- a/lsteamclient/win_constructors_table.dat
+++ b/lsteamclient/win_constructors_table.dat
@@ -50,6 +50,7 @@
{"SteamUser017", &create_winISteamUser_SteamUser017},
{"SteamFriends014", &create_winISteamFriends_SteamFriends014},
{"STEAMAPPS_INTERFACE_VERSION006", &create_winISteamApps_STEAMAPPS_INTERFACE_VERSION006},
+ {"STEAMHTMLSURFACE_INTERFACE_VERSION_001", &create_winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_001},
{"SteamClient015", &create_winISteamClient_SteamClient015},
{"STEAMUGC_INTERFACE_VERSION002", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION002},
{"SteamClient014", &create_winISteamClient_SteamClient014},