Cppcheck report - Fission: gameModules/gfMinigameCore/components/flipsaw/gfCFlipsawMinigameComponent.cpp

#include "gfCFlipsawMinigameComponent.h"

#include <fsCore/src/fsNRnd.h>
#include <fsCore/src/fsCAppSettings.h>
#include <fsCore/src/debug/fsAssert.h>

#include <fsAudio/fsIAudioManager.h>
#include <fsRenderer/src/components/fsCSpriteComponent.h>
#include <fsRenderer/src/fsCBrushManager.h>
#include <fsRenderer/src/fsCBrush.h>
#include <fsAppCore/src/fsCAppMessageDispatcher.h>

#include "gfCFlipsawMiniGameLogicComponent.h"
#include "../gfIStencil.h"


const fsCUniqueId gfCFlipsawMinigameComponent::mTypeId("gfCFlipsawMinigameComponent");
const fsCUniqueId gfCFlipsawMinigameComponent::mFlipsawPieceSelectedMsg("flipsawPieceSelected");
const fsCUniqueId gfCFlipsawMinigameComponent::mFlipsawAnotherPieceSelectedMsg("flipsawAnotherPieceSelected");
const fsCUniqueId gfCFlipsawMinigameComponent::mFlipsawClearHintTintMsg("flipsawClearTint");
const fsStr gfCFlipsawMinigameComponent::mFlipsawPrefix("FLP");

fsSColour4B gfCFlipsawMinigameComponent::mWrongColourTint(fsSColour4B::fsWHITE());
fsSColour4B gfCFlipsawMinigameComponent::mSelectedColourTint(200, 0, 200, 255);
fsSColour4B gfCFlipsawMinigameComponent::mHintColourTint(0, 200, 0, 255);
fsBool gfCFlipsawMinigameComponent::mLockHomePos(false);


void gfCFlipsawMinigameComponent::gameLogicSet(gfCFlipsawMiniGameLogicComponent* const pParentLogic)
{
	mGameLogic = pParentLogic;	
}

fsBool gfCFlipsawMinigameComponent::selected() const
{
	return mSelected;
}

void gfCFlipsawMinigameComponent::hintSwap()
{
	auto siblingEntities = fsCAppCoreMain::instanceGet()->sceneGet()->entitiesWithComponentsOfFamilyType<gfCFlipsawMinigameComponent>();
	auto home = std::find_if(std::begin(siblingEntities), std::end(siblingEntities),
		[this](fsCEntity const* ent)
		{
			return fsPoint{ent->componentGet<gfCFlipsawMinigameComponent>()->parentGet()->posGet()}
					== mHomePosition;
		});

	auto* sprComp = parentGet()->spriteComponentGet();
	if (!mSelected)
	{
		sprComp->colourSet(mHintColourTint);
		mHinted = true;
	}
	
	sprComp = (*home)->spriteComponentGet();
	sprComp->colourSet(mHintColourTint);
	(*home)->componentGet<gfCFlipsawMinigameComponent>()->mHinted = true;
}

void gfCFlipsawMinigameComponent::cut(std::shared_ptr<fsCBrush> pTexture, gfIStencil* const pStencil)
{
	std::shared_ptr<fsCBrush> brush = fsCBrushManager::instanceGet()->getNoCache(
		pStencil->textureGet()->dimensionsGet().x, pStencil->textureGet()->dimensionsGet().y);
	brush->textureCopyThroughStencil(pTexture, pStencil->textureGet(), pStencil->sourceTextureCutXGet(),
	                                 pStencil->sourceTextureCutYGet());

	fsISpriteComponent* const sc = parentGet()->spriteComponentGet();
	sc->brushSet(brush);
}

void gfCFlipsawMinigameComponent::listenersDeregisterDo()
{
	gfCRotateMinigameComponent::listenersDeregisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(mFlipsawPieceSelectedMsg,
	                                                           static_cast<gfIMinigameComponent*>(this));
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(mFlipsawAnotherPieceSelectedMsg,
	                                                           static_cast<gfIMinigameComponent*>(this));
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(mFlipsawClearHintTintMsg,
															   static_cast<gfIMinigameComponent*>(this));
	//	fsIInputManager::instanceGet()->listenerDeregister( fsIInputManager::mPointerDownMsg, this );		// deregistered up in gesture component
	//	fsIInputManager::instanceGet()->listenerDeregister( fsIInputManager::mPointerUpMsg, this );		// deregistered up in gesture component
}

void gfCFlipsawMinigameComponent::listenersRegisterDo()
{
	gfCRotateMinigameComponent::listenersRegisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(mFlipsawPieceSelectedMsg,
	                                                         static_cast<gfIMinigameComponent*>(this));
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(mFlipsawAnotherPieceSelectedMsg,
	                                                         static_cast<gfIMinigameComponent*>(this));
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(mFlipsawClearHintTintMsg,
															 static_cast<gfIMinigameComponent*>(this));
	//	fsIInputManager::instanceGet()->listenerRegister( fsIInputManager::mPointerDownMsg, this );		// deregistered up in gesture component
	//	fsIInputManager::instanceGet()->listenerRegister( fsIInputManager::mPointerUpMsg, this );		// deregistered up in gesture component
}

fsBool gfCFlipsawMinigameComponent::messageProcessDo(const fsCUniqueId& pMessageType,
                                                     const fsIMessageDispatcher::sMessageParameters& pParam)
{
	if (mFlipsawPieceSelectedMsg == pMessageType && mSelected)
	{
		const gfCFlipsawMinigameComponent* const otherFlipComp = static_cast<const sFlipsawEventMsgParam&>(pParam).
			mFlipComp;
		positionsSwap(otherFlipComp);
		homeCheck(true);
		return true;
	}
	if (mFlipsawAnotherPieceSelectedMsg == pMessageType)
	{
		return mSelected;
	}
	if (mFlipsawClearHintTintMsg == pMessageType)
	{
		if (mHinted)
		{
			tintSet();
			mHinted = false;
		}
	}
	if (fsIInputManager::mPointerUpMsg == pMessageType)
	{
		if (!mLockHomePos || fsPoint{parentGet()->posGet()} != mHomePosition)
		{
			const auto& param = static_cast<const fsIInputManager::sPointerMsgParam&>(pParam);
			if (hitTest(param.mPos))
			{
				const fsBool anotherSelected = fsCAppMessageDispatcher::instanceGet()->messageDispatch(
					mFlipsawAnotherPieceSelectedMsg, fsIMessageDispatcher::mNullParam);

				if (mNumRotSteps && !anotherSelected && mRunningTime - mMouseDownTime < 300)
				{
					rotate();
				}
				else
				{
					flip();
				}
				return true;
			}
		}
	}
	return (gfCRotateMinigameComponent::messageProcessDo(pMessageType, pParam));
}

void gfCFlipsawMinigameComponent::flip()
{
	if (mSelected)
	{
		mSelected = false;
	}
	else
	{
		sFlipsawEventMsgParam msgParam(this);
		if (fsCAppMessageDispatcher::instanceGet()->messageDispatch(mFlipsawPieceSelectedMsg, msgParam))
		{
			homeCheck(true);
		}
		else
		{
			mSelected = true;
		}
		if (!mHinted)
		{
			fsCAppMessageDispatcher::instanceGet()->messageDispatch(mFlipsawClearHintTintMsg, msgParam);
		}

	}
	tintSet();
}

void gfCFlipsawMinigameComponent::serialiseDo()
{
	parentGet()->s32Serialise(mNumRotSteps);
	parentGet()->pointSerialise(parentGet()->posGet());

	if (mNumRotSteps)
	{
		gfCRotateMinigameComponent::serialiseDo();
	}
}

void gfCFlipsawMinigameComponent::deserialiseDo()
{
	mNumRotSteps = parentGet()->s32Deserialise();
	parentGet()->posSet(parentGet()->pointDeserialise());

	if (mNumRotSteps)
	{
		gfCRotateMinigameComponent::deserialiseDo();
	}
	else if (homeGet())
	{
		completionStateUpdate(true, false);
	}
	tintSet();
}

void gfCFlipsawMinigameComponent::resetDo()
{
	mInitialised = false;
	mSelected = false;
}

void gfCFlipsawMinigameComponent::homePositionStore()
{
	mHomePosition = parentGet()->posGet();
}

void gfCFlipsawMinigameComponent::initialiseDo(const fsCVariableTable& pVars)
{
	mNumRotSteps = pVars.s32GetWithDefault("stepsFLP", 0);

	if (mNumRotSteps)
	{
		gfCRotateMinigameComponent::initialiseDo(pVars);
	}
	else
	{
		mLockHomeRot = true;
	}

	mLockHomePos = 1 == pVars.s32GetWithDefault("homePosLock", 0);

	if (!mInitialised)
	{
		mWrongColourTint = {pVars.strGetWithDefault("wrongColTint", "ffffffff")};
		mSelectedColourTint = {pVars.strGetWithDefault("selectedColTint", "cd00cdff")};
		mHintColourTint = {pVars.strGetWithDefault("selectedColTint", "00c800ff")};

		auto siblingEntities = mGameLogic->gamePiecesGet();

		for (auto ent : siblingEntities)
		{
			ent->homePositionStore();
		}

		auto s = mGameLogic->gamePiecesGet();
		positionsRandomise(s);

		for (auto ent : siblingEntities)
		{
			ent->initialisationFinalise();
		}
	}

	if (mNumRotSteps)
	{
		gfCRotateMinigameComponent::initialiseDo(pVars);
	}
}

void gfCFlipsawMinigameComponent::initialisationFinalise()
{
	tintSet();
	mInitialised = true;
}

void gfCFlipsawMinigameComponent::positionsRandomise(std::vector<gfCFlipsawMinigameComponent*>& pFlipEnts)<--- Parameter 'pFlipEnts' can be declared as reference to const
{
	const fsS32 numFlipComps = static_cast<fsS32>(pFlipEnts.size());

	fsBool needToShuffle = true;
	while (needToShuffle)
	{
		for (fsS32 shuff = 0; shuff < numFlipComps; ++shuff)
		{
			const fsS32 firstInd = fsNRnd::uInt32GetWithLimit(numFlipComps);
			const fsS32 secondInd = fsNRnd::uInt32GetWithLimit(numFlipComps);
			pFlipEnts[firstInd]->positionsSwap(pFlipEnts[secondInd]);
		}

		needToShuffle = false;
		for (auto* const flipComp : pFlipEnts)
		{
			if (fsPoint{flipComp->parentGet()->posGet()} == flipComp->mHomePosition)
			{
				needToShuffle = true;
				break;
			}
		}
	}
}

void gfCFlipsawMinigameComponent::positionsSwap(const gfCFlipsawMinigameComponent* const pOther) const
{
	if(mGameLogic == pOther->mGameLogic)
	{
		const fsPoint firstPos = parentGet()->posGet();
		parentGet()->posSet(pOther->parentGet()->posGet());
		pOther->parentGet()->posSet(firstPos);
	}
}

void gfCFlipsawMinigameComponent::skipDo()
{
	gfCRotateMinigameComponent::skipDo();
	parentGet()->posSet(mHomePosition);
	mSelected = false;
	tintSet();
	//	completionStateUpdate( true, false );
}

void gfCFlipsawMinigameComponent::tintSet() const
{
	auto* const sprComp = parentGet()->spriteComponentGet();
	fsAssert(sprComp != nullptr, "Expected a sprite component on a Flipsaw entity.\n");
	if (mSelected)
	{
		sprComp->colourSet(mSelectedColourTint);
	}
	else if (fsPoint{parentGet()->posGet()} == mHomePosition)
	{
		sprComp->colourSet(fsSColour4B::fsWHITE());
	}
	else
	{
		sprComp->colourSet(mWrongColourTint);
	}
}

fsBool gfCFlipsawMinigameComponent::homeGet() const
{
	return fsPoint{parentGet()->posGet()} == mHomePosition && gfCRotateMinigameComponent::homeGet();
}

fsBool gfCFlipsawMinigameComponent::fullHomeLock() const
{
	return mLockHomePos || gfCRotateMinigameComponent::fullHomeLock();
}

void gfCFlipsawMinigameComponent::homeCheck(fsBool pPlayEffect)
{
	mSelected = false;
	if (fullHomeLock() && homeGet())
	{
		completionStateUpdate(true, pPlayEffect);
		fsStr effectName = fsCAppCoreMain::instanceGet()->settingsGet()->strGetWithDefault(
			"sfxFlipsawPlacePiece", "audio/sfx/find.wav");
		fsIAudioManager::instanceGet()->effectPlay(fsCResourceName(effectName, fsCResourceName::eRES_LOCATION_ASSETS));
	}
	tintSet();
}

fsBool gfCFlipsawMinigameComponent::acceptingInputGet() const
{
	return (mHomePosition != parentGet()->posGet());
}

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

gfCFlipsawMinigameComponent::gfCFlipsawMinigameComponent(fsCEntity* const pParent) :
	gfCRotateMinigameComponent(pParent),
	mInitialised(false),
	mSelected(false),
	mHinted(false),
	mGameLogic(nullptr)
{
}

fsBool gfCFlipsawMinigameComponent::isActiveGet() const
{
	return selected();
}

fsBool gfCFlipsawMinigameComponent::hintDo()
{
	hintSwap();
	return true;
}

gfCFlipsawMinigameComponent::~gfCFlipsawMinigameComponent()
{
}