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

#include "gfCParkLevelComponent.h"

#include <cmath>
#include <vector>

#include <fsCore/src/fsCUniqueId.h>
#include <fsCore/src/fsCResourceName.h>
#include <fsCore/src/fsCAppSettings.h>

#include <fsAppCore/fsIDisplay.h>
#include <fsAppCore/fsIInputManager.h>
#include <fsAppCore/src/fsCAppCoreMain.h>
#include <fsAppCore/src/fsCEntity.h>
#include <fsAppCore/src/fsCEntityFactory.h>
#include <fsAppCore/src/fsCProfileManager.h>
#include <fsAppCore/src/fsILevelBasedAppCoreMain.h>
#include <fsAppCore/src/components/gui/fsIGuiComponent.h>

#include <fsCore/src/fsCVariableTable.h>
#include <fsCore/fsSColour.h>
#include <fsCore/fsIFile.h>
#include <fsCore/src/debug/fsLog.h>

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

#include <fsTileMap/fsITileMap.h>
#include <fsTileMap/fsITile.h>
#include <fsTileMap/fsIObject.h>
#include <fsTileMap/fsILayer.h>
#include <fsTileMap/src/fsCView.h>
#include <fsTileMap/src/fsCBoundryScroller.h>

#include <gfCatalogue/src/gfCCatalogueParserYaml.h>
#include <gfCatalogue/src/gfCCatalogueCatalogue.h>
#include <gfCatalogue/src/gfCCatalogueItem.h>

#include "gfCParkGuestViewComponent.h"
#include "gfCParkStaffViewComponent.h"
#include "gfCParkOfficeTapComponent.h"
#include "gfCParkSlotStaffComponent.h"
#include "gfCParkLensComponent.h"
#include "gfCParkLayoutManager.h"
#include "gfCPurchaseActionSlotFill.h"
#include "gfCTimeUserSavedData.h"
#include "sim/gfCParkDaySim.h"

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

// Placeholder day-loop values, tuned by feel.
const fsS32 gfCParkLevelComponent::mDayDurationMs = 5 * 60 * 1000;

namespace
{
std::vector<fsStr> guestNeedsParse(fsStr pNeeds)
{
	std::vector<fsStr> needs;
	while (!pNeeds.emptyGet())
	{
		fsStr need = pNeeds.chomp(",");
		need.leadingWhitespaceTrim();
		need.trailingWhitespaceTrim();
		if (!need.emptyGet())
		{
			needs.push_back(need);
		}
	}
	return needs;
}

// One visitor every 2.5s. The fixed scenery gate admits up to 60 per day;
// asset-defined entrance buildings can raise that quota.
const fsS32 gSpawnIntervalMs = 2500;
const fsS32 gBaseVisitorQuota = 60;

// Natural scenery and free walking access draw a small audience before the
// player builds anything. Buildings and decorations add authored appeal.
const fsS32 gBaseVisitorDemand = 30;

// A walk is inherently worthwhile; suitable park furniture can lift its visit
// quality by up to 20 points without replacing optional services.
const fsS32 gBaseWalkingSatisfaction = 60;
const fsS32 gMaxDecorationComfortBonus = 20;

// Reputation provides a deliberately modest return-visitor effect: every five
// points above/below neutral changes demand by one, capped naturally by 0-100.
fsS32 reputationDemandModifier(fsS32 pReputation)
{
	if (pReputation >= 50)
	{
		return (pReputation - 50) / 5;
	}
	return -((50 - pReputation) / 5);
}

// Per-day coin goal (placeholder ramp).
const fsS32 gCoinGoalByDay[gfCParkLevelComponent::mNumDays] = {100, 150, 200, 250, 300};

// TEMPORARY testing float - far more than content costs so nothing is gated.
// Can't be 0: staffing costs coins and coins only come from serving, so an
// empty purse deadlocks the park. Drop to ~one staff hire once proven.
const fsS32 gStartingCoins = 1000;

// Walk time from gate to slot (patience doesn't run while walking).
const fsS32 gGuestTravelMs = 4000;

// A building breaks after this many services or this long open, whichever
// first. Placeholder values.
const fsS32 gServicesBeforeBreak = 8;
const fsS32 gOpenMsBeforeBreak = 120000;
const fsS32 gRepairTimeMs = 8000;

// How often, during play, progress is flushed to disk (see progressPersist).
const fsS32 gAutosaveIntervalMs = 5000;

// Map furniture: fixed scenery with no catalogue entry, art living with the
// scene. Office is a landmark, gate is a wide low fence.
const fsStr gStaffOfficeObjectName("staffOffice");
const fsStr gStaffOfficeImage("parkscenes/pinecreekhillspark/staffOffice.png");
const fsF32 gStaffOfficeDrawScale = 2.5f;

const fsStr gParkGateObjectName("parkGate");
const fsStr gParkGateImage("parkscenes/pinecreekhillspark/parkGate.png");
const fsF32 gParkGateDrawScale = 1.6f;

// Translucent per-type tints for the greybox slot markers.
fsSColour4B slotTypeColour(const fsStr& pType)
{
	if (pType == "tickets") return fsSColour4B(235, 205, 70, 140);
	if (pType == "food")    return fsSColour4B(235, 140, 55, 140);
	if (pType == "rides")   return fsSColour4B(70, 185, 225, 150);
	if (pType == "staff")   return fsSColour4B(205, 95, 205, 140);
	return fsSColour4B(210, 210, 210, 140);
}

// Per-index saved-data keys for the ownership collections (the flat saved-data
// table has no list type). Built in one place so save and restore can't drift.
fsStr ownedSlotKey(fsS32 pIndex, const char* pField)
{
	return fsStr("parkOwnedSlot") + fsStr(pIndex) + pField;
}
fsStr hiredStaffKey(fsS32 pIndex, const char* pField)
{
	return fsStr("parkHiredStaff") + fsStr(pIndex) + pField;
}
fsStr deployedSlotKey(fsS32 pIndex)
{
	return fsStr("parkDeployedSlot") + fsStr(pIndex);
}
fsStr decorationKey(fsS32 pIndex, const char* pField)
{
	return fsStr("parkDecoration") + fsStr(pIndex) + pField;
}
fsStr clearedCellKey(fsS32 pIndex, const char* pField)
{
	return fsStr("parkClearedCell") + fsStr(pIndex) + pField;
}

// Placeholder size for a decoration with no art yet (the same green as the
// guest-view stand-in, so a missing PNG reads as "placed" rather than invisible).
const fsS32 gDecorationPlaceholderSize = 40;

// Used when an older/hand-authored catalogue omits placementwidth.
const fsS32 gServiceBuildingDefaultWidth = 64;

struct SGridRect
{
	fsS32 mLeft;
	fsS32 mTop;
	fsS32 mRight;
	fsS32 mBottom;
};

fsBool gridRectsOverlap(const SGridRect& pLhs, const SGridRect& pRhs)
{
	return pLhs.mLeft < pRhs.mRight && pLhs.mRight > pRhs.mLeft &&
	       pLhs.mTop < pRhs.mBottom && pLhs.mBottom > pRhs.mTop;
}

SGridRect gridRectFromAnchor(fsNTileMap::fsCView* const pView,
	fsS32 pLocalX, fsS32 pLocalY, fsS32 pColumns, fsS32 pRows)
{
	const fsPoint mapTopLeft = pView->mapPixelToLocal(fsPoint(0, 0));
	const fsPoint firstTileBottomRight = pView->mapPixelToLocal(
		fsPoint(pView->mMap->tileWidthGet(), pView->mMap->tileHeightGet()));
	const fsF32 tileLocalWidth = static_cast<fsF32>(firstTileBottomRight.x - mapTopLeft.x);
	const fsF32 tileLocalHeight = static_cast<fsF32>(firstTileBottomRight.y - mapTopLeft.y);

	SGridRect rect;
	rect.mLeft = static_cast<fsS32>(std::floor(
		(pLocalX - mapTopLeft.x) / tileLocalWidth - pColumns * 0.5f + 0.5f));
	rect.mTop = static_cast<fsS32>(std::floor(
		(pLocalY - mapTopLeft.y) / tileLocalHeight - pRows + 0.5f));
	rect.mRight = rect.mLeft + pColumns;
	rect.mBottom = rect.mTop + pRows;
	return rect;
}
}

void gfCParkLevelComponent::levelCreate(const fsStr& pLevelName, fsBool pResume)
{
	// Not gfCTileMapLevelLoaderComponent: that spawns a walker-avatar and
	// coords.txt pipeline (torsion machinery) a tap park doesn't want. Just the
	// fsCView the loader would build, minus the baggage.
	const fsCVariableTable* const levelSettings = fsILevelBasedAppCoreMain::instanceGet()->levelSettingsGet();
	auto* const map = fsNTileMap::fsITileMap::create(fsCResourceName(levelSettings->strGet("mapFile"),
	                                                                 fsCResourceName::eRES_LOCATION_ASSETS));
	// Single-screen park: view = whole map, scaled so its pixel width fills the
	// canvas (slightly taller than the canvas, so top/bottom crop).
	const fsS32 mapPixelWidth = map->widthGet() * map->tileWidthGet();
	const fsF32 fillWidthScale = static_cast<fsF32>(fsIDisplay::instanceGet()->designCanvasWidthGet())
	                             / static_cast<fsF32>(mapPixelWidth);
	auto* const view = fsNTileMap::fsCView::create(
		map,
		new fsNTileMap::fsCBoundryScroller(),
		map->widthGet(), map->heightGet(), fillWidthScale);

	// The view renders centred at its own origin, so a plain container holding
	// it at (0,0) has its origin on the park centre. The lens transforms this
	// container (see gfCParkLensComponent::targetGetDo), so zoom scales about the
	// centre and pan moves the whole park. Everything else still finds the view
	// by name ("tilemapView") - childFind is recursive.
	fsCEntity* const camera = parentGet()->entityFactoryGet()->emptyEntityCreate("parkCamera");
	camera->childAdd(view);
	parentGet()->childAdd(camera);

	// Find the clearable "forest" tile layer once; clearing, building placement
	// and guest routing all read walkability off it.
	forestLayerResolve(view);

	// Before the markers and moving layers, so everything draws in front of it.
	mapFurnitureCreate(view, gStaffOfficeObjectName, gStaffOfficeImage, gStaffOfficeDrawScale,
	                   /*pRepairDispatchTap*/ true);
	mapFurnitureCreate(view, gParkGateObjectName, gParkGateImage, gParkGateDrawScale);

	slotMarkersCreate(view);

	// Draws the sim's guests (on this entity so it can reach the sim).
	parentGet()->componentAdd<gfCParkGuestViewComponent>();

	// After the guest view, so the guest layer it shares exists.
	parentGet()->componentAdd<gfCParkStaffViewComponent>();

	// Pan/zoom lens (Phase 1). Its own full-canvas, brushless sprite catches
	// drag/pinch anywhere on screen; the lens then drives the view's scale/pos,
	// and the whole park (view children) follows. Added after the view so the
	// "tilemapView" lookup in targetGetDo resolves.
	const fsS32 canvasW = fsIDisplay::instanceGet()->designCanvasWidthGet();
	const fsS32 canvasH = fsIDisplay::instanceGet()->designCanvasHeightGet();
	fsCEntity* const lensEnt = parentGet()->entityFactoryGet()->emptyEntityCreate("parkLens");
	lensEnt->componentAdd(fsCSpriteComponent::mTypeId);
	if (auto* const lensHit = lensEnt->spriteComponentGet())
	{
		// Hit-test bounds only. The false = pModifyRenderData: set the size for
		// hit testing but build no render quad, so this brushless sprite is not
		// drawn (a drawn brushless sprite is an opaque white rectangle - it was
		// covering the whole screen). Same pattern as HOG's map hit sprite.
		lensHit->widthSet(canvasW, false);
		lensHit->heightSet(canvasH, false);
	}
	parentGet()->childAdd(lensEnt);

	// Content = map's on-screen size at fit-to-width: width fills the canvas,
	// height is taller (the map is cropped top/bottom), so at min zoom only
	// vertical pan does anything; zooming in frees both axes.
	const fsS32 contentHeight = static_cast<fsS32>(map->heightGet() * map->tileHeightGet() * fillWidthScale);
	lensEnt->componentAdd<gfCParkLensComponent>()->configure(
		fsPoint(canvasW, canvasH),
		fsPoint(canvasW, contentHeight),
		/*minZoom*/ 1.0f, /*maxZoom*/ 2.5f);

	mDayIndex = 1;

	if (pResume)
	{
		progressRestore();

		// The sim state was restored above, but building sprites are only ever
		// created at purchase time - re-place them here so a resumed park shows
		// its bought buildings (and their staff-tap components) instead of empty
		// slots. Staff/guests draw themselves off the restored sim.
		for (const SOwnedSlot& purchasedSlot : mPurchasedSlots)
		{
			if (purchasedSlot.mRuntime)
			{
				serviceBuildingPresentationPlace(view, purchasedSlot.mName,
					purchasedSlot.mBuildingImage, purchasedSlot.mDrawWidth,
					purchasedSlot.mLocalX, purchasedSlot.mLocalY);
			}
			else
			{
				gfCPurchaseActionSlotFill::buildingPresentationPlace(
					view, purchasedSlot.mName, purchasedSlot.mBuildingImage);
			}
		}

		// Cosmetic decorations restore the same way - re-dropped at their saved
		// view-local position.
		for (const SOwnedDecoration& decoration : mOwnedDecorations)
		{
			decorationPresentationPlace(view, decoration.mImage, decoration.mDrawWidth,
			                            decoration.mLocalX, decoration.mLocalY);
		}

		// Re-hide every previously cleared forest tile so a resumed park shows the
		// land the player already opened up (walkability is data-driven, so the
		// grid is already open - this only re-syncs what's drawn).
		for (const fsPoint& cell : mClearedCells)
		{
			clearedCellApply(view, cell.x, cell.y);
		}
	}
	else
	{
		// New Game: ignore any saved keys and start a clean day 1. The persist
		// below then overwrites the save (counts back to 0, day 1) so a later
		// Continue can't resume a previous game's park.
		daySimBegin();
	}

	// Flush immediately, so a save exists (with mCurrentLocation) the moment the
	// park opens - Continue then works even if the player quits within seconds,
	// before the first autosave tick.
	progressPersist();
}

void gfCParkLevelComponent::mapFurnitureCreate(fsNTileMap::fsCView* const pView, const fsStr& pObjectName,
                                               const fsStr& pImagePath, fsF32 pDrawScale,
                                               fsBool pRepairDispatchTap)
{
	fsNTileMap::fsITileMap* const map = pView->mMap;
	for (fsS32 layer = 0; layer < map->layerCountGet(); ++layer)
	{
		if (fsNTileMap::fsILayer::eType::OBJECT != map->layerTypeGet(layer))
		{
			continue;
		}

		for (fsNTileMap::fsIObjectRef const& obj : map->triggersGet(layer))
		{
			if (obj->nameGet() != pObjectName)
			{
				continue;
			}

			const fsCResourceName furnitureRes(pImagePath, fsCResourceName::eRES_LOCATION_ASSETS);
			if (!fsIFile::fileExistsGet(furnitureRes))
			{
				fsLogError("Map furniture image not found: %s", pImagePath.utf8Get());
				return;
			}

			// Sized and stood on its footprint exactly like a purchased building
			// (see gfCPurchaseActionSlotFill) so it sits in the scene the same way.
			const fsPoint pos = obj->posGet();
			const fsPoint topLeft = pView->mapPixelToLocal(pos);
			const fsPoint botRight = pView->mapPixelToLocal(
				fsPoint(pos.x + obj->widthGet(), pos.y + obj->heightGet()));

			fsCEntity* const furniture = pView->entityFactoryGet()->emptyEntityCreate(pObjectName);
			furniture->componentAdd(fsCSpriteComponent::mTypeId);
			auto* const sprt = furniture->spriteComponentGet();
			sprt->brushSet(fsCBrushManager::instanceGet()->get(furnitureRes, false));

			const fsS32 nativeW = sprt->widthGet();
			const fsS32 nativeH = sprt->heightGet();
			const fsS32 drawW = static_cast<fsS32>((botRight.x - topLeft.x) * pDrawScale);
			fsS32 drawH = static_cast<fsS32>((botRight.y - topLeft.y) * pDrawScale);
			if (nativeW > 0 && nativeH > 0)
			{
				drawH = static_cast<fsS32>(drawW * (static_cast<fsF32>(nativeH) / static_cast<fsF32>(nativeW)));
			}
			sprt->widthSet(drawW);
			sprt->heightSet(drawH);
			furniture->posSet(fsPoint((topLeft.x + botRight.x) / 2, botRight.y - drawH / 2));

			// Added before the guest layer exists, so staff and guests walk in
			// front of it rather than disappearing behind.
			pView->childAdd(furniture);

			// Tappable to arm a repair dispatch. Added after childAdd so its input
			// listener registers with the entity in the scene.
			if (pRepairDispatchTap)
			{
				furniture->componentAdd<gfCParkOfficeTapComponent>();
			}
			return;
		}
	}
}

void gfCParkLevelComponent::slotMarkersCreate(fsNTileMap::fsCView* const pView)
{
	fsNTileMap::fsITileMap* const map = pView->mMap;
	for (fsS32 layer = 0; layer < map->layerCountGet(); ++layer)
	{
		if (fsNTileMap::fsILayer::eType::OBJECT != map->layerTypeGet(layer))
		{
			continue;
		}

		for (fsNTileMap::fsIObjectRef const& obj : map->triggersGet(layer))
		{
			// Only typed objects are slots; untyped ones are anchors.
			if (obj->typeGet().emptyGet())
			{
				continue;
			}

			// Slot footprint -> view-local via the backdrop's transform.
			const fsPoint pos = obj->posGet();
			const fsPoint topLeft = pView->mapPixelToLocal(pos);
			const fsPoint botRight = pView->mapPixelToLocal(
				fsPoint(pos.x + obj->widthGet(), pos.y + obj->heightGet()));

			fsCEntity* const marker = pView->entityFactoryGet()->emptyEntityCreate(obj->nameGet() + "Marker");
			marker->componentAdd(fsCSpriteComponent::mTypeId);
			// No brush: a sized, coloured sprite is a solid quad (as the screen fade).
			auto* const sprt = marker->spriteComponentGet();
			sprt->widthSet(botRight.x - topLeft.x);
			sprt->heightSet(botRight.y - topLeft.y);
			sprt->colourSet(slotTypeColour(obj->typeGet()));
			marker->posSet(fsPoint((topLeft.x + botRight.x) / 2, (topLeft.y + botRight.y) / 2));
			pView->childAdd(marker);
		}
	}
}

fsCEntity* gfCParkLevelComponent::decorationPresentationPlace(
	fsNTileMap::fsCView* pView, const fsStr& pImage, fsS32 pDrawWidth,
	fsS32 pLocalX, fsS32 pLocalY)
{
	if (!pView)
	{
		return nullptr;
	}

	// Ever-increasing so names never collide (decorations are never looked up by
	// name, but a duplicate would still confuse a recursive childFind elsewhere).
	static fsS32 sDecorationSeq = 0;
	fsCEntity* const ent =
		pView->entityFactoryGet()->emptyEntityCreate(fsStr("decoration") + fsStr(sDecorationSeq++));
	ent->componentAdd(fsCSpriteComponent::mTypeId);
	auto* const sprt = ent->spriteComponentGet();

	// Same existence-check-before-brushSet discipline as a placed building: a
	// missing file would crash brushSet, so fall back to a small solid block.
	const fsCResourceName decorationRes(pImage, fsCResourceName::eRES_LOCATION_ASSETS);
	fsS32 nativeW = 0;
	fsS32 nativeH = 0;
	if (!pImage.emptyGet() && fsIFile::fileExistsGet(decorationRes))
	{
		// No hit map needed - decorations aren't tappable, they're pure scenery.
		sprt->brushSet(fsCBrushManager::instanceGet()->get(decorationRes, false));
		nativeW = sprt->widthGet();
		nativeH = sprt->heightGet();
	}
	else
	{
		sprt->colourSet(fsSColour4B(120, 200, 120, 255));
	}

	const fsS32 drawW = pDrawWidth > 0
		? pDrawWidth
		: (nativeW > 0 ? nativeW : gDecorationPlaceholderSize);
	fsS32 drawH = drawW;
	if (nativeW > 0 && nativeH > 0)
	{
		drawH = static_cast<fsS32>(drawW *
			(static_cast<fsF32>(nativeH) / static_cast<fsF32>(nativeW)));
	}
	sprt->widthSet(drawW);
	sprt->heightSet(drawH);

	// New grid-aware records are bottom-centred exactly like the live preview.
	// A zero width identifies an older save, whose coordinates were centre-based.
	ent->posSet(fsPoint(pLocalX, pDrawWidth > 0 ? pLocalY - drawH / 2 : pLocalY));
	pView->childAdd(ent);

	// Children render in insertion order, so keep guests drawn above a decoration
	// dropped mid-day.
	if (fsCEntity* const guestLayer = pView->childFind(gfCParkGuestViewComponent::mGuestLayerName))
	{
		guestLayer->bringToFrontOfSiblings();
	}

	return ent;
}

void gfCParkLevelComponent::decorationPlacedRecord(
	const fsStr& pImage, fsS32 pDrawWidth, fsS32 pFootprintColumns, fsS32 pFootprintRows,
	fsS32 pLocalX, fsS32 pLocalY, fsS32 pVisitorAppeal, fsS32 pVisitorComfort)
{
	SOwnedDecoration owned;
	owned.mImage = pImage;
	owned.mDrawWidth = pDrawWidth;
	owned.mFootprintColumns = pFootprintColumns > 0 ? pFootprintColumns : 1;
	owned.mFootprintRows = pFootprintRows > 0 ? pFootprintRows : 1;
	owned.mLocalX = pLocalX;
	owned.mLocalY = pLocalY;
	owned.mVisitorAppeal = pVisitorAppeal > 0 ? pVisitorAppeal : 0;
	owned.mVisitorComfort = pVisitorComfort > 0 ? pVisitorComfort : 0;
	mOwnedDecorations.push_back(owned);
	visitorNumbersRefresh();
}

fsCEntity* gfCParkLevelComponent::serviceBuildingPresentationPlace(
	fsNTileMap::fsCView* pView, const fsStr& pSlotName, const fsStr& pImage,
	fsS32 pDrawWidth, fsS32 pLocalX, fsS32 pLocalY)
{
	if (!pView)
	{
		return nullptr;
	}

	fsCEntity* const ent = pView->entityFactoryGet()->emptyEntityCreate(pSlotName + "Building");
	ent->componentAdd(fsCSpriteComponent::mTypeId);
	auto* const sprt = ent->spriteComponentGet();

	const fsCResourceName buildingRes(pImage, fsCResourceName::eRES_LOCATION_ASSETS);
	if (!pImage.emptyGet() && fsIFile::fileExistsGet(buildingRes))
	{
		sprt->brushSet(fsCBrushManager::instanceGet()->get(buildingRes, false));
	}
	else
	{
		sprt->colourSet(fsSColour4B(228, 216, 194, 255));
	}

	const fsS32 nativeW = sprt->widthGet();
	const fsS32 nativeH = sprt->heightGet();
	const fsS32 drawW = pDrawWidth > 0 ? pDrawWidth : gServiceBuildingDefaultWidth;
	fsS32 drawH = drawW;
	if (nativeW > 0 && nativeH > 0)
	{
		drawH = static_cast<fsS32>(drawW *
			(static_cast<fsF32>(nativeH) / static_cast<fsF32>(nativeW)));
	}
	sprt->widthSet(drawW);
	sprt->heightSet(drawH);
	ent->posSet(fsPoint(pLocalX, pLocalY - drawH / 2));
	pView->childAdd(ent);

	if (fsCEntity* const guestLayer = pView->childFind(gfCParkGuestViewComponent::mGuestLayerName))
	{
		guestLayer->bringToFrontOfSiblings();
	}

	ent->componentAdd<gfCParkSlotStaffComponent>()->slotNameSet(pSlotName);
	return ent;
}

fsBool gfCParkLevelComponent::serviceBuildingPlace(
	fsNTileMap::fsCView* pView, const fsStr& pImage, const fsStr& pServiceType,
	fsS32 pServiceTimeMs, fsS32 pMaxQueueLength, fsS32 pVisitorQuota,
	fsS32 pVisitorAppeal, fsS32 pDrawWidth,
	fsS32 pFootprintColumns, fsS32 pFootprintRows,
	fsS32 pLocalX, fsS32 pLocalY)
{
	if (!pView || !mSim || pServiceType.emptyGet() || pServiceTimeMs <= 0 || pMaxQueueLength <= 0)
	{
		return false;
	}
	if (!parkPlacementValid(
		pView, pLocalX, pLocalY, pFootprintColumns, pFootprintRows))
	{
		return false;
	}

	const fsStr slotName = fsStr("runtimeBuildingSlot") + fsStr(mRuntimeSlotSequence++);
	if (!serviceBuildingPresentationPlace(pView, slotName, pImage, pDrawWidth, pLocalX, pLocalY))
	{
		return false;
	}

	mSim->slotAdd(slotName, pServiceType, pServiceTimeMs, pMaxQueueLength, true);
	mSim->slotWearLimitsSetAll(gServicesBeforeBreak, gOpenMsBeforeBreak);

	SOwnedSlot owned;
	owned.mName = slotName;
	owned.mServiceTimeMs = pServiceTimeMs;
	owned.mMaxQueueLength = pMaxQueueLength;
	owned.mBuildingImage = pImage;
	owned.mRuntime = true;
	owned.mServiceType = pServiceType;
	owned.mLocalX = pLocalX;
	owned.mLocalY = pLocalY;
	owned.mDrawWidth = pDrawWidth > 0 ? pDrawWidth : gServiceBuildingDefaultWidth;
	owned.mFootprintColumns = pFootprintColumns > 0 ? pFootprintColumns : 1;
	owned.mFootprintRows = pFootprintRows > 0 ? pFootprintRows : 1;
	owned.mVisitorQuota = pVisitorQuota > 0 ? pVisitorQuota : 0;
	owned.mVisitorAppeal = pVisitorAppeal > 0 ? pVisitorAppeal : 0;
	mPurchasedSlots.push_back(owned);
	visitorNumbersRefresh();
	return true;
}

fsBool gfCParkLevelComponent::runtimeSlotPositionGet(const fsStr& pSlotName, fsVec2d& pOut) const
{
	for (const SOwnedSlot& slot : mPurchasedSlots)
	{
		if (slot.mRuntime && slot.mName == pSlotName)
		{<--- Consider using std::find_if algorithm instead of a raw loop.
			pOut = fsVec2d(static_cast<fsF32>(slot.mLocalX), static_cast<fsF32>(slot.mLocalY));
			return true;
		}
	}
	return false;
}

fsBool gfCParkLevelComponent::runtimeSlotGetByIndex(fsS32 pIndex, fsStr& pNameOut,
                                                    fsVec2d& pPositionOut) const
{
	if (pIndex < 0)
	{
		return false;
	}

	fsS32 runtimeIndex = 0;
	for (const SOwnedSlot& slot : mPurchasedSlots)
	{
		if (!slot.mRuntime)
		{
			continue;
		}
		if (runtimeIndex++ == pIndex)
		{
			pNameOut = slot.mName;
			pPositionOut = fsVec2d(
				static_cast<fsF32>(slot.mLocalX), static_cast<fsF32>(slot.mLocalY));
			return true;
		}
	}
	return false;
}

fsBool gfCParkLevelComponent::parkPlacementValid(
	fsNTileMap::fsCView* pView, fsS32 pLocalX, fsS32 pLocalY,
	fsS32 pFootprintColumns, fsS32 pFootprintRows) const
{
	if (!pView || pFootprintColumns <= 0 || pFootprintRows <= 0)
	{
		return false;
	}

	const SGridRect candidate = gridRectFromAnchor(
		pView, pLocalX, pLocalY, pFootprintColumns, pFootprintRows);
	if (candidate.mLeft < 0 || candidate.mTop < 0 ||
		candidate.mRight > pView->mMap->widthGet() ||
		candidate.mBottom > pView->mMap->heightGet())
	{
		return false;
	}

	for (const SOwnedSlot& slot : mPurchasedSlots)
	{
		if (!slot.mRuntime)
		{
			continue;
		}
		const SGridRect occupied = gridRectFromAnchor(
			pView, slot.mLocalX, slot.mLocalY,
			slot.mFootprintColumns > 0 ? slot.mFootprintColumns : 1,
			slot.mFootprintRows > 0 ? slot.mFootprintRows : 1);
		if (gridRectsOverlap(candidate, occupied))
		{
			return false;
		}
	}

	// Decorations share the same grid and reserve their asset-defined footprint,
	// so buildings and later decorations cannot overlap them.
	for (const SOwnedDecoration& decoration : mOwnedDecorations)
	{
		const SGridRect occupied = gridRectFromAnchor(
			pView, decoration.mLocalX, decoration.mLocalY,
			decoration.mFootprintColumns > 0 ? decoration.mFootprintColumns : 1,
			decoration.mFootprintRows > 0 ? decoration.mFootprintRows : 1);
		if (gridRectsOverlap(candidate, occupied))
		{
			return false;
		}
	}

	// Every authored object reserves its footprint. That protects fixed slots,
	// the gate and staff office, while still allowing free placement elsewhere.
	fsNTileMap::fsITileMap* const map = pView->mMap;
	for (fsS32 layer = 0; layer < map->layerCountGet(); ++layer)
	{
		if (fsNTileMap::fsILayer::eType::OBJECT != map->layerTypeGet(layer))
		{
			continue;
		}
		for (fsNTileMap::fsIObjectRef const& obj : map->triggersGet(layer))
		{
			const fsPoint pos = obj->posGet();
			const fsS32 width = obj->widthGet() > 0 ? obj->widthGet() : 1;
			const fsS32 height = obj->heightGet() > 0 ? obj->heightGet() : 1;
			SGridRect occupied;
			occupied.mLeft = pos.x / map->tileWidthGet();
			occupied.mTop = pos.y / map->tileHeightGet();
			occupied.mRight =
				(pos.x + width + map->tileWidthGet() - 1) / map->tileWidthGet();
			occupied.mBottom =
				(pos.y + height + map->tileHeightGet() - 1) / map->tileHeightGet();
			if (gridRectsOverlap(candidate, occupied))
			{
				return false;
			}
		}
	}

	// Uncleared forest is not buildable - the footprint must sit entirely on open
	// (cleared or never-forested) ground.
	for (fsS32 row = candidate.mTop; row < candidate.mBottom; ++row)
	{
		for (fsS32 col = candidate.mLeft; col < candidate.mRight; ++col)
		{
			if (cellForestGet(pView, col, row))
			{
				return false;
			}
		}
	}

	return true;
}

fsBool gfCParkLevelComponent::cellClearedGet(fsS32 pCol, fsS32 pRow) const
{
	for (const fsPoint& cell : mClearedCells)<--- Consider using std::any_of algorithm instead of a raw loop.
	{
		if (cell.x == pCol && cell.y == pRow)
		{
			return true;
		}
	}
	return false;
}

void gfCParkLevelComponent::forestLayerResolve(fsNTileMap::fsCView* const pView)
{
	mForestLayerId = -1;
	if (!pView || !pView->mMap)
	{
		return;
	}
	fsNTileMap::fsITileMap* const map = pView->mMap;
	for (fsS32 layer = 0; layer < map->layerCountGet(); ++layer)
	{
		if (fsNTileMap::fsILayer::eType::TILE == map->layerTypeGet(layer) &&
			map->layerNameGet(layer) == "forest")
		{
			mForestLayerId = layer;
			return;
		}
	}
}

fsBool gfCParkLevelComponent::cellForestGet(fsNTileMap::fsCView* pView, fsS32 pCol, fsS32 pRow) const
{
	if (!pView || !pView->mMap || mForestLayerId < 0)
	{
		return false;
	}
	fsNTileMap::fsITileMap* const map = pView->mMap;
	if (pCol < 0 || pRow < 0 || pCol >= map->widthGet() || pRow >= map->heightGet())
	{
		return false;
	}
	if (cellClearedGet(pCol, pRow))
	{
		return false;
	}
	const fsNTileMap::fsITileRef tile = map->tileGet(mForestLayerId, pCol, pRow);
	return tile && tile->tileSetIdGet() != -1;
}

fsBool gfCParkLevelComponent::cellWalkableGet(fsNTileMap::fsCView* pView, fsS32 pCol, fsS32 pRow) const
{
	if (!pView || !pView->mMap)
	{
		return false;
	}
	fsNTileMap::fsITileMap* const map = pView->mMap;
	if (pCol < 0 || pRow < 0 || pCol >= map->widthGet() || pRow >= map->heightGet())
	{
		return false;
	}
	return !cellForestGet(pView, pCol, pRow);
}

fsPoint gfCParkLevelComponent::cellFromLocal(fsNTileMap::fsCView* pView, const fsVec2d& pLocal) const
{
	fsNTileMap::fsITileMap* const map = pView->mMap;
	const fsPoint mapTopLeft = pView->mapPixelToLocal(fsPoint(0, 0));
	const fsPoint firstTileBottomRight = pView->mapPixelToLocal(
		fsPoint(map->tileWidthGet(), map->tileHeightGet()));
	const fsF32 tileLocalWidth = static_cast<fsF32>(firstTileBottomRight.x - mapTopLeft.x);
	const fsF32 tileLocalHeight = static_cast<fsF32>(firstTileBottomRight.y - mapTopLeft.y);
	if (tileLocalWidth <= 0.0f || tileLocalHeight <= 0.0f)
	{
		return fsPoint(0, 0);
	}
	const fsS32 col = static_cast<fsS32>(std::floor((pLocal.x - mapTopLeft.x) / tileLocalWidth));
	const fsS32 row = static_cast<fsS32>(std::floor((pLocal.y - mapTopLeft.y) / tileLocalHeight));
	return fsPoint(col, row);
}

fsVec2d gfCParkLevelComponent::cellCentreLocal(fsNTileMap::fsCView* pView, fsS32 pCol, fsS32 pRow) const
{
	fsNTileMap::fsITileMap* const map = pView->mMap;
	const fsPoint centre = pView->mapPixelToLocal(fsPoint(
		pCol * map->tileWidthGet() + map->tileWidthGet() / 2,
		pRow * map->tileHeightGet() + map->tileHeightGet() / 2));
	return fsVec2d(static_cast<fsF32>(centre.x), static_cast<fsF32>(centre.y));
}

std::vector<fsPoint> gfCParkLevelComponent::pathFindCells(fsNTileMap::fsCView* pView,
                                                          const fsPoint& pFrom, const fsPoint& pTo) const
{
	std::vector<fsPoint> path;
	if (!pView || !pView->mMap)
	{
		return path;
	}
	fsNTileMap::fsITileMap* const map = pView->mMap;
	const fsS32 width = map->widthGet();
	const fsS32 height = map->heightGet();
	if (!cellWalkableGet(pView, pFrom.x, pFrom.y) || !cellWalkableGet(pView, pTo.x, pTo.y))
	{
		return path;
	}
	if (pFrom.x == pTo.x && pFrom.y == pTo.y)
	{
		path.push_back(pFrom);
		return path;
	}

	// Grid BFS. cameFrom holds each visited cell's predecessor index (-1 = unset,
	// -2 = the start), so the route can be walked back once the target is found.
	const fsS32 cellCount = width * height;
	std::vector<fsS32> cameFrom(cellCount, -1);
	std::vector<fsS32> queue;
	queue.reserve(cellCount);
	const fsS32 startIndex = pFrom.y * width + pFrom.x;
	const fsS32 targetIndex = pTo.y * width + pTo.x;
	cameFrom[startIndex] = -2;
	queue.push_back(startIndex);

	const fsS32 stepX[4] = {1, -1, 0, 0};
	const fsS32 stepY[4] = {0, 0, 1, -1};
	fsBool found = false;
	for (fsS32 head = 0; head < static_cast<fsS32>(queue.size()) && !found; ++head)
	{
		const fsS32 current = queue[head];
		const fsS32 cx = current % width;
		const fsS32 cy = current / width;
		for (fsS32 dir = 0; dir < 4; ++dir)
		{
			const fsS32 nx = cx + stepX[dir];
			const fsS32 ny = cy + stepY[dir];
			if (nx < 0 || ny < 0 || nx >= width || ny >= height)
			{
				continue;
			}
			const fsS32 neighbour = ny * width + nx;
			if (cameFrom[neighbour] != -1 || !cellWalkableGet(pView, nx, ny))
			{
				continue;
			}
			cameFrom[neighbour] = current;
			if (neighbour == targetIndex)
			{
				found = true;
				break;
			}
			queue.push_back(neighbour);
		}
	}

	if (!found)
	{
		return path;
	}
	for (fsS32 at = targetIndex; at != -2; at = cameFrom[at])
	{
		path.push_back(fsPoint(at % width, at / width));
	}
	// Walked target -> start; flip so callers get start -> target.
	for (fsS32 i = 0, j = static_cast<fsS32>(path.size()) - 1; i < j; ++i, --j)
	{
		const fsPoint tmp = path[i];
		path[i] = path[j];
		path[j] = tmp;
	}
	return path;
}

fsPoint gfCParkLevelComponent::nearestWalkableCell(fsNTileMap::fsCView* pView, const fsPoint& pCell) const
{
	if (cellWalkableGet(pView, pCell.x, pCell.y))
	{
		return pCell;
	}
	if (!pView || !pView->mMap)
	{
		return pCell;
	}
	const fsS32 maxRadius = pView->mMap->widthGet() + pView->mMap->heightGet();
	for (fsS32 radius = 1; radius <= maxRadius; ++radius)
	{
		for (fsS32 dy = -radius; dy <= radius; ++dy)
		{
			for (fsS32 dx = -radius; dx <= radius; ++dx)
			{
				// Only the ring at this radius (its interior was tested already).
				if (dx > -radius && dx < radius && dy > -radius && dy < radius)
				{
					continue;
				}
				const fsS32 cx = pCell.x + dx;
				const fsS32 cy = pCell.y + dy;
				if (cellWalkableGet(pView, cx, cy))
				{
					return fsPoint(cx, cy);
				}
			}
		}
	}
	return pCell;
}

fsPoint gfCParkLevelComponent::nearestReachableCell(fsNTileMap::fsCView* pView,
                                                    const fsPoint& pFrom, const fsPoint& pDesired) const
{
	if (!pView || !pView->mMap || !cellWalkableGet(pView, pFrom.x, pFrom.y))
	{
		return pFrom;
	}
	fsNTileMap::fsITileMap* const map = pView->mMap;
	const fsS32 width = map->widthGet();
	const fsS32 height = map->heightGet();

	std::vector<bool> visited(width * height, false);
	std::vector<fsS32> queue;
	queue.reserve(width * height);
	const fsS32 startIndex = pFrom.y * width + pFrom.x;
	visited[startIndex] = true;
	queue.push_back(startIndex);

	fsPoint best = pFrom;
	auto sqDist = [&](fsS32 cx, fsS32 cy)
	{
		const fsS32 dx = cx - pDesired.x;
		const fsS32 dy = cy - pDesired.y;
		return dx * dx + dy * dy;
	};
	fsS32 bestDist = sqDist(pFrom.x, pFrom.y);

	const fsS32 stepX[4] = {1, -1, 0, 0};
	const fsS32 stepY[4] = {0, 0, 1, -1};
	for (fsS32 head = 0; head < static_cast<fsS32>(queue.size()); ++head)
	{
		const fsS32 current = queue[head];
		const fsS32 cx = current % width;
		const fsS32 cy = current / width;
		const fsS32 d = sqDist(cx, cy);
		if (d < bestDist)
		{
			bestDist = d;
			best = fsPoint(cx, cy);
			if (0 == bestDist)
			{
				break;   // reached the desired cell exactly
			}
		}
		for (fsS32 dir = 0; dir < 4; ++dir)
		{
			const fsS32 nx = cx + stepX[dir];
			const fsS32 ny = cy + stepY[dir];
			if (nx < 0 || ny < 0 || nx >= width || ny >= height)
			{
				continue;
			}
			const fsS32 neighbour = ny * width + nx;
			if (visited[neighbour] || !cellWalkableGet(pView, nx, ny))
			{
				continue;
			}
			visited[neighbour] = true;
			queue.push_back(neighbour);
		}
	}
	return best;
}

fsS32 gfCParkLevelComponent::forestClearCostGet() const
{
	return fsCAppCoreMain::instanceGet()->settingsGet()->s32GetWithDefault(
		"forestClearCostCoins", 25);
}

void gfCParkLevelComponent::clearedCellApply(fsNTileMap::fsCView* const pView, fsS32 pCol, fsS32 pRow)
{
	if (pView && mForestLayerId >= 0)
	{
		pView->tileHide(mForestLayerId, pCol, pRow);
	}
}

fsBool gfCParkLevelComponent::forestClearAt(fsNTileMap::fsCView* pView, fsS32 pCol, fsS32 pRow)
{
	if (!cellForestGet(pView, pCol, pRow))
	{
		return false;
	}

	// Clears grow outward from open ground: at least one orthogonal neighbour
	// must already be walkable, so the player can't carve out an unreachable hole.
	const fsBool touchesOpen =
		cellWalkableGet(pView, pCol + 1, pRow) || cellWalkableGet(pView, pCol - 1, pRow) ||
		cellWalkableGet(pView, pCol, pRow + 1) || cellWalkableGet(pView, pCol, pRow - 1);
	if (!touchesOpen)
	{
		return false;
	}

	const fsS32 cost = forestClearCostGet();
	if (mSim && cost > 0)
	{
		if (mSim->economyGet().coinsGet() < cost)
		{
			return false;
		}
		mSim->economyGet().coinsSet(mSim->economyGet().coinsGet() - cost);
	}

	mClearedCells.push_back(fsPoint(pCol, pRow));
	clearedCellApply(pView, pCol, pRow);
	// New land can raise appeal-independent walking access; keep sim numbers fresh
	// and persist so the clear survives a quit exactly like a purchase.
	visitorNumbersRefresh();
	progressPersist();
	return true;
}

void gfCParkLevelComponent::daySimBegin()
{
	mDayRemainingMs = mDayDurationMs;
	mDayEndShown = false;

	mSim = std::make_unique<gfCParkDaySim>(
		gSpawnIntervalMs, visitorQuotaHighestOwnedGet(), gCoinGoalByDay[mDayIndex - 1]);
	mSim->visitorDemandSet(visitorDemandFromParkGet());
	mSim->walkingSatisfactionPercentSet(walkingSatisfactionFromParkGet());
	// Re-granted per day (fresh sim); progressRestore overwrites it when resuming.
	mSim->economyGet().coinsSet(gStartingCoins);
	// Presentation paces guest sprites to this same walk time.
	mSim->guestTravelMsSet(gGuestTravelMs);
	mSim->unstaffedVisitHappyChancePercentSet(
		fsCAppCoreMain::instanceGet()->settingsGet()->s32GetWithDefault(
			"unstaffedGuestHappyChancePercent", 50));

	guestTemplatesLoad();

	// Clear last day's guests so the new day starts empty rather than yesterday's
	// crowd walking out at once. A no-op on the first day (view exists, empty).
	if (gfCParkGuestViewComponent* const guestView =
		parentGet()->firstComponentOfFamilyType<gfCParkGuestViewComponent>())
	{
		guestView->reset();
	}

	if (auto* const view = dynamic_cast<fsNTileMap::fsCView*>(
		fsCAppCoreMain::instanceGet()->sceneGet()->childFind("tilemapView")))
	{
		gfCParkLayoutManager::slotsRegister(view->mMap, *mSim);
	}

	for (const SOwnedSlot& purchasedSlot : mPurchasedSlots)
	{
		if (purchasedSlot.mRuntime && !purchasedSlot.mServiceType.emptyGet())
		{
			mSim->slotAdd(purchasedSlot.mName, purchasedSlot.mServiceType,
				purchasedSlot.mServiceTimeMs, purchasedSlot.mMaxQueueLength, true);
		}
	}

	// A fresh sim re-registers slots locked with an empty staff pool, but the
	// player's buildings persist on the map - re-apply ownership or the park
	// looks built yet serves nobody.
	for (const SOwnedSlot& purchasedSlot : mPurchasedSlots)
	{
		mSim->slotUnlock(purchasedSlot.mName);
		if (purchasedSlot.mServiceTimeMs > 0)
		{
			mSim->slotServiceTimeMsSet(purchasedSlot.mName, purchasedSlot.mServiceTimeMs);
		}
		if (purchasedSlot.mMaxQueueLength > 0)
		{
			mSim->slotMaxQueueLengthSet(purchasedSlot.mName, purchasedSlot.mMaxQueueLength);
		}
	}
	for (const SHiredStaff& hired : mHiredStaff)
	{
		mSim->staffPoolGrow(hired.mType, 1);
	}

	// Re-deploy after the pool exists, or staffDeploy() finds nobody available.
	for (const fsStr& deployedSlot : mDeployedSlots)
	{
		mSim->staffDeploy(deployedSlot);
	}

	// After registration (touches every slot). Buildings start each day repaired,
	// so wear is within-day pressure.
	mSim->slotWearLimitsSetAll(gServicesBeforeBreak, gOpenMsBeforeBreak);
	mSim->repairTimeMsSet(gRepairTimeMs);
}

void gfCParkLevelComponent::slotPurchasedRecord(const fsStr& pSlotName, fsS32 pServiceTimeMs,
	                                            fsS32 pMaxQueueLength, const fsStr& pBuildingImage,
	                                            fsS32 pVisitorQuota, fsS32 pVisitorAppeal)
{
	for (SOwnedSlot& purchasedSlot : mPurchasedSlots)
	{
		if (purchasedSlot.mName == pSlotName)
		{<--- Consider using std::find_if algorithm instead of a raw loop.
			purchasedSlot.mServiceTimeMs = pServiceTimeMs;
			purchasedSlot.mMaxQueueLength = pMaxQueueLength;
			purchasedSlot.mBuildingImage = pBuildingImage;
			purchasedSlot.mRuntime = false;
			purchasedSlot.mServiceType = fsStr();
			purchasedSlot.mLocalX = 0;
			purchasedSlot.mLocalY = 0;
			purchasedSlot.mDrawWidth = 0;
			purchasedSlot.mFootprintColumns = 0;
			purchasedSlot.mFootprintRows = 0;
			purchasedSlot.mVisitorQuota = pVisitorQuota > 0 ? pVisitorQuota : 0;
			purchasedSlot.mVisitorAppeal = pVisitorAppeal > 0 ? pVisitorAppeal : 0;
			visitorNumbersRefresh();
			return;
		}
	}

	SOwnedSlot owned;
	owned.mName = pSlotName;
	owned.mServiceTimeMs = pServiceTimeMs;
	owned.mMaxQueueLength = pMaxQueueLength;
	owned.mBuildingImage = pBuildingImage;
	owned.mRuntime = false;
	owned.mVisitorQuota = pVisitorQuota > 0 ? pVisitorQuota : 0;
	owned.mVisitorAppeal = pVisitorAppeal > 0 ? pVisitorAppeal : 0;
	mPurchasedSlots.push_back(owned);
	visitorNumbersRefresh();
}

fsS32 gfCParkLevelComponent::visitorQuotaHighestOwnedGet() const
{
	fsS32 visitorQuota = gBaseVisitorQuota;
	for (const SOwnedSlot& slot : mPurchasedSlots)
	{
		if (slot.mVisitorQuota > visitorQuota)
		{
			visitorQuota = slot.mVisitorQuota;
		}
	}
	return visitorQuota;
}

fsS32 gfCParkLevelComponent::visitorDemandFromParkGet() const
{
	fsS32 visitorDemand = gBaseVisitorDemand + reputationDemandModifier(mParkReputation);
	for (const SOwnedSlot& slot : mPurchasedSlots)
	{
		visitorDemand += slot.mVisitorAppeal;<--- Consider using std::accumulate algorithm instead of a raw loop.
	}
	for (const SOwnedDecoration& decoration : mOwnedDecorations)
	{
		visitorDemand += decoration.mVisitorAppeal;<--- Consider using std::accumulate algorithm instead of a raw loop.
	}
	return visitorDemand;
}

fsS32 gfCParkLevelComponent::walkingSatisfactionFromParkGet() const
{
	fsS32 comfortBonus = 0;
	for (const SOwnedDecoration& decoration : mOwnedDecorations)
	{
		comfortBonus += decoration.mVisitorComfort;<--- Consider using std::accumulate algorithm instead of a raw loop.
	}
	if (comfortBonus > gMaxDecorationComfortBonus)
	{
		comfortBonus = gMaxDecorationComfortBonus;
	}
	return gBaseWalkingSatisfaction + comfortBonus;
}

void gfCParkLevelComponent::reputationSettle()
{
	if (!mSim || mReputationSettledDay >= mDayIndex)
	{
		return;
	}
	mParkReputation = mSim->economyGet().reputationAfterDayGet(mParkReputation);
	mReputationSettledDay = mDayIndex;
}

void gfCParkLevelComponent::visitorNumbersRefresh()
{
	if (!mSim)
	{
		return;
	}
	mSim->visitorQuotaSet(visitorQuotaHighestOwnedGet());
	mSim->visitorDemandSet(visitorDemandFromParkGet());
	mSim->walkingSatisfactionPercentSet(walkingSatisfactionFromParkGet());
}

void gfCParkLevelComponent::staffHiredRecord(const fsStr& pStaffType, fsS32 pWage)
{
	SHiredStaff hired;
	hired.mType = pStaffType;
	hired.mWage = pWage;
	mHiredStaff.push_back(hired);
}

fsS32 gfCParkLevelComponent::dailyWagesGet() const
{
	fsS32 wages = 0;
	for (const SHiredStaff& hired : mHiredStaff)
	{
		wages += hired.mWage;<--- Consider using std::accumulate algorithm instead of a raw loop.
	}
	return wages;
}

void gfCParkLevelComponent::staffDeployedRecord(const fsStr& pSlotName)
{
	for (const fsStr& deployedSlot : mDeployedSlots)
	{
		if (deployedSlot == pSlotName)
		{<--- Consider using std::any_of algorithm instead of a raw loop.
			return;
		}
	}
	mDeployedSlots.push_back(pSlotName);
}

void gfCParkLevelComponent::staffRecalledRecord(const fsStr& pSlotName)
{
	for (std::vector<fsStr>::iterator it = mDeployedSlots.begin(); it != mDeployedSlots.end(); ++it)
	{
		if (*it == pSlotName)
		{<--- Consider using std::find_if algorithm instead of a raw loop.
			mDeployedSlots.erase(it);
			return;
		}
	}
}

void gfCParkLevelComponent::guestTemplatesLoad()
{
	// Its own catalogue root (guests aren't shop items) - just reuses the
	// catalogue format for its per-entry params.
	gfCCatalogueParserYaml parser;
	std::unique_ptr<gfCCatalogueCatalogue> catalogue(parser.catalogueLoad("catalogue/guests.yml"));

	for (fsS32 i = 0; i < catalogue->numChildrenGet(); ++i)
	{
		if (const auto* const item = dynamic_cast<const gfCCatalogueItem*>(catalogue->childGetByIndex(i)))
		{
			std::vector<fsStr> needs = guestNeedsParse(item->paramGet("needs"));
			if (needs.empty())
			{
				// Backward-compatible content fallback while catalogues migrate.
				needs = guestNeedsParse(item->paramGet("needslottype"));
			}
			fsS32 visitMs = item->paramGet("visitms").toS32();
			fsS32 needIntervalMs = item->paramGet("needintervalms").toS32();
			if (visitMs <= 0)
			{
				visitMs = 45000;
			}
			if (needIntervalMs <= 0)
			{
				needIntervalMs = 8000;
			}
			const fsS32 arrivalWeight = item->paramGet("arrivalweight").toS32();
			const fsS32 partySize = item->paramGet("partysize").toS32();
			mSim->guestTemplateAdd(item->nameGet(), needs,
			                       item->paramGet("spend").toS32(),
			                       item->paramGet("patiencems").toS32(),
			                       visitMs, needIntervalMs,
			                       arrivalWeight > 0 ? arrivalWeight : 1,
			                       partySize > 0 ? partySize : 1);
		}
	}
}

void gfCParkLevelComponent::dayAdvance()
{
	if (mDayIndex < mNumDays)
	{
		++mDayIndex;
		daySimBegin();
		// New day rolled in - persist so Continue resumes on the right day.
		progressPersist();
	}
}

void gfCParkLevelComponent::updateDo(fsS32 pDeltaMs)
{
	// Day over and summary up - freeze the sim rather than running it on behind
	// the summary (which drove the timer negative).
	if (mDayEndShown)
	{
		return;
	}

	mSim->tick(pDeltaMs);

	// Periodic autosave so a mid-day quit resumes where it left off (desktop
	// window-close fires no save hook at all).
	mAutosaveTimerMs += pDeltaMs;
	if (mAutosaveTimerMs >= gAutosaveIntervalMs)
	{
		mAutosaveTimerMs = 0;
		progressPersist();
	}

	mDayRemainingMs -= pDeltaMs;
	if (mDayRemainingMs <= 0)
	{
		// Clamped so the HUD reads 0 rather than a growing negative.
		mDayRemainingMs = 0;
		mDayEndShown = true;

		// Payroll off the day's takings before scoring, shown on the summary.
		// Clamped at zero - no debt.
		mLastDayWages = dailyWagesGet();
		if (mLastDayWages > 0)
		{
			const fsS32 remaining = mSim->economyGet().coinsGet() - mLastDayWages;
			mSim->economyGet().coinsSet(remaining > 0 ? remaining : 0);
		}
		reputationSettle();
		parentGet()->childAdd(fsIGuiComponent::guiCreateFromFile(fsCResourceName(
			fsCAppCoreMain::instanceGet()->settingsGet()->strGet("endOfDaySummary"),
			fsCResourceName::eRES_LOCATION_ASSETS)));

		// Day's final coins/wages are now settled - persist the end-of-day state.
		progressPersist();
	}
}

void gfCParkLevelComponent::listenersRegisterDo()
{
	fsIMessageListener::listenersRegisterDo();
	fsIInputManager::instanceGet()->listenerRegister(fsIInputManager::mTypedCharMsg, this);
}

void gfCParkLevelComponent::listenersDeregisterDo()
{
	fsIMessageListener::listenersDeregisterDo();
	fsIInputManager::instanceGet()->listenerDeregister(fsIInputManager::mTypedCharMsg, this);
}

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

	// Same keys/multipliers as gfCHogLevelComponent. timeStepSet() drives both
	// the app timer and the hardware scale, so sim and animation stay in sync.
	const fsS32 typedChar = static_cast<const fsIInputManager::sKeyboardMsgParam&>(pParam).mKey;
	if ('1' == typedChar)
	{
		fsCAppCoreMain::instanceGet()->timeStepSet(1.0f);
		return true;
	}
	if ('2' == typedChar)
	{
		fsCAppCoreMain::instanceGet()->timeStepSet(4.0f);
		return true;
	}
	if ('3' == typedChar)
	{
		fsCAppCoreMain::instanceGet()->timeStepSet(8.0f);
		return true;
	}

	return false;
}

void gfCParkLevelComponent::progressSave() const
{
	fsCUserSavedData* const userData = fsCProfileManager::instanceGet()->userSavedDataGet();
	userData->s32Set(gfCTimeUserSavedData::mParkDayIndex, mDayIndex);
	userData->s32Set(gfCTimeUserSavedData::mDayRemainingMs, mDayRemainingMs);
	userData->s32Set(gfCTimeUserSavedData::mDayCoins, mSim->economyGet().coinsGet());
	userData->s32Set(gfCTimeUserSavedData::mDayHappyVisitors,
	                 mSim->economyGet().happyCountGet());
	userData->s32Set(gfCTimeUserSavedData::mDayUnhappyVisitors,
	                 mSim->economyGet().unhappyCountGet());
	userData->s32Set(gfCTimeUserSavedData::mDayServicesPurchased,
	                 mSim->economyGet().servicesPurchasedCountGet());
	userData->s32Set(gfCTimeUserSavedData::mDaySatisfactionTotal,
	                 mSim->economyGet().satisfactionTotalGet());
	userData->s32Set(gfCTimeUserSavedData::mParkReputation, mParkReputation);
	userData->s32Set(gfCTimeUserSavedData::mParkReputationSettledDay,
	                 mReputationSettledDay);

	// Ownership (kept outside the per-day sim) - persist it too, else Continue
	// rebuilds the day but the park is empty of everything the player bought.
	userData->s32Set(gfCTimeUserSavedData::mParkOwnedSlotCount, static_cast<fsS32>(mPurchasedSlots.size()));
	for (fsS32 i = 0; i < static_cast<fsS32>(mPurchasedSlots.size()); ++i)
	{
		const SOwnedSlot& slot = mPurchasedSlots[i];
		userData->strSet(ownedSlotKey(i, "Name"), slot.mName);
		userData->s32Set(ownedSlotKey(i, "ServiceMs"), slot.mServiceTimeMs);
		userData->s32Set(ownedSlotKey(i, "QueueLen"), slot.mMaxQueueLength);
		userData->strSet(ownedSlotKey(i, "Image"), slot.mBuildingImage);
		userData->s32Set(ownedSlotKey(i, "Runtime"), slot.mRuntime ? 1 : 0);
		userData->strSet(ownedSlotKey(i, "ServiceType"), slot.mServiceType);
		userData->s32Set(ownedSlotKey(i, "X"), slot.mLocalX);
		userData->s32Set(ownedSlotKey(i, "Y"), slot.mLocalY);
		userData->s32Set(ownedSlotKey(i, "DrawWidth"), slot.mDrawWidth);
		userData->s32Set(ownedSlotKey(i, "FootprintColumns"), slot.mFootprintColumns);
		userData->s32Set(ownedSlotKey(i, "FootprintRows"), slot.mFootprintRows);
		userData->s32Set(ownedSlotKey(i, "VisitorQuota"), slot.mVisitorQuota);
		userData->s32Set(ownedSlotKey(i, "VisitorAppeal"), slot.mVisitorAppeal);
	}

	userData->s32Set(gfCTimeUserSavedData::mParkHiredStaffCount, static_cast<fsS32>(mHiredStaff.size()));
	for (fsS32 i = 0; i < static_cast<fsS32>(mHiredStaff.size()); ++i)
	{
		const SHiredStaff& hired = mHiredStaff[i];
		userData->strSet(hiredStaffKey(i, "Type"), hired.mType);
		userData->s32Set(hiredStaffKey(i, "Wage"), hired.mWage);
	}

	userData->s32Set(gfCTimeUserSavedData::mParkDeployedSlotCount, static_cast<fsS32>(mDeployedSlots.size()));
	for (fsS32 i = 0; i < static_cast<fsS32>(mDeployedSlots.size()); ++i)
	{
		userData->strSet(deployedSlotKey(i), mDeployedSlots[i]);
	}

	userData->s32Set(gfCTimeUserSavedData::mParkDecorationCount, static_cast<fsS32>(mOwnedDecorations.size()));
	for (fsS32 i = 0; i < static_cast<fsS32>(mOwnedDecorations.size()); ++i)
	{
		const SOwnedDecoration& decoration = mOwnedDecorations[i];
		userData->strSet(decorationKey(i, "Image"), decoration.mImage);
		userData->s32Set(decorationKey(i, "DrawWidth"), decoration.mDrawWidth);
		userData->s32Set(decorationKey(i, "FootprintColumns"), decoration.mFootprintColumns);
		userData->s32Set(decorationKey(i, "FootprintRows"), decoration.mFootprintRows);
		userData->s32Set(decorationKey(i, "X"), decoration.mLocalX);
		userData->s32Set(decorationKey(i, "Y"), decoration.mLocalY);
		userData->s32Set(decorationKey(i, "VisitorAppeal"), decoration.mVisitorAppeal);
		userData->s32Set(decorationKey(i, "VisitorComfort"), decoration.mVisitorComfort);
	}

	userData->s32Set(gfCTimeUserSavedData::mParkClearedCellCount,
	                 static_cast<fsS32>(mClearedCells.size()));
	for (fsS32 i = 0; i < static_cast<fsS32>(mClearedCells.size()); ++i)
	{
		userData->s32Set(clearedCellKey(i, "Col"), mClearedCells[i].x);
		userData->s32Set(clearedCellKey(i, "Row"), mClearedCells[i].y);
	}
}

void gfCParkLevelComponent::progressPersist()
{
	progressSave();
	// Actually write the profile file - progressSave only touched the in-memory
	// table. mCurrentLocation (set when the level loaded) rides along in the same
	// table, so this is also what makes Continue find a level to load at all.
	fsCProfileManager::instanceGet()->allDataSave(/*pIsAutoSave*/ true);
}

void gfCParkLevelComponent::ownershipRestore(fsCUserSavedData* const pUserData)
{
	// Rebuilt from disk, so start clean rather than appending to whatever a
	// prior in-session state left behind.
	mPurchasedSlots.clear();
	mHiredStaff.clear();
	mDeployedSlots.clear();
	mOwnedDecorations.clear();
	mClearedCells.clear();
	mRuntimeSlotSequence = 0;
	mParkReputation = pUserData->s32GetWithDefault(
		gfCTimeUserSavedData::mParkReputation, 50);
	mReputationSettledDay = pUserData->s32GetWithDefault(
		gfCTimeUserSavedData::mParkReputationSettledDay, 0);

	const fsS32 slotCount = pUserData->s32GetWithDefault(gfCTimeUserSavedData::mParkOwnedSlotCount, 0);
	for (fsS32 i = 0; i < slotCount; ++i)
	{
		SOwnedSlot owned;
		owned.mName = pUserData->strGet(ownedSlotKey(i, "Name"));
		owned.mServiceTimeMs = pUserData->s32Get(ownedSlotKey(i, "ServiceMs"));
		owned.mMaxQueueLength = pUserData->s32Get(ownedSlotKey(i, "QueueLen"));
		owned.mBuildingImage = pUserData->strGet(ownedSlotKey(i, "Image"));
		owned.mRuntime = 0 != pUserData->s32GetWithDefault(ownedSlotKey(i, "Runtime"), 0);
		owned.mServiceType = pUserData->strGet(ownedSlotKey(i, "ServiceType"));
		owned.mLocalX = pUserData->s32GetWithDefault(ownedSlotKey(i, "X"), 0);
		owned.mLocalY = pUserData->s32GetWithDefault(ownedSlotKey(i, "Y"), 0);
		owned.mDrawWidth = pUserData->s32GetWithDefault(
			ownedSlotKey(i, "DrawWidth"), gServiceBuildingDefaultWidth);
		owned.mFootprintColumns = pUserData->s32GetWithDefault(
			ownedSlotKey(i, "FootprintColumns"), 1);
		owned.mFootprintRows = pUserData->s32GetWithDefault(
			ownedSlotKey(i, "FootprintRows"), 1);
		owned.mVisitorQuota = pUserData->s32GetWithDefault(
			ownedSlotKey(i, "VisitorQuota"), 0);
		owned.mVisitorAppeal = pUserData->s32GetWithDefault(
			ownedSlotKey(i, "VisitorAppeal"), 0);
		if (owned.mRuntime)
		{
			++mRuntimeSlotSequence;
		}
		mPurchasedSlots.push_back(owned);
	}

	const fsS32 staffCount = pUserData->s32GetWithDefault(gfCTimeUserSavedData::mParkHiredStaffCount, 0);
	for (fsS32 i = 0; i < staffCount; ++i)
	{
		SHiredStaff hired;
		hired.mType = pUserData->strGet(hiredStaffKey(i, "Type"));
		hired.mWage = pUserData->s32Get(hiredStaffKey(i, "Wage"));
		mHiredStaff.push_back(hired);
	}

	const fsS32 deployedCount = pUserData->s32GetWithDefault(gfCTimeUserSavedData::mParkDeployedSlotCount, 0);
	for (fsS32 i = 0; i < deployedCount; ++i)
	{
		mDeployedSlots.push_back(pUserData->strGet(deployedSlotKey(i)));
	}

	const fsS32 decorationCount = pUserData->s32GetWithDefault(gfCTimeUserSavedData::mParkDecorationCount, 0);
	for (fsS32 i = 0; i < decorationCount; ++i)
	{
		SOwnedDecoration owned;
		owned.mImage = pUserData->strGet(decorationKey(i, "Image"));
		owned.mDrawWidth = pUserData->s32GetWithDefault(
			decorationKey(i, "DrawWidth"), 0);
		owned.mFootprintColumns = pUserData->s32GetWithDefault(
			decorationKey(i, "FootprintColumns"), 1);
		owned.mFootprintRows = pUserData->s32GetWithDefault(
			decorationKey(i, "FootprintRows"), 1);
		owned.mLocalX = pUserData->s32Get(decorationKey(i, "X"));
		owned.mLocalY = pUserData->s32Get(decorationKey(i, "Y"));
		owned.mVisitorAppeal = pUserData->s32GetWithDefault(
			decorationKey(i, "VisitorAppeal"), 0);
		owned.mVisitorComfort = pUserData->s32GetWithDefault(
			decorationKey(i, "VisitorComfort"), 0);
		mOwnedDecorations.push_back(owned);
	}

	const fsS32 clearedCount = pUserData->s32GetWithDefault(
		gfCTimeUserSavedData::mParkClearedCellCount, 0);
	for (fsS32 i = 0; i < clearedCount; ++i)
	{
		mClearedCells.push_back(fsPoint(
			pUserData->s32Get(clearedCellKey(i, "Col")),
			pUserData->s32Get(clearedCellKey(i, "Row"))));
	}
}

void gfCParkLevelComponent::progressRestore()
{
	fsCUserSavedData* const userData = fsCProfileManager::instanceGet()->userSavedDataGet();
	if (userData->keyExistsGet(gfCTimeUserSavedData::mParkDayIndex))
	{
		mDayIndex = userData->s32Get(gfCTimeUserSavedData::mParkDayIndex);
	}

	// Must precede daySimBegin(): its re-apply loops unlock/staff the fresh sim
	// from exactly these three collections, so they have to be populated first.
	ownershipRestore(userData);

	daySimBegin();

	if (userData->keyExistsGet(gfCTimeUserSavedData::mDayRemainingMs))
	{
		mDayRemainingMs = userData->s32Get(gfCTimeUserSavedData::mDayRemainingMs);
	}
	mSim->economyGet().progressSet(
		userData->s32GetWithDefault(gfCTimeUserSavedData::mDayCoins,
		                            mSim->economyGet().coinsGet()),
		userData->s32GetWithDefault(gfCTimeUserSavedData::mDayHappyVisitors, 0),
		userData->s32GetWithDefault(gfCTimeUserSavedData::mDayUnhappyVisitors, 0),
		userData->s32GetWithDefault(gfCTimeUserSavedData::mDayServicesPurchased, 0),
		userData->s32GetWithDefault(gfCTimeUserSavedData::mDaySatisfactionTotal, 0));
}

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

gfCParkLevelComponent::gfCParkLevelComponent(fsCEntity* const pParent):
fsIMessageListenerComponent(pParent),
mDayIndex(1),
mDayRemainingMs(0),
mDayEndShown(false),
mAutosaveTimerMs(0),
mForestLayerId(-1),
mLastDayWages(0),
mParkReputation(50),
mReputationSettledDay(0),
mRepairArmed(false),
mRuntimeSlotSequence(0)
{
}

gfCParkLevelComponent::~gfCParkLevelComponent()
{
}