Cppcheck report - Fission: gameModules/gfMinigameCore/components/jigsaw/gfCJigsawMinigameComponent.cpp

#include "gfCJigsawMinigameComponent.h"

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

#include <fsAppCore/fsIDisplay.h>
#include <fsRenderer/src/fsCBrush.h>
#include <fsRenderer/src/fsCBrushManager.h>
#include <fsRenderer/src/components/fsCSpriteComponent.h>
#include <fsAppCore/src/components/fsCNameComponent.h>
#include <fsAppCore/src/fsCEntityFactory.h>
#include <fsAppCore/src/fsILevelBasedAppCoreMain.h>
#include <fsAppCore/src/fsCAppMessageDispatcher.h>
#include <fsAppCore/src/fsCProfileManager.h>

#include <fsAudio/fsIAudioManager.h>

#include "components/gfCDrawOrderControllerComponent.h"
#include "gfCJigsawCluster.h"
#include "gfCJigsawDrawerComponent.h"
#include "gfCJigsawStencil.h"
#include "gfCJigsawComponentCutter.h"
#include "gfCJigsawLogicComponent.h"
#include "gfComponents/components/gfCGhostSpriteComponent.h"
#include "gfComponents/components/subScene/gfCSubSceneComponent.h"

const fsCUniqueId gfCJigsawMinigameComponent::mTypeId("gfCJigsawMinigameComponent");
const fsCUniqueId gfCJigsawMinigameComponent::mToggleEdgesMsg("toggleEdges");
const fsCUniqueId gfCJigsawMinigameComponent::mJigssawDroppedPieceMsg("jigsawDroppedPiece");
const fsStr gfCJigsawMinigameComponent::mEntityPrefix("JIG");
const fsStr gfCJigsawMinigameComponent::mStartSuffix("-start");

#define TOP_BORDER 10
#define BOTTOM_BORDER 10
fsS32 gfCJigsawMinigameComponent::mBorderTop(TOP_BORDER);
fsS32 gfCJigsawMinigameComponent::mBorderBottom(BOTTOM_BORDER);

fsPoint gfCJigsawMinigameComponent::mBaseSize(0, 0);
fsPoint gfCJigsawMinigameComponent::mMaxPos(0, 0);
fsPoint gfCJigsawMinigameComponent::mMinPos(0, 0);
fsBool gfCJigsawMinigameComponent::mClusteringEnabled(false);
fsS32 gfCJigsawMinigameComponent::mHomePositionThreshold(16);


void gfCJigsawMinigameComponent::gameLogicSet(gfCJigsawLogicComponent* const pParentLogic)
{
	mGameLogic = pParentLogic;	
}

fsBool gfCJigsawMinigameComponent::activePickAndPlaceStartPiece() const
{
	return mStartPair && fsStr::npos != fsCNameComponent::get(parentGet())->nameSansSuffixGet().
		find(gfCJigsawMinigameComponent::mStartSuffix)
	&& !mStartPair->componentGet<gfCJigsawMinigameComponent>()->completedGet();
	
}

gfCDrawOrderControllerComponent* const gfCJigsawMinigameComponent::drawOrderGet() const
{
	return  fsCAppCoreMain::instanceGet()->sceneGet()->firstEntityWithComponentsOfFamilyType<gfCDrawOrderControllerComponent>()->
				componentGet<gfCDrawOrderControllerComponent>();
}

gfCJigsawDeckComponent* const gfCJigsawMinigameComponent::deckGet() const
{
	return  fsCAppCoreMain::instanceGet()->sceneGet()->firstEntityWithComponentsOfFamilyType<gfCJigsawDeckComponent>()->
				componentGet<gfCJigsawDeckComponent>();
}

void gfCJigsawMinigameComponent::relink()
{
	fsINode* const grandparent = grandparentGet();
	grandparent->childRemove(parentGet());
	grandparent->childAdd(parentGet());
	listenersDeregister();
	listenersRegister();
}

void gfCJigsawMinigameComponent::unlink()
{
	if (mStartPair)
	{
		return;
	}
	
	grandparentGet()->childRemove(moveEntityGet());
}

void gfCJigsawMinigameComponent::link(fsCEntity* pParent)
{
	if (mStartPair)
	{
		return;
	}
	
	fsVec2d screenPos;
	if (mShadowEntity)
	{
		pParent->childAdd(mShadowEntity);
		pParent->screenCoordConvertToLocal(mShadowEntity->screenPositionGet(), screenPos);
		mShadowEntity->posSet(screenPos);
		mShadowEntity->matrixUpdate();
	}

	pParent->childAdd(moveEntityGet());
	pParent->screenCoordConvertToLocal(moveEntityGet()->screenPositionGet(), screenPos);
	moveEntityGet()->posSet(screenPos);

	grandparentGet()->matrixUpdate();
}

void gfCJigsawMinigameComponent::drawOrderUpdate()
{
	if (!mStartPair)
	{
		parentGet()->pushToBackOfSiblings();
	}
	drawOrderGet()->drawableEntitiesCreate();
}

void gfCJigsawMinigameComponent::homePositionRangesGet()
{
	if (mMaxPos == fsPoint(0, 0) && mMinPos == fsPoint(0, 0))
	{
		auto jigsawSiblings = siblingssGet();
		for (gfCJigsawMinigameComponent* const jigComp : jigsawSiblings)
		{
			fsPoint originalHomePos = jigComp->mHomePosition.originalHomeGet();
			if (originalHomePos.x > mMaxPos.x)
			{
				mMaxPos.x = originalHomePos.x;
			}
			if (originalHomePos.x < mMinPos.x)
			{
				mMinPos.x = originalHomePos.x;
			}
			if (originalHomePos.y > mMaxPos.y)
			{
				mMaxPos.y = originalHomePos.y;
			}
			if (originalHomePos.y < mMinPos.y)
			{
				mMinPos.y = originalHomePos.y;
			} 
		}
	}
}

void gfCJigsawMinigameComponent::edgePiecesOnlyToggle()
{
	homePositionRangesGet();

	auto jigsawSiblings = siblingssGet();
	for (gfCJigsawMinigameComponent* const jigComp : jigsawSiblings)
	{
		const fsPoint originalHomePos = jigComp->mHomePosition.originalHomeGet();

		if (!
			// (originalHomePos.x == mMinPos.x || originalHomePos.x == mMaxPos.x ||
			(originalHomePos.y == mMinPos.y || originalHomePos.y == mMaxPos.y))
		{
			jigComp->parentGet()->visibleSet(!jigComp->parentGet()->visibleGet());
		}
	}
}

void gfCJigsawMinigameComponent::bordersRegister(fsS32 pTop, fsS32 pBottom)<--- Either there is a missing 'override', or the member function 'gfCJigsawMinigameComponent::bordersRegister' can be static.
{
	mBorderTop = pTop;
	mBorderBottom = pBottom;
}

void gfCJigsawMinigameComponent::homePositonModify(const fsPoint& pAdjustment, fsBool pFirstTime)
{
	mHomePosition.offsetSet(pAdjustment);
	if ((!pFirstTime && homePositionWithinLimits()) || mInHomePosition)
	{
		completionStateUpdate(true, false);
	}
}

fsBool gfCJigsawMinigameComponent::messageProcessDo(const fsCUniqueId& pMessageType,
                                                    const fsIMessageDispatcher::sMessageParameters& pParam)
{
	if (pMessageType == fsILevelBasedAppCoreMain::mLevelInitialisedMsg)
	{
		if (mClusteringEnabled)
		{
			gfCJigsawCluster::clustersRelink(this);
			return true;
		}
		return false;
	}

	if (acceptingInputGet())
	{
		const auto& param = static_cast<const fsIInputManager::sPointerMsgParam&>(pParam);
		if (pMessageType == fsIInputManager::mPointerDownMsg && 0 == param.mIdx)
		{
			if (hitTest(param.mPos))
			{
				if (mStartPair)
				{
					parentGet()->skipMeSet(true);
					mStartPair->visibleSet(true);
					mStartPair->posSet(parentGet()->posGet());
				}
				else
				{
					gfCJigsawCluster::clusterFncExecute(this, &gfCJigsawMinigameComponent::shadowCreate);
				}
			}
		}
		else if (pMessageType == fsIInputManager::mPointerUpMsg && 0 == param.mIdx)
		{
			gfCJigsawCluster::clusterFncExecute(this, &gfCJigsawMinigameComponent::shadowDestroy);
			fsCAppMessageDispatcher::instanceGet()->messageDispatch(mJigssawDroppedPieceMsg,
			                                                        fsIMessageDispatcher::mNullParam);
		}
		else if (pMessageType == mToggleEdgesMsg)
		{
			edgePiecesOnlyToggle();
			return true;
		}

		if (fsCProfileManager::instanceGet()->userSavedDataGet()->cheatModeGet(fsCUserSavedData::eCHEAT_MODE::eDEV))
		{
			if (pMessageType == fsIInputManager::mPointerDownMsg && 1 == param.mIdx)
			{
				if (mShadowEntity)
				{
					mShadowEntity->posSet(fsPoint(mHomePosition.get().x + 8, mHomePosition.get().y));
					mShadowEntity->angleSet(0);
					return true;
				}
			}
		}
	}

	return gfIMinigameComponent::messageProcessDo(pMessageType, pParam);
}

void gfCJigsawMinigameComponent::listenersDeregisterDo()
{
	gfIMinigameComponent::listenersDeregisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(mToggleEdgesMsg, this);
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(fsILevelBasedAppCoreMain::mLevelInitialisedMsg, this);
	//	fsIInputManager::instanceGet()->listenerDeregister( fsIInputManager::mPointerDownMsg, this );		// deregistered up in gesture component
}

void gfCJigsawMinigameComponent::listenersRegisterDo()
{
	gfIMinigameComponent::listenersRegisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(mToggleEdgesMsg, this);
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(fsILevelBasedAppCoreMain::mLevelInitialisedMsg, this);
	//	fsIInputManager::instanceGet()->listenerRegister( fsIInputManager::mPointerDownMsg, this );			// registered up in gesture component
}

void gfCJigsawMinigameComponent::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(), 16);

	fsISpriteComponent* sc = parentGet()->spriteComponentGet();
	sc->brushSet(brush);
	mCutFromStencil = true;
	mBaseSize.x = pStencil->baseWidthGet();
	mBaseSize.y = pStencil->baseHeigthGet();
}

void gfCJigsawMinigameComponent::onTap(const fsPoint& pTapPos)
{
	if (mClusteringEnabled)
	{
		gfCJigsawCluster::clusterFncExecute(this, &gfCJigsawMinigameComponent::angleRotate);
		gfCJigsawCluster::clusterFncExecute(this, &gfCJigsawMinigameComponent::pieceDrop);
	}
	else 
	{
		if (++mCurrRotStep >= fsNMaths::absS32(mNumRotSteps))
		{
			mCurrRotStep = 0;
		}
		angleSet(mClusteringEnabled);
		pieceDrop();
	}

}

void gfCJigsawMinigameComponent::moveHome()
{
	auto* const jigComp = moveEntityGet()->componentGet<gfCJigsawMinigameComponent>();
	jigComp->mInHomePosition = true;
	jigComp->parentGet()->posSet(jigComp->mHomePosition.get());
	jigComp->mCurrRotStep = 0;
	angleSet(false);
	if (mStartPair)
	{
		mInHomePosition = true;
	}
}

void gfCJigsawMinigameComponent::completionFinalise(fsBool pShowCompletion)
{
	moveHome();

	if (mStartPair)
	{
		completionStateUpdate(true, false);
		mStartPair->componentGet<gfCJigsawMinigameComponent>()->completionStateUpdate(true, pShowCompletion);
	}
	else
	{
		completionStateUpdate(true, pShowCompletion);
	}
}

void gfCJigsawMinigameComponent::shadowDestroy()
{
	if (mShadowEntity)
	{
		mShadowEntity->destroy();
		mShadowEntity = nullptr;
	}
}

void gfCJigsawMinigameComponent::shadowCreate()
{
	mShadowEntity = parentGet()->entityFactoryGet()->entityConstruct("shadow");
	auto* sprt = mShadowEntity->spriteComponentGet();
	sprt->brushSet(parentGet()->spriteComponentGet()->brushGet());
	sprt->colourSet(fsSColour4B(0, 0, 0., 128));
	grandparentGet()->childAdd(mShadowEntity);
	mShadowEntity->posSet(fsPoint(parentGet()->posGet().x + 8, parentGet()->posGet().y + 8));
	mShadowEntity->angleSet(parentGet()->angleGet());
	mShadowEntity->pushToBackOfSiblings();
	mShadowEntity->matrixUpdate();

	moveBegin(fsPoint(0, 0));
}

void gfCJigsawMinigameComponent::onDragStart(const fsPoint& pStartPos)
{
	gfCJigsawCluster::clusterMoveFncExecute(this, &gfCJigsawMinigameComponent::moveBegin, pStartPos);
	//	fsCGameMessageDispatcher::instanceGet()->priorityListenerRegister(this);
}

void gfCJigsawMinigameComponent::onDragMove(const fsPoint& pCurrPos)
{
	positionUpdateFromDrag(pCurrPos);
}

void gfCJigsawMinigameComponent::onDragEnd(const fsPoint& pEndPos)
{
	positionUpdateFromDrag(pEndPos);
	pieceDrop();
}

void gfCJigsawMinigameComponent::completionFinalise()
{
	completionFinalise(true);
}

void gfCJigsawMinigameComponent::playSFX(const fsStr& pName) const
{
	fsStr effectName = fsCAppCoreMain::instanceGet()->settingsGet()->strGetWithDefault(
		pName, "audio/sfx/find.wav");
	fsIAudioManager::instanceGet()->effectPlay(
		fsCResourceName(effectName, fsCResourceName::eRES_LOCATION_ASSETS));
}

void gfCJigsawMinigameComponent::posSet(fsPoint const& pPos)<--- Either there is a missing 'override', or the member function 'gfCJigsawMinigameComponent::posSet' can be static.
{
}

void gfCJigsawMinigameComponent::droppedPiece()
{
	drawOrderGet()->dropPiece(this);
}

void gfCJigsawMinigameComponent::pieceDrop()
{
	if (mClusteringEnabled)
	{
		if (homePositionWithinLimits())
		{
			gfCJigsawCluster::clusterFncExecute(this, &gfCJigsawMinigameComponent::droppedPiece);
			gfCJigsawCluster::clusterFncExecute(this, &gfCJigsawMinigameComponent::drawOrderUpdate);
			gfCJigsawCluster::clusterFncExecute(this, &gfCJigsawMinigameComponent::completionFinalise);
			playSFX("sfxJigsawDropInPlace");
		}
		else
		{
			gfCJigsawCluster::clusterCreate(this);
			gfCJigsawCluster::clusterFncExecute(this, &gfCJigsawMinigameComponent::droppedPiece);
			playSFX("sfxJigsawDropMiss");
		}
	}
	else
	{
		if (homePositionWithinLimits())
		{
			droppedPiece();
			drawOrderUpdate();
			completionFinalise(true);
			playSFX("sfxJigsawDropInPlace");
		}
		else
		{
			droppedPiece();
			if (mStartPair)
			{
				mStartPair->visibleSet(false);
				parentGet()->skipMeSet(false);
			}
			playSFX("sfxJigsawDropMiss");
		}
	}
}

void gfCJigsawMinigameComponent::positionRegulate(fsPoint& pDragPos) const
{
	fsISpriteComponent* const sprtCmp = parentGet()->visibleGet() ? parentGet()->spriteComponentGet() :
		mStartPair->spriteComponentGet();
	fsS32 border = sprtCmp->widthGet() / 2;

	if (pDragPos.x < (-fsIDisplay::instanceGet()->designCanvasWidthGet() / 2 + border))
	{
		pDragPos.x = (-fsIDisplay::instanceGet()->designCanvasWidthGet() / 2 + border);
	}
	else if (pDragPos.x > (fsIDisplay::instanceGet()->designCanvasWidthGet() / 2 - border))
	{
		pDragPos.x = (fsIDisplay::instanceGet()->designCanvasWidthGet() / 2 - border);
	}

	const fsS32 topOrBottom = (pDragPos.y < 0) ? mBorderTop : mBorderBottom;
	border = (sprtCmp->heightGet() / 2 <= topOrBottom) ? topOrBottom : sprtCmp->heightGet() / 2;

	if (pDragPos.y < (-fsIDisplay::instanceGet()->designCanvasHeightGet() / 2 + border))
	{
		pDragPos.y = (-fsIDisplay::instanceGet()->designCanvasHeightGet() / 2 + border);
	}
	else if (pDragPos.y > (fsIDisplay::instanceGet()->designCanvasHeightGet() / 2 - border))
	{
		pDragPos.y = (fsIDisplay::instanceGet()->designCanvasHeightGet() / 2 - border);
	}
}

void gfCJigsawMinigameComponent::positionUpdateFromDrag(const fsPoint& pDragPos)
{
	fsVec2d localDragPos;
	fsINode* const moveTarget = moveEntityGet();

	moveTarget->parentGet()->screenCoordConvertToLocal(pDragPos, localDragPos);

	if (localDragPos.x != (-fsIDisplay::instanceGet()->designCanvasWidthGet() / 2) &&
		localDragPos.y != (-fsIDisplay::instanceGet()->designCanvasHeightGet() / 2))
	{
		fsPoint newPos = moveTarget->posGet() + (localDragPos - mPrevDragPos);
		positionRegulate(newPos);
		fsPoint adjustedNewDragPos = newPos - moveTarget->posGet() + mPrevDragPos;
		gfCJigsawCluster::clusterMoveFncExecute(this, &gfCJigsawMinigameComponent::move, adjustedNewDragPos);
	}
}

fsBool gfCJigsawMinigameComponent::homePositionWithinLimits()
{
	gfCJigsawMinigameComponent* const jigComp = moveEntityGet()->componentGet<gfCJigsawMinigameComponent>();
	const fsPoint deltaToHome = (jigComp->mHomePosition.get() - jigComp->parentGet()->posGet());
	if (fsNMaths::absS32(deltaToHome.x) < mHomePositionThreshold &&
		fsNMaths::absS32(deltaToHome.y) < mHomePositionThreshold &&
		0 == mCurrRotStep)
	{
		return true;
	}
	return false;
}

std::vector<gfCJigsawMinigameComponent*> gfCJigsawMinigameComponent::siblingssGet()
{
	auto jigEnts = fsCAppCoreMain::instanceGet()->sceneGet()->entitiesWithComponentsOfFamilyType<gfCJigsawMinigameComponent>();
	std::vector<gfCJigsawMinigameComponent*> jigComps;
	for (fsCEntity* slidaEnt : jigEnts)
	{
		jigComps.push_back(slidaEnt->componentGet<gfCJigsawMinigameComponent>());<--- Consider using std::transform algorithm instead of a raw loop.
	}
	return jigComps;
}

void gfCJigsawMinigameComponent::move(const fsPoint& pNewDragPos)
{
	fsINode* const moveTarget = moveEntityGet();
	moveTarget->posSet(moveTarget->posGet() + (pNewDragPos - mPrevDragPos));
	mPrevDragPos = pNewDragPos;

	if (mShadowEntity)
	{
		const fsU32 shadowOffset = 8;
		mShadowEntity->posSet(fsPoint(moveTarget->posGet().x + shadowOffset,
		                              moveTarget->posGet().y + shadowOffset));
		mShadowEntity->angleSet(parentGet()->angleGet());
	}
}

void gfCJigsawMinigameComponent::moveBegin(const fsPoint& pNewDragPos)
{
	fsCEntity* const moveTarget = moveEntityGet();
	fsVec2d localPos;
	moveTarget->parentGet()->screenCoordConvertToLocal(pNewDragPos, localPos);
	mPrevDragPos = localPos;
	if(mShadowEntity)
	{
		mShadowEntity->bringToFrontOfSiblings();
	}
	moveTarget->bringToFrontOfSiblings();
	unlink();
	link(mGameLogic->desktopGet());
}

fsCEntity* const gfCJigsawMinigameComponent::moveEntityGet() const
{
	return nullptr != mStartPair ? mStartPair : parentGet();
}

void gfCJigsawMinigameComponent::serialiseDo()
{
	gfIMinigameComponent::serialiseDo();
	parentGet()->pointSerialise(parentGet()->posGet());
	parentGet()->s32Serialise(mCurrRotStep);
	parentGet()->boolSerialise(mInHomePosition);
	parentGet()->boolSerialise(mCutFromStencil);

	if (!mStartPair)
	{
		parentGet()->strSerialise(gfCJigsawCluster::saveLink(mNextInCluster));
		parentGet()->strSerialise(gfCJigsawCluster::saveLink(mPrevInCluster));
	}
}

void gfCJigsawMinigameComponent::deserialiseDo()
{
	gfIMinigameComponent::deserialiseDo();
	parentGet()->posSet(parentGet()->pointDeserialise());
	mCurrRotStep = parentGet()->s32Deserialise();
	mInHomePosition = parentGet()->boolDeserialise();
	mCutFromStencil = parentGet()->boolDeserialise();

	if (!mStartPair)
	{
		gfCJigsawCluster::loadLink(mNextInCluster, parentGet()->strDeserialise());
		gfCJigsawCluster::loadLink(mPrevInCluster, parentGet()->strDeserialise());
	}

	angleSet(false);

	if (!mCutFromStencil)
	{
		// cut from stencil components have home position modified before completion check is run
		if (mInHomePosition)
		{
			fsStr pieceName = fsCNameComponent::get(parentGet())->nameSansSuffixGet();
			if (fsStr::npos == pieceName.find(mStartSuffix))
			{
				completionFinalise(false);
				if (mStartPair)
				{
					mStartPair->skipMeSet(true);
				}
			}
		}
	}
}

gfCJigsawMinigameComponent* const gfCJigsawMinigameComponent::namedSiblingsGet(const fsStr& pName)
{
	auto siblings = siblingssGet();
	auto match = std::find_if(siblings.begin(), siblings.end(),
	                          [pName](gfCJigsawMinigameComponent* const sibling)
	                          {
		                          return fsCNameComponent::get(sibling)->nameSansPrefixGet() == pName;
	                          });

	return *match;
}

void gfCJigsawMinigameComponent::startEntitiesLocate()
{
	if (!mStartPair)
	{
		auto jigsawSiblings = siblingssGet();
		for (gfCJigsawMinigameComponent* startPair : jigsawSiblings)
		{
			fsStr startName = fsCNameComponent::get(startPair)->nameSansSuffixGet();
			if (fsStr::npos != startName.find(mStartSuffix))
			{
				startName.erase(startName.find(mStartSuffix));

				for (gfCJigsawMinigameComponent* pairSibling : jigsawSiblings)
				{
					fsStr pieceName = fsCNameComponent::get(pairSibling)->nameSansSuffixGet();
					if (startName == pieceName)
					{
						pairSibling->mStartPair = startPair->parentGet();
						startPair->mStartPair = pairSibling->parentGet();

						auto extraEntForHint = parentGet()->entityFactoryGet()->emptyEntityCreate("ghostEntity");
						extraEntForHint->posSet(pairSibling->parentGet()->posGet());
						startPair->grandparentGet()->parentGet()->childAdd(extraEntForHint);

						startPair->mGhostSprite = startPair->parentGet()->componentAdd<gfCGhostSpriteComponent>();
						startPair->mOtherGhost = extraEntForHint->componentAdd<gfCGhostSpriteComponent>();
						startPair->mOtherGhost->sourceSpriteSet(pairSibling->parentGet()->spriteComponentGet());

						pairSibling->parentGet()->visibleSet(false);
						break;
					}
				}
			}
		}
	}
}

void gfCJigsawMinigameComponent::hintPieceAndHomeSlot()
{
		mGhostSprite->forceVisibleSet(true);
		mOtherGhost->forceVisibleSet(true);
}

void gfCJigsawMinigameComponent::resetDo()
{
	mInHomePosition = false;
	mNextInCluster = nullptr;
	mPrevInCluster = nullptr;

	if (mStartPair)
	{
		gfCJigsawMinigameComponent* startJigComp;
		gfCJigsawMinigameComponent* moveableJigComp;
		fsStr pieceName = fsCNameComponent::get(this)->nameSansSuffixGet();
		if (fsStr::npos != pieceName.find(mStartSuffix))
		{
			startJigComp = this;
			moveableJigComp = mStartPair->componentGet<gfCJigsawMinigameComponent>();
		}
		else //if (fsStr::npos == pieceName.find(mStartSuffix))
		{
			moveableJigComp = this;
			startJigComp = mStartPair->componentGet<gfCJigsawMinigameComponent>();
		}

		moveableJigComp->parentGet()->posSet(startJigComp->mHomePosition.get());
		moveableJigComp->mCurrRotStep = 0;
		moveableJigComp->angleSet(mClusteringEnabled);
		moveableJigComp->parentGet()->visibleSet(false);
		moveableJigComp->mInHomePosition = false;

		startJigComp->parentGet()->visibleSet(true);
		startJigComp->mInHomePosition = false;
	}
}

void gfCJigsawMinigameComponent::skipDo()
{
	if (!mInHomePosition)
	{
		if (mStartPair)
		{
			gfCJigsawMinigameComponent* startJigComp;
			gfCJigsawMinigameComponent* moveableJigComp;
			fsStr pieceName = fsCNameComponent::get(this)->nameSansSuffixGet();
			if (fsStr::npos != pieceName.find(mStartSuffix))
			{
				startJigComp = this;
				moveableJigComp = mStartPair->componentGet<gfCJigsawMinigameComponent>();
			}
			else //if (fsStr::npos == pieceName.find(mStartSuffix))
			{
				moveableJigComp = this;
				startJigComp = mStartPair->componentGet<gfCJigsawMinigameComponent>();
			}

			if (!moveableJigComp->mInHomePosition)
			{
				moveableJigComp->mInHomePosition = true;
				moveableJigComp->parentGet()->posSet(moveableJigComp->mHomePosition.get());
				moveableJigComp->mCurrRotStep = 0;
				moveableJigComp->angleSet(mClusteringEnabled);
				moveableJigComp->completionStateUpdate(true, false);
				moveableJigComp->parentGet()->visibleSet(true);

				startJigComp->completionStateUpdate(true, false);
				startJigComp->parentGet()->visibleSet(false);
				startJigComp->mInHomePosition = true;
			}
		}
		else
		{
			moveHome();

			mCurrRotStep = 0;
			angleSet(mClusteringEnabled);
			completionStateUpdate(true, false);
			drawOrderUpdate();
		}
	}
}

//#define DEBUG_EASY_START
void gfCJigsawMinigameComponent::randomPositionSet(const fsCVariableTable& pVars)
{
#if defined fsDEBUG && defined DEBUG_EASY_START
	parentGet()->posSet(fsPoint(parentGet()->posGet().x + 10, parentGet()->posGet().y + 10));
#else
	parentGet()->posSet(deckGet()->startSlotPop());
#endif
}

void gfCJigsawMinigameComponent::randomRotationSet(const fsCVariableTable& pVars)
{
	const fsS32 rotAngle = pVars.s32Get("rotationStep");
	if (rotAngle)
	{
		gestureTypesSet(true, true, false);
		fsAssert((360 % rotAngle) == 0, "Jigsaw rotation angle must be a fraction of 360.\n");
		mNumRotSteps = 360 / rotAngle;
#if !(defined fsDEBUG && defined DEBUG_EASY_START)
		mCurrRotStep = fsNRnd::uInt32GetWithLimit(fsNMaths::absS32(mNumRotSteps));
		angleSet(mClusteringEnabled);
#endif
	}
}

void gfCJigsawMinigameComponent::angleRotate()
{
	if (++mCurrRotStep >= fsNMaths::absS32(mNumRotSteps))
	{
		mCurrRotStep = 0;
	}
	angleSet(mClusteringEnabled);
}

void gfCJigsawMinigameComponent::positionRelativeTo(gfCJigsawMinigameComponent* const pPiece) const
{
	fsPoint homeDiff = mHomePosition.get() - pPiece->mHomePosition.get();
	if (mCurrRotStep == 1)
	{
		auto tmp = homeDiff.x;
		homeDiff.x = homeDiff.y;
		homeDiff.y = -tmp;
	}
	else if (mCurrRotStep == 2)
	{
		homeDiff.x = -homeDiff.x;
		homeDiff.y = -homeDiff.y;
	}
	else if (mCurrRotStep == 3)
	{
		auto tmp = homeDiff.x;
		homeDiff.x = -homeDiff.y;
		homeDiff.y = tmp;
	}
	const fsPoint newPos = pPiece->parentGet()->posGet() + homeDiff;
	parentGet()->posSet(newPos);
}

void gfCJigsawMinigameComponent::angleSet(fsBool pPosSetRelativeToRoot)
{
	if (mNumRotSteps)
	{
		const auto newAngle = ((fsNMaths::fsPI * 2) / mNumRotSteps) * mCurrRotStep;
		if (pPosSetRelativeToRoot)
		{
			positionRelativeTo(gfCJigsawCluster::rootGet(this));
		}
		parentGet()->angleSet(newAngle);
	}
}

fsBool gfCJigsawMinigameComponent::acceptingInputGet() const
{
	return !mInHomePosition;
}

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

void gfCJigsawMinigameComponent::staticsReset()
{
	mMaxPos = fsPoint(0, 0);
	mMinPos = fsPoint(0, 0);

	mBorderBottom = BOTTOM_BORDER;
	mBorderTop = TOP_BORDER;

	mClusteringEnabled = false;

	mHomePositionThreshold = 16;
}

void gfCJigsawMinigameComponent::initialiseDo(const fsCVariableTable& pVars)
{
	mHomePosition.set(parentGet()->posGet());

	startEntitiesLocate();

	mClusteringEnabled = pVars.boolGetWithDefault("clusteringEnabled", false);
	mHomePositionThreshold = pVars.s32GetWithDefault("homePositionThreshold", 16);

	if (!mStartPair)
	{
		randomPositionSet(pVars);
		randomRotationSet(pVars);
	}
}

gfCJigsawMinigameComponent::gfCJigsawMinigameComponent(fsCEntity* const pParent) :
	gfIMinigameComponent(pParent),
	mPrevDragPos(fsPoint(0, 0)),
	mNumRotSteps(0),
	mCurrRotStep(0),
	mInHomePosition(false),
	mShadowEntity(nullptr),
	mStartPair(nullptr),
	mCutFromStencil(false),
	mNextInCluster(nullptr),
	mPrevInCluster(nullptr),
	mGameLogic(nullptr),
	mGhostSprite(nullptr),
	mOtherGhost(nullptr)
{
	staticsReset();

	gestureTypesSet(false, true, false);
	// if (!mStartSlots)
	// {
	// 	mStartSlots = new std::vector<fsPoint>;
	// 	mDrawableSiblings.clear();
	// }
}

fsBool gfCJigsawMinigameComponent::isHintableGet() const
{
	return activePickAndPlaceStartPiece();
}

fsBool gfCJigsawMinigameComponent::hintDo()
{
	hintPieceAndHomeSlot();
	return true;
}

gfCJigsawMinigameComponent::~gfCJigsawMinigameComponent()
{
	staticsReset();
}

gfCJigsawMinigameComponent::CHomePosition::CHomePosition() :
	mAdjustment(0, 0),
	mPos(0, 0)
{
}

fsPoint gfCJigsawMinigameComponent::CHomePosition::originalHomeGet() const
{
	return mPos;
}

fsPoint gfCJigsawMinigameComponent::CHomePosition::get() const
{
	return mPos + mAdjustment;
}

void gfCJigsawMinigameComponent::CHomePosition::set(const fsPoint& pPos)
{
	mPos = pPos;
}

void gfCJigsawMinigameComponent::CHomePosition::offsetSet(const fsPoint& pPos)
{
	mAdjustment = pPos;
}

const fsPoint& gfCJigsawMinigameComponent::CHomePosition::offsetGet() const
{
	return mAdjustment;
}