Didrole avatar Didrole committed e0ab35e

Updated IClient* interfaces, added ISteamFriends013, ISteamRemoteStorage008 and ISteamUserStats011

Comments (0)

Files changed (18)

Open Steamworks/AppsCommon.h

 	k_ERegisterActivactionCodeAlreadyOwned = 4
 };
 
+enum EAppOwernshipFlags
+{
+	k_EAppOwernshipFlagsNone =				0,
+	k_EAppOwernshipFlagsOwnsLicense =		1 << 0,
+	k_EAppOwernshipFlagsFreeLicense =		1 << 1,
+	k_EAppOwernshipFlagsRegionRestricted =	1 << 2,
+	k_EAppOwernshipFlagsLowViolence =		1 << 3,
+};
+
+enum EAppReleaseState
+{
+	k_EAppReleaseStateUnknown = 0,
+	k_EAppReleaseStateUnavailable,
+	k_EAppReleaseStatePrerelease,
+	k_EAppReleaseStatePreloadonly,
+	k_EAppReleaseStateReleased,
+};
 
 struct SHADigestWrapper_t
 {

Open Steamworks/BillingCommon.h

 	enum EResult m_EResult;
 };
 
-// TODO: Add callback 411
-// TODO: Add callback 412
+struct RequestFreeLicenseResponse_t
+{
+	enum { k_iCallback = k_iSteamBillingCallbacks + 12 };
+
+	EResult m_EResult;
+	AppId_t m_uAppId;
+};
 
 struct OEMTicketActivationResponse_t
 {

Open Steamworks/FriendsCommon.h

 #define STEAMFRIENDS_INTERFACE_VERSION_010 "SteamFriends010"
 #define STEAMFRIENDS_INTERFACE_VERSION_011 "SteamFriends011"
 #define STEAMFRIENDS_INTERFACE_VERSION_012 "SteamFriends012"
+#define STEAMFRIENDS_INTERFACE_VERSION_013 "SteamFriends013"
 
 //-----------------------------------------------------------------------------
 // Purpose: avatar sizes, used in ISteamFriends::GetFriendAvatar()
 	k_nUserRestrictionRating	= 16,	// user is too young according to rating in current region
 };
 
+enum EOverlayToStoreFlag
+{
+	k_EOverlayToStoreFlagNone		= 0,
+	k_EOverlayToStoreFlagAddToCart	= 1,
+};
+
 
 // size limits on Rich Presence data
 enum { k_cchMaxRichPresenceKeys = 20 };
 	CSteamID m_steamIDTarget;
 	AppId_t m_nAppID;
 	bool m_bWebPage;
+	EOverlayToStoreFlag m_eFlag;
 };
 
 struct ClanEventReceived_t

Open Steamworks/IClientAppManager.h

 	virtual EAppUpdateError LaunchApp( AppId_t unAppID, uint32 uLaunchOption, const char *pszUserArgs ) = 0;
 	virtual bool ShutdownApp( AppId_t unAppID, bool bForce ) = 0;
 
-	virtual EAppState GetAppState( AppId_t unAppID ) = 0;
+	virtual EAppState GetAppInstallState( AppId_t unAppID ) = 0;
 
 	// /!\ IPC is broken for this function
 	virtual bool GetAppSizeOnDisk( AppId_t unAppID, uint64 *pullAppSize, uint64 *pullUnk ) = 0;
 
 	virtual uint32 GetAppDependency( AppId_t unAppID ) = 0;
 	virtual uint32 GetDependentApps( AppId_t unAppID, AppId_t *punAppIDs, int32 cAppIDsMax ) = 0;
+	virtual bool RemoveAppDependencies( AppId_t unAppID ) = 0;
 
 	virtual uint32 GetUpdateInfo( AppId_t unAppID, AppUpdateInfo_s *pUpdateInfo ) = 0;
 
 
 	virtual bool BIsAppUpToDate( AppId_t unAppID ) = 0;
 	
-	virtual bool BCheckBetaPassword( AppId_t unAppID, const char *cszBetaKey, const char *cszBetaPassword ) = 0;
+	virtual bool BCacheBetaPassword( AppId_t unAppID, const char *cszBetaKey, const char *cszBetaPassword ) = 0;
+	virtual bool BRequestBetaPasswords( AppId_t unAppID ) = 0;
+	virtual bool BIsCachedBetaPasswordValid( AppId_t unAppID, const char *cszBetaKey ) = 0;
 
 	virtual bool SetDownloadingEnabled( bool bState ) = 0;
 	virtual bool BIsDownloadingEnabled() = 0;
 	virtual bool BNeedsFile( AppId_t unAppID, char const *cszFilePath, uint64 ullFileSize, uint32 uUnk ) = 0;
 	virtual bool BAddFileOnDisk( AppId_t unAppID, char const *cszFilePath, uint64 ullFileSize, uint32 uUnk, SHADigestWrapper_t ubSha1 ) = 0;
 	virtual uint64 FinishAddingFiles( AppId_t unAppID ) = 0;
+
+	virtual bool GetAppStateInfo( AppId_t unAppID, EAppReleaseState * peReleaseState, EAppOwernshipFlags * peOwernshipFlags ) = 0;
 };
 
 #endif // ICLIENTAPPMANAGER_H

Open Steamworks/IClientBilling.h

 
 	virtual bool ActivateOEMTicket( const char *pchOEMLicenseFile ) = 0;
 
-	virtual bool GetLicenseForAppID( AppId_t unAppId, PackageId_t * punPackageID ) = 0;
 	virtual uint32 GetPackageName( PackageId_t unPackageID, char *pchName, int32 cubName ) = 0;
 	virtual bool GetPackageInfo( PackageId_t unPackageID, uint32 * puNumAppIds, uint32 * puNumDepotIDs, EBillingType * peBillingType, ELicenseType * peLicenseType, EPackageStatus * pePackageStatus, int32 * piCodeClass, int32 * piGameCode, int32 * piTerritoryCode, bool *pbRequiresShipping, bool *pbIsPreorder ) = 0;
 	virtual uint32 GetAppsInPackage( PackageId_t unPackageID, AppId_t puIds[], uint32 uMaxIds, bool bExcludeDepots, bool bExcludeApps ) = 0;
 	virtual uint32 GetPackageExtendedInfo( PackageId_t unPackageID, uint8 *pubData, int32 cubData, bool bSharedKVSymbols ) = 0;
 
-	// Result returned by callback id 412
 	virtual SteamAPICall_t RequestFreeLicenseForApp( AppId_t unAppId ) = 0;
 };
 

Open Steamworks/IClientDepotBuilder.h

 	virtual uint32 FinishAppBuild( uint32 uBuildID, uint32 nAppID, const char *cszBetaKey, bool bOnlyFinish, uint32 cNumSkipDepots ) = 0;
 
 	virtual uint32 VerifyChunkStore( uint32, uint32, const char * ) = 0;
+	virtual uint32 StartUploadTest( uint32, uint32 ) = 0;
 };
 
 #endif // ICLIENTDEPOTBUILDER_H

Open Steamworks/IClientEngine.h

 	virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0;
 
 	virtual HSteamUser CreateLocalUser( HSteamPipe* phSteamPipe, EAccountType eAccountType ) = 0;
+	virtual void CreatePipeToLocalUser( HSteamUser hSteamUser, HSteamPipe* phSteamPipe ) = 0;
 
 	virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0;
 

Open Steamworks/IClientFriends.h

 	virtual void ActivateGameOverlay( const char *pchDialog ) = 0;
 	virtual void ActivateGameOverlayToUser( const char *pchDialog, CSteamID steamID ) = 0;
 	virtual void ActivateGameOverlayToWebPage( const char *pchURL ) = 0;
-	virtual void ActivateGameOverlayToStore( AppId_t nAppId ) = 0;
+	virtual void ActivateGameOverlayToStore( AppId_t nAppId, EOverlayToStoreFlag eFlag ) = 0;
 	virtual void ActivateGameOverlayInviteDialog( CSteamID steamIDLobby ) = 0;
 
 	virtual void NotifyGameOverlayStateChanged( bool bActive ) = 0;

Open Steamworks/IClientRemoteStorage.h

 	virtual bool SetSyncPlatforms( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile, ERemoteStoragePlatform eRemoteStoragePlatform ) = 0;
 	virtual ERemoteStoragePlatform GetSyncPlatforms( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile ) = 0;
 
+	virtual GID_t FileWriteStreamOpen( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile ) = 0;
+	virtual EResult FileWriteStreamClose( GID_t hStream ) = 0;
+	virtual EResult FileWriteStreamCancel( GID_t hStream ) = 0;
+	virtual EResult FileWriteStreamWriteChunk( GID_t hStream, const void *pvData, int32 cubData ) = 0;
+
 	virtual int32 GetFileCount( AppId_t nAppId, bool bFromExternalAPI ) = 0;
 	virtual const char *GetFileNameAndSize( AppId_t nAppId, int32 iFile, ERemoteStorageFileRoot *peRemoteStorageFileRoot, int32 *pnFileSizeInBytes, bool bFromExternalAPI ) = 0;
 

Open Steamworks/IClientUser.h

 	virtual bool GetCurrentWebAuthToken( char *pchBuffer, int32 cubBuffer ) = 0;
 
 	virtual bool GetLanguage( char* pchLanguage, int32 cbLanguage ) = 0;
-	virtual void SetCyberCafe( bool bCyberCafe ) = 0;
+
+	virtual bool BIsCyberCafe() = 0;
+	virtual bool BIsAcademicAccount() = 0;
 
 	virtual void CreateAccount( const char *pchAccountName, const char *pchNewPassword, const char *pchNewEmail, int32 iQuestion, const char *pchNewQuestion, const char *pchNewAnswer ) = 0;
 
 	
 	virtual bool InCommunityBeta() = 0;
 	virtual void SetInCommunityBeta( bool bInBeta ) = 0;
+
+	virtual bool GetAppOwnershipInfo( AppId_t unAppId, RTime32* pRTime32Created, char* pchCountry ) = 0; // Use a 3 bytes buffer for the country
 };
 
 #endif // ICLIENTUSER_H

Open Steamworks/ISteam006.h

 	virtual int IsUsingSdkContentServer( int* pbUsingSdkCS, TSteamError* pError ) = 0;
 	virtual int GetDepotParent( unsigned int uDepotId, unsigned int* puParentId, TSteamError* pError ) = 0;
 	virtual int GetCurrentCellID( unsigned int* puCellID, unsigned int* puPing, TSteamError* pError ) = 0;
+	virtual int ForceProcessLocalEngine() = 0;
 	virtual SteamCallHandle_t SetUser2( const char* cszUser, TSteamError* pError ) = 0;
 };
 

Open Steamworks/ISteamFriends013.h

+//==========================  Open Steamworks  ================================
+//
+// This file is part of the Open Steamworks project. All individuals associated
+// with this project do not claim ownership of the contents
+// 
+// The code, comments, and all related files, projects, resources,
+// redistributables included with this project are Copyright Valve Corporation.
+// Additionally, Valve, the Valve logo, Half-Life, the Half-Life logo, the
+// Lambda logo, Steam, the Steam logo, Team Fortress, the Team Fortress logo,
+// Opposing Force, Day of Defeat, the Day of Defeat logo, Counter-Strike, the
+// Counter-Strike logo, Source, the Source logo, and Counter-Strike Condition
+// Zero are trademarks and or registered trademarks of Valve Corporation.
+// All other trademarks are property of their respective owners.
+//
+//=============================================================================
+
+#ifndef ISTEAMFRIENDS013_H
+#define ISTEAMFRIENDS013_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "SteamTypes.h"
+#include "FriendsCommon.h"
+
+
+//-----------------------------------------------------------------------------
+// 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
+//-----------------------------------------------------------------------------
+abstract_class ISteamFriends013
+{
+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
+	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
+	STEAMWORKS_STRUCT_RETURN_2(CSteamID, GetFriendByIndex, int, iFriend, int, iFriendFlags) /*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 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;
+	STEAMWORKS_STRUCT_RETURN_1(CSteamID, GetClanByIndex, int, iClan) /*virtual CSteamID GetClanByIndex( int iClan ) = 0;*/
+	virtual const char *GetClanName( CSteamID steamIDClan ) = 0;
+	virtual const char *GetClanTag( CSteamID steamIDClan ) = 0;
+
+	virtual bool GetClanActivityCounts( CSteamID steamID, int *pnOnline, int *pnInGame, int *pnChatting ) = 0;
+	virtual SteamAPICall_t DownloadClanActivityCounts( CSteamID groupIDs[], int nIds ) = 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
+	// steamIDSource can be the steamID of a group, game server, lobby or chat room
+	virtual int GetFriendCountFromSource( CSteamID steamIDSource ) = 0;
+	STEAMWORKS_STRUCT_RETURN_2(CSteamID, GetFriendFromSourceByIndex, CSteamID, steamIDSource, int, iFriend) /*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", "LobbyInvite", "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 
+	//		"stats" - opens the overlay web browser to the specified user's stats
+	//		"achievements" - opens the overlay web browser to the specified user's achievements
+	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.
+	// You can also use ActivateGameOverlay( "LobbyInvite" ) to allow the user to create invitations for their current public 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
+	STEAMWORKS_STRUCT_RETURN_1(CSteamID, GetClanOwner, CSteamID, steamIDClan) /*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)
+	STEAMWORKS_STRUCT_RETURN_2(CSteamID, GetClanOfficerByIndex, CSteamID, steamIDClan, int, iOfficer) /*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 EUserRestriction 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;
+	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;
+	STEAMWORKS_STRUCT_RETURN_1(CSteamID, GetCoplayFriend, int, iCoplayFriend) /*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;
+	STEAMWORKS_STRUCT_RETURN_2(CSteamID, GetChatMemberByIndex, CSteamID, steamIDClan, int, iUser) /*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;
+
+	virtual SteamAPICall_t GetFollowerCount( CSteamID steamID ) = 0;
+	virtual SteamAPICall_t IsFollowing( CSteamID steamID ) = 0;
+	virtual SteamAPICall_t EnumerateFollowingList( uint32 uStartIndex ) = 0;
+};
+
+
+
+#endif // ISTEAMFRIENDS013_H

Open Steamworks/ISteamRemoteStorage008.h

+//==========================  Open Steamworks  ================================
+//
+// This file is part of the Open Steamworks project. All individuals associated
+// with this project do not claim ownership of the contents
+// 
+// The code, comments, and all related files, projects, resources,
+// redistributables included with this project are Copyright Valve Corporation.
+// Additionally, Valve, the Valve logo, Half-Life, the Half-Life logo, the
+// Lambda logo, Steam, the Steam logo, Team Fortress, the Team Fortress logo,
+// Opposing Force, Day of Defeat, the Day of Defeat logo, Counter-Strike, the
+// Counter-Strike logo, Source, the Source logo, and Counter-Strike Condition
+// Zero are trademarks and or registered trademarks of Valve Corporation.
+// All other trademarks are property of their respective owners.
+//
+//=============================================================================
+
+#ifndef ISTEAMREMOTESTORAGE008_H
+#define ISTEAMREMOTESTORAGE008_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "SteamTypes.h"
+#include "RemoteStorageCommon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing, reading and writing files stored remotely 
+//			and cached locally
+//-----------------------------------------------------------------------------
+abstract_class ISteamRemoteStorage008
+{
+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;
+
+	virtual GID_t FileWriteStreamOpen( const char *pchFile ) = 0;
+	virtual EResult FileWriteStreamWriteChunk( GID_t hStream, const void *pvData, int32 cubData ) = 0;
+	virtual EResult FileWriteStreamClose( GID_t hStream ) = 0;
+	virtual EResult FileWriteStreamCancel( GID_t hStream ) = 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
+	virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent ) = 0; // Returns a RemoteStorageDownloadUGCResult_t callback
+	virtual bool GetUGCDownloadProgress( UGCHandle_t hContent, uint32 *puDownloadedBytes, uint32 *puTotalBytes ) = 0;
+	virtual bool	GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner ) = 0;
+	virtual int32	UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead ) = 0;
+
+	// user generated content iteration
+	virtual int32	GetCachedUGCCount() = 0;
+	virtual	UGCHandle_t GetCachedUGCHandle( int32 iCachedContent ) = 0;
+
+	// 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 JobID_t CreatePublishedFileUpdateRequest( PublishedFileId_t unPublishedFileId ) = 0;
+	virtual bool UpdatePublishedFileFile( JobID_t hUpdateRequest, const char *pchFile ) = 0;
+	virtual bool UpdatePublishedFilePreviewFile( JobID_t hUpdateRequest, const char *pchPreviewFile ) = 0;
+	virtual bool UpdatePublishedFileTitle( JobID_t hUpdateRequest, const char *pchTitle ) = 0;
+	virtual bool UpdatePublishedFileDescription( JobID_t hUpdateRequest, const char *pchDescription ) = 0;
+	virtual bool UpdatePublishedFileVisibility( JobID_t hUpdateRequest, ERemoteStoragePublishedFileVisibility eVisibility ) = 0;
+	virtual bool UpdatePublishedFileTags( JobID_t hUpdateRequest, SteamParamStringArray_t *pTags ) = 0;
+	virtual SteamAPICall_t CommitPublishedFileUpdate( JobID_t hUpdateRequest ) = 0;
+
+	virtual SteamAPICall_t GetPublishedFileDetails( PublishedFileId_t unPublishedFileId ) = 0;
+	virtual SteamAPICall_t DeletePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+	virtual SteamAPICall_t EnumerateUserPublishedFiles( uint32 uStartIndex ) = 0;
+	virtual SteamAPICall_t SubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+	virtual SteamAPICall_t EnumerateUserSubscribedFiles( uint32 uStartIndex ) = 0;
+	virtual SteamAPICall_t UnsubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+	
+	virtual bool UpdatePublishedFileSetChangeDescription( JobID_t hUpdateRequest, const char *cszDescription ) = 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( AppId_t nAppId, CSteamID creatorSteamID, uint32 uStartIndex, SteamParamStringArray_t * pRequiredTags, SteamParamStringArray_t * pExcludedTags ) = 0;
+	virtual SteamAPICall_t PublishVideo( EWorkshopVideoProvider eVideoProvider, const char *cszVideoAccountName, const char *cszVideoIdentifier, const char *cszFileName, AppId_t nConsumerAppId, const char *cszTitle, const char *cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags ) = 0;
+	virtual SteamAPICall_t SetUserPublishedFileAction( PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction ) = 0;
+	virtual SteamAPICall_t EnumeratePublishedFilesByUserAction( EWorkshopFileAction eAction, uint32 uStartIndex ) = 0;
+	virtual SteamAPICall_t EnumeratePublishedWorkshopFiles( EWorkshopEnumerationType eType, uint32 uStartIndex, uint32 cDays, uint32 cCount, SteamParamStringArray_t *pTags, SteamParamStringArray_t *pUserTags ) = 0;
+};
+
+#endif // ISTEAMREMOTESTORAGE008_H

Open Steamworks/ISteamUserStats011.h

+//==========================  Open Steamworks  ================================
+//
+// This file is part of the Open Steamworks project. All individuals associated
+// with this project do not claim ownership of the contents
+// 
+// The code, comments, and all related files, projects, resources,
+// redistributables included with this project are Copyright Valve Corporation.
+// Additionally, Valve, the Valve logo, Half-Life, the Half-Life logo, the
+// Lambda logo, Steam, the Steam logo, Team Fortress, the Team Fortress logo,
+// Opposing Force, Day of Defeat, the Day of Defeat logo, Counter-Strike, the
+// Counter-Strike logo, Source, the Source logo, and Counter-Strike Condition
+// Zero are trademarks and or registered trademarks of Valve Corporation.
+// All other trademarks are property of their respective owners.
+//
+//=============================================================================
+
+#ifndef ISTEAMUSERSTATS011_H
+#define ISTEAMUSERSTATS011_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "SteamTypes.h"
+#include "UserStatsCommon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing stats, achievements, and leaderboard information
+//-----------------------------------------------------------------------------
+abstract_class ISteamUserStats011
+{
+public:
+	// Ask the server to send down this user's data and achievements for this game
+	virtual bool RequestCurrentStats() = 0;
+
+	// Data accessors
+#if !(defined(_WIN32) && defined(__GNUC__))
+	virtual bool GetStat( const char *pchName, int32 *pData ) = 0;
+	virtual bool GetStat( const char *pchName, float *pData ) = 0;
+#else
+	virtual bool GetStat( const char *pchName, float *pData ) = 0;
+	virtual bool GetStat( const char *pchName, int32 *pData ) = 0;
+#endif
+
+	// Set / update data
+#if !(defined(_WIN32) && defined(__GNUC__))
+	virtual bool SetStat( const char *pchName, int32 nData ) = 0;
+	virtual bool SetStat( const char *pchName, float fData ) = 0;
+#else
+	virtual bool SetStat( const char *pchName, float fData ) = 0;
+	virtual bool SetStat( const char *pchName, int32 nData ) = 0;
+#endif
+	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 IClientUtils::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 (display name, desc, etc) for an Achievement
+	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;
+
+	// Get the number of achievements
+	virtual uint32 GetNumAchievements( CGameID nGameID ) = 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()
+#if !(defined(_WIN32) && defined(__GNUC__))
+	virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0;
+	virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0;
+#else
+	virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData ) = 0;
+	virtual bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData ) = 0;
+#endif
+	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
+#if !(defined(_WIN32) && defined(__GNUC__))
+	virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0;
+	virtual bool GetGlobalStat( const char *pchStatName, double *pData ) = 0;
+#else
+	virtual bool GetGlobalStat( const char *pchStatName, double *pData ) = 0;
+	virtual bool GetGlobalStat( const char *pchStatName, int64 *pData ) = 0;
+#endif
+
+	// 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.
+#if !(defined(_WIN32) && defined(__GNUC__))
+	virtual int32 GetGlobalStatHistory( const char *pchStatName, int64 *pData, uint32 cubData ) = 0;
+	virtual int32 GetGlobalStatHistory( const char *pchStatName, double *pData, uint32 cubData ) = 0;
+#else
+	virtual int32 GetGlobalStatHistory( const char *pchStatName, double *pData, uint32 cubData ) = 0;
+	virtual int32 GetGlobalStatHistory( const char *pchStatName, int64 *pData, uint32 cubData ) = 0;
+#endif
+};
+
+#endif // ISTEAMUSERSTATS011_H

Open Steamworks/Open Steamworks.vcproj

 						RelativePath=".\ISteamFriends012.h"
 						>
 					</File>
+					<File
+						RelativePath=".\ISteamFriends013.h"
+						>
+					</File>
 				</Filter>
 				<Filter
 					Name="ISteamGameServer"
 						>
 					</File>
 					<File
+						RelativePath=".\ISteamRemoteStorage008.h"
+						>
+					</File>
+					<File
 						RelativePath=".\RemoteStorageCommon.h"
 						>
 					</File>
 						>
 					</File>
 					<File
+						RelativePath=".\ISteamUserStats011.h"
+						>
+					</File>
+					<File
 						RelativePath=".\UserStatsCommon.h"
 						>
 					</File>

Open Steamworks/RemoteStorageCommon.h

 #define STEAMREMOTESTORAGE_INTERFACE_VERSION_005 "STEAMREMOTESTORAGE_INTERFACE_VERSION005"
 #define STEAMREMOTESTORAGE_INTERFACE_VERSION_006 "STEAMREMOTESTORAGE_INTERFACE_VERSION006"
 #define STEAMREMOTESTORAGE_INTERFACE_VERSION_007 "STEAMREMOTESTORAGE_INTERFACE_VERSION007"
+#define STEAMREMOTESTORAGE_INTERFACE_VERSION_008 "STEAMREMOTESTORAGE_INTERFACE_VERSION008"
 
 #define CLIENTREMOTESTORAGE_INTERFACE_VERSION "CLIENTREMOTESTORAGE_INTERFACE_VERSION001"
 

Open Steamworks/Steamclient.h

 #include "ISteamFriends010.h"
 #include "ISteamFriends011.h"
 #include "ISteamFriends012.h"
+#include "ISteamFriends013.h"
 
 // screenshots
 #include "ISteamScreenshots001.h"
 #include "ISteamUserStats008.h"
 #include "ISteamUserStats009.h"
 #include "ISteamUserStats010.h"
+#include "ISteamUserStats011.h"
 
 // utils
 #include "ISteamUtils001.h"
 #include "ISteamRemoteStorage005.h"
 #include "ISteamRemoteStorage006.h"
 #include "ISteamRemoteStorage007.h"
+#include "ISteamRemoteStorage008.h"
 
 // content server
 #include "ISteamContentServer001.h"

Open Steamworks/UserStatsCommon.h

 #define STEAMUSERSTATS_INTERFACE_VERSION_008 "STEAMUSERSTATS_INTERFACE_VERSION008"
 #define STEAMUSERSTATS_INTERFACE_VERSION_009 "STEAMUSERSTATS_INTERFACE_VERSION009"
 #define STEAMUSERSTATS_INTERFACE_VERSION_010 "STEAMUSERSTATS_INTERFACE_VERSION010"
+#define STEAMUSERSTATS_INTERFACE_VERSION_011 "STEAMUSERSTATS_INTERFACE_VERSION011"
 
 #define CLIENTUSERSTATS_INTERFACE_VERSION "CLIENTUSERSTATS_INTERFACE_VERSION002"
 
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.