You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2385 lines
87 KiB
2385 lines
87 KiB
#define _CRT_SECURE_NO_WARNINGS |
|
|
|
#include "FakeSteamAPI_ContextProvider.h" |
|
#include "FakeSteamAPI_Utilities.h" |
|
|
|
#define VFunction_STUB { } |
|
|
|
#define DerivedInterfaceGenerator(name) \ |
|
class name ## Derived : public name { \ |
|
public: \ |
|
static name& GetInstance(void) { \ |
|
static name ## Derived instance; \ |
|
return instance; \ |
|
} \ |
|
} |
|
|
|
#define DerivedInterfaceGenerator_Begin(name) \ |
|
class name ## Derived : public name { |
|
#define DerivedInterfaceGenerator_End(name) \ |
|
public: \ |
|
static name& GetInstance(void) { \ |
|
static name ## Derived instance; \ |
|
return instance; \ |
|
} \ |
|
} |
|
|
|
//Total 21 interfaces |
|
struct CSteamAPIContextStruct { |
|
ISteamClient *m_pSteamClient; |
|
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; |
|
ISteamController *m_pController; |
|
ISteamUGC *m_pSteamUGC; |
|
ISteamAppList *m_pSteamAppList; |
|
ISteamMusic *m_pSteamMusic; |
|
ISteamMusicRemote *m_pSteamMusicRemote; |
|
ISteamHTMLSurface *m_pSteamHTMLSurface; |
|
ISteamInventory *m_pSteamInventory; |
|
ISteamVideo *m_pSteamVideo; |
|
ISteamParentalSettings *m_pSteamParentalSettings; |
|
}; |
|
|
|
/* |
|
class ISteamClientDerived : ISteamClient { |
|
public: |
|
static ISteamClient& GetInstance (void) { |
|
return instance; |
|
} |
|
protected: |
|
static ISteamClientDerived instance; |
|
}; |
|
*/ |
|
|
|
/* |
|
DerivedInterfaceGenerator(ISteamClient); |
|
DerivedInterfaceGenerator(ISteamUser); |
|
DerivedInterfaceGenerator(ISteamFriends); |
|
DerivedInterfaceGenerator(ISteamUtils); |
|
DerivedInterfaceGenerator(ISteamMatchmaking); |
|
DerivedInterfaceGenerator(ISteamUserStats); |
|
DerivedInterfaceGenerator(ISteamApps); |
|
DerivedInterfaceGenerator(ISteamMatchmakingServers); |
|
DerivedInterfaceGenerator(ISteamNetworking); |
|
DerivedInterfaceGenerator(ISteamRemoteStorage); |
|
DerivedInterfaceGenerator(ISteamScreenshots); |
|
DerivedInterfaceGenerator(ISteamHTTP); |
|
DerivedInterfaceGenerator(ISteamController); |
|
DerivedInterfaceGenerator(ISteamUGC); |
|
DerivedInterfaceGenerator(ISteamAppList); |
|
DerivedInterfaceGenerator(ISteamMusic); |
|
DerivedInterfaceGenerator(ISteamMusicRemote); |
|
DerivedInterfaceGenerator(ISteamHTMLSurface); |
|
DerivedInterfaceGenerator(ISteamInventory); |
|
DerivedInterfaceGenerator(ISteamVideo); |
|
DerivedInterfaceGenerator(ISteamParentalSettings); |
|
*/ |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamClient); |
|
virtual HSteamPipe CreateSteamPipe() { |
|
return 0; |
|
} |
|
virtual bool BReleaseSteamPipe(HSteamPipe hSteamPipe) { |
|
return 0; |
|
} |
|
virtual HSteamUser ConnectToGlobalUser(HSteamPipe hSteamPipe) { |
|
return 0; |
|
} |
|
virtual HSteamUser CreateLocalUser(HSteamPipe *phSteamPipe, EAccountType eAccountType) { |
|
return 0; |
|
} |
|
virtual void ReleaseUser(HSteamPipe hSteamPipe, HSteamUser hUser) VFunction_STUB |
|
virtual ISteamUser *GetISteamUser(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamGameServer *GetISteamGameServer(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual void SetLocalIPBinding(uint32 unIP, uint16 usPort) VFunction_STUB |
|
virtual ISteamFriends *GetISteamFriends(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamUtils *GetISteamUtils(HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamMatchmaking *GetISteamMatchmaking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamMatchmakingServers *GetISteamMatchmakingServers(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual void *GetISteamGenericInterface(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamUserStats *GetISteamUserStats(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamGameServerStats *GetISteamGameServerStats(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamApps *GetISteamApps(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamNetworking *GetISteamNetworking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamRemoteStorage *GetISteamRemoteStorage(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamScreenshots *GetISteamScreenshots(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
STEAM_PRIVATE_API(virtual void RunFrame() VFunction_STUB ) |
|
virtual uint32 GetIPCCallCount() { |
|
return 0; |
|
} |
|
virtual void SetWarningMessageHook(SteamAPIWarningMessageHook_t pFunction) VFunction_STUB |
|
virtual bool BShutdownIfAllPipesClosed() { |
|
return 0; |
|
} |
|
virtual ISteamHTTP *GetISteamHTTP(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
STEAM_PRIVATE_API(virtual void *DEPRECATED_GetISteamUnifiedMessages(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
}) |
|
virtual ISteamController *GetISteamController(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamUGC *GetISteamUGC(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamAppList *GetISteamAppList(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamMusic *GetISteamMusic(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamMusicRemote *GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamHTMLSurface *GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
STEAM_PRIVATE_API(virtual void DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess(void(*)()) VFunction_STUB ) |
|
STEAM_PRIVATE_API(virtual void DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess(void(*)()) VFunction_STUB ) |
|
STEAM_PRIVATE_API(virtual void Set_SteamAPI_CCheckCallbackRegisteredInProcess(SteamAPI_CheckCallbackRegistered_t func) VFunction_STUB ) |
|
virtual ISteamInventory *GetISteamInventory(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamVideo *GetISteamVideo(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
virtual ISteamParentalSettings *GetISteamParentalSettings(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion) { |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamClient); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamUser); |
|
virtual HSteamUser GetHSteamUser() { |
|
return 0; |
|
} |
|
virtual bool BLoggedOn() { |
|
return 0; |
|
} |
|
virtual CSteamID GetSteamID() { |
|
CSteamID fuck; |
|
return fuck; |
|
} |
|
virtual int InitiateGameConnection(void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure) { |
|
return 0; |
|
} |
|
virtual void TerminateGameConnection(uint32 unIPServer, uint16 usPortServer) VFunction_STUB |
|
virtual void TrackAppUsageEvent(CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "") VFunction_STUB |
|
virtual bool GetUserDataFolder(char *pchBuffer, int cubBuffer) { |
|
return 0; |
|
} |
|
virtual void StartVoiceRecording() VFunction_STUB |
|
virtual void StopVoiceRecording() VFunction_STUB |
|
virtual EVoiceResult GetAvailableVoice(uint32 *pcbCompressed, uint32 *pcbUncompressed_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0) { |
|
return (EVoiceResult)0; |
|
} |
|
virtual EVoiceResult GetVoice(bool bWantCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, bool bWantUncompressed_Deprecated = false, void *pUncompressedDestBuffer_Deprecated = 0, uint32 cbUncompressedDestBufferSize_Deprecated = 0, uint32 *nUncompressBytesWritten_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0) { |
|
return (EVoiceResult)0; |
|
} |
|
virtual EVoiceResult DecompressVoice(const void *pCompressed, uint32 cbCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, uint32 nDesiredSampleRate) { |
|
return (EVoiceResult)0; |
|
} |
|
virtual uint32 GetVoiceOptimalSampleRate() { |
|
return 0; |
|
} |
|
virtual HAuthTicket GetAuthSessionTicket(void *pTicket, int cbMaxTicket, uint32 *pcbTicket) { |
|
return 0; |
|
} |
|
virtual EBeginAuthSessionResult BeginAuthSession(const void *pAuthTicket, int cbAuthTicket, CSteamID steamID) { |
|
return (EBeginAuthSessionResult)0; |
|
} |
|
virtual void EndAuthSession(CSteamID steamID) VFunction_STUB |
|
virtual void CancelAuthTicket(HAuthTicket hAuthTicket) VFunction_STUB |
|
virtual EUserHasLicenseForAppResult UserHasLicenseForApp(CSteamID steamID, AppId_t appID) { |
|
return (EUserHasLicenseForAppResult)0; |
|
} |
|
virtual bool BIsBehindNAT() { |
|
return 0; |
|
} |
|
virtual void AdvertiseGame(CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer) VFunction_STUB |
|
virtual SteamAPICall_t RequestEncryptedAppTicket(void *pDataToInclude, int cbDataToInclude) { |
|
return 0; |
|
} |
|
virtual bool GetEncryptedAppTicket(void *pTicket, int cbMaxTicket, uint32 *pcbTicket) { |
|
return 0; |
|
} |
|
virtual int GetGameBadgeLevel(int nSeries, bool bFoil) { |
|
return 0; |
|
} |
|
virtual int GetPlayerSteamLevel() { |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestStoreAuthURL(const char *pchRedirectURL) { |
|
return 0; |
|
} |
|
virtual bool BIsPhoneVerified() { |
|
return 0; |
|
} |
|
virtual bool BIsTwoFactorEnabled() { |
|
return 0; |
|
} |
|
virtual bool BIsPhoneIdentifying() { |
|
return 0; |
|
} |
|
virtual bool BIsPhoneRequiringVerification() { |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamUser); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamFriends); |
|
virtual const char *GetPersonaName() { |
|
return 0; |
|
} |
|
virtual SteamAPICall_t SetPersonaName(const char *pchPersonaName) { |
|
return 0; |
|
} |
|
virtual EPersonaState GetPersonaState() { |
|
return (EPersonaState)0; |
|
} |
|
virtual int GetFriendCount(int iFriendFlags) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual CSteamID GetFriendByIndex(int iFriend, int iFriendFlags) { |
|
CSteamID fuck; |
|
return fuck; |
|
} |
|
virtual EFriendRelationship GetFriendRelationship(CSteamID steamIDFriend) { |
|
return (EFriendRelationship)0; |
|
} |
|
virtual EPersonaState GetFriendPersonaState(CSteamID steamIDFriend) { |
|
return (EPersonaState)0; |
|
} |
|
virtual const char *GetFriendPersonaName(CSteamID steamIDFriend) { |
|
return 0; |
|
} |
|
virtual bool GetFriendGamePlayed(CSteamID steamIDFriend, OUT_STRUCT() FriendGameInfo_t *pFriendGameInfo) { |
|
return 0; |
|
} |
|
virtual const char *GetFriendPersonaNameHistory(CSteamID steamIDFriend, int iPersonaName) { |
|
return 0; |
|
} |
|
virtual int GetFriendSteamLevel(CSteamID steamIDFriend) { |
|
return 0; |
|
} |
|
virtual const char *GetPlayerNickname(CSteamID steamIDPlayer) { |
|
return 0; |
|
} |
|
virtual int GetFriendsGroupCount() { |
|
return 0; |
|
} |
|
virtual FriendsGroupID_t GetFriendsGroupIDByIndex(int iFG) { |
|
return 0; |
|
} |
|
virtual const char *GetFriendsGroupName(FriendsGroupID_t friendsGroupID) { |
|
return 0; |
|
} |
|
virtual int GetFriendsGroupMembersCount(FriendsGroupID_t friendsGroupID) { |
|
return 0; |
|
} |
|
virtual void GetFriendsGroupMembersList(FriendsGroupID_t friendsGroupID, OUT_ARRAY_CALL(nMembersCount, GetFriendsGroupMembersCount, friendsGroupID) CSteamID *pOutSteamIDMembers, int nMembersCount) VFunction_STUB |
|
virtual bool HasFriend(CSteamID steamIDFriend, int iFriendFlags) { |
|
return 0; |
|
} |
|
virtual int GetClanCount() { |
|
return 0; |
|
} |
|
virtual CSteamID GetClanByIndex(int iClan) { |
|
CSteamID fuck; |
|
return fuck; |
|
} |
|
virtual const char *GetClanName(CSteamID steamIDClan) { |
|
return 0; |
|
} |
|
virtual const char *GetClanTag(CSteamID steamIDClan) { |
|
return 0; |
|
} |
|
virtual bool GetClanActivityCounts(CSteamID steamIDClan, int *pnOnline, int *pnInGame, int *pnChatting) { |
|
return 0; |
|
} |
|
virtual SteamAPICall_t DownloadClanActivityCounts(ARRAY_COUNT(cClansToRequest) CSteamID *psteamIDClans, int cClansToRequest) { |
|
return 0; |
|
} |
|
virtual int GetFriendCountFromSource(CSteamID steamIDSource) { |
|
return 0; |
|
} |
|
virtual CSteamID GetFriendFromSourceByIndex(CSteamID steamIDSource, int iFriend) { |
|
CSteamID fuck; |
|
return fuck; |
|
} |
|
virtual bool IsUserInSource(CSteamID steamIDUser, CSteamID steamIDSource) { |
|
return 0; |
|
} |
|
virtual void SetInGameVoiceSpeaking(CSteamID steamIDUser, bool bSpeaking) VFunction_STUB |
|
virtual void ActivateGameOverlay(const char *pchDialog) VFunction_STUB |
|
virtual void ActivateGameOverlayToUser(const char *pchDialog, CSteamID steamID) VFunction_STUB |
|
virtual void ActivateGameOverlayToWebPage(const char *pchURL) VFunction_STUB |
|
virtual void ActivateGameOverlayToStore(AppId_t nAppID, EOverlayToStoreFlag eFlag) VFunction_STUB |
|
virtual void SetPlayedWith(CSteamID steamIDUserPlayedWith) VFunction_STUB |
|
virtual void ActivateGameOverlayInviteDialog(CSteamID steamIDLobby) VFunction_STUB |
|
virtual int GetSmallFriendAvatar(CSteamID steamIDFriend) { |
|
return 0; |
|
} |
|
virtual int GetMediumFriendAvatar(CSteamID steamIDFriend) { |
|
return 0; |
|
} |
|
virtual int GetLargeFriendAvatar(CSteamID steamIDFriend) { |
|
return 0; |
|
} |
|
virtual bool RequestUserInformation(CSteamID steamIDUser, bool bRequireNameOnly) { |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestClanOfficerList(CSteamID steamIDClan) { |
|
return 0; |
|
} |
|
virtual CSteamID GetClanOwner(CSteamID steamIDClan) { |
|
CSteamID fuck; |
|
return fuck; |
|
} |
|
virtual int GetClanOfficerCount(CSteamID steamIDClan) { |
|
return 0; |
|
} |
|
virtual CSteamID GetClanOfficerByIndex(CSteamID steamIDClan, int iOfficer) { |
|
CSteamID fuck; |
|
return fuck; |
|
} |
|
virtual uint32 GetUserRestrictions() { |
|
return 0; |
|
} |
|
virtual bool SetRichPresence(const char *pchKey, const char *pchValue) { |
|
//FakeSteamAPI_AppendLog(LogLevel_Info, "Application is setting rich presence(%s) to \"%s\".", pchKey, pchValue); |
|
return 0; |
|
} |
|
virtual void ClearRichPresence() VFunction_STUB |
|
virtual const char *GetFriendRichPresence(CSteamID steamIDFriend, const char *pchKey) { |
|
return 0; |
|
} |
|
virtual int GetFriendRichPresenceKeyCount(CSteamID steamIDFriend) { |
|
return 0; |
|
} |
|
virtual const char *GetFriendRichPresenceKeyByIndex(CSteamID steamIDFriend, int iKey) { |
|
return 0; |
|
} |
|
virtual void RequestFriendRichPresence(CSteamID steamIDFriend) VFunction_STUB |
|
virtual bool InviteUserToGame(CSteamID steamIDFriend, const char *pchConnectString) { |
|
return 0; |
|
} |
|
virtual int GetCoplayFriendCount() { |
|
return 0; |
|
} |
|
virtual CSteamID GetCoplayFriend(int iCoplayFriend) { |
|
CSteamID fuck; |
|
return fuck; |
|
} |
|
virtual int GetFriendCoplayTime(CSteamID steamIDFriend) { |
|
return 0; |
|
} |
|
virtual AppId_t GetFriendCoplayGame(CSteamID steamIDFriend) { |
|
return 0; |
|
} |
|
virtual SteamAPICall_t JoinClanChatRoom(CSteamID steamIDClan) { |
|
return 0; |
|
} |
|
virtual bool LeaveClanChatRoom(CSteamID steamIDClan) { |
|
return 0; |
|
} |
|
virtual int GetClanChatMemberCount(CSteamID steamIDClan) { |
|
return 0; |
|
} |
|
virtual CSteamID GetChatMemberByIndex(CSteamID steamIDClan, int iUser) { |
|
CSteamID fuck; |
|
return fuck; |
|
} |
|
virtual bool SendClanChatMessage(CSteamID steamIDClanChat, const char *pchText) { |
|
return 0; |
|
} |
|
virtual int GetClanChatMessage(CSteamID steamIDClanChat, int iMessage, void *prgchText, int cchTextMax, EChatEntryType *peChatEntryType, CSteamID *psteamidChatter) { |
|
return 0; |
|
} |
|
virtual bool IsClanChatAdmin(CSteamID steamIDClanChat, CSteamID steamIDUser) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsClanChatWindowOpenInSteam(CSteamID steamIDClanChat) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool OpenClanChatWindowInSteam(CSteamID steamIDClanChat) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool CloseClanChatWindowInSteam(CSteamID steamIDClanChat) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetListenForFriendsMessages(bool bInterceptEnabled) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ReplyToFriendMessage(CSteamID steamIDFriend, const char *pchMsgToSend) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetFriendMessage(CSteamID steamIDFriend, int iMessageID, void *pvData, int cubData, EChatEntryType *peChatEntryType) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t GetFollowerCount(CSteamID steamID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t IsFollowing(CSteamID steamID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t EnumerateFollowingList(uint32 unStartIndex) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsClanPublic(CSteamID steamIDClan) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsClanOfficialGameGroup(CSteamID steamIDClan) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamFriends); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamUtils); |
|
virtual uint32 GetSecondsSinceAppActive() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetSecondsSinceComputerActive() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual EUniverse GetConnectedUniverse() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (EUniverse)0; |
|
} |
|
virtual uint32 GetServerRealTime() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetIPCountry() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetImageSize(int iImage, uint32 *pnWidth, uint32 *pnHeight) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetImageRGBA(int iImage, uint8 *pubDest, int nDestBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetCSERIPPort(uint32 *unIP, uint16 *usPort) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint8 GetCurrentBatteryPower() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetAppID() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SetOverlayNotificationPosition(ENotificationPosition eNotificationPosition) VFunction_STUB |
|
virtual bool IsAPICallCompleted(SteamAPICall_t hSteamAPICall, bool *pbFailed) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ESteamAPICallFailure GetAPICallFailureReason(SteamAPICall_t hSteamAPICall) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (ESteamAPICallFailure)0; |
|
} |
|
virtual bool GetAPICallResult(SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
STEAM_PRIVATE_API(virtual void RunFrame() VFunction_STUB ) |
|
virtual uint32 GetIPCCallCount() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SetWarningMessageHook(SteamAPIWarningMessageHook_t pFunction) VFunction_STUB |
|
virtual bool IsOverlayEnabled() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BOverlayNeedsPresent() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
CALL_RESULT(CheckFileSignature_t) |
|
virtual SteamAPICall_t CheckFileSignature(const char *szFileName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ShowGamepadTextInput(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32 unCharMax, const char *pchExistingText) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetEnteredGamepadTextLength() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetEnteredGamepadTextInput(char *pchText, uint32 cchText) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetSteamUILanguage() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsSteamRunningInVR() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SetOverlayNotificationInset(int nHorizontalInset, int nVerticalInset) VFunction_STUB |
|
virtual bool IsSteamInBigPictureMode() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void StartVRDashboard() VFunction_STUB |
|
virtual bool IsVRHeadsetStreamingEnabled() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SetVRHeadsetStreamingEnabled(bool bEnabled) VFunction_STUB |
|
DerivedInterfaceGenerator_End(ISteamUtils); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamMatchmaking); |
|
virtual int GetFavoriteGameCount() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetFavoriteGame(int iGame, AppId_t *pnAppID, uint32 *pnIP, uint16 *pnConnPort, uint16 *pnQueryPort, uint32 *punFlags, uint32 *pRTime32LastPlayedOnServer) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int AddFavoriteGame(AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool RemoveFavoriteGame(AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestLobbyList() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void AddRequestLobbyListStringFilter(const char *pchKeyToMatch, const char *pchValueToMatch, ELobbyComparison eComparisonType) VFunction_STUB |
|
virtual void AddRequestLobbyListNumericalFilter(const char *pchKeyToMatch, int nValueToMatch, ELobbyComparison eComparisonType) VFunction_STUB |
|
virtual void AddRequestLobbyListNearValueFilter(const char *pchKeyToMatch, int nValueToBeCloseTo) VFunction_STUB |
|
virtual void AddRequestLobbyListFilterSlotsAvailable(int nSlotsAvailable) VFunction_STUB |
|
virtual void AddRequestLobbyListDistanceFilter(ELobbyDistanceFilter eLobbyDistanceFilter) VFunction_STUB |
|
virtual void AddRequestLobbyListResultCountFilter(int cMaxResults) VFunction_STUB |
|
virtual void AddRequestLobbyListCompatibleMembersFilter(CSteamID steamIDLobby) VFunction_STUB |
|
virtual CSteamID GetLobbyByIndex(int iLobby) { |
|
CSteamID fuck; |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return fuck; |
|
} |
|
virtual SteamAPICall_t CreateLobby(ELobbyType eLobbyType, int cMaxMembers) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t JoinLobby(CSteamID steamIDLobby) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void LeaveLobby(CSteamID steamIDLobby) VFunction_STUB |
|
virtual bool InviteUserToLobby(CSteamID steamIDLobby, CSteamID steamIDInvitee) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetNumLobbyMembers(CSteamID steamIDLobby) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual CSteamID GetLobbyMemberByIndex(CSteamID steamIDLobby, int iMember) { |
|
CSteamID fuck; |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return fuck; |
|
} |
|
virtual const char *GetLobbyData(CSteamID steamIDLobby, const char *pchKey) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetLobbyData(CSteamID steamIDLobby, const char *pchKey, const char *pchValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetLobbyDataCount(CSteamID steamIDLobby) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetLobbyDataByIndex(CSteamID steamIDLobby, int iLobbyData, char *pchKey, int cchKeyBufferSize, char *pchValue, int cchValueBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool DeleteLobbyData(CSteamID steamIDLobby, const char *pchKey) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetLobbyMemberData(CSteamID steamIDLobby, CSteamID steamIDUser, const char *pchKey) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SetLobbyMemberData(CSteamID steamIDLobby, const char *pchKey, const char *pchValue) VFunction_STUB |
|
virtual bool SendLobbyChatMsg(CSteamID steamIDLobby, const void *pvMsgBody, int cubMsgBody) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetLobbyChatEntry(CSteamID steamIDLobby, int iChatID, CSteamID *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool RequestLobbyData(CSteamID steamIDLobby) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SetLobbyGameServer(CSteamID steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, CSteamID steamIDGameServer) VFunction_STUB |
|
virtual bool GetLobbyGameServer(CSteamID steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, CSteamID *psteamIDGameServer) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetLobbyMemberLimit(CSteamID steamIDLobby, int cMaxMembers) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetLobbyMemberLimit(CSteamID steamIDLobby) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetLobbyType(CSteamID steamIDLobby, ELobbyType eLobbyType) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetLobbyJoinable(CSteamID steamIDLobby, bool bLobbyJoinable) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual CSteamID GetLobbyOwner(CSteamID steamIDLobby) { |
|
CSteamID fuck; |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return fuck; |
|
} |
|
virtual bool SetLobbyOwner(CSteamID steamIDLobby, CSteamID steamIDNewOwner) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetLinkedLobby(CSteamID steamIDLobby, CSteamID steamIDLobbyDependent) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamMatchmaking); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamUserStats); |
|
virtual bool RequestCurrentStats() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetStat(const char *pchName, int32 *pData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetStat(const char *pchName, float *pData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetStat(const char *pchName, int32 nData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetStat(const char *pchName, float fData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateAvgRateStat(const char *pchName, float flCountThisSession, double dSessionLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetAchievement(const char *pchName, bool *pbAchieved) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetAchievement(const char *pchName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
FakeSteamAPI_AppendLog(LogLevel_Info, "Application is setting achievement %s. Returning false to the application.", pchName); |
|
return false; |
|
} |
|
virtual bool ClearAchievement(const char *pchName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetAchievementAndUnlockTime(const char *pchName, bool *pbAchieved, uint32 *punUnlockTime) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool StoreStats() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetAchievementIcon(const char *pchName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetAchievementDisplayAttribute(const char *pchName, const char *pchKey) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IndicateAchievementProgress(const char *pchName, uint32 nCurProgress, uint32 nMaxProgress) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetNumAchievements() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetAchievementName(uint32 iAchievement) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestUserStats(CSteamID steamIDUser) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetUserStat(CSteamID steamIDUser, const char *pchName, int32 *pData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetUserStat(CSteamID steamIDUser, const char *pchName, float *pData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetUserAchievement(CSteamID steamIDUser, const char *pchName, bool *pbAchieved) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetUserAchievementAndUnlockTime(CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ResetAllStats(bool bAchievementsToo) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t FindOrCreateLeaderboard(const char *pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t FindLeaderboard(const char *pchLeaderboardName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetLeaderboardName(SteamLeaderboard_t hSteamLeaderboard) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetLeaderboardEntryCount(SteamLeaderboard_t hSteamLeaderboard) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ELeaderboardSortMethod GetLeaderboardSortMethod(SteamLeaderboard_t hSteamLeaderboard) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (ELeaderboardSortMethod)0; |
|
} |
|
virtual ELeaderboardDisplayType GetLeaderboardDisplayType(SteamLeaderboard_t hSteamLeaderboard) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (ELeaderboardDisplayType)0; |
|
} |
|
virtual SteamAPICall_t DownloadLeaderboardEntries(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t DownloadLeaderboardEntriesForUsers(SteamLeaderboard_t hSteamLeaderboard, CSteamID *prgUsers, int cUsers) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetDownloadedLeaderboardEntry(SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t UploadLeaderboardScore(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32 *pScoreDetails, int cScoreDetailsCount) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t AttachLeaderboardUGC(SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t GetNumberOfCurrentPlayers() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestGlobalAchievementPercentages() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetMostAchievedAchievementInfo(char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetNextMostAchievedAchievementInfo(int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetAchievementAchievedPercent(const char *pchName, float *pflPercent) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestGlobalStats(int nHistoryDays) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetGlobalStat(const char *pchStatName, int64 *pData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetGlobalStat(const char *pchStatName, double *pData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int32 GetGlobalStatHistory(const char *pchStatName, int64 *pData, uint32 cubData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int32 GetGlobalStatHistory(const char *pchStatName, double *pData, uint32 cubData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamUserStats); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamApps); |
|
virtual bool BIsSubscribed() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsLowViolence() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsCybercafe() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsVACBanned() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetCurrentGameLanguage() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetAvailableGameLanguages() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsSubscribedApp(AppId_t appID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsDlcInstalled(AppId_t appID) { |
|
static int nAllowedDlcsArray[1024]; |
|
static int nAllowedDlcsCount = 0; |
|
static bool bInited = false; |
|
bool bAssumeInstalled; |
|
|
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
|
|
if (!bInited) { |
|
FILE *fp; |
|
|
|
bInited = true; |
|
|
|
fp = fopen("DlcsFilter.txt", "r"); |
|
if (fp != NULL) { |
|
FakeSteamAPI_AppendLog(LogLevel_Info, "Dlcs filter text found."); |
|
|
|
while (fscanf(fp, "%d", &nAllowedDlcsArray[nAllowedDlcsCount]) == 1) |
|
nAllowedDlcsCount++; |
|
|
|
FakeSteamAPI_AppendLog( |
|
LogLevel_Info, |
|
"Read total %d allowed Dlc%s.", |
|
nAllowedDlcsCount, |
|
nAllowedDlcsCount == 1 ? "" : "s" |
|
); |
|
|
|
fclose(fp); |
|
} |
|
} |
|
|
|
bAssumeInstalled = false; |
|
for (int i = 0; i < nAllowedDlcsCount; i++) { |
|
if (nAllowedDlcsArray[i] == appID) { |
|
bAssumeInstalled = true; |
|
break; |
|
} |
|
} |
|
|
|
FakeSteamAPI_AppendLog( |
|
LogLevel_Info, |
|
"Application is requesting DLC %d. Assuming %s.", |
|
(int)appID, |
|
bAssumeInstalled ? "installed" : "not installed" |
|
); |
|
|
|
return bAssumeInstalled; |
|
} |
|
virtual uint32 GetEarliestPurchaseUnixTime(AppId_t nAppID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsSubscribedFromFreeWeekend() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetDLCCount() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BGetDLCDataByIndex(int iDLC, AppId_t *pAppID, bool *pbAvailable, char *pchName, int cchNameBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void InstallDLC(AppId_t nAppID) VFunction_STUB |
|
virtual void UninstallDLC(AppId_t nAppID) VFunction_STUB |
|
virtual void RequestAppProofOfPurchaseKey(AppId_t nAppID) VFunction_STUB |
|
virtual bool GetCurrentBetaName(char *pchName, int cchNameBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool MarkContentCorrupt(bool bMissingFilesOnly) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetInstalledDepots(AppId_t appID, DepotId_t *pvecDepots, uint32 cMaxDepots) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetAppInstallDir(AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsAppInstalled(AppId_t appID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual CSteamID GetAppOwner() { |
|
CSteamID fuck; |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return fuck; |
|
} |
|
virtual const char *GetLaunchQueryParam(const char *pchKey) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetDlcDownloadProgress(AppId_t nAppID, uint64 *punBytesDownloaded, uint64 *punBytesTotal) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetAppBuildId() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void RequestAllProofOfPurchaseKeys() VFunction_STUB |
|
virtual SteamAPICall_t GetFileDetails(const char* pszFileName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamApps); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamMatchmakingServers); |
|
virtual HServerListRequest RequestInternetServerList(AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual HServerListRequest RequestLANServerList(AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual HServerListRequest RequestFriendsServerList(AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual HServerListRequest RequestFavoritesServerList(AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual HServerListRequest RequestHistoryServerList(AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual HServerListRequest RequestSpectatorServerList(AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void ReleaseRequest(HServerListRequest hServerListRequest) VFunction_STUB |
|
virtual gameserveritem_t *GetServerDetails(HServerListRequest hRequest, int iServer) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void CancelQuery(HServerListRequest hRequest) VFunction_STUB |
|
virtual void RefreshQuery(HServerListRequest hRequest) VFunction_STUB |
|
virtual bool IsRefreshing(HServerListRequest hRequest) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetServerCount(HServerListRequest hRequest) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void RefreshServer(HServerListRequest hRequest, int iServer) VFunction_STUB |
|
virtual HServerQuery PingServer(uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual HServerQuery PlayerDetails(uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual HServerQuery ServerRules(uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void CancelServerQuery(HServerQuery hServerQuery) VFunction_STUB |
|
DerivedInterfaceGenerator_End(ISteamMatchmakingServers); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamNetworking); |
|
virtual bool SendP2PPacket(CSteamID steamIDRemote, const void *pubData, uint32 cubData, EP2PSend eP2PSendType, int nChannel = 0) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsP2PPacketAvailable(uint32 *pcubMsgSize, int nChannel = 0) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ReadP2PPacket(void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, CSteamID *psteamIDRemote, int nChannel = 0) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AcceptP2PSessionWithUser(CSteamID steamIDRemote) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool CloseP2PSessionWithUser(CSteamID steamIDRemote) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool CloseP2PChannelWithUser(CSteamID steamIDRemote, int nChannel) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetP2PSessionState(CSteamID steamIDRemote, P2PSessionState_t *pConnectionState) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AllowP2PPacketRelay(bool bAllow) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SNetListenSocket_t CreateListenSocket(int nVirtualP2PPort, uint32 nIP, uint16 nPort, bool bAllowUseOfPacketRelay) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SNetSocket_t CreateP2PConnectionSocket(CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SNetSocket_t CreateConnectionSocket(uint32 nIP, uint16 nPort, int nTimeoutSec) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool DestroySocket(SNetSocket_t hSocket, bool bNotifyRemoteEnd) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool DestroyListenSocket(SNetListenSocket_t hSocket, bool bNotifyRemoteEnd) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SendDataOnSocket(SNetSocket_t hSocket, void *pubData, uint32 cubData, bool bReliable) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsDataAvailableOnSocket(SNetSocket_t hSocket, uint32 *pcubMsgSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool RetrieveDataFromSocket(SNetSocket_t hSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsDataAvailable(SNetListenSocket_t hListenSocket, uint32 *pcubMsgSize, SNetSocket_t *phSocket) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool RetrieveData(SNetListenSocket_t hListenSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, SNetSocket_t *phSocket) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetSocketInfo(SNetSocket_t hSocket, CSteamID *pSteamIDRemote, int *peSocketStatus, uint32 *punIPRemote, uint16 *punPortRemote) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetListenSocketInfo(SNetListenSocket_t hListenSocket, uint32 *pnIP, uint16 *pnPort) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ESNetSocketConnectionType GetSocketConnectionType(SNetSocket_t hSocket) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (ESNetSocketConnectionType)0; |
|
} |
|
virtual int GetMaxPacketSize(SNetSocket_t hSocket) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamNetworking); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamRemoteStorage); |
|
virtual bool FileWrite(const char *pchFile, const void *pvData, int32 cubData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int32 FileRead(const char *pchFile, void *pvData, int32 cubDataToRead) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t FileWriteAsync(const char *pchFile, const void *pvData, uint32 cubData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t FileReadAsync(const char *pchFile, uint32 nOffset, uint32 cubToRead) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool FileReadAsyncComplete(SteamAPICall_t hReadCall, void *pvBuffer, uint32 cubToRead) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool FileForget(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool FileDelete(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t FileShare(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetSyncPlatforms(const char *pchFile, ERemoteStoragePlatform eRemoteStoragePlatform) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual UGCFileWriteStreamHandle_t FileWriteStreamOpen(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool FileWriteStreamWriteChunk(UGCFileWriteStreamHandle_t writeHandle, const void *pvData, int32 cubData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool FileWriteStreamClose(UGCFileWriteStreamHandle_t writeHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool FileWriteStreamCancel(UGCFileWriteStreamHandle_t writeHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool FileExists(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool FilePersisted(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int32 GetFileSize(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int64 GetFileTimestamp(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ERemoteStoragePlatform GetSyncPlatforms(const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (ERemoteStoragePlatform)0; |
|
} |
|
virtual int32 GetFileCount() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetFileNameAndSize(int iFile, int32 *pnFileSizeInBytes) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetQuota(uint64 *pnTotalBytes, uint64 *puAvailableBytes) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsCloudEnabledForAccount() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsCloudEnabledForApp() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SetCloudEnabledForApp(bool bEnabled) VFunction_STUB |
|
virtual SteamAPICall_t UGCDownload(UGCHandle_t hContent, uint32 unPriority) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetUGCDownloadProgress(UGCHandle_t hContent, int32 *pnBytesDownloaded, int32 *pnBytesExpected) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetUGCDetails(UGCHandle_t hContent, AppId_t *pnAppID, OUT_STRING() char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int32 UGCRead(UGCHandle_t hContent, void *pvData, int32 cubDataToRead, uint32 cOffset, EUGCReadAction eAction) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int32 GetCachedUGCCount() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual UGCHandle_t GetCachedUGCHandle(int32 iCachedContent) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
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) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest(PublishedFileId_t unPublishedFileId) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdatePublishedFileFile(PublishedFileUpdateHandle_t updateHandle, const char *pchFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdatePublishedFilePreviewFile(PublishedFileUpdateHandle_t updateHandle, const char *pchPreviewFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdatePublishedFileTitle(PublishedFileUpdateHandle_t updateHandle, const char *pchTitle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdatePublishedFileDescription(PublishedFileUpdateHandle_t updateHandle, const char *pchDescription) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdatePublishedFileVisibility(PublishedFileUpdateHandle_t updateHandle, ERemoteStoragePublishedFileVisibility eVisibility) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdatePublishedFileTags(PublishedFileUpdateHandle_t updateHandle, SteamParamStringArray_t *pTags) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t CommitPublishedFileUpdate(PublishedFileUpdateHandle_t updateHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t GetPublishedFileDetails(PublishedFileId_t unPublishedFileId, uint32 unMaxSecondsOld) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t DeletePublishedFile(PublishedFileId_t unPublishedFileId) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t EnumerateUserPublishedFiles(uint32 unStartIndex) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t SubscribePublishedFile(PublishedFileId_t unPublishedFileId) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t EnumerateUserSubscribedFiles(uint32 unStartIndex) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t UnsubscribePublishedFile(PublishedFileId_t unPublishedFileId) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdatePublishedFileSetChangeDescription(PublishedFileUpdateHandle_t updateHandle, const char *pchChangeDescription) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t GetPublishedItemVoteDetails(PublishedFileId_t unPublishedFileId) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t UpdateUserPublishedItemVote(PublishedFileId_t unPublishedFileId, bool bVoteUp) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t GetUserPublishedItemVoteDetails(PublishedFileId_t unPublishedFileId) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t EnumerateUserSharedWorkshopFiles(CSteamID steamId, uint32 unStartIndex, SteamParamStringArray_t *pRequiredTags, SteamParamStringArray_t *pExcludedTags) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 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) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t SetUserPublishedFileAction(PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t EnumeratePublishedFilesByUserAction(EWorkshopFileAction eAction, uint32 unStartIndex) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t EnumeratePublishedWorkshopFiles(EWorkshopEnumerationType eEnumerationType, uint32 unStartIndex, uint32 unCount, uint32 unDays, SteamParamStringArray_t *pTags, SteamParamStringArray_t *pUserTags) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t UGCDownloadToLocation(UGCHandle_t hContent, const char *pchLocation, uint32 unPriority) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamRemoteStorage); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamScreenshots); |
|
virtual ScreenshotHandle WriteScreenshot(void *pubRGB, uint32 cubRGB, int nWidth, int nHeight) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ScreenshotHandle AddScreenshotToLibrary(const char *pchFilename, const char *pchThumbnailFilename, int nWidth, int nHeight) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void TriggerScreenshot() VFunction_STUB |
|
virtual void HookScreenshots(bool bHook) VFunction_STUB |
|
virtual bool SetLocation(ScreenshotHandle hScreenshot, const char *pchLocation) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool TagUser(ScreenshotHandle hScreenshot, CSteamID steamID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool TagPublishedFile(ScreenshotHandle hScreenshot, PublishedFileId_t unPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool IsScreenshotsHooked() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ScreenshotHandle AddVRScreenshotToLibrary(EVRScreenshotType eType, const char *pchFilename, const char *pchVRFilename) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamScreenshots); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamHTTP); |
|
virtual HTTPRequestHandle CreateHTTPRequest(EHTTPMethod eHTTPRequestMethod, const char *pchAbsoluteURL) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestContextValue(HTTPRequestHandle hRequest, uint64 ulContextValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestNetworkActivityTimeout(HTTPRequestHandle hRequest, uint32 unTimeoutSeconds) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestHeaderValue(HTTPRequestHandle hRequest, const char *pchHeaderName, const char *pchHeaderValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestGetOrPostParameter(HTTPRequestHandle hRequest, const char *pchParamName, const char *pchParamValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SendHTTPRequest(HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SendHTTPRequestAndStreamResponse(HTTPRequestHandle hRequest, SteamAPICall_t *pCallHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool DeferHTTPRequest(HTTPRequestHandle hRequest) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool PrioritizeHTTPRequest(HTTPRequestHandle hRequest) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetHTTPResponseHeaderSize(HTTPRequestHandle hRequest, const char *pchHeaderName, uint32 *unResponseHeaderSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetHTTPResponseHeaderValue(HTTPRequestHandle hRequest, const char *pchHeaderName, uint8 *pHeaderValueBuffer, uint32 unBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetHTTPResponseBodySize(HTTPRequestHandle hRequest, uint32 *unBodySize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetHTTPResponseBodyData(HTTPRequestHandle hRequest, uint8 *pBodyDataBuffer, uint32 unBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetHTTPStreamingResponseBodyData(HTTPRequestHandle hRequest, uint32 cOffset, uint8 *pBodyDataBuffer, uint32 unBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ReleaseHTTPRequest(HTTPRequestHandle hRequest) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetHTTPDownloadProgressPct(HTTPRequestHandle hRequest, float *pflPercentOut) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestRawPostBody(HTTPRequestHandle hRequest, const char *pchContentType, uint8 *pubBody, uint32 unBodyLen) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual HTTPCookieContainerHandle CreateCookieContainer(bool bAllowResponsesToModify) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ReleaseCookieContainer(HTTPCookieContainerHandle hCookieContainer) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetCookie(HTTPCookieContainerHandle hCookieContainer, const char *pchHost, const char *pchUrl, const char *pchCookie) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestCookieContainer(HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestUserAgentInfo(HTTPRequestHandle hRequest, const char *pchUserAgentInfo) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestRequiresVerifiedCertificate(HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetHTTPRequestAbsoluteTimeoutMS(HTTPRequestHandle hRequest, uint32 unMilliseconds) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetHTTPRequestWasTimedOut(HTTPRequestHandle hRequest, bool *pbWasTimedOut) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamHTTP); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamController); |
|
virtual bool Init() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool Shutdown() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void RunFrame() VFunction_STUB |
|
virtual int GetConnectedControllers(ControllerHandle_t *handlesOut) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ShowBindingPanel(ControllerHandle_t controllerHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ControllerActionSetHandle_t GetActionSetHandle(const char *pszActionSetName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void ActivateActionSet(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle) VFunction_STUB |
|
virtual ControllerActionSetHandle_t GetCurrentActionSet(ControllerHandle_t controllerHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void ActivateActionSetLayer(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle) VFunction_STUB |
|
virtual void DeactivateActionSetLayer(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle) VFunction_STUB |
|
virtual void DeactivateAllActionSetLayers(ControllerHandle_t controllerHandle) VFunction_STUB |
|
virtual int GetActiveActionSetLayers(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t *handlesOut) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ControllerDigitalActionHandle_t GetDigitalActionHandle(const char *pszActionName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ControllerDigitalActionData_t GetDigitalActionData(ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle) { |
|
ControllerDigitalActionData_t fuck; |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return fuck; |
|
} |
|
virtual int GetDigitalActionOrigins(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, EControllerActionOrigin *originsOut) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ControllerAnalogActionHandle_t GetAnalogActionHandle(const char *pszActionName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ControllerAnalogActionData_t GetAnalogActionData(ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle) { |
|
ControllerAnalogActionData_t fuck; |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return fuck; |
|
} |
|
virtual int GetAnalogActionOrigins(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, EControllerActionOrigin *originsOut) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void StopAnalogActionMomentum(ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction) VFunction_STUB |
|
virtual void TriggerHapticPulse(ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec) VFunction_STUB |
|
virtual void TriggerRepeatedHapticPulse(ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags) VFunction_STUB |
|
virtual void TriggerVibration(ControllerHandle_t controllerHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed) VFunction_STUB |
|
virtual void SetLEDColor(ControllerHandle_t controllerHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags) VFunction_STUB |
|
virtual int GetGamepadIndexForController(ControllerHandle_t ulControllerHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ControllerHandle_t GetControllerForGamepadIndex(int nIndex) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ControllerMotionData_t GetMotionData(ControllerHandle_t controllerHandle) { |
|
ControllerMotionData_t fuck; |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return fuck; |
|
} |
|
virtual bool ShowDigitalActionOrigins(ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle, float flScale, float flXPosition, float flYPosition) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ShowAnalogActionOrigins(ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle, float flScale, float flXPosition, float flYPosition) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetStringForActionOrigin(EControllerActionOrigin eOrigin) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual const char *GetGlyphForActionOrigin(EControllerActionOrigin eOrigin) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual ESteamInputType GetInputTypeForHandle(ControllerHandle_t controllerHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (ESteamInputType)0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamController); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamUGC); |
|
virtual UGCQueryHandle_t CreateQueryUserUGCRequest(AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual UGCQueryHandle_t CreateQueryAllUGCRequest(EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual UGCQueryHandle_t CreateQueryUGCDetailsRequest(PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t SendQueryUGCRequest(UGCQueryHandle_t handle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetQueryUGCResult(UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetQueryUGCPreviewURL(UGCQueryHandle_t handle, uint32 index, char *pchURL, uint32 cchURLSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetQueryUGCMetadata(UGCQueryHandle_t handle, uint32 index, char *pchMetadata, uint32 cchMetadatasize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetQueryUGCChildren(UGCQueryHandle_t handle, uint32 index, PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetQueryUGCStatistic(UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 *pStatValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetQueryUGCNumAdditionalPreviews(UGCQueryHandle_t handle, uint32 index) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetQueryUGCAdditionalPreview(UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, char *pchURLOrVideoID, uint32 cchURLSize, char *pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType *pPreviewType) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetQueryUGCNumKeyValueTags(UGCQueryHandle_t handle, uint32 index) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetQueryUGCKeyValueTag(UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, char *pchKey, uint32 cchKeySize, char *pchValue, uint32 cchValueSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ReleaseQueryUGCRequest(UGCQueryHandle_t handle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AddRequiredTag(UGCQueryHandle_t handle, const char *pTagName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AddExcludedTag(UGCQueryHandle_t handle, const char *pTagName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetReturnOnlyIDs(UGCQueryHandle_t handle, bool bReturnOnlyIDs) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetReturnKeyValueTags(UGCQueryHandle_t handle, bool bReturnKeyValueTags) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetReturnLongDescription(UGCQueryHandle_t handle, bool bReturnLongDescription) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetReturnMetadata(UGCQueryHandle_t handle, bool bReturnMetadata) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetReturnChildren(UGCQueryHandle_t handle, bool bReturnChildren) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetReturnAdditionalPreviews(UGCQueryHandle_t handle, bool bReturnAdditionalPreviews) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetReturnTotalOnly(UGCQueryHandle_t handle, bool bReturnTotalOnly) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetReturnPlaytimeStats(UGCQueryHandle_t handle, uint32 unDays) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetLanguage(UGCQueryHandle_t handle, const char *pchLanguage) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetAllowCachedResponse(UGCQueryHandle_t handle, uint32 unMaxAgeSeconds) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetCloudFileNameFilter(UGCQueryHandle_t handle, const char *pMatchCloudFileName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetMatchAnyTag(UGCQueryHandle_t handle, bool bMatchAnyTag) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetSearchText(UGCQueryHandle_t handle, const char *pSearchText) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetRankedByTrendDays(UGCQueryHandle_t handle, uint32 unDays) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AddRequiredKeyValueTag(UGCQueryHandle_t handle, const char *pKey, const char *pValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestUGCDetails(PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t CreateItem(AppId_t nConsumerAppId, EWorkshopFileType eFileType) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual UGCUpdateHandle_t StartItemUpdate(AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetItemTitle(UGCUpdateHandle_t handle, const char *pchTitle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetItemDescription(UGCUpdateHandle_t handle, const char *pchDescription) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetItemUpdateLanguage(UGCUpdateHandle_t handle, const char *pchLanguage) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetItemMetadata(UGCUpdateHandle_t handle, const char *pchMetaData) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetItemVisibility(UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetItemTags(UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t *pTags) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetItemContent(UGCUpdateHandle_t handle, const char *pszContentFolder) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetItemPreview(UGCUpdateHandle_t handle, const char *pszPreviewFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool RemoveItemKeyValueTags(UGCUpdateHandle_t handle, const char *pchKey) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AddItemKeyValueTag(UGCUpdateHandle_t handle, const char *pchKey, const char *pchValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AddItemPreviewFile(UGCUpdateHandle_t handle, const char *pszPreviewFile, EItemPreviewType type) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AddItemPreviewVideo(UGCUpdateHandle_t handle, const char *pszVideoID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateItemPreviewFile(UGCUpdateHandle_t handle, uint32 index, const char *pszPreviewFile) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateItemPreviewVideo(UGCUpdateHandle_t handle, uint32 index, const char *pszVideoID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool RemoveItemPreview(UGCUpdateHandle_t handle, uint32 index) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t SubmitItemUpdate(UGCUpdateHandle_t handle, const char *pchChangeNote) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual EItemUpdateStatus GetItemUpdateProgress(UGCUpdateHandle_t handle, uint64 *punBytesProcessed, uint64* punBytesTotal) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (EItemUpdateStatus)0; |
|
} |
|
virtual SteamAPICall_t SetUserItemVote(PublishedFileId_t nPublishedFileID, bool bVoteUp) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t GetUserItemVote(PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t AddItemToFavorites(AppId_t nAppId, PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RemoveItemFromFavorites(AppId_t nAppId, PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t SubscribeItem(PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t UnsubscribeItem(PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetNumSubscribedItems() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetSubscribedItems(PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetItemState(PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetItemInstallInfo(PublishedFileId_t nPublishedFileID, uint64 *punSizeOnDisk, char *pchFolder, uint32 cchFolderSize, uint32 *punTimeStamp) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetItemDownloadInfo(PublishedFileId_t nPublishedFileID, uint64 *punBytesDownloaded, uint64 *punBytesTotal) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool DownloadItem(PublishedFileId_t nPublishedFileID, bool bHighPriority) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BInitWorkshopForGameServer(DepotId_t unWorkshopDepotID, const char *pszFolder) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SuspendDownloads(bool bSuspend) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
} |
|
virtual SteamAPICall_t StartPlaytimeTracking(PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t StopPlaytimeTracking(PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t StopPlaytimeTrackingForAllItems() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t AddDependency(PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RemoveDependency(PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t AddAppDependency(PublishedFileId_t nPublishedFileID, AppId_t nAppID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RemoveAppDependency(PublishedFileId_t nPublishedFileID, AppId_t nAppID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t GetAppDependencies(PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t DeleteItem(PublishedFileId_t nPublishedFileID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamUGC); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamAppList); |
|
virtual uint32 GetNumInstalledApps() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetInstalledApps(AppId_t *pvecAppID, uint32 unMaxAppIDs) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetAppName(AppId_t nAppID, char *pchName, int cchNameMax) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetAppInstallDir(AppId_t nAppID, char *pchDirectory, int cchNameMax) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual int GetAppBuildId(AppId_t nAppID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamAppList); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamMusic); |
|
virtual bool BIsEnabled() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsPlaying() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual AudioPlayback_Status GetPlaybackStatus() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (AudioPlayback_Status)0; |
|
} |
|
virtual void Play() VFunction_STUB |
|
virtual void Pause() VFunction_STUB |
|
virtual void PlayPrevious() VFunction_STUB |
|
virtual void PlayNext() VFunction_STUB |
|
virtual void SetVolume(float flVolume) VFunction_STUB |
|
virtual float GetVolume() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamMusic); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamMusicRemote); |
|
virtual bool RegisterSteamMusicRemote(const char *pchName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool DeregisterSteamMusicRemote() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsCurrentMusicRemote() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BActivationSuccess(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetDisplayName(const char *pchDisplayName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetPNGIcon_64x64(void *pvBuffer, uint32 cbBufferLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool EnablePlayPrevious(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool EnablePlayNext(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool EnableShuffled(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool EnableLooped(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool EnableQueue(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool EnablePlaylists(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdatePlaybackStatus(AudioPlayback_Status nStatus) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateShuffled(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateLooped(bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateVolume(float flValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool CurrentEntryWillChange() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool CurrentEntryIsAvailable(bool bAvailable) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateCurrentEntryText(const char *pchText) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateCurrentEntryElapsedSeconds(int nValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool UpdateCurrentEntryCoverArt(void *pvBuffer, uint32 cbBufferLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool CurrentEntryDidChange() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool QueueWillChange() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ResetQueueEntries() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetQueueEntry(int nID, int nPosition, const char *pchEntryText) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetCurrentQueueEntry(int nID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool QueueDidChange() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool PlaylistWillChange() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ResetPlaylistEntries() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetPlaylistEntry(int nID, int nPosition, const char *pchEntryText) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetCurrentPlaylistEntry(int nID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool PlaylistDidChange() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamMusicRemote); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamHTMLSurface); |
|
virtual ~ISteamHTMLSurfaceDerived() {} |
|
virtual bool Init() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return false; |
|
} |
|
virtual bool Shutdown() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return false; |
|
} |
|
virtual SteamAPICall_t CreateBrowser(const char *pchUserAgent, const char *pchUserCSS) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void RemoveBrowser(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void LoadURL(HHTMLBrowser unBrowserHandle, const char *pchURL, const char *pchPostData) VFunction_STUB |
|
virtual void SetSize(HHTMLBrowser unBrowserHandle, uint32 unWidth, uint32 unHeight) VFunction_STUB |
|
virtual void StopLoad(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void Reload(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void GoBack(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void GoForward(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void AddHeader(HHTMLBrowser unBrowserHandle, const char *pchKey, const char *pchValue) VFunction_STUB |
|
virtual void ExecuteJavascript(HHTMLBrowser unBrowserHandle, const char *pchScript) VFunction_STUB |
|
virtual void MouseUp(HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton) VFunction_STUB |
|
virtual void MouseDown(HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton) VFunction_STUB |
|
virtual void MouseDoubleClick(HHTMLBrowser unBrowserHandle, EHTMLMouseButton eMouseButton) VFunction_STUB |
|
virtual void MouseMove(HHTMLBrowser unBrowserHandle, int x, int y) VFunction_STUB |
|
virtual void MouseWheel(HHTMLBrowser unBrowserHandle, int32 nDelta) VFunction_STUB |
|
virtual void KeyDown(HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers) VFunction_STUB |
|
virtual void KeyUp(HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, EHTMLKeyModifiers eHTMLKeyModifiers) VFunction_STUB |
|
virtual void KeyChar(HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, EHTMLKeyModifiers eHTMLKeyModifiers) VFunction_STUB |
|
virtual void SetHorizontalScroll(HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) VFunction_STUB |
|
virtual void SetVerticalScroll(HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) VFunction_STUB |
|
virtual void SetKeyFocus(HHTMLBrowser unBrowserHandle, bool bHasKeyFocus) VFunction_STUB |
|
virtual void ViewSource(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void CopyToClipboard(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void PasteFromClipboard(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void Find(HHTMLBrowser unBrowserHandle, const char *pchSearchStr, bool bCurrentlyInFind, bool bReverse) VFunction_STUB |
|
virtual void StopFind(HHTMLBrowser unBrowserHandle) VFunction_STUB |
|
virtual void GetLinkAtPosition(HHTMLBrowser unBrowserHandle, int x, int y) VFunction_STUB |
|
virtual void SetCookie(const char *pchHostname, const char *pchKey, const char *pchValue, const char *pchPath = "/", RTime32 nExpires = 0, bool bSecure = false, bool bHTTPOnly = false) VFunction_STUB |
|
virtual void SetPageScaleFactor(HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY) VFunction_STUB |
|
virtual void SetBackgroundMode(HHTMLBrowser unBrowserHandle, bool bBackgroundMode) VFunction_STUB |
|
virtual void SetDPIScalingFactor(HHTMLBrowser unBrowserHandle, float flDPIScaling) VFunction_STUB |
|
virtual void AllowStartRequest(HHTMLBrowser unBrowserHandle, bool bAllowed) VFunction_STUB |
|
virtual void JSDialogResponse(HHTMLBrowser unBrowserHandle, bool bResult) VFunction_STUB |
|
virtual void FileLoadDialogResponse(HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles) VFunction_STUB |
|
DerivedInterfaceGenerator_End(ISteamHTMLSurface); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamInventory); |
|
virtual EResult GetResultStatus(SteamInventoryResult_t resultHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return (EResult)0; |
|
} |
|
virtual bool GetResultItems(SteamInventoryResult_t resultHandle, SteamItemDetails_t *pOutItemsArray, uint32 *punOutItemsArraySize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetResultItemProperty(SteamInventoryResult_t resultHandle, uint32 unItemIndex, const char *pchPropertyName, char *pchValueBuffer, uint32 *punValueBufferSizeOut) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetResultTimestamp(SteamInventoryResult_t resultHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool CheckResultSteamID(SteamInventoryResult_t resultHandle, CSteamID steamIDExpected) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void DestroyResult(SteamInventoryResult_t resultHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
} |
|
virtual bool GetAllItems(SteamInventoryResult_t *pResultHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetItemsByID(SteamInventoryResult_t *pResultHandle, const SteamItemInstanceID_t *pInstanceIDs, uint32 unCountInstanceIDs) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SerializeResult(SteamInventoryResult_t resultHandle, void *pOutBuffer, uint32 *punOutBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool DeserializeResult(SteamInventoryResult_t *pOutResultHandle, const void *pBuffer, uint32 unBufferSize, bool bRESERVED_MUST_BE_FALSE = false) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GenerateItems(SteamInventoryResult_t *pResultHandle, const SteamItemDef_t *pArrayItemDefs, const uint32 *punArrayQuantity, uint32 unArrayLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GrantPromoItems(SteamInventoryResult_t *pResultHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AddPromoItem(SteamInventoryResult_t *pResultHandle, SteamItemDef_t itemDef) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool AddPromoItems(SteamInventoryResult_t *pResultHandle, const SteamItemDef_t *pArrayItemDefs, uint32 unArrayLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ConsumeItem(SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool ExchangeItems(SteamInventoryResult_t *pResultHandle, const SteamItemDef_t *pArrayGenerate, const uint32 *punArrayGenerateQuantity, uint32 unArrayGenerateLength, const SteamItemInstanceID_t *pArrayDestroy, const uint32 *punArrayDestroyQuantity, uint32 unArrayDestroyLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool TransferItemQuantity(SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void SendItemDropHeartbeat() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
} |
|
virtual bool TriggerItemDrop(SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool TradeItems(SteamInventoryResult_t *pResultHandle, CSteamID steamIDTradePartner, const SteamItemInstanceID_t *pArrayGive, const uint32 *pArrayGiveQuantity, uint32 nArrayGiveLength, const SteamItemInstanceID_t *pArrayGet, const uint32 *pArrayGetQuantity, uint32 nArrayGetLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool LoadItemDefinitions() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetItemDefinitionIDs(SteamItemDef_t *pItemDefIDs, uint32 *punItemDefIDsArraySize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetItemDefinitionProperty(SteamItemDef_t iDefinition, const char *pchPropertyName, char *pchValueBuffer, uint32 *punValueBufferSizeOut) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs(CSteamID steamID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetEligiblePromoItemDefinitionIDs(CSteamID steamID, SteamItemDef_t *pItemDefIDs, uint32 *punItemDefIDsArraySize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t StartPurchase(const SteamItemDef_t *pArrayItemDefs, const uint32 *punArrayQuantity, uint32 unArrayLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamAPICall_t RequestPrices() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual uint32 GetNumItemsWithPrices() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetItemsWithPrices(SteamItemDef_t *pArrayItemDefs, uint64 *pPrices, uint32 unArrayLength) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool GetItemPrice(SteamItemDef_t iDefinition, uint64 *pPrice) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual SteamInventoryUpdateHandle_t StartUpdateProperties() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool RemoveProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, const char *pchPropertyValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, bool bValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, int64 nValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SetProperty(SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, float flValue) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool SubmitUpdateProperties(SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamInventory); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamVideo); |
|
virtual void GetVideoURL(AppId_t unVideoAppID) VFunction_STUB |
|
virtual bool IsBroadcasting(int *pnNumViewers) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual void GetOPFSettings(AppId_t unVideoAppID) VFunction_STUB |
|
virtual bool GetOPFStringForApp(AppId_t unVideoAppID, char *pchBuffer, int32 *pnBufferSize) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamVideo); |
|
|
|
DerivedInterfaceGenerator_Begin(ISteamParentalSettings); |
|
virtual bool BIsParentalLockEnabled() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsParentalLockLocked() { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsAppBlocked(AppId_t nAppID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsAppInBlockList(AppId_t nAppID) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsFeatureBlocked(EParentalFeature eFeature) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
virtual bool BIsFeatureInBlockList(EParentalFeature eFeature) { |
|
FakeSteamAPI_LogFuncBeingCalled(); |
|
return 0; |
|
} |
|
DerivedInterfaceGenerator_End(ISteamParentalSettings); |
|
|
|
static CSteamAPIContextStruct sSteamContext; |
|
|
|
bool FakeSteamAPI_InitializeContext(void) { |
|
sSteamContext.m_pSteamClient = &ISteamClientDerived::GetInstance(); |
|
sSteamContext.m_pSteamUser = &ISteamUserDerived::GetInstance(); |
|
sSteamContext.m_pSteamFriends = &ISteamFriendsDerived::GetInstance(); |
|
sSteamContext.m_pSteamUtils = &ISteamUtilsDerived::GetInstance(); |
|
sSteamContext.m_pSteamMatchmaking = &ISteamMatchmakingDerived::GetInstance(); |
|
sSteamContext.m_pSteamUserStats = &ISteamUserStatsDerived::GetInstance(); |
|
sSteamContext.m_pSteamApps = &ISteamAppsDerived::GetInstance(); |
|
sSteamContext.m_pSteamMatchmakingServers = &ISteamMatchmakingServersDerived::GetInstance(); |
|
sSteamContext.m_pSteamNetworking = &ISteamNetworkingDerived::GetInstance(); |
|
sSteamContext.m_pSteamRemoteStorage = &ISteamRemoteStorageDerived::GetInstance(); |
|
sSteamContext.m_pSteamHTTP = &ISteamHTTPDerived::GetInstance(); |
|
sSteamContext.m_pSteamScreenshots = &ISteamScreenshotsDerived::GetInstance(); |
|
sSteamContext.m_pSteamMusic = &ISteamMusicDerived::GetInstance(); |
|
sSteamContext.m_pController = &ISteamControllerDerived::GetInstance(); |
|
sSteamContext.m_pSteamUGC = &ISteamUGCDerived::GetInstance(); |
|
sSteamContext.m_pSteamAppList = &ISteamAppListDerived::GetInstance(); |
|
sSteamContext.m_pSteamMusic = &ISteamMusicDerived::GetInstance(); |
|
sSteamContext.m_pSteamMusicRemote = &ISteamMusicRemoteDerived::GetInstance(); |
|
sSteamContext.m_pSteamHTMLSurface = &ISteamHTMLSurfaceDerived::GetInstance(); |
|
sSteamContext.m_pSteamInventory = &ISteamInventoryDerived::GetInstance(); |
|
sSteamContext.m_pSteamVideo = &ISteamVideoDerived::GetInstance(); |
|
sSteamContext.m_pSteamParentalSettings = &ISteamParentalSettingsDerived::GetInstance(); |
|
|
|
return true; |
|
} |
|
|
|
CSteamAPIContext& FakeSteamAPI_GetContextInstance(void) { |
|
static bool bInitialized = false; |
|
if (!bInitialized) |
|
FakeSteamAPI_InitializeContext(); |
|
return *(CSteamAPIContext*)&sSteamContext; |
|
}
|
|
|