1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
#include "StarStatisticsService_pc_steam.hpp"
#include "StarLogging.hpp"
namespace Star {
SteamStatisticsService::SteamStatisticsService(PcPlatformServicesStatePtr)
: m_callbackUserStatsReceived(this, &SteamStatisticsService::onUserStatsReceived),
m_callbackUserStatsStored(this, &SteamStatisticsService::onUserStatsStored),
m_callbackAchievementStored(this, &SteamStatisticsService::onAchievementStored) {
m_appId = SteamUtils()->GetAppID();
refresh();
}
bool SteamStatisticsService::initialized() const {
return m_initialized;
}
Maybe<String> SteamStatisticsService::error() const {
return m_error;
}
bool SteamStatisticsService::setStat(String const& name, String const& type, Json const& value) {
if (type == "int")
return SteamUserStats()->SetStat(name.utf8Ptr(), (int32_t)value.toInt());
if (type == "float")
return SteamUserStats()->SetStat(name.utf8Ptr(), value.toFloat());
return false;
}
Json SteamStatisticsService::getStat(String const& name, String const& type, Json def) const {
if (type == "int") {
int32_t intValue = 0;
if (SteamUserStats()->GetStat(name.utf8Ptr(), &intValue))
return Json(intValue);
}
if (type == "float") {
float floatValue = 0.0f;
if (SteamUserStats()->GetStat(name.utf8Ptr(), &floatValue))
return Json(floatValue);
}
return def;
}
bool SteamStatisticsService::reportEvent(String const&, Json const&) {
// Steam doesn't support events
return false;
}
bool SteamStatisticsService::unlockAchievement(String const& name) {
if (!SteamUserStats()->SetAchievement(name.utf8Ptr())) {
Logger::error("Cannot set Steam achievement {}", name);
return false;
}
return true;
}
StringSet SteamStatisticsService::achievementsUnlocked() const {
StringSet achievements;
for (uint32_t i = 0; i < SteamUserStats()->GetNumAchievements(); ++i) {
String achievement = SteamUserStats()->GetAchievementName(i);
bool unlocked = false;
if (SteamUserStats()->GetAchievement(achievement.utf8Ptr(), &unlocked) && unlocked) {
achievements.add(achievement);
}
}
return {};
}
void SteamStatisticsService::refresh() {
if (!SteamUser()->BLoggedOn()) {
m_error = {"Not logged in"};
return;
}
SteamUserStats()->RequestCurrentStats();
}
void SteamStatisticsService::flush() {
SteamUserStats()->StoreStats();
}
bool SteamStatisticsService::reset() {
SteamUserStats()->ResetAllStats(true);
return true;
}
void SteamStatisticsService::onUserStatsReceived(UserStatsReceived_t* callback) {
if (callback->m_nGameID != m_appId)
return;
if (callback->m_eResult != k_EResultOK) {
m_error = {strf("Steam RequestCurrentStats failed with code {}", (int)callback->m_eResult)};
return;
}
Logger::debug("Steam RequestCurrentStats successful");
m_initialized = true;
}
void SteamStatisticsService::onUserStatsStored(UserStatsStored_t* callback) {
if (callback->m_nGameID != m_appId)
return;
if (callback->m_eResult == k_EResultOK) {
Logger::debug("Steam StoreStats successful");
return;
}
if (callback->m_eResult == k_EResultInvalidParam) {
// A stat we set broke a constraint and was reverted on the service.
Logger::info("Steam StoreStats: Some stats failed validation");
return;
}
m_error = {strf("Steam StoreStats failed with code {}", (int)callback->m_eResult)};
}
void SteamStatisticsService::onAchievementStored(UserAchievementStored_t* callback) {
if (callback->m_nGameID != m_appId)
return;
Logger::debug("Steam achievement {} stored successfully", callback->m_rgchAchievementName);
}
}
|