steam/SteamAchievements.cpp at master · wamsoft/steam · GitHub

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#include "SteamAchievements.h"
#include "ncbind.hpp"
#include <tchar.h>

extern std::string convertTtstrToUtf8String(ttstr &buf);
extern ttstr convertUtf8StringToTtstr(const std::string &buf);

SteamAchievements::SteamAchievements() :
 m_iAppID( 0),
 m_bInitialized( false),
 m_CallbackUserStatsReceived(this, &SteamAchievements::OnUserStatsReceived),
 m_CallbackUserStatsStored(this, &SteamAchievements::OnUserStatsStored),
 m_CallbackAchievementStored(this, &SteamAchievements::OnAchievementStored)
{
	m_iAppID = SteamUtils()->GetAppID();
	requestInitialize();
}


SteamAchievements::~SteamAchievements()
{
}

bool
SteamAchievements::requestInitialize()
{
	// Is Steam loaded? If not we can't get stats.
	if (NULL == SteamUserStats() || NULL == SteamUser()) {
		return false;
	}
	// Is the user logged on?  If not we can't get stats.
	if (!SteamUser()->BLoggedOn()) {
		return false;
	}
	// Request user stats.
	return SteamUserStats()->RequestCurrentStats();
}

int
SteamAchievements::getAchievementsCount()
{
	return SteamUserStats()->GetNumAchievements();
}


tTJSVariant
SteamAchievements::getAchievement(tTJSVariant n)
{
	tTJSVariant ret;
	if (m_bInitialized) {
		std::string name;
		getName(n, name);
		if (name != "") {
			const char *ach = name.c_str();
			bool achieved = false;
			uint32 unlockTime;
			if (SteamUserStats()->GetAchievementAndUnlockTime(ach, &achieved, &unlockTime)) {
				std::string name = SteamUserStats()->GetAchievementDisplayAttribute(ach, "name");
				std::string desc = SteamUserStats()->GetAchievementDisplayAttribute(ach, "desc");
				iTJSDispatch2 *dict = TJSCreateDictionaryObject();
				if (dict) {
					ncbPropAccessor obj(dict);
					obj.SetValue(TJS_W("ach"), ach);
					obj.SetValue(TJS_W("achieved"), achieved);
					obj.SetValue(TJS_W("unlockTime"), unlockTime);
					obj.SetValue(TJS_W("name"), convertUtf8StringToTtstr(name));
					obj.SetValue(TJS_W("desc"), convertUtf8StringToTtstr(desc));
					ret = tTJSVariant(dict, dict);
					dict->Release();
				}
			}
		}
	}
	return ret;
}

bool
SteamAchievements::setAchievement(tTJSVariant n)
{
	// Have we received a call back from Steam yet?
	if (m_bInitialized)	{
		std::string name;
		getName(n, name);
		if (name != "") {
			SteamUserStats()->SetAchievement(name.c_str());
			return SteamUserStats()->StoreStats();
		}
	}
	// If not then we can't set achievements yet
	return false;
}

bool
SteamAchievements::clearAchievement(tTJSVariant n)
{
	// Have we received a call back from Steam yet?
	if (m_bInitialized)	{
		std::string name;
		getName(n, name);
		if (name != "") {
			return SteamUserStats()->ClearAchievement(name.c_str());
		}
	}
	// If not then we can't set achievements yet
	return false;
}


void
SteamAchievements::OnUserStatsReceived(UserStatsReceived_t *pCallback)
{
 // we may get callbacks for other games' stats arriving, ignore them
	if (m_iAppID == pCallback->m_nGameID) {
		if (k_EResultOK == pCallback->m_eResult) {
			OutputDebugString(_T("Received stats and achievements from Steam\n"));
			m_bInitialized = true;
		}
	} else {
		TCHAR buffer[128];
		_sntprintf(buffer, 128, _T("RequestStats - failed, %d\n"), pCallback->m_eResult);
		OutputDebugString(buffer);
	}
}

void
SteamAchievements::OnUserStatsStored(UserStatsStored_t *pCallback)
{
	// we may get callbacks for other games' stats arriving, ignore them
	if (m_iAppID == pCallback->m_nGameID) {
		if (k_EResultOK == pCallback->m_eResult) {
			OutputDebugString(_T("Stored stats for Steam\n"));
		}
	} else {
		TCHAR buffer[128];
		_sntprintf(buffer, 128, _T("StatsStored - failed, %d\n"), pCallback->m_eResult);
		OutputDebugString(buffer);
	}
}

void
SteamAchievements::OnAchievementStored(UserAchievementStored_t *pCallback)
{
	// we may get callbacks for other games' stats arriving, ignore them
	if (m_iAppID == pCallback->m_nGameID) {
		OutputDebugString(_T("Stored Achievement for Steam\n"));
	}
}

void
SteamAchievements::getName(tTJSVariant n, std::string &name)
{
	if (n.Type() == tvtInteger) {
		tjs_int num = n;
		name = SteamUserStats()->GetAchievementName(num);
	} else if (n.Type() == tvtString) {
		ttstr str = n.GetString();
		name = convertTtstrToUtf8String(str);
	}
}