gfCSlotSim.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           gfCSlotSim.h
*
*       Purpose:        Headless building-slot state machine: serves one guest
*                               at a time plus a bounded FIFO queue (one-table Diner-Dash
*                               mechanic). Engine-independent (fsCore only) so it's
*                               unit-testable - see gameModules/gfTimeCore/tests.
*
*                               Genre guard: a guest can queue at an unstaffed slot, but
*                               tick() never progresses service for it - only a staffed
*                               slot serves. Staffing is player-driven via gfCParkDaySim.
*
*********************************************************************/
 
#ifndef gfCSlotSimhdr
#define gfCSlotSimhdr
 
#include <vector>
 
#include <fsCore/fsStr.h>
#include <fsCore/fsBaseTypes.h>
 
enum class eSlotSimState
{
        eLOCKED,
        eOPEN,
        // Worn out - serves nobody until a repair staff member is sent.
        eBROKEN
};
 
class gfCSlotSim
{
public:
 
        gfCSlotSim(const fsStr& pName, const fsStr& pSlotType, fsS32 pServiceTimeMs, fsS32 pMaxQueueLength);
 
        const fsStr& nameGet() const { return mName; }
        const fsStr& slotTypeGet() const { return mSlotType; }
        eSlotSimState stateGet() const { return mState; }
        void unlock() { mState = eSlotSimState::eOPEN; }
 
        fsBool staffedGet() const { return mStaffed; }
        void staffedSet(fsBool pStaffed) { mStaffed = pStaffed; }
 
        // Non-mutating "could a guest commit to walking here?" - they pick a slot
        // before setting off and only join on arrival.
        fsBool hasRoomGet() const;
 
        // Rough wait for a guest joining the back of the queue now (current service
        // left + a service per queued guest). Only meaningful when staffed; used so a
        // guest won't commit to a line too long to reach within their patience.
        fsS32 estimatedWaitMsGet() const;
 
        // Both come from the catalogue entry, applied on purchase - the TMX
        // registration runs first and doesn't know them yet.
        void serviceTimeMsSet(fsS32 pServiceTimeMs) { mServiceTimeMs = pServiceTimeMs; }
        void maxQueueLengthSet(fsS32 pMaxQueueLength) { mMaxQueueLength = pMaxQueueLength; }
 
        fsBool queueingGet(const fsStr& pGuestName) const;
        fsBool servingGet(const fsStr& pGuestName) const { return mServingGuestName == pGuestName; }
        // Removes a waiting guest that abandoned the queue. False if they were not
        // queued; serving guests are never removed through this path.
        fsBool queueLeave(const fsStr& pGuestName);
 
        // Adds to service (if free) or the queue (if room). False if locked or full.
        fsBool queueJoin(const fsStr& pGuestName);
 
        // Bumps whoever is mid-service back to the head of the queue, returning their
        // name (empty if none). Used on staff recall - a served guest left in an
        // unstaffed slot would be frozen and block everyone behind them.
        fsStr servingSuspend();
 
        // Whichever wear limit is reached first breaks the slot. Either can be 0
        // ("never breaks that way"); both default to 0 so slots are indestructible
        // unless a game opts in - keeps the doctests breakdown-free.
        void wearLimitsSet(fsS32 pServicesBeforeBreak, fsS32 pOpenMsBeforeBreak);
 
        fsBool brokenGet() const { return eSlotSimState::eBROKEN == mState; }
 
        // Sends a repairer in: fixes a broken slot, or maintains a still-open one
        // (preventive - resets wear, keeps serving). False if locked or already being
        // repaired. gfCParkDaySim owns the staff accounting.
        fsBool repairBegin(fsS32 pRepairTimeMs);
        fsBool repairingGet() const { return mRepairRemainingMs > 0; }
 
        // Removes everyone (serving + queued) and returns their names. Used on break.
        std::vector<fsStr> occupantsEjectAll();
 
        // Advances service, wear and any in-progress repair - so a slot can break or
        // reopen inside this call. Returns the guest finished this tick, or empty.
        fsStr tick(fsS32 pDeltaMs);
 
private:
 
        // Head of the queue into the serving position, timer started.
        void serveNextBegin();
 
        // Trips to eBROKEN once either wear limit is passed.
        void wearCheck();
 
        fsStr mName;
        fsStr mSlotType;
        eSlotSimState mState;
        fsBool mStaffed;
        fsS32 mServiceTimeMs;
        fsS32 mMaxQueueLength;
 
        std::vector<fsStr> mQueue;
        fsStr mServingGuestName;
        fsS32 mServiceRemainingMs;
 
        // Wear accrues from both use and elapsed open time; a repair clears both.
        fsS32 mServicesBeforeBreak;
        fsS32 mOpenMsBeforeBreak;
        fsS32 mServicesSinceRepair;
        fsS32 mOpenMsSinceRepair;
        fsS32 mRepairRemainingMs;
};
 
#endif