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

#include "gfCCollectionListenerComponent.h"

#include <fsAppCore/src/fsCEntity.h>
#include <fsAppCore/src/fsCProfileManager.h>
#include <fsAppCore/src/fsCAppMessageDispatcher.h>

#include <fsCore/src/fsCVariableTable.h>
#include <fsCore/src/fsCResourceName.h>

#include <gfHogCore/src/gfCHogUserSavedData.h>

#include <gfComponents/components/gfICollectableComponent.h>

#include <gfAchievements/src/gfCAchievementManager.h>

const fsCUniqueId gfCCollectionListenerComponent::mTypeId("gfCCollectionListenerComponent");


void gfCCollectionListenerComponent::listenersRegisterDo()
{
	fsIMessageListener::listenersRegisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(gfICollectableComponent::mCollectionEndMsg, this);

	fsCVariableTable config;
	config.load(fsCResourceName("collectionTypes.txt", fsCResourceName::eRES_LOCATION_ASSETS));

	fsS32 i = 1;
	fsStr tag = config.strGetWithDefault("tag" + fsStr(i), "");
	while (!tag.emptyGet())
	{
		sRule rule;
		rule.mTag = tag;
		rule.mAchievementKey = config.strGetWithDefault(tag + ".achievementKey", "");
		rule.mStat = config.strGetWithDefault(tag + ".stat", "");
		mRules.push_back(rule);
		tag = config.strGetWithDefault("tag" + fsStr(++i), "");
	}
}

void gfCCollectionListenerComponent::listenersDeregisterDo()
{
	fsIMessageListener::listenersDeregisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(gfICollectableComponent::mCollectionEndMsg, this);
}

fsBool gfCCollectionListenerComponent::messageProcessDo(const fsCUniqueId& pMessageType,
                                                         const fsIMessageDispatcher::sMessageParameters& pParam)
{
	if (gfICollectableComponent::mCollectionEndMsg == pMessageType)
	{
		const gfICollectableComponent::sEntityCollectedParam& msgParams = static_cast<const
			gfICollectableComponent::sEntityCollectedParam&>(pParam);

		for (const sRule& rule : mRules)
		{
			if (msgParams.mEnt->tagExists(rule.mTag))
			{<--- Consider using std::find_if algorithm instead of a raw loop.
				if (!rule.mAchievementKey.emptyGet())
				{
					fsStr name = msgParams.mEnt->nameGet();
					name.erase(name.rfind("."));
					gfCAchievementManager::instanceGet()->achievementUnlock(
						rule.mAchievementKey, name, msgParams.mEnt->posGet());
				}
				if (!rule.mStat.emptyGet())
				{
					fsCProfileManager::instanceGet()->userSavedDataGet()->s32Inc(rule.mStat);
				}
				break;
			}
		}

		return false;
	}
	return false;
}

fsIComponent* gfCCollectionListenerComponent::create(fsCEntity* pParent)
{
	return new gfCCollectionListenerComponent(pParent);
}

gfCCollectionListenerComponent::gfCCollectionListenerComponent(fsCEntity* const pParent) :
	fsIMessageListenerComponent(pParent)
{
}

gfCCollectionListenerComponent::~gfCCollectionListenerComponent()
{
}