//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. ======= // // Purpose: interface to app data in Steam // //============================================================================= #ifndef ISTEAMAPPS_H #define ISTEAMAPPS_H #ifdef STEAM_WIN32 #pragma once #endif #include "steam_api_common.h" const int k_cubAppProofOfPurchaseKeyMax = 240; // max supported length of a legacy cd key //----------------------------------------------------------------------------- // 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 legacy 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) // returns the SteamID of the original owner. If this CSteamID is different from ISteamUser::GetSteamID(), // the user has a temporary license borrowed via Family Sharing virtual CSteamID GetAppOwner() = 0; // Returns the associated launch param if the game is run via steam://run///?param1=value1¶m2=value2¶m3=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. // Check for new launch parameters on callback NewUrlLaunchParameters_t virtual const char *GetLaunchQueryParam( const char *pchKey ) = 0; // get download progress for optional DLC virtual bool GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0; // return the buildid of this app, may change at any time based on backend updates to the game virtual int GetAppBuildId() = 0; // Request all proof of purchase keys for the calling appid and asociated DLC. // A series of AppProofOfPurchaseKeyResponse_t callbacks will be sent with // appropriate appid values, ending with a final callback where the m_nAppId // member is k_uAppIdInvalid (zero). virtual void RequestAllProofOfPurchaseKeys() = 0; STEAM_CALL_RESULT( FileDetailsResult_t ) virtual SteamAPICall_t GetFileDetails( const char* pszFileName ) = 0; // Get command line if game was launched via Steam URL, e.g. steam://run////. // This method of passing a connect string (used when joining via rich presence, accepting an // invite, etc) is preferable to passing the connect string on the operating system command // line, which is a security risk. In order for rich presence joins to go through this // path and not be placed on the OS command line, you must set a value in your app's // configuration on Steam. Ask Valve for help with this. // // If game was already running and launched again, the NewUrlLaunchParameters_t will be fired. virtual int GetLaunchCommandLine( char *pszCommandLine, int cubCommandLine ) = 0; // Check if user borrowed this game via Family Sharing, If true, call GetAppOwner() to get the lender SteamID virtual bool BIsSubscribedFromFamilySharing() = 0; // check if game is a timed trial with limited playtime virtual bool BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPlayed ) = 0; // set current DLC AppID being played (or 0 if none). Allows Steam to track usage of major DLC extensions virtual bool SetDlcContext( AppId_t nAppID ) = 0; }; #define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION008" #ifndef STEAM_API_EXPORTS // Global interface accessor inline ISteamApps *SteamApps(); STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamApps *, SteamApps, STEAMAPPS_INTERFACE_VERSION ); // Global accessor for the gameserver client inline ISteamApps *SteamGameServerApps(); STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamApps *, SteamGameServerApps, STEAMAPPS_INTERFACE_VERSION ); #endif // callbacks #if defined( VALVE_CALLBACK_PACK_SMALL ) #pragma pack( push, 4 ) #elif defined( VALVE_CALLBACK_PACK_LARGE ) #pragma pack( push, 8 ) #else #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx #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: posted after the user gains executes a Steam URL with command line or query parameters // such as steam://run///-commandline/?param1=value1¶m2=value2¶m3=value3 etc // while the game is already running. The new params can be queried // with GetLaunchQueryParam and GetLaunchCommandLine //--------------------------------------------------------------------------------- struct NewUrlLaunchParameters_t { enum { k_iCallback = k_iSteamAppsCallbacks + 14 }; }; //----------------------------------------------------------------------------- // Purpose: response to RequestAppProofOfPurchaseKey/RequestAllProofOfPurchaseKeys // for supporting third-party CD keys, or other proof-of-purchase systems. //----------------------------------------------------------------------------- struct AppProofOfPurchaseKeyResponse_t { enum { k_iCallback = k_iSteamAppsCallbacks + 21 }; EResult m_eResult; uint32 m_nAppID; uint32 m_cchKeyLength; char m_rgchKey[k_cubAppProofOfPurchaseKeyMax]; }; //----------------------------------------------------------------------------- // Purpose: response to GetFileDetails //----------------------------------------------------------------------------- struct FileDetailsResult_t { enum { k_iCallback = k_iSteamAppsCallbacks + 23 }; EResult m_eResult; uint64 m_ulFileSize; // original file size in bytes uint8 m_FileSHA[20]; // original file SHA1 hash uint32 m_unFlags; // }; //----------------------------------------------------------------------------- // Purpose: called for games in Timed Trial mode //----------------------------------------------------------------------------- struct TimedTrialStatus_t { enum { k_iCallback = k_iSteamAppsCallbacks + 30 }; AppId_t m_unAppID; // appID bool m_bIsOffline; // if true, time allowed / played refers to offline time, not total time uint32 m_unSecondsAllowed; // how many seconds the app can be played in total uint32 m_unSecondsPlayed; // how many seconds the app was already played }; #pragma pack( pop ) #endif // ISTEAMAPPS_H