267 lines
14 KiB
C++
267 lines
14 KiB
C++
/* Copyright (C) 2019 Mr Goldberg
|
|
This file is part of the Goldberg Emulator
|
|
|
|
The Goldberg Emulator is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 3 of the License, or (at your option) any later version.
|
|
|
|
The Goldberg Emulator is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the Goldberg Emulator; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#ifndef __INCLUDED_STEAM_USER_STATS_H__
|
|
#define __INCLUDED_STEAM_USER_STATS_H__
|
|
|
|
#include "base.h"
|
|
|
|
#include <iomanip>
|
|
#include <fstream>
|
|
#include "../json/json.hpp"
|
|
|
|
struct Steam_Leaderboard {
|
|
std::string name;
|
|
ELeaderboardSortMethod sort_method;
|
|
ELeaderboardDisplayType display_type;
|
|
};
|
|
|
|
class Steam_User_Stats :
|
|
public ISteamUserStats003,
|
|
public ISteamUserStats004,
|
|
public ISteamUserStats005,
|
|
public ISteamUserStats006,
|
|
public ISteamUserStats007,
|
|
public ISteamUserStats008,
|
|
public ISteamUserStats009,
|
|
public ISteamUserStats010,
|
|
public ISteamUserStats
|
|
{
|
|
public:
|
|
static constexpr auto achievements_user_file = "achievements.json";
|
|
|
|
private:
|
|
|
|
Local_Storage* local_storage;
|
|
Settings* settings;
|
|
SteamCallResults* callback_results;
|
|
class SteamCallBacks* callbacks;
|
|
std::vector<struct Steam_Leaderboard> leaderboards;
|
|
|
|
nlohmann::json defined_achievements;
|
|
nlohmann::json user_achievements;
|
|
|
|
unsigned int find_leaderboard(std::string name);
|
|
|
|
void load_achievements_db();
|
|
void load_achievements();
|
|
void save_achievements();
|
|
|
|
public:
|
|
Steam_User_Stats(Settings* settings, Local_Storage* local_storage, class SteamCallResults* callback_results, class SteamCallBacks* callbacks);
|
|
|
|
nlohmann::json const& GetAchievementsDb() const;
|
|
|
|
// Ask the server to send down this user's data and achievements for this game
|
|
STEAM_CALL_BACK(UserStatsReceived_t)
|
|
bool RequestCurrentStats();
|
|
|
|
// Data accessors
|
|
bool GetStat(const char* pchName, int32* pData);
|
|
bool GetStat(const char* pchName, float* pData);
|
|
|
|
// Set / update data
|
|
bool SetStat(const char* pchName, int32 nData);
|
|
bool SetStat(const char* pchName, float fData);
|
|
bool UpdateAvgRateStat(const char* pchName, float flCountThisSession, double dSessionLength);
|
|
|
|
// Achievement flag accessors
|
|
bool GetAchievement(const char* pchName, bool* pbAchieved);
|
|
bool SetAchievement(const char* pchName);
|
|
bool ClearAchievement(const char* pchName);
|
|
|
|
|
|
// Get the achievement status, and the time it was unlocked if unlocked.
|
|
// If the return value is true, but the unlock time is zero, that means it was unlocked before Steam
|
|
// began tracking achievement unlock times (December 2009). Time is seconds since January 1, 1970.
|
|
bool GetAchievementAndUnlockTime(const char* pchName, bool* pbAchieved, uint32* punUnlockTime);
|
|
|
|
// Store the current data on the server, will get a callback when set
|
|
// And one callback for every new achievement
|
|
//
|
|
// If the callback has a result of k_EResultInvalidParam, one or more stats
|
|
// uploaded has been rejected, either because they broke constraints
|
|
// or were out of date. In this case the server sends back updated values.
|
|
// The stats should be re-iterated to keep in sync.
|
|
bool StoreStats();
|
|
|
|
// Achievement / GroupAchievement metadata
|
|
|
|
// Gets the icon of the achievement, which is a handle to be used in ISteamUtils::GetImageRGBA(), or 0 if none set.
|
|
// A return value of 0 may indicate we are still fetching data, and you can wait for the UserAchievementIconFetched_t callback
|
|
// which will notify you when the bits are ready. If the callback still returns zero, then there is no image set for the
|
|
// specified achievement.
|
|
int GetAchievementIcon(const char* pchName);
|
|
|
|
|
|
// Get general attributes for an achievement. Accepts the following keys:
|
|
// - "name" and "desc" for retrieving the localized achievement name and description (returned in UTF8)
|
|
// - "hidden" for retrieving if an achievement is hidden (returns "0" when not hidden, "1" when hidden)
|
|
const char* GetAchievementDisplayAttribute(const char* pchName, const char* pchKey);
|
|
|
|
// Achievement progress - triggers an AchievementProgress callback, that is all.
|
|
// Calling this w/ N out of N progress will NOT set the achievement, the game must still do that.
|
|
bool IndicateAchievementProgress(const char* pchName, uint32 nCurProgress, uint32 nMaxProgress);
|
|
|
|
// Used for iterating achievements. In general games should not need these functions because they should have a
|
|
// list of existing achievements compiled into them
|
|
uint32 GetNumAchievements();
|
|
|
|
// Get achievement name iAchievement in [0,GetNumAchievements)
|
|
const char* GetAchievementName(uint32 iAchievement);
|
|
|
|
// Friends stats & achievements
|
|
|
|
// downloads stats for the user
|
|
// returns a UserStatsReceived_t received when completed
|
|
// if the other user has no stats, UserStatsReceived_t.m_eResult will be set to k_EResultFail
|
|
// these stats won't be auto-updated; you'll need to call RequestUserStats() again to refresh any data
|
|
STEAM_CALL_RESULT(UserStatsReceived_t)
|
|
SteamAPICall_t RequestUserStats(CSteamID steamIDUser);
|
|
|
|
|
|
// requests stat information for a user, usable after a successful call to RequestUserStats()
|
|
bool GetUserStat(CSteamID steamIDUser, const char* pchName, int32* pData);
|
|
bool GetUserStat(CSteamID steamIDUser, const char* pchName, float* pData);
|
|
|
|
bool GetUserAchievement(CSteamID steamIDUser, const char* pchName, bool* pbAchieved);
|
|
|
|
// See notes for GetAchievementAndUnlockTime above
|
|
bool GetUserAchievementAndUnlockTime(CSteamID steamIDUser, const char* pchName, bool* pbAchieved, uint32* punUnlockTime);
|
|
|
|
// Reset stats
|
|
bool ResetAllStats(bool bAchievementsToo);
|
|
|
|
// Leaderboard functions
|
|
|
|
// asks the Steam back-end for a leaderboard by name, and will create it if it's not yet
|
|
// This call is asynchronous, with the result returned in LeaderboardFindResult_t
|
|
STEAM_CALL_RESULT(LeaderboardFindResult_t)
|
|
SteamAPICall_t FindOrCreateLeaderboard(const char* pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType);
|
|
|
|
// as above, but won't create the leaderboard if it's not found
|
|
// This call is asynchronous, with the result returned in LeaderboardFindResult_t
|
|
STEAM_CALL_RESULT(LeaderboardFindResult_t)
|
|
SteamAPICall_t FindLeaderboard(const char* pchLeaderboardName);
|
|
|
|
// returns the name of a leaderboard
|
|
const char* GetLeaderboardName(SteamLeaderboard_t hSteamLeaderboard);
|
|
|
|
// returns the total number of entries in a leaderboard, as of the last request
|
|
int GetLeaderboardEntryCount(SteamLeaderboard_t hSteamLeaderboard);
|
|
|
|
// returns the sort method of the leaderboard
|
|
ELeaderboardSortMethod GetLeaderboardSortMethod(SteamLeaderboard_t hSteamLeaderboard);
|
|
|
|
// returns the display type of the leaderboard
|
|
ELeaderboardDisplayType GetLeaderboardDisplayType(SteamLeaderboard_t hSteamLeaderboard);
|
|
|
|
// Asks the Steam back-end for a set of rows in the leaderboard.
|
|
// This call is asynchronous, with the result returned in LeaderboardScoresDownloaded_t
|
|
// LeaderboardScoresDownloaded_t will contain a handle to pull the results from GetDownloadedLeaderboardEntries() (below)
|
|
// You can ask for more entries than exist, and it will return as many as do exist.
|
|
// k_ELeaderboardDataRequestGlobal requests rows in the leaderboard from the full table, with nRangeStart & nRangeEnd in the range [1, TotalEntries]
|
|
// k_ELeaderboardDataRequestGlobalAroundUser requests rows around the current user, nRangeStart being negate
|
|
// e.g. DownloadLeaderboardEntries( hLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -3, 3 ) will return 7 rows, 3 before the user, 3 after
|
|
// k_ELeaderboardDataRequestFriends requests all the rows for friends of the current user
|
|
STEAM_CALL_RESULT(LeaderboardScoresDownloaded_t)
|
|
SteamAPICall_t DownloadLeaderboardEntries(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd);
|
|
|
|
// as above, but downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers
|
|
// if a user doesn't have a leaderboard entry, they won't be included in the result
|
|
// a max of 100 users can be downloaded at a time, with only one outstanding call at a time
|
|
STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers)
|
|
STEAM_CALL_RESULT(LeaderboardScoresDownloaded_t)
|
|
SteamAPICall_t DownloadLeaderboardEntriesForUsers(SteamLeaderboard_t hSteamLeaderboard,
|
|
STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID* prgUsers, int cUsers);
|
|
|
|
// Returns data about a single leaderboard entry
|
|
// use a for loop from 0 to LeaderboardScoresDownloaded_t::m_cEntryCount to get all the downloaded entries
|
|
// e.g.
|
|
// void OnLeaderboardScoresDownloaded( LeaderboardScoresDownloaded_t *pLeaderboardScoresDownloaded )
|
|
// {
|
|
// for ( int index = 0; index < pLeaderboardScoresDownloaded->m_cEntryCount; index++ )
|
|
// {
|
|
// LeaderboardEntry_t leaderboardEntry;
|
|
// int32 details[3]; // we know this is how many we've stored previously
|
|
// GetDownloadedLeaderboardEntry( pLeaderboardScoresDownloaded->m_hSteamLeaderboardEntries, index, &leaderboardEntry, details, 3 );
|
|
// assert( leaderboardEntry.m_cDetails == 3 );
|
|
// ...
|
|
// }
|
|
// once you've accessed all the entries, the data will be free'd, and the SteamLeaderboardEntries_t handle will become invalid
|
|
bool GetDownloadedLeaderboardEntry(SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t* pLeaderboardEntry, int32* pDetails, int cDetailsMax);
|
|
|
|
// Uploads a user score to the Steam back-end.
|
|
// This call is asynchronous, with the result returned in LeaderboardScoreUploaded_t
|
|
// Details are extra game-defined information regarding how the user got that score
|
|
// pScoreDetails points to an array of int32's, cScoreDetailsCount is the number of int32's in the list
|
|
STEAM_CALL_RESULT(LeaderboardScoreUploaded_t)
|
|
SteamAPICall_t UploadLeaderboardScore(SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32* pScoreDetails, int cScoreDetailsCount);
|
|
|
|
SteamAPICall_t UploadLeaderboardScore(SteamLeaderboard_t hSteamLeaderboard, int32 nScore, int32* pScoreDetails, int cScoreDetailsCount);
|
|
|
|
// Attaches a piece of user generated content the user's entry on a leaderboard.
|
|
// hContent is a handle to a piece of user generated content that was shared using ISteamUserRemoteStorage::FileShare().
|
|
// This call is asynchronous, with the result returned in LeaderboardUGCSet_t.
|
|
STEAM_CALL_RESULT(LeaderboardUGCSet_t)
|
|
SteamAPICall_t AttachLeaderboardUGC(SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC);
|
|
|
|
// Retrieves the number of players currently playing your game (online + offline)
|
|
// This call is asynchronous, with the result returned in NumberOfCurrentPlayers_t
|
|
STEAM_CALL_RESULT(NumberOfCurrentPlayers_t)
|
|
SteamAPICall_t GetNumberOfCurrentPlayers();
|
|
|
|
// Requests that Steam fetch data on the percentage of players who have received each achievement
|
|
// for the game globally.
|
|
// This call is asynchronous, with the result returned in GlobalAchievementPercentagesReady_t.
|
|
STEAM_CALL_RESULT(GlobalAchievementPercentagesReady_t)
|
|
SteamAPICall_t RequestGlobalAchievementPercentages();
|
|
|
|
// Get the info on the most achieved achievement for the game, returns an iterator index you can use to fetch
|
|
// the next most achieved afterwards. Will return -1 if there is no data on achievement
|
|
// percentages (ie, you haven't called RequestGlobalAchievementPercentages and waited on the callback).
|
|
int GetMostAchievedAchievementInfo(char* pchName, uint32 unNameBufLen, float* pflPercent, bool* pbAchieved);
|
|
|
|
// Get the info on the next most achieved achievement for the game. Call this after GetMostAchievedAchievementInfo or another
|
|
// GetNextMostAchievedAchievementInfo call passing the iterator from the previous call. Returns -1 after the last
|
|
// achievement has been iterated.
|
|
int GetNextMostAchievedAchievementInfo(int iIteratorPrevious, char* pchName, uint32 unNameBufLen, float* pflPercent, bool* pbAchieved);
|
|
|
|
// Returns the percentage of users who have achieved the specified achievement.
|
|
bool GetAchievementAchievedPercent(const char* pchName, float* pflPercent);
|
|
|
|
// Requests global stats data, which is available for stats marked as "aggregated".
|
|
// This call is asynchronous, with the results returned in GlobalStatsReceived_t.
|
|
// nHistoryDays specifies how many days of day-by-day history to retrieve in addition
|
|
// to the overall totals. The limit is 60.
|
|
STEAM_CALL_RESULT(GlobalStatsReceived_t)
|
|
SteamAPICall_t RequestGlobalStats(int nHistoryDays);
|
|
|
|
// Gets the lifetime totals for an aggregated stat
|
|
bool GetGlobalStat(const char* pchStatName, int64* pData);
|
|
bool GetGlobalStat(const char* pchStatName, double* pData);
|
|
|
|
// Gets history for an aggregated stat. pData will be filled with daily values, starting with today.
|
|
// So when called, pData[0] will be today, pData[1] will be yesterday, and pData[2] will be two days ago,
|
|
// etc. cubData is the size in bytes of the pubData buffer. Returns the number of
|
|
// elements actually set.
|
|
int32 GetGlobalStatHistory(const char* pchStatName, STEAM_ARRAY_COUNT(cubData) int64* pData, uint32 cubData);
|
|
int32 GetGlobalStatHistory(const char* pchStatName, STEAM_ARRAY_COUNT(cubData) double* pData, uint32 cubData);
|
|
};
|
|
|
|
#endif//__INCLUDED_STEAM_USER_STATS_H__
|