API Reference

This page documents the two static code surfaces a developer touches when reskinning Traffic Overtaker into their own game: TO_API (all persistence, currency, vehicle ownership, high scores, audio/quality settings, and scene navigation) and TO_Events (the static event bus). Both live under Assets/TO/Scripts/ and are written to be called directly from your own UI scripts, gameplay code, or custom managers without needing a reference to a manager instance. Every member listed here was read verbatim from the source (Assets/TO/Scripts/TO_API.cs and Assets/TO/Scripts/Misc/TO_Events.cs) — signatures match the shipping code exactly.

Both classes follow the project convention: the TO_ prefix, the BoneCrackerGames namespace, and all members are static, so you call them by type name (TO_API.GetCurrency(), TO_Events.OnRaceStarted += ...). Other TO scripts (also in BoneCrackerGames) see them with no using directive; from a script of your own outside that namespace, add using BoneCrackerGames; (or fully-qualify the type). There are no assembly definitions, so everything shares the default Assembly-CSharp. For the bigger picture of how these classes fit into the manager/singleton layer, see 04_SystemArchitecture.md.

TO_API — persistence and navigation

TO_API is the single entry point for everything that survives between play sessions. It is a thin, static wrapper over Unity's PlayerPrefs (plus the TO_PlayerPrefsX helper for booleans), so there is no instance to find and no component to add — you call the static methods from anywhere. Several setters fire TO_Events.Event_OnOptionsChanged() after writing, so UI that listens to that event refreshes automatically. The currency setters fire TO_API.OnPlayerMoneyChanged for the same reason.

A note on persistence boundaries: most getters/setters read and write a PlayerPrefs key, but GetControllerType() reads the live RCCP_Settings.Instance.mobileController value (not a PlayerPrefs key). Quality is the reverse — SetQuality() / GetQuality() both persist to the QualityLevel PlayerPrefs key and mirror it to Unity's QualitySettings (so GetQuality() returns the saved level, falling back to QualitySettings.GetQualityLevel() only on first launch). Keep this in mind when you reset or migrate save data.

Events on TO_API

Currency and player identity

Vehicle ownership

Ownership is stored per vehicle as a {VehicleName}Owned key, where VehicleName is the prefab name of the entry in TO_PlayerCars. The index passed to these methods is the index into that roster. See 06_PlayerVehicles.md for the roster itself.

High scores

Audio, graphics, and controller settings

SetShadows() and SetPP() take no argument — each call flips the stored boolean. Controller types are covered in detail in 11_ControllerTypes.md.

Scene navigation and reset

MainMenu() is hard-coded to build index 0, while ResetGame() loads the configurable mainMenuSceneIndex from TO_Settings. If you reorder your Build Settings so the main menu is not index 0, audit both paths.

PlayerPrefs keys used by TO_API

Every key below was confirmed against TO_API.cs. Defaults marked "TO_Settings" are pulled from the TO_Settings ScriptableObject at read time, so changing the asset changes the fallback for a fresh install.

The keys SelectedPlayerCarIndex and SelectedModeIndex carry the cross-scene selection but are not read or written inside TO_API.cs — they are managed elsewhere (the main menu and gameplay managers), so they are intentionally omitted from the table above.

TO_API usage example

// Award currency at the end of a run and persist a new best score.
void OnRunFinished(int runScore) {

    TO_API.AddCurrency(runScore);           // fires OnPlayerMoneyChanged

    int best = TO_API.GetHighScores()[0];
    if (runScore > best)
        PlayerPrefs.SetInt("bestScoreOvertake", runScore);
}

// Unlock a car from a shop button, then refresh the wallet label.
void BuyCar(int rosterIndex, int price) {

    if (TO_API.GetCurrency() >= price && !TO_API.OwnedVehicle(rosterIndex)) {
        TO_API.ConsumeCurrency(price);
        TO_API.UnlockVehicle(rosterIndex);
    }
}

TO_Events — the static event bus

TO_Events decouples gameplay systems from UI. Producers (the gameplay manager, the player, the menu) call a Event_OnXxx() trigger method; consumers (HUD, sound, analytics) subscribe to the matching static event. Every trigger method null-checks its event before invoking, so it is always safe to fire even when nothing is listening. This is the standard pattern inherited from the project's HR2 lineage and is used throughout the UI scripts described in 04_SystemArchitecture.md.

Events and their delegates

Trigger methods

Each event has a matching public trigger you call to raise it. These are what the managers invoke; you normally only call them if you are writing your own producer.

TO_Events usage example

// A HUD widget that reacts to run lifecycle and options.
void OnEnable() {
    TO_Events.OnRaceStarted   += HandleRaceStarted;
    TO_Events.OnPlayerDied    += HandlePlayerDied;
    TO_Events.OnOptionsChanged += RefreshFromSettings;
}

void OnDisable() {
    TO_Events.OnRaceStarted   -= HandleRaceStarted;
    TO_Events.OnPlayerDied    -= HandlePlayerDied;
    TO_Events.OnOptionsChanged -= RefreshFromSettings;
}

void HandleRaceStarted() { /* show the live HUD */ }

void HandlePlayerDied(TO_Player player, int[] scores) {
    int finalScore = scores.Length > 0 ? scores[0] : 0;
    // present the game-over panel with finalScore
}

Always subscribe in OnEnable and unsubscribe in OnDisable (or OnDestroy). Because every event is a static, a forgotten unsubscribe keeps your destroyed object's handler alive across scene loads, which leaks the object and can throw MissingReferenceException the next time the event fires. This is the single most common mistake when extending the event bus.

See Also

• 04_SystemArchitecture.md — how TO_API and TO_Events sit beneath the managers, singletons, and UI.
• 12_EditorTools.md — the editor menus and custom inspectors that author the data these APIs read at runtime.
• 06_PlayerVehicles.md — the TO_PlayerCars roster that vehicle-ownership indexes refer to.
• 11_ControllerTypes.md — controller-type values used by Get/SetControllerType.