v1.15.0 · documentation

Common Game System

A headless C# foundation framework for Unity 6.3 LTS PC single-player projects. Twenty-three production services — save/load, input, scene flow, audio, UI, tweening, FSM and more — wired together by a single Bootstrap.Run(). No DI container, no scene singletons, no setup code in your game scripts.

Unity 6.3 LTS23 services0 dependenciesIL2CPP-readyURP-agnosticAI-ready

Overview

What you get

Engine

Unity 6.3 LTS (6000.3.0f1) · .NET Standard 2.1

Public services

23 — wired by a single Bootstrap.Run()

Third-party deps

0 — Unity Engine + Addressables / Input System / UGUI (first-party) only

Scripting backend

Mono + IL2CPP both verified ([Preserve] + link.xml)

Render pipeline

URP-agnostic — works with URP / HDRP / Built-in / Custom RP (0 rendering code)

Tests

2,550 EditMode passing · 23 Accepted Architecture Decision Records

Samples

7 importable — 4 fully assembled runnable scenes (UI Framework · Motion Lab · Save/Load + Seeded Random · Command Console)

Editor tooling

Welcome / Quick Start window + runtime Service Debugger (Tools ▸ Common Game System)

License

Proprietary — Unity Asset Store EULA

Platforms

PC (Windows / macOS / Linux), single-player

Quick Start

Boot in ≤ 20 lines

The framework boots itself. You only consume services — there is no init code to call.

using CommonGameSystem.Core;
using UnityEngine;

[DefaultExecutionOrder(100)]  // required — see Consumer Conventions
public sealed class MyGame : MonoBehaviour
{
    private IPanelStack _ui;
    private IAudioService _audio;

    private void Start()
    {
        // The framework already registered all 23 services before Start() ran.
        _ui    = ServiceLocator.Resolve<IPanelStack>();
        _audio = ServiceLocator.Resolve<IAudioService>();

        _audio.PlayMusic(myMainTheme, fadeInSeconds: 2f);
        _ui.Push(mainMenuPanel);   // mainMenuPanel implements IPanel
    }
}

That's it — all 23 services were registered before your Start() ran.

Reference

The 23 services

Service Locator

ServiceLocator

Interface → instance registry. Lightweight dependency resolution with no DI container.

Logger

ILogger

Build-tiered log levels, category filters, in-game developer console. Thread-safe.

Event Bus

IEventBus

Type-safe publish/subscribe for decoupled, global game messaging.

Configuration

IConfiguration

ScriptableObject + PlayerPrefs settings (audio / graphics / input) with write-through persistence.

Save / Load

ISaveService

JSON slot saves, versioned migration hooks, cross-platform atomic write.

Input

IInputService

New Input System wrapper — action-map context stack and key rebinding.

Time Service

M12

ITimeService

Pausable per-clock deltaTime — Gameplay / UI / Background clocks run independently.

Object Pool

M10

IObjectPoolService

IPoolable interface, per-category pools, prewarm and automatic return.

Audio

IAudioService

BGM / SFX / Voice channels, pooled AudioSources, fade in/out, volume binding.

UI Framework

M11

IPanelStack

Modal/panel stack, keyboard + gamepad navigation, transition animations.

Scene Flow (+ additive)

ISceneService

Async scene load with loading screen + cancel, plus additive scene layering (v1.13.0).

Localization

M13

ILocalizationService

i18n string tables, runtime SetLocale with live LocalizedText re-binding (no restart).

Achievements / Stats

M14

IAchievementService

Data-driven SO tables, named stat counters, threshold auto-unlock, M6 persistence.

Scheduler / Timer

M15

IScheduler

Pause/slow-mo-aware After / Every / NextFrame timers + worker→main dispatcher.

Tween / Easing

M16

ITweenService

Pause-aware value interpolation, closed typed To/From overloads, 31 easing curves, 0-alloc.

Asset Provider

M17

IAssetProvider

Addressables-backed async loading with a refcount model + scope-bound auto-unload.

Seeded Random

M18

IRandomService

Deterministic xoshiro256** with named/forkable streams + save-correct snapshot/restore.

FSM Service

M19

IStateMachineService

Generic flat finite-state machine over a game-defined TContext, guarded transitions.

Pushdown / State-Stack

M20

IPushdownStackService

LIFO stack of resumable logical scopes (dialogue-over-gameplay, menu back-stack).

Tween Sequencing

M21

ITweenSequenceService

Fluent builder over Tween — ordered + parallel, pause-aware per-clock timelines.

Addressable Scene

M23

IAddressableSceneService

Async additive scene load/unload from the Addressables catalog, per-key refcount, never-throw.

Deferred Event Queue

M24

IDeferredBus

Capture an event now, publish it later at a chosen Flush() — defer out of a physics callback or a collection you're iterating.

Command Registry

M25

ICommandRegistry

Runtime command nucleus — register / tokenize / execute, history ring, prefix autocomplete. The console UI stays yours.

Each service ships a per-module reference doc and a NullX no-op implementation inside the package (Documentation/Modules/).

How it works

Architecture in 60 seconds

No DI container. A static ServiceLocator holds IService → instance pairs.
Consumer code: var x = ServiceLocator.Resolve<IService>() — cache the instance, never resolve inside Update().
Framework body: services are constructor-injected by Bootstrap.Run — implementations import zero ServiceLocator (test-isolated).
Pillar 3 escape hatch: every service ships a NullX no-op. ServiceLocator.Replace<IService>(new NullX()) mutes a subsystem game-wide with zero caller changes.
AI-ready: ships with AGENT.md + 5 task skills (cgs-init / cgs-panel / cgs-event / cgs-config / cgs-test) for Claude Code, Cursor, and GitHub Copilot.

Releases

Changelog

v1.15.02026-07-25

Three new Core services (20 → 23), wired by the same single Bootstrap.Run(): Addressable Scene (IAddressableSceneService — async additive scene load/unload from the Addressables catalog, per-key refcount, never-throw runtime data), Deferred Event Queue (IDeferredBus — capture an event now and publish it later at a chosen Flush() point), and Command Registry (ICommandRegistry — a runtime command nucleus with register / tokenize / execute, history and prefix autocomplete; the in-game console UI stays yours). Samples grew to 7 importable, 4 of them fully assembled runnable scenes: Motion Lab (8-ease tween gallery, waypoint sequencing, and the per-Clock money shot — gameplay TimeScale 0 freezes the gallery while the UI spinner keeps moving), Save/Load + Seeded Random (after Load, the next three seeded rolls exactly match the prediction armed at Save), M25 Command Console (working in-game dev console with history and autocomplete), plus an RPG Starter code template. New editor tooling under Tools ▸ Common Game System: a Welcome / Quick Start window (environment checks, one-click sample import) and a runtime Service Debugger (live service registry, per-Clock time scales, active tween/FSM/audio/command stats). Fixes: persisted audio settings now apply at boot (mixer early-init race), the UI sample's volume/mute controls act immediately and now ship a public-domain BGM so you can hear them work, panel-navigation NullReferenceException, the "No cameras rendering" watermark, and a play-exit teardown exception. Still 0 third-party dependencies; IL2CPP-ready; URP-agnostic; 2,550 automated EditMode tests.

v1.14.02026-06-14

Initial Unity Asset Store release. 20 production services wired by a single Bootstrap.Run() — Service Locator, Logger, Event Bus, Save/Load, Configuration, Input, Time, Object Pool, Audio, UI Panel Stack, Scene Flow (+additive), Localization, Achievements/Stats, Scheduler, Tween, Asset Provider, Random, FSM, Pushdown Stack, Tween Sequencing. 0 third-party dependencies, IL2CPP-ready, URP-agnostic, AI-ready (AGENT.md + 5 task skills). Versions prior to 1.14.0 were internal development milestones and were never published.

Full per-version engineering changelog ships inside the package (CHANGELOG.md).

Legal

License

Common Game System is proprietary software distributed exclusively through the Unity Asset Store. Use is governed by the Unity Asset Store EULA.

✓ Use in commercial & non-commercial games shipped on Unity-supported platforms.
✓ Modify consumer-side code that calls the framework's public APIs.
✗ Re-publishing the framework (or substantial derivatives) on any asset marketplace.
✗ Removing copyright / license notices or sub-licensing the source.

Support

Get help

Questions or support requests:yoop80075@gmail.com· or the Asset Store publisher Q&A tab on the package page.