gfCParkDaySim.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           gfCParkDaySim.h
*
*       Purpose:        Headless day-loop orchestrator: arrival director, visitors,
*                               service slots and economy. Exploring is primary; authored
*                               service needs are optional diversions during a park visit.
*
*********************************************************************/
 
#ifndef gfCParkDaySimhdr
#define gfCParkDaySimhdr
 
#include <vector>
 
#include <fsCore/fsStr.h>
#include <fsCore/fsBaseTypes.h>
 
#include "gfCSlotSim.h"
#include "gfCGuestAgentSim.h"
#include "gfCArrivalDirectorSim.h"
#include "gfCDayEconomySim.h"
 
class gfCParkDaySim
{
public:
 
        gfCParkDaySim(fsS32 pSpawnIntervalMs, fsS32 pMaxGuests, fsS32 pCoinGoal);
 
        void slotAdd(const fsStr& pName, const fsStr& pSlotType, fsS32 pServiceTimeMs, fsS32 pMaxQueueLength,
                     fsBool pUnlocked);
 
        // Unlocks a registered slot when its building is purchased. False if no
        // such slot exists.
        fsBool slotUnlock(const fsStr& pName);
 
        // Staff types (kiosk mans a building, repair fixes broken ones). Keyed by
        // string so staff.yml stays the source of truth for roles.
        static const fsStr mStaffTypeKiosk;
        static const fsStr mStaffTypeRepair;
 
        // Genre guard: staff are a scarce, player-deployed resource. Growing the
        // pool doesn't staff anything - only deploy/recall does.
        void staffPoolGrow(const fsStr& pStaffType, fsS32 pBy = 1);
        fsS32 staffTotalGet(const fsStr& pStaffType) const;
        fsS32 staffAvailableGet(const fsStr& pStaffType) const;
 
        // Untyped overloads mean "kiosk" (keeps the doctests unchanged).
        void staffPoolGrow(fsS32 pBy = 1) { staffPoolGrow(mStaffTypeKiosk, pBy); }
        fsS32 staffTotalGet() const { return staffTotalGet(mStaffTypeKiosk); }
        fsS32 staffAvailableGet() const { return staffAvailableGet(mStaffTypeKiosk); }
 
        // False (no-op) if there's no such slot, it's already staffed, or the
        // pool has nobody available.
        fsBool staffDeploy(const fsStr& pSlotName);
 
        // False (no-op) if there's no such slot or it isn't staffed.
        fsBool staffRecall(const fsStr& pSlotName);
 
        fsBool slotStaffedGet(const fsStr& pSlotName) const;
        fsBool slotBrokenGet(const fsStr& pSlotName) const;
        fsBool slotRepairingGet(const fsStr& pSlotName) const;
 
        // Applied to every slot; 0 for a limit means "never breaks that way". Both
        // default to 0, so slots are indestructible unless a game opts in.
        void slotWearLimitsSetAll(fsS32 pServicesBeforeBreak, fsS32 pOpenMsBeforeBreak);
        void repairTimeMsSet(fsS32 pRepairTimeMs) { mRepairTimeMs = pRepairTimeMs; }
 
        // Sends an idle repairer to a slot (fix or preventive), tying them up until
        // done. False if none free or one is already on it.
        fsBool slotRepairBegin(const fsStr& pSlotName);
 
        // Registers a visitor type selected by smooth catalogue-authored weighting.
        // The single-need overload keeps small callers concise; catalogue content
        // uses the vector overload to author a sequence of secondary needs.
        void guestTemplateAdd(const fsStr& pNamePrefix, const fsStr& pNeedSlotType,
                              fsS32 pSpend, fsS32 pPatienceMs, fsS32 pVisitMs = 5000,
                              fsS32 pNeedIntervalMs = 0, fsS32 pArrivalWeight = 1,
                              fsS32 pPartySize = 1);
        void guestTemplateAdd(const fsStr& pNamePrefix, const std::vector<fsStr>& pNeedSlotTypes,
                              fsS32 pSpend, fsS32 pPatienceMs, fsS32 pVisitMs,
                              fsS32 pNeedIntervalMs, fsS32 pArrivalWeight = 1,
                              fsS32 pPartySize = 1);
 
        // Walk time to a slot before service can start. Defaults to 0 (keeps the
        // doctests' timings); the game sets a real value.
        void guestTravelMsSet(fsS32 pTravelMs) { mGuestTravelMs = pTravelMs; }
        // Environmental comfort changes the value of the wandering portion of every
        // visit. It applies to current guests as well as future arrivals.
        void walkingSatisfactionPercentSet(fsS32 pPercent);
        fsS32 walkingSatisfactionPercentGet() const { return mWalkingSatisfactionPercent; }
 
        // Daily admissions cap supplied by the best owned entrance. It can increase
        // mid-day when an entrance is built without resetting the spawn timer.
        void visitorQuotaSet(fsS32 pVisitorQuota);
        fsS32 visitorQuotaGet() const { return mVisitorQuota; }
        void visitorDemandSet(fsS32 pVisitorDemand);
        fsS32 visitorDemandGet() const { return mVisitorDemand; }
        fsS32 visitorArrivalTargetGet() const { return mArrivalDirector.maxGuestsGet(); }
 
        // Chance that a guest who reaches an unstaffed matching building completes a
        // self-guided visit and leaves happy. Zero preserves the strict staffed-only
        // simulation; the park game opts into a content-tuned percentage.
        void unstaffedVisitHappyChancePercentSet(fsS32 pChancePercent);
 
        // Overrides one walking guest's remaining travel time. The sim is
        // spatial-free, so it can only apply a flat guestTravelMs to every walk -
        // which makes distant slots look faster (same time, more distance). The
        // presentation layer, which knows the real distance, calls this so travel
        // time tracks distance and the sprite walks at a constant speed. No-op if
        // there's no such guest. See gfCParkGuestViewComponent.
        void guestTravelTimeSet(const fsStr& pGuestName, fsS32 pTravelMs);
 
        // Applied when a building is purchased into the slot. False if no such slot.
        fsBool slotServiceTimeMsSet(const fsStr& pSlotName, fsS32 pServiceTimeMs);
        fsBool slotMaxQueueLengthSet(const fsStr& pSlotName, fsS32 pMaxQueueLength);
 
        void tick(fsS32 pDeltaMs);
 
        fsS32 activeGuestCountGet() const { return static_cast<fsS32>(mGuests.size()); }
        fsS32 guestsSpawnedGet() const { return mGuestsSpawnedCount; }
 
        // Read-only guest enumeration for presentation, paired with
        // activeGuestCountGet(). Null if out of range. Guests are erased the tick
        // they enter LEAVING_*, so a caller wanting to animate departures must hold
        // its own copy (see gfCParkGuestViewComponent).
        const gfCGuestAgentSim* guestGetByIndex(fsS32 pIndex) const;
 
        // Departures from the most recent tick (name + why), cleared at the start of
        // the next - the only place to see *why* a guest left, since they're erased
        // the same tick. A caller running after each tick sees each one once.
        struct SDeparture
        {
                fsStr mName;
                fsBool mHappy;
                fsS32 mSatisfactionPercent;
        };
 
        fsS32 departureCountGet() const { return static_cast<fsS32>(mDepartures.size()); }
        const SDeparture* departureGetByIndex(fsS32 pIndex) const;
        const gfCDayEconomySim& economyGet() const { return mEconomy; }
        gfCDayEconomySim& economyGet() { return mEconomy; }
 
private:
 
        struct SGuestTemplate
        {
                fsStr mNamePrefix;
                std::vector<fsStr> mNeedSlotTypes;
                fsS32 mSpend;
                fsS32 mPatienceMs;
                fsS32 mVisitMs;
                fsS32 mNeedIntervalMs;
                fsS32 mArrivalWeight;
                fsS32 mPartySize;
                fsS32 mSelectionCredit;
        };
 
        void guestSpawn();
        gfCGuestAgentSim* guestFind(const fsStr& pName);
 
        // Prefer a staffed matching slot whose wait fits this guest's patience;
        // otherwise fall back to an unstaffed matching building with room.
        gfCSlotSim* slotWithRoomFind(const fsStr& pSlotType, fsS32 pPatienceRemainingMs);
        fsBool unstaffedVisitHappyRoll();
 
        // Joins the guest's assigned slot, setting state. False if it filled up
        // while they walked over.
        fsBool guestSlotJoin(gfCGuestAgentSim& pGuest);
        void guestServiceComplete(gfCGuestAgentSim& pGuest);
 
        std::vector<gfCSlotSim> mSlots;
        std::vector<gfCGuestAgentSim> mGuests;
        std::vector<SDeparture> mDepartures;
        std::vector<SGuestTemplate> mGuestTemplates;
 
        gfCArrivalDirectorSim mArrivalDirector;
        gfCDayEconomySim mEconomy;
 
        fsS32 mGuestsSpawnedCount;
        fsS32 mVisitorQuota;
        fsS32 mVisitorDemand;
 
        struct SStaffPool
        {
                fsStr mType;
                fsS32 mTotal;
                fsS32 mDeployed;
        };
 
        SStaffPool* staffPoolFind(const fsStr& pStaffType);
        const SStaffPool* staffPoolFind(const fsStr& pStaffType) const;
 
        std::vector<SStaffPool> mStaffPools;
        fsS32 mGuestTravelMs;
        fsS32 mWalkingSatisfactionPercent;
        fsS32 mRepairTimeMs;
        fsS32 mUnstaffedVisitHappyChancePercent;
        fsU32 mUnstaffedVisitRandomState;
 
        // Slots being repaired, so the repairer is handed back on completion.
        std::vector<fsStr> mSlotsUnderRepair;
 
        gfCSlotSim* slotFind(const fsStr& pName);
        const gfCSlotSim* slotFind(const fsStr& pName) const;
};
 
#endif