📝 Lesson 5.3: Capstone Project — "Coin Rush"

The Brief & Architecture

Coin Rush: the player rolls a ball around a walled arena. Coins spawn at random spots; touching one adds its value to the score and it despawns. A 30-second countdown ticks down; at zero, the game ends and shows the final score plus the best score ever (saved to disk). Press a key to play again.

Before writing code, picture how the pieces connect. Notice the shape from the whole course: the GameManager broadcasts via events; systems react. Nothing reaches into the manager except deliberate commands.

Phase 1 — Player & Coins

Modules 1–2: components, lifecycle, input, physics, triggers.

The player is a physics object: read input in Update, apply force in FixedUpdate (Lessons 1.2, 2.1, 2.2). Cache the Rigidbody in Awake (Lessons 1.3, 5.1).

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class PlayerController : MonoBehaviour
{
    [SerializeField] private float moveForce = 12f;

    private Rigidbody body;
    private Vector2 input;

    void Awake() => body = GetComponent<Rigidbody>();   // cache (Lesson 1.3 / 5.1)

    void Update()
    {
        // Read input every frame so nothing is missed (Lesson 1.2).
        input.x = Input.GetAxisRaw("Horizontal");
        input.y = Input.GetAxisRaw("Vertical");
    }

    void FixedUpdate()
    {
        // Apply physics on the fixed step (Lesson 2.2).
        Vector3 dir = new Vector3(input.x, 0f, input.y);
        if (dir.sqrMagnitude > 1f) dir.Normalize();     // no fast diagonals (Lesson 2.1)
        body.AddForce(dir * moveForce);
    }
}

A coin is a trigger (Lesson 2.2): when the Player enters, it awards points and despawns. We'll fill in its data and pooling in Phase 2 — for now, the collision shape of the game:

using UnityEngine;

[RequireComponent(typeof(Collider))]
public class Coin : MonoBehaviour
{
    private CoinData data;               // assigned by the spawner (Phase 2)
    private System.Action<Coin> onCollected;   // how to return to the pool (Phase 2)

    public void Init(CoinData data, System.Action<Coin> onCollected)
    {
        this.data = data;
        this.onCollected = onCollected;
    }

    void OnTriggerEnter(Collider other)
    {
        if (!other.CompareTag("Player")) return;   // only the player (Lesson 2.2)

        GameManager.Instance.AddScore(data.value); // command the manager (Lesson 4.1)
        onCollected?.Invoke(this);                  // back to the pool (Lesson 5.1)
    }
}

Phase 2 — Data & Pooled Spawner

Modules 3 & 5: ScriptableObjects, coroutines, object pooling.

Coin stats live in a ScriptableObject (Lesson 3.1), so designers can make "SilverCoin" and "GoldCoin" assets with different values without touching code:

using UnityEngine;

[CreateAssetMenu(fileName = "CoinData", menuName = "CoinRush/Coin Data")]
public class CoinData : ScriptableObject
{
    public int value = 1;
    public Color color = Color.yellow;
}

The spawner ties together three course ideas: a coroutine spawns on an interval (Lesson 3.3), an object pool reuses coins instead of churning them (Lesson 5.1), and it only runs while the game is in the Playing state (Lesson 4.1):

using System.Collections;
using UnityEngine;
using UnityEngine.Pool;

public class CoinSpawner : MonoBehaviour
{
    [SerializeField] private Coin coinPrefab;
    [SerializeField] private CoinData coinData;
    [SerializeField] private float interval = 0.75f;
    [SerializeField] private Vector2 areaHalfSize = new(8f, 8f);

    private ObjectPool<Coin> pool;

    void Awake()
    {
        pool = new ObjectPool<Coin>(
            () => Instantiate(coinPrefab),
            c => c.gameObject.SetActive(true),
            c => c.gameObject.SetActive(false),
            c => Destroy(c.gameObject),
            defaultCapacity: 30);
    }

    // Started/stopped by the GameManager's state (Phase 3).
    public void BeginSpawning() => StartCoroutine(SpawnLoop());
    public void StopSpawning()  => StopAllCoroutines();

    private IEnumerator SpawnLoop()
    {
        var wait = new WaitForSeconds(interval);   // cached (Lesson 3.3 / 5.1)
        while (true)
        {
            SpawnOne();
            yield return wait;
        }
    }

    private void SpawnOne()
    {
        Coin coin = pool.Get();                    // reused, no GC (Lesson 5.1)
        float x = Random.Range(-areaHalfSize.x, areaHalfSize.x);
        float z = Random.Range(-areaHalfSize.y, areaHalfSize.y);
        coin.transform.position = new Vector3(x, 0.5f, z);
        coin.Init(coinData, ReturnCoin);          // give it its data + return path
    }

    private void ReturnCoin(Coin coin) => pool.Release(coin);
}

Phase 3 — The GameManager

Modules 3–4: singleton, state machine, events, coroutines.

The heart of the game. A singleton (Lesson 4.1) that owns the state machine, score, and a countdown coroutine (Lesson 3.3), and broadcasts everything via events (Lesson 3.2) so the UI and spawner react without being referenced:

using System;
using System.Collections;
using UnityEngine;

public enum GameState { Ready, Playing, GameOver }

public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }

    [SerializeField] private CoinSpawner spawner;
    [SerializeField] private float roundSeconds = 30f;

    public GameState State { get; private set; } = GameState.Ready;
    public int Score { get; private set; }
    public int TimeLeft { get; private set; }

    // Announcements (Lesson 3.2) — UI subscribes to these.
    public event Action<int> ScoreChanged;
    public event Action<int> TimeChanged;
    public event Action<GameState> StateChanged;

    void Awake()
    {
        if (Instance != null && Instance != this) { Destroy(gameObject); return; }
        Instance = this;                       // singleton (Lesson 4.1)
    }

    void Start() => SetState(GameState.Ready);

    void Update()
    {
        // Space starts a new round from Ready or GameOver.
        if (Input.GetKeyDown(KeyCode.Space) && State != GameState.Playing)
            StartRound();
    }

    public void AddScore(int amount)
    {
        if (State != GameState.Playing) return;
        Score += amount;
        ScoreChanged?.Invoke(Score);           // broadcast (Lesson 3.2)
    }

    private void StartRound()
    {
        Score = 0;
        ScoreChanged?.Invoke(Score);
        SetState(GameState.Playing);
        spawner.BeginSpawning();
        StartCoroutine(Countdown());           // coroutine timer (Lesson 3.3)
    }

    private IEnumerator Countdown()
    {
        TimeLeft = Mathf.CeilToInt(roundSeconds);
        var oneSecond = new WaitForSeconds(1f);
        while (TimeLeft > 0)
        {
            TimeChanged?.Invoke(TimeLeft);
            yield return oneSecond;
            TimeLeft--;
        }
        TimeChanged?.Invoke(0);
        EndRound();
    }

    private void EndRound()
    {
        spawner.StopSpawning();
        SetState(GameState.GameOver);
    }

    private void SetState(GameState newState)
    {
        State = newState;
        StateChanged?.Invoke(newState);
    }
}

Phase 4 — UI & Save

Module 4: event-driven UI and persistence.

The HUD subscribes to the manager's events (Lessons 3.2, 4.2) and updates only on change — no polling, no coupling. It also shows/hides the game-over panel based on state, and persists the high score with PlayerPrefs (Lesson 4.3):

using UnityEngine;
using TMPro;

public class HUD : MonoBehaviour
{
    [SerializeField] private TMP_Text scoreLabel;
    [SerializeField] private TMP_Text timeLabel;
    [SerializeField] private GameObject gameOverPanel;
    [SerializeField] private TMP_Text resultLabel;

    void OnEnable()
    {
        var gm = GameManager.Instance;
        gm.ScoreChanged += OnScore;            // subscribe (Lesson 3.2)
        gm.TimeChanged  += OnTime;
        gm.StateChanged += OnState;
    }

    void OnDisable()
    {
        var gm = GameManager.Instance;
        if (gm == null) return;
        gm.ScoreChanged -= OnScore;            // mirror unsubscribe (Lesson 3.2)
        gm.TimeChanged  -= OnTime;
        gm.StateChanged -= OnState;
    }

    private void OnScore(int score) => scoreLabel.text = $"Score: {score}";
    private void OnTime(int seconds) => timeLabel.text = $"Time: {seconds}";

    private void OnState(GameState state)
    {
        bool over = state == GameState.GameOver;
        gameOverPanel.SetActive(over);
        if (over) ShowResult();
    }

    private void ShowResult()
    {
        int score = GameManager.Instance.Score;
        int best = PlayerPrefs.GetInt("HighScore", 0);   // load (Lesson 4.3)
        if (score > best)
        {
            best = score;
            PlayerPrefs.SetInt("HighScore", best);       // save new record
            PlayerPrefs.Save();
        }
        resultLabel.text = $"Final: {score}\nBest: {best}\n\nPress Space to play again";
    }
}

For a full save game (position, level, inventory) you'd use the JSON SaveManager from Lesson 4.3. For a single high-score integer, PlayerPrefs is the right, simpler tool — choosing correctly between them is the lesson.

Phase 5 — Polish, Test, Verify

Module 5: performance, testing, debugging.

Performance (Lesson 5.1). Do a Profiler pass while playing and watch the GC Alloc column. The design is already allocation-light: coins are pooled, references cached, UI updates only on events, and the wait objects are cached. If a spike appears, trace it — that's the workflow, not a guess.

Testing (Lesson 5.2). The scoring logic is worth locking down. Pull it into a pure C# rule and unit-test it in Edit Mode — no scene, instant feedback:

// Pure logic — no MonoBehaviour, so it's trivially testable (Lesson 5.2).
public class ScoreRules
{
    // Late coins (last 10 seconds) are worth double — a bit of game feel.
    public int Points(int coinValue, int secondsLeft)
        => secondsLeft <= 10 ? coinValue * 2 : coinValue;
}

using NUnit.Framework;

public class ScoreRulesTests
{
    [Test]
    public void EarlyCoin_NormalValue()
    {
        Assert.AreEqual(5, new ScoreRules().Points(5, secondsLeft: 25));
    }

    [Test]
    public void LateCoin_DoubleValue()
    {
        Assert.AreEqual(10, new ScoreRules().Points(5, secondsLeft: 8));
    }
}

Then wire the rule into AddScore (Score += rules.Points(amount, TimeLeft);) — logic in a plain class, MonoBehaviour as glue, exactly the separation from Lesson 5.2.

Debugging (Lesson 5.2). If a coin isn't collected, the checklist writes itself: Is the Player tagged Player? Is the coin's collider a trigger? Does the Player have a Rigidbody (the "one must have a Rigidbody" rule, Lesson 2.2)? Add a Debug.Log($"hit {other.name}", this) in OnTriggerEnter to see what's actually touching. Draw the spawn area with a Gizmo to confirm placement.

Self-Assessment & Quiz

Course Conclusion

📚 Where to Go Next

• Unity Learn — official tutorials and pathways
• Unity Manual & Scripting Reference
• Unity — architecture & best-practice guides
• Ray's other courses: Introduction to C#, Intermediate C#, Advanced C#.

🚀 Keep Building

The best next step is to make something small and finish it. Take Coin Rush and add one feature. Then start a fresh idea. Every game you complete teaches more than a dozen tutorials — and you now have the C# scripting foundation to build whatever you imagine.