Cppcheck report - Fission: gameModules/gfComponents/components/gfCLockComponent.cpp

#include "gfCLockComponent.h"

#include <fsAppCore/src/components/gui/fsCNotificationsGui.h>
#include <fsRenderer/src/components/fsCSpriteComponent.h>
#include <fsAppCore/src/components/fsCNameComponent.h>
#include <fsAppCore/src/fsCLocalisedStrings.h>
#include <fsAppCore/src/fsCAppMessageDispatcher.h>
#include <fsAppCore/src/fsILevelBasedAppCoreMain.h>

#include "gfCTaskComponent.h"
#include "gfCGhostSpriteComponent.h"

const fsCUniqueId gfCLockComponent::mTypeId("fsCLockComponent");
const fsStr gfCLockComponent::mEntityPrefix("PRE");
const fsStr gfCLockComponent::mInOrderPrefix("ORD");


void gfCLockComponent::listenersRegisterDo()
{
	gfCTappableCollectableComponent::listenersRegisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(fsILevelBasedAppCoreMain::mLevelEntitiesCreatedMsg, this);
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(fsILevelBasedAppCoreMain::mLevelPostResetMsg, this);
}

void gfCLockComponent::listenersDeregisterDo()
{
	gfCTappableCollectableComponent::listenersDeregisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(fsILevelBasedAppCoreMain::mLevelEntitiesCreatedMsg, this);
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(fsILevelBasedAppCoreMain::mLevelPostResetMsg, this);
}

fsBool gfCLockComponent::messageProcessDo(const fsCUniqueId& pMessageType,
                                           const fsIMessageDispatcher::sMessageParameters& pParam)
{
	if (pMessageType == fsILevelBasedAppCoreMain::mLevelEntitiesCreatedMsg ||
	    pMessageType == fsILevelBasedAppCoreMain::mLevelPostResetMsg)
	{
		activate();
		return false;
	}
	return gfCTappableCollectableComponent::messageProcessDo(pMessageType, pParam);
}

void gfCLockComponent::midCollectionHandle()
{
	if (eCOLLECTION_STATE::eCOLLECTED_EFFECT_PLAYING == stateGet())
	{
		stateSet(eCOLLECTION_STATE::eCOLLECTIBLE);
		gfICollectableComponent::collectionProcessTriggerDo();
	}
}

void gfCLockComponent::serialiseDo()
{
	gfCTappableCollectableComponent::serialiseDo();

	parentGet()->boolSerialise(mInOrderLock);

	lockKeysStateSave();
}

void gfCLockComponent::lockKeysStateSave()
{
	for (auto& lockKey : mKeys)
	{
		parentGet()->boolSerialise(lockKey.second);
	}
}

void gfCLockComponent::deserialiseDo()
{
	gfCTappableCollectableComponent::deserialiseDo();

	mInOrderLock = parentGet()->boolDeserialise();

	lockKeysStateLoad();
}

void gfCLockComponent::lockKeysStateLoad()
{
	for (auto& lockKey : mKeys)
	{
		lockKey.second = parentGet()->boolDeserialise();
	}
}

void gfCLockComponent::smash()
{
	fsBool smashed = false;
	for (auto& key : mKeys)
	{
		if (!key.second)
		{
			smashed = true;
			key.second = true;
		}
	}

	if (smashed)
	{
		gfICollectableComponent::collectionProcessTriggerDo();
	}
}

void gfCLockComponent::deactivateDo()
{
	gfCTappableCollectableComponent::deactivateDo();
	for (auto& key : mKeys)
	{
		key.second = false;
	}
}

void gfCLockComponent::collectionProcessTriggerDo()
{
	fsStr hintTextKey = "HINT-";
	for (auto key : mKeys)
	{
		if (key.second == false)
		{
			hintTextKey += key.first + "-";<--- Consider using std::accumulate algorithm instead of a raw loop.
		}
	}

	if (!mTaskName.emptyGet())
	{
		hintTextKey += mTaskName + "+";
	}

	hintTextKey += fsCNameComponent::get(parentGet())->nameSansPrefixGet();
	fsStr displayString;
	if (fsCLocalisedStrings::localisedStringGetIfExists(hintTextKey, displayString))
	{
		fsCNotificationsGui::instanceGet()->notificationAddToQueue(displayString);
	}
	else
	{
		hintTextKey.replaceAll("HINT-", "hint-");
		if (fsCLocalisedStrings::localisedStringGetIfExists(hintTextKey, displayString))
		{
			fsCNotificationsGui::instanceGet()->notificationAddToQueue(displayString);
		}
	}
}

void gfCLockComponent::onCollectionEffectCompleteDo()
{
	if (!mTaskName.emptyGet())
	{
		fsCAppMessageDispatcher::instanceGet()->messageDispatch(gfCTaskComponent::mTaskCompleteMsg,
		                                                        fsIMessageDispatcher::sStrMessageParam(mTaskName));
	}
	else
	{
		gfICollectableComponent::onCollectionEffectCompleteDo();
	}
}

void gfCLockComponent::initialiseFromName()
{
	fsStr entName = fsCNameComponent::get(parentGet())->nameSansSuffixGet();
	entName.erase(0, mEntityPrefix.dataSizeGet() + 1);

	if (0 == entName.find(mInOrderPrefix))
	{
		entName.erase(0, mEntityPrefix.dataSizeGet() + 1);
		mInOrderLock = true;
	}

	while (fsStr::npos != entName.find("-"))
	{
		const fsStr keyName = entName.chomp("-");
		mKeys.push_back(std::pair<fsStr, fsBool>(keyName, false));
	}

	if (fsStr::npos != entName.find(fsCNameComponent::mTaskChar))
	{
		mTaskName = entName.chomp("+");
		hintStringExistsCheck();
	}

	fsAssert(mKeys.empty() == false, "Expected lock %s to require keys to unlock.\n", parentGet()->nameGet().utf8Get());
}

void gfCLockComponent::hintStringExistsCheck() const
{
#if defined fsDEBUG
	fsStr hintTextKey = fsCNameComponent::get(parentGet())->nameSansSuffixGet();
	hintTextKey.erase(0, hintTextKey.find('-') + 1);
	hintTextKey = "HINT-" + hintTextKey;
	fsStr displayString;
	if (!fsCLocalisedStrings::localisedStringGetIfExists(hintTextKey, displayString))
	{
		hintTextKey.replaceAll("HINT-", "hint-");
		if (!fsCLocalisedStrings::localisedStringGetIfExists(hintTextKey, displayString))
		{
			displayString = "Missing string entry for " + hintTextKey;
			fsCNotificationsGui::instanceGet()->notificationAddToQueue(displayString);
		}
	}
#endif
}

fsBool gfCLockComponent::keyOver(fsCEntity* const pDragDropEnt)
{
	return parentGet()->spriteComponentGet()->hitTest(pDragDropEnt->spriteComponentGet(), true);
}

fsBool gfCLockComponent::keyUsable(fsCEntity* const pKeyEnt)
{
	auto keyIt = keyLocate(fsCNameComponent::get(pKeyEnt)->nameSansPrefixGet());
	return mKeys.end() != keyIt && keyIt->second == false;
}

fsBool gfCLockComponent::keyConsumable(fsCEntity* const pKeyEnt, fsCEntity* const pDragDropEnt)
{
	return keyUsable(pKeyEnt) && keyOver(pDragDropEnt);
}

fsBool gfCLockComponent::keyConsumed(fsCEntity* const pKeyEnt, fsCEntity* const pDragDropEnt)
{
	if (keyConsumable(pKeyEnt, pDragDropEnt))
	{
		auto keyIt = keyLocate(fsCNameComponent::get(pKeyEnt)->nameSansPrefixGet());
		keyIt->second = true;
		if (!lockedGet())
		{
			gfICollectableComponent::collectionProcessTriggerDo();
		}
		return true;
	}
	return false;
}

std::vector<std::pair<fsStr, fsBool>>::iterator gfCLockComponent::keyLocate(const fsStr& pKeyName)
{
	if (mInOrderLock)
	{
		auto firstUnusedKey = std::find_if(mKeys.begin(), mKeys.end(),
		                                   [](std::pair<fsStr, fsBool> keyIt)
		                                   {
			                                   return keyIt.second == false;
		                                   });

		if (firstUnusedKey != mKeys.end() && firstUnusedKey->first == pKeyName)
		{
			return firstUnusedKey;
		}
	}
	else
	{
		for (auto keyIt = mKeys.begin(); keyIt != mKeys.end(); ++keyIt)
		{
			if (keyIt->first == pKeyName)
			{<--- Consider using std::find_if algorithm instead of a raw loop.
				return keyIt;
			}
		}
	}
	return mKeys.end();
}

fsBool gfCLockComponent::lockedGet() const
{
	for (auto key : mKeys)<--- Consider using std::any_of algorithm instead of a raw loop.
	{
		if (false == key.second)
		{
			return true;
		}
	}
	return false;
}

fsIComponent* gfCLockComponent::create(fsCEntity* pParent)
{
	gfCLockComponent* const lockComp = new gfCLockComponent(pParent);

	gfCGhostSpriteComponent* ghostSprComp = pParent->componentAdd<gfCGhostSpriteComponent>();
	ghostSprComp->parentEntityInteractiveSet(true);
	lockComp->mGhostSpriteComp = ghostSprComp;

	lockComp->initialiseFromName();
	return lockComp;
}

gfCLockComponent::gfCLockComponent(fsCEntity* const pParent) :
	gfCTappableCollectableComponent(pParent),
	mInOrderLock(false)
{
}

gfCLockComponent::~gfCLockComponent()
{
}