Cppcheck report - Fission: gameModules/gfTimeCore/src/gfCParkClearComponent.cpp

#include "gfCParkClearComponent.h"

#include <fsCore/fsPoint.h>
#include <fsCore/fsVec2d.h>
#include <fsCore/fsSColour.h>

#include <fsAppCore/fsIInputManager.h>
#include <fsAppCore/fsIScene.h>
#include <fsAppCore/src/fsCAppCoreMain.h>
#include <fsAppCore/src/fsCEntity.h>
#include <fsAppCore/src/fsCEntityFactory.h>

#include <fsRenderer/src/components/fsCSpriteComponent.h>

#include <fsTileMap/src/fsCView.h>
#include <fsTileMap/fsITileMap.h>

#include "gfCParkLevelComponent.h"
#include "gfCParkGuestViewComponent.h"
#include "sim/gfCParkDaySim.h"
#include "sim/gfCDayEconomySim.h"

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

namespace
{
const fsStr gPreviewEntityName("parkClearPreview");
const fsS32 gPreviewAlpha = 150;

fsNTileMap::fsCView* viewGet()
{
	return dynamic_cast<fsNTileMap::fsCView*>(
		fsCAppCoreMain::instanceGet()->sceneGet()->childFind("tilemapView"));
}

gfCParkLevelComponent* levelGet()
{
	fsIScene* const scene = fsCAppCoreMain::instanceGet()->sceneGet();
	if (fsCEntity* const levelEnt = scene->firstEntityWithComponentsOfFamilyType<gfCParkLevelComponent>())
	{
		return levelEnt->firstComponentOfFamilyType<gfCParkLevelComponent>();
	}
	return nullptr;
}

// One-tile marker size in view-local pixels, from the map's scaled transform.
fsPoint tileLocalSizeGet(fsNTileMap::fsCView* const pView)
{
	const fsPoint topLeft = pView->mapPixelToLocal(fsPoint(0, 0));
	const fsPoint bottomRight = pView->mapPixelToLocal(
		fsPoint(pView->mMap->tileWidthGet(), pView->mMap->tileHeightGet()));
	return fsPoint(bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
}

fsBool pointerOverHudGet(fsIScene* const pScene, const fsPoint& pScreenPos)
{
	const char* const buttonNames[] = {
		"clearButton",
		"shopButton",
		"buildingsCategoryButton",
		"staffCategoryButton",
		"decorationsCategoryButton",
		"backButton",
		"shopMenuScrollLeftButton",
		"shopMenuScrollRightButton",
		"itemButton0", "itemButton1", "itemButton2", "itemButton3",
		"itemButton4", "itemButton5", "itemButton6", "itemButton7"
	};
	for (const char* const buttonName : buttonNames)<--- Consider using std::any_of algorithm instead of a raw loop.
	{
		fsCEntity* const buttonEnt = pScene->childFind(buttonName);
		if (buttonEnt && buttonEnt->visibleGet())
		{
			if (fsISpriteComponent* const sprite = buttonEnt->spriteComponentGet())
			{
				if (sprite->hitTest(pScreenPos, false))
				{
					return true;
				}
			}
		}
	}
	return false;
}
}

void gfCParkClearComponent::clearBegin()
{
	previewDestroy();
	previewCreate();
}

void gfCParkClearComponent::clearEnd()
{
	previewDestroy();
	parentGet()->destroy();
}

void gfCParkClearComponent::previewCreate()
{
	fsNTileMap::fsCView* const view = viewGet();
	if (!view)
	{
		return;
	}

	mPreviewEntity = view->entityFactoryGet()->emptyEntityCreate(gPreviewEntityName);
	mPreviewEntity->componentAdd(fsCSpriteComponent::mTypeId);
	// No brush: a sized, coloured sprite is a solid quad, same as the slot markers.
	if (auto* const sprt = mPreviewEntity->spriteComponentGet())
	{
		const fsPoint tileSize = tileLocalSizeGet(view);
		sprt->widthSet(tileSize.x);
		sprt->heightSet(tileSize.y);
		sprt->colourSet(fsSColour4B(70, 200, 90, gPreviewAlpha));
	}
	view->childAdd(mPreviewEntity);

	// Guests still draw above the targeting marker.
	if (fsCEntity* const guestLayer = view->childFind(gfCParkGuestViewComponent::mGuestLayerName))
	{
		guestLayer->bringToFrontOfSiblings();
	}

	previewUpdate(fsIInputManager::instanceGet()->mousePosGet());
}

void gfCParkClearComponent::previewDestroy()
{
	if (mPreviewEntity)
	{
		mPreviewEntity->destroy();
		mPreviewEntity = nullptr;
	}
}

fsBool gfCParkClearComponent::previewUpdate(const fsPoint& pScreenPos)
{
	mHoverValid = false;
	fsNTileMap::fsCView* const view = viewGet();
	gfCParkLevelComponent* const level = levelGet();
	if (!view || !level)
	{
		return false;
	}

	fsVec2d localPos;
	if (!view->screenCoordConvertToLocal(fsVec2d(pScreenPos.x, pScreenPos.y), localPos))
	{
		return false;
	}

	const fsPoint cell = level->cellFromLocal(view, localPos);
	mHoverCol = cell.x;
	mHoverRow = cell.y;

	// Clearable = forest, adjacent to open ground, affordable. Mirrors the checks
	// forestClearAt makes so the marker never promises a clear that won't happen.
	if (level->cellForestGet(view, mHoverCol, mHoverRow))
	{
		const fsBool touchesOpen =
			level->cellWalkableGet(view, mHoverCol + 1, mHoverRow) ||
			level->cellWalkableGet(view, mHoverCol - 1, mHoverRow) ||
			level->cellWalkableGet(view, mHoverCol, mHoverRow + 1) ||
			level->cellWalkableGet(view, mHoverCol, mHoverRow - 1);
		const gfCParkDaySim* const sim = level->simGet();
		const fsBool affordable =
			sim && sim->economyGet().coinsGet() >= level->forestClearCostGet();
		mHoverValid = touchesOpen && affordable;
	}

	if (mPreviewEntity)
	{
		if (auto* const sprt = mPreviewEntity->spriteComponentGet())
		{
			const fsVec2d centre = level->cellCentreLocal(view, mHoverCol, mHoverRow);
			mPreviewEntity->posSet(centre);
			sprt->colourSet(mHoverValid
				? fsSColour4B(70, 200, 90, gPreviewAlpha)
				: fsSColour4B(235, 70, 70, gPreviewAlpha));
		}
	}
	return mHoverValid;
}

fsBool gfCParkClearComponent::messageProcessDo(const fsCUniqueId& pMessageType,
                                               const fsIMessageDispatcher::sMessageParameters& pParam)
{
	if (fsIInputManager::mPointerDownMsg != pMessageType &&
		fsIInputManager::mPointerMoveMsg != pMessageType)
	{
		return false;
	}

	const auto& params = static_cast<const fsIInputManager::sPointerMsgParam&>(pParam);
	if (0 != params.mIdx)
	{
		return false;
	}

	fsIScene* const scene = fsCAppCoreMain::instanceGet()->sceneGet();
	if (pointerOverHudGet(scene, params.mPos))
	{
		// Yield HUD taps so the clear/shop buttons own their own gesture.
		return false;
	}

	const fsBool valid = previewUpdate(params.mPos);
	if (fsIInputManager::mPointerMoveMsg == pMessageType || !valid)
	{
		// An illegal tap leaves the tool armed - move the marker and try again.
		return true;
	}

	fsNTileMap::fsCView* const view = viewGet();
	gfCParkLevelComponent* const level = levelGet();
	if (view && level)
	{
		level->forestClearAt(view, mHoverCol, mHoverRow);
		// The cleared cell (and its now-open neighbours) re-evaluate on this refresh.
		previewUpdate(params.mPos);
	}
	return true;
}

void gfCParkClearComponent::listenersRegisterDo()
{
	fsIMessageListener::listenersRegisterDo();
	fsIInputManager::instanceGet()->listenerRegister(fsIInputManager::mPointerDownMsg, this);
	fsIInputManager::instanceGet()->listenerRegister(fsIInputManager::mPointerMoveMsg, this);
}

void gfCParkClearComponent::listenersDeregisterDo()
{
	fsIMessageListener::listenersDeregisterDo();
	fsIInputManager::instanceGet()->listenerDeregister(fsIInputManager::mPointerDownMsg, this);
	fsIInputManager::instanceGet()->listenerDeregister(fsIInputManager::mPointerMoveMsg, this);
}

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

gfCParkClearComponent::gfCParkClearComponent(fsCEntity* const pParent):
fsIMessageListenerComponent(pParent),
mPreviewEntity(nullptr),
mHoverCol(0),
mHoverRow(0),
mHoverValid(false)
{
}

gfCParkClearComponent::~gfCParkClearComponent()
{
}