Checkout Frenzy - Convenience Store Simulator

About Checkout Frenzy - Convenience Store Simulator – Unity Asset Pack

Checkout Frenzy - Convenience Store Simulator Unity Asset Overview

The Checkout Frenzy - Convenience Store Simulator template is structured around an event-driven simulation architecture designed to separate core gameplay loops from UI rendering and spatial interactions. At the architectural center is a decoupled manager system featuring a central state coordinator, localized register controllers, and a data-driven item catalog built on ScriptableObjects.

The simulation loop relies heavily on the observer pattern to avoid polling states inside Update() methods. Game events such as item scanning, customer queuing, payment processing, and inventory replenishment communicate through C# System.Action delegates and UnityEvent hooks. This ensures that UI updates—such as digital cash register screens and day-end earnings summaries—only trigger when physical or logical state changes occur.

Data-Driven Item & Register Logic

Product metadata is encapsulated within ItemDataSO ScriptableObject containers. This decouples visual prefabs, sound effects, barcodes, base wholesale prices, and retail pricing from individual game objects. The scanning mechanism detects item collisions via localized trigger volumes, passing references to a central transaction handler.

using System;
using UnityEngine;

namespace CheckoutFrenzy.Core
{
    public class CheckoutRegister : MonoBehaviour
    {
        public static event Action<float> OnTransactionCompleted;
        
        [SerializeField] private Transform beltDropPoint;
        private float _currentTotal;

        public void ProcessScannedItem(ItemDataSO itemData)
        {
            if (itemData == null) return;

            _currentTotal += itemData.RetailPrice;
            UpdateRegisterDisplay(_currentTotal);
        }

        public void FinalizePayment(float amountTendered)
        {
            float changeDue = amountTendered - _currentTotal;
            if (changeDue >= 0f)
            {
                OnTransactionCompleted?.Invoke(_currentTotal);
                ResetRegister();
            }
        }

        private void ResetRegister()
        {
            _currentTotal = 0f;
            UpdateRegisterDisplay(0f);
        }

        private void UpdateRegisterDisplay(float value)
        {
            // Event-driven UI update dispatch
        }
    }
}

Garbage Collection & Allocation Profiling

To maintain stable frame times under heavy simulation load, the asset minimizes runtime heap allocations:

• String Formatting: Transaction subtotals and customer counts utilize cached string builders or static number formats to prevent per-frame string concatenation allocations in the UI loop.
• Object Pooling: Customers, purchasable physical items, and dynamic UI floating text elements use an internal generic object pool (GenericObjectPool<T>) to eliminate garbage collection spikes caused by continuous Instantiate() and Destroy() calls.
• Collection Reuse: Pathfinding query arrays and customer target lists are pre-allocated during initialization rather than created dynamically inside simulation loops.

Customer AI & NavMesh Simulation Performance

Customer behavior in Checkout Frenzy relies on a combination of a Finite State Machine (FSM) and Unity's NavMesh navigation system. Agents navigate between store shelves, evaluate shopping decisions, proceed to available checkout counters, and queue in orderly lines.

NavMesh Agent Optimization

Simulating multiple active customer agents simultaneously requires careful configuration of pathfinding updates and collision avoidance. Instead of updating agent destinations on every frame, destination points are assigned asynchronously upon entering a new state (e.g., Browsing, Queueing, or Exiting).

• Obstacle Avoidance: Agents utilize Low-Quality / RVOSimple obstacle avoidance settings to balance CPU thread consumption with dense agent movement near register queues.
• Queue Node Management: Queues are managed via dynamic structural arrays connected to each CheckoutRegister. As an agent moves up in line, target positions shift dynamically through array index assignment rather than constant recalculation of global paths.
• Off-Mesh Link Traversal: Store transitions (e.g., entering through sliding doors or stepping over restock crates) are handled cleanly using baked NavMeshLinks.

Mono vs. IL2CPP Overhead Consideration

When deploying to IL2CPP target platforms (such as Standalone PC or Mobile), the abstract state machine design benefits significantly from generic method stripping and direct interface calls. Virtual method overhead within the FSM is minimized by structuring high-frequency state updates through direct class references rather than deep polymorphic calls.

Inspector Configuration & Workflow

The system prioritizes custom Unity Editor integration to facilitate fast setup and scene iteration. Custom property drawers and inspector overrides render real-time status indicators for store statistics, shelf capacities, and active registers directly within the Editor viewport.

Key Inspector Setup Components

• StoreDataSO Inspector: Serves as the global configuration asset where overall store difficulty, customer spawn rates, opening/closing hours, and starting capital are managed.
• Shelf Anchor System: Specialized components attached to shelf prefabs automatically map snapping points for product placement, rendering visual Gizmos in the Scene View for rapid level layout.
• Register Register Node Inspector: Allows level designers to visualize queue paths, conveyor belt speed, scanning trigger zones, and bag drop locations using interactive Handles.

Quick-Start Unity Integration Guide

Setting up Checkout Frenzy in a fresh scene requires establishing the primary system managers, baking target navigation spaces, and initializing item databases.

Step 1: Hierarchy Setup & Core Managers

Instantiate the core manager prefabs into your scene structure. The primary controllers are divided into distinct functional roles:

// Scene Hierarchy Layout Structure
[ -- SYSTEM MANAGERS -- ]
  ├── StoreManager (Handles time of day, income totals, store open status)
  ├── CustomerSpawner (Controls customer pool and spawn rates)
  └── UIManager (Coordinates HUD, cash register UI, day summary screens)
[ -- ENVIRONMENT -- ]
  ├── NavMeshSurface (Baked environment geometry)
  └── Shelves & Registers
[ -- OBJECT POOLS -- ]
  ├── CustomerPool
  └── ItemPool

Step 2: Database Initialization

Create a master product list by right-clicking in the Project View and navigating to Create > Checkout Frenzy > Item Database. Assign all localized ItemDataSO assets into the database array. Connect this database asset to the StoreManager inspector slot.

Step 3: Baking Navigation Surfaces

Select your store environment geometry, flag appropriate surfaces as Navigation Static (or assign to a dedicated Layer), and execute a surface bake via the Unity NavMeshSurface component. Ensure that physical register counters and shelf bases are set as non-walkable bounds or flagged with NavMeshObstacle components.

Step 4: Linking Checkout Stations

Place the CheckoutCounter prefab into the store layout. In the Inspector, configure the QueueManager sub-component by assigning line marker Transforms to establish where customer agents will wait during checkout sequences.

Developers Who Downloaded This Also Downloaded

Related Unity Templates Assets