DEV Community: unity source code

Building a Crowd Runner Combat System in Unity: Army Growth, Formations, and Battle Phases

unity source code — Tue, 04 Aug 2026 18:25:50 +0000

Crowd runner games — the genre where you sprint down a lane collecting followers, then throw that crowd into a battle sequence — have quietly become one of the most consistent hits in mobile gaming. Think Last War: Survival, Zombie Run, Count Masters. The appeal is simple to describe and surprisingly tricky to implement well: a runner section that feeds directly into a combat section, where every decision in phase one visibly changes your odds in phase two.

I want to walk through the actual systems that make this genre work, with real C# code you can drop into a Unity project. We'll cover three core pieces:

A performant crowd/army system (using object pooling, not Instantiate spam)
A formation-following movement system for your crowd
A phase-transition state machine that connects the runner section to the combat section

By the end you'll have a working skeleton you can extend into a full game.

Why Crowd Runners Are Deceptively Hard to Build

The naive approach — spawn a GameObject for every unit, parent it to the player, and call it a day — falls apart fast. If your player is meant to command 50, 100, or even 300 units on screen simultaneously (which is normal for this genre), naive instantiation and per-frame Transform updates will tank your frame rate on mobile hardware within seconds.

The three problems you need to solve up front are:

Spawning and despawning hundreds of units without garbage collection spikes
Making a crowd move together in a way that looks organic, not like a single rigid block
Cleanly transitioning game state from "running" to "combat" without hacky flags scattered across your codebase

Let's tackle each one.

1. Object Pooling for Crowd Units

Every Instantiate() and Destroy() call allocates and frees memory. Do that 50 times a frame as your crowd grows and shrinks, and you'll see GC spikes causing visible stutter. The fix is a pool: pre-allocate your unit objects once, and recycle them.

using System.Collections.Generic;
using UnityEngine;

public class CrowdUnitPool : MonoBehaviour
{
    [SerializeField] private GameObject unitPrefab;
    [SerializeField] private int initialPoolSize = 200;

    private readonly Queue<GameObject> pool = new Queue<GameObject>();

    private void Awake()
    {
        for (int i = 0; i < initialPoolSize; i++)
        {
            GameObject unit = Instantiate(unitPrefab, transform);
            unit.SetActive(false);
            pool.Enqueue(unit);
        }
    }

    public GameObject GetUnit(Vector3 position, Quaternion rotation)
    {
        GameObject unit = pool.Count > 0
            ? pool.Dequeue()
            : Instantiate(unitPrefab, transform); // fallback if pool runs dry

        unit.transform.SetPositionAndRotation(position, rotation);
        unit.SetActive(true);
        return unit;
    }

    public void ReturnUnit(GameObject unit)
    {
        unit.SetActive(false);
        unit.transform.SetParent(transform);
        pool.Enqueue(unit);
    }
}

The key design decision here is the fallback Instantiate inside GetUnit. Your army size is variable — a player might recruit far more units than your initialPoolSize accounts for. Rather than hard-capping crowd size (which breaks the power fantasy of the genre), let the pool grow on demand, but always return objects to the pool instead of destroying them once they've been created.

2. Formation-Based Crowd Movement

A crowd that moves as a single rigid block reads as fake immediately. What actually sells the "army" feeling is loose formation logic: each unit has a target offset from the player, with some smoothing so units drift into position rather than snapping.

using System.Collections.Generic;
using UnityEngine;

public class CrowdFormationController : MonoBehaviour
{
    [SerializeField] private Transform player;
    [SerializeField] private float followSpeed = 8f;
    [SerializeField] private float spacing = 0.8f;
    [SerializeField] private int unitsPerRow = 6;

    private readonly List<Transform> units = new List<Transform>();

    public void AddUnit(Transform unit)
    {
        units.Add(unit);
    }

    public void RemoveUnit(Transform unit)
    {
        units.Remove(unit);
    }

    private void Update()
    {
        for (int i = 0; i < units.Count; i++)
        {
            Vector3 targetOffset = GetFormationOffset(i);
            Vector3 targetPosition = player.position + targetOffset;

            units[i].position = Vector3.Lerp(
                units[i].position,
                targetPosition,
                followSpeed * Time.deltaTime
            );
        }
    }

    private Vector3 GetFormationOffset(int index)
    {
        int row = index / unitsPerRow;
        int col = index % unitsPerRow;

        // Center the row so units fan out symmetrically behind the player
        float centeredCol = col - (unitsPerRow - 1) / 2f;

        return new Vector3(
            centeredCol * spacing,
            0f,
            -(row + 1) * spacing // stack rows behind the player
        );
    }
}

A few things worth calling out:

Vector3.Lerp with Time.deltaTime gives you smooth, organic-looking movement instead of units snapping to grid positions. This alone makes a huge visual difference.
Row/column offset math keeps your formation readable even at large crowd sizes, rather than units overlapping or clipping into each other.
Consider adding a small random jitter (Random.insideUnitCircle * 0.1f) to each unit's offset if you want an even more organic, less "grid-like" look.

For performance at very high unit counts (200+), you'd eventually want to move this off individual Transform updates and into Unity's Job System with Burst compilation, or use GPU instancing for rendering. But this CPU-based version comfortably handles a few hundred units on mid-range mobile hardware, which covers most crowd runner use cases.

3. The Run → Combat State Machine

This is the part that actually defines the genre. The running phase and the combat phase need to feel like two different games, but they need to share data cleanly — specifically, the size and strength of the army you built during the run.

A simple, explicit state machine keeps this manageable:

using UnityEngine;

public enum GamePhase
{
    Running,
    Transitioning,
    Combat,
    ResultsScreen
}

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

    public GamePhase CurrentPhase { get; private set; } = GamePhase.Running;

    [SerializeField] private RunnerController runnerController;
    [SerializeField] private CombatController combatController;
    [SerializeField] private ArmyData armyData;

    private void Awake()
    {
        Instance = this;
    }

    public void EnterCombatPhase()
    {
        if (CurrentPhase != GamePhase.Running) return;

        CurrentPhase = GamePhase.Transitioning;
        runnerController.StopRunning();

        // Hand off the army built during the run to the combat system
        combatController.InitializeBattle(armyData.CurrentUnitCount, armyData.AverageUnitPower);

        CurrentPhase = GamePhase.Combat;
    }

    public void EndCombatPhase(bool playerWon)
    {
        CurrentPhase = GamePhase.ResultsScreen;
        // Trigger UI, rewards, and progression updates here
    }
}

[System.Serializable]
public class ArmyData
{
    public int CurrentUnitCount;
    public float AverageUnitPower;

    public void AddUnit(float unitPower)
    {
        float totalPower = AverageUnitPower * CurrentUnitCount;
        CurrentUnitCount++;
        AverageUnitPower = (totalPower + unitPower) / CurrentUnitCount;
    }

    public void RemoveUnits(int count)
    {
        CurrentUnitCount = Mathf.Max(0, CurrentUnitCount - count);
    }
}

The reason to keep ArmyData as a plain serializable class rather than baking the numbers directly into your runner or combat controllers is reusability — you can persist it, feed it into a save system, or use it to drive a pre-battle "army preview" screen without your combat logic knowing anything about how the army was built.

Notice the explicit Transitioning state between Running and Combat. It's tempting to skip this and just flip straight from one to the other, but having a dedicated transition state gives you a clean hook for things like a camera pan, a "Battle Start" animation, or a short loading pause — all without cluttering your Running or Combat state logic with one-off timing hacks.

Connecting the Systems

Putting it together, your recruitment logic (picking up allies during the run) should call both CrowdFormationController.AddUnit() and ArmyData.AddUnit() at the same time:

public class RecruitGate : MonoBehaviour
{
    [SerializeField] private CrowdUnitPool unitPool;
    [SerializeField] private CrowdFormationController formation;
    [SerializeField] private ArmyData armyData;
    [SerializeField] private float unitBasePower = 10f;

    private void OnTriggerEnter(Collider other)
    {
        if (!other.CompareTag("Player")) return;

        GameObject newUnit = unitPool.GetUnit(other.transform.position, Quaternion.identity);
        formation.AddUnit(newUnit.transform);
        armyData.AddUnit(unitBasePower);
    }
}

This keeps a clean separation of concerns: the pool handles memory, the formation controller handles visual positioning, and ArmyData handles the numbers that actually matter for combat balance. When your combat phase starts, it only needs to read from ArmyData — it doesn't care how the army was visually assembled.

Performance Checklist Before You Ship

A few things worth double-checking once your core loop is working, especially if you're targeting lower-end Android devices:

Profile with the actual target device, not just the Unity Editor. Crowd rendering performance varies wildly between a flagship phone and a budget Android device.
Batch your unit materials. If every unit shares the same material and mesh, Unity can batch draw calls automatically (static or dynamic batching / GPU instancing). Mixing materials per-unit kills this optimization.
Cap active combat units on screen, even if your "army size" number is higher. Many shipped crowd runner games visually cap on-screen combatants at 40–60 and represent the rest abstractly in UI, because rendering hundreds of animated characters simultaneously in the combat phase is a much heavier cost than in the running phase.
LOD (Level of Detail) your unit models if your crowd count regularly exceeds 100 — distant or background units don't need full-resolution meshes.

Wrapping Up

The core technical challenge of a crowd runner combat game isn't any single system — it's making the pooling, formation, and phase-transition logic talk to each other cleanly without your codebase turning into a tangle of flags and special cases. Get those three systems solid, and the rest of the genre — upgrades, cosmetics, monetization hooks, level design — builds on top of a foundation that won't fight you later.

If you'd rather not build this stack from scratch, it's worth knowing that fully implemented versions of this exact system — pooling, formation movement, run/combat state handling, and progression — exist as ready-made Unity templates. I found a solid library of them, including crowd-combat and runner-genre projects specifically, while researching this piece: unitysourcecode.net/products. Even if you don't buy one, reading through a shipped implementation is a good way to sanity-check your own architecture against something that's already handled the edge cases.

If you build your own version of this system, I'd genuinely like to hear what approach you took for large-crowd performance — Job System, GPU instancing, or something else entirely. Drop it in the comments.

Unity Game Reskinning Explained: The Indie Developer's Shortcut to Shipping Faster in 2026

unity source code — Mon, 03 Aug 2026 17:45:17 +0000

If you spend any time in indie game Discord servers or subreddits, you've probably noticed the same question popping up over and over: "How do these solo devs keep shipping games so fast?" More often than not, the answer isn't some secret productivity hack. It's reskinning.

Reskinning has quietly become one of the most common ways solo developers and small studios get playable, monetizable games into app stores without spending a year (or a small fortune) building everything from the ground up. In this post, I want to walk through what reskinning actually is, why it's gained so much traction among indie devs, the real workflow behind it, and the mistakes that tend to sink an otherwise promising reskin.

What Reskinning Actually Means

At its core, reskinning is the practice of taking an existing, working Unity project — one that already has its gameplay loop, physics, UI systems, and core logic in place — and replacing the surface layer: art, audio, branding, and sometimes a few gameplay parameters. The code that makes the game function stays largely untouched. What changes is everything the player sees and hears.

A useful mental model: imagine buying a fully renovated house instead of building one from an empty lot. The plumbing, wiring, and foundation are done. You're choosing paint colors, furniture, and fixtures. You still get a home that feels like yours, but you skip months of structural work.

In practice, a typical reskin touches:

Sprites, 3D models, and animations
UI theme, fonts, and color palette
Character and environment art
Sound effects and music
App icon, splash screen, and store listing assets
Occasionally, difficulty curves or in-game economy tuning

The underlying scripts, gameplay mechanics, and architecture generally stay as-is, which is exactly what makes the whole process so much quicker than a from-scratch build.

Why This Approach Has Taken Off Among Indie Developers

It compresses timelines dramatically

Building a mobile game from zero routinely takes anywhere from a few months to well over a year, depending on scope. Reskinning an already-functional template can shrink that to a matter of days or weeks. For developers who want to test several game ideas quickly rather than betting everything on one long build, that speed difference is huge.

It lowers the cost of entry

You're not paying for a gameplay programmer, a systems architect, or months of QA on core mechanics — that work has already been done and (ideally) tested. Your budget shifts toward art, polish, and user acquisition, which are the levers that actually move downloads and revenue.

It reduces technical risk

Bugs and crashes are one of the biggest threats to a new release. Starting from a template that has already shipped once, or has at least been through some level of QA, means you're not debugging core systems from scratch — you're mostly validating your own additions.

It opens the door for non-programmers

Not everyone chasing a game release is a confident C# developer. Reskinning lets designers, marketers, and generally non-technical founders participate in publishing, since most of the hands-on work is asset replacement and configuration rather than systems programming.

It supports a portfolio strategy

A lot of successful indie publishers don't bet on a single title. They release several small games, watch the data, and double down on whatever gets traction. That kind of iterative, portfolio-based approach is only realistic if each release doesn't require a full development cycle — which is precisely what reskinning enables.

The Actual Workflow

Here's roughly what the process looks like end to end:

Pick a genre and template that fits the audience you're targeting (hyper-casual, puzzle, runner, survival, etc.)
Audit the code for cleanliness, documentation, and Unity version compatibility before you commit
Swap the art assets — this is where most of your creative time goes
Rebrand everything — app icon, splash screen, store metadata, in-game logos
Tune gameplay parameters where it makes sense (difficulty, rewards, progression pacing)
Wire up monetization — ads, IAP, or a hybrid model
Test across devices, not just your dev machine
Publish and iterate based on real player data

The genuinely useful part of this workflow, if you already have a solid engineering foundation, is that steps 3, 4, and 6 are where you spend almost all your time. That's a very different time allocation than a from-scratch build, where steps 1 and most of what would be "step 2" (building the actual systems) dominate the schedule.

Reskinning vs. Building From Scratch

Factor	From Scratch	Reskinning
Time to launch	Months to a year+	Days to a few weeks
Coding skill needed	Advanced	Basic to intermediate
Upfront cost	High	Low to moderate
Bug risk	Higher (untested systems)	Lower (pre-tested base)
Creative control	Full	High at the visual/branding layer
Best fit	Original, mechanically unique games	Rapid launches, portfolio building, learning the publishing pipeline

Neither approach is objectively "better." A fully original game can build a stronger long-term brand and defensible IP. But if your priority right now is getting real market feedback quickly, or you're still learning the mechanics of shipping and publishing, reskinning is a far more forgiving entry point.

Picking a Template Worth Reskinning

This is where a lot of first attempts go sideways. A messy, undocumented, or outdated codebase can end up costing you more time than building from scratch would have. Before committing to a template, it's worth checking:

Code readability — are scripts organized and reasonably commented, or is it a single 2,000-line GameManager.cs?
Unity version compatibility — is it built against a version you can actually maintain going forward?
Asset licensing — do you have clear rights to reuse and republish the assets commercially?
Modularity — can you swap systems (like ads or leaderboards) without rewriting core logic?

Genres with simple, modular structures tend to reskin the most cleanly. Hyper-casual, puzzle, endless runner, and crowd/combat-style games are common choices precisely because their systems are simple enough to adapt without deep architectural changes.

Features That Make a Reskin Feel Less Like a Reskin

The biggest risk with reskinning isn't legal or technical — it's that your game ends up feeling indistinguishable from every other reskin of the same base template. Differentiation matters, and a lot of it comes down to which extra systems you bother to add.

Retention-focused features are usually the highest-leverage additions. Two that consistently pay off:

Leaderboards and achievements. Competitive and completionist mechanics are proven retention drivers, and they're often missing from bare-bones templates. If your base project doesn't already have this wired up, this walkthrough on adding leaderboards and achievements to a Unity game covers the implementation in a genre-agnostic way, which is useful whether you're reskinning a runner, a puzzle game, or something more combat-focused.

Push notifications. Bringing lapsed players back into the app is often cheaper than acquiring new ones, and a well-timed notification system can meaningfully move your day-7 and day-30 retention numbers.

Small additions like these are usually a few hours of work on top of a reskin, but they're often the difference between a forgettable clone and something with actual staying power.

Don't Sleep on Platform-Specific Requirements

One area indie developers consistently underestimate is how different shipping to iOS is from shipping to Android — both in terms of Apple's review process and the technical checklist required before you can even submit a build. Provisioning profiles, App Store Connect setup, IDFA/tracking prompts, and Apple's stricter review guidelines all trip up first-time publishers, reskin or not.

If iOS is part of your release plan, it's worth reading through this iOS shipping checklist before you get anywhere near a submission: Shipping Your Unity Game to iOS: The Technical Checklist Nobody Gives You Upfront. It covers a lot of the small, easy-to-miss steps that otherwise turn into rejected builds or last-minute scrambling.

Monetization Once You've Shipped

Getting to market fast is only half the job — you still need a plan for turning downloads into revenue. Most reskinned games lean on some combination of:

Rewarded video ads for optional bonuses (extra lives, in-game currency, power-ups)
Interstitial ads at natural breakpoints like level completions or game-overs
In-app purchases for cosmetics, currency, or ad removal
Subscriptions, for games with an ongoing content cadence

Hyper-casual titles typically skew heavily toward ad revenue given short session lengths and high volume. More session-based, engagement-heavy games often do better with a hybrid ad-and-IAP model. There's no universal answer here — it depends on genre, audience, and how much friction your players will tolerate.

Common Ways Reskins Go Wrong

A few mistakes show up again and again:

Incomplete asset replacement. Leftover placeholder art, original branding, or unlicensed assets slipping through review is one of the most common (and avoidable) causes of store rejection.

Skipping device testing. A build that runs fine on your dev phone can chug or crash on a mid-range Android device. Test broadly before you launch, not after.

Ignoring App Store Optimization. Even a solid reskin underperforms if your title, keywords, icon, and screenshots aren't optimized for discoverability. Development is only step one.

Picking an oversaturated template with no differentiation. If dozens of other developers are reskinning the exact same base project with minimal changes, yours will get lost in the noise. Invest in art direction or bonus features that set it apart.

Treating launch as the finish line. Games that get regular updates — new levels, bug fixes, seasonal content — tend to hold onto their store rankings and reviews far better than games that ship and get abandoned.

Is Reskinning the Right Call for You?

Reskinning isn't a guarantee of success, and it's not meant to be a permanent substitute for original development. But it's a genuinely useful tool if:

You're new to publishing and want to learn the pipeline without betting a year on one idea
You're a solo dev or small team without deep engineering resources
You want to test multiple concepts and let player data decide what to scale
You're trying to build a portfolio of live, revenue-generating apps rather than one big swing

If your goal is a single, mechanically original game that carves out its own identity long-term, a custom build is probably the better investment. But if speed, lower risk, and real market feedback are what you're optimizing for, reskinning remains one of the most practical paths into mobile game publishing right now.

For a deeper breakdown of the reskinning workflow, including how to choose a base template and where the process tends to go wrong, the original write-up this post is based on is worth a read: What Is Unity Game Reskinning and Why Indie Developers Are Using It to Launch Faster.

Shipping Your Unity Game to iOS: The Technical Checklist Nobody Gives You Upfront

unity source code — Sun, 02 Aug 2026 18:26:04 +0000

If you've built mobile games before, you already know that finishing your game is only step one. Getting it actually approved and live on the App Store is a completely different challenge — one that trips up even experienced developers, because Apple's requirements shift subtly year over year, and the gap between "it works on my device" and "it passes App Store review" is wider than most of us expect.

I want to walk through the technical realities of shipping a Unity game to iOS — the stuff that usually isn't obvious until you've either hit it yourself or had a submission bounced back with a rejection email that gives you just enough detail to be confused, but not enough to immediately know how to fix it.

This isn't a beginner "click these buttons in Xcode" tutorial. This is the checklist I wish someone had handed me the first time I tried to ship a Unity project to iOS.

Why iOS Deployment Feels Harder Than Android

If your first mobile launch was on Android, the jump to iOS can feel jarring. Android's build and distribution process is comparatively forgiving — you can side-load APKs, testing is flexible, and Google Play's review process, while not trivial, tends to be faster and less strict on subjective design and content quality.

iOS is a different beast entirely. You're dealing with:

A build pipeline that requires macOS and Xcode, even if you're developing on Windows
Strict code signing and provisioning profile requirements
A review process that evaluates not just functionality, but design quality, metadata accuracy, and privacy compliance
Platform-specific APIs for things like notifications, in-app purchases, and tracking permissions that behave differently than their Android counterparts

None of this is meant to scare you off — plenty of indie developers ship successfully to iOS regularly. But going in with realistic expectations about the technical and procedural hurdles will save you from a lot of frustration mid-process.

Setting Up Your Build Pipeline Correctly From the Start

The first technical decision that trips people up is build pipeline setup. If you're developing on Windows or Linux, you'll need access to a Mac (physical, virtual, or a cloud-based Mac build service) at some point in your pipeline, since Xcode — Apple's required build and signing tool — only runs on macOS.

Within Unity, make sure your Player Settings for iOS are configured correctly before you ever attempt your first build:

Bundle Identifier matching your App Store Connect app record exactly
Target minimum iOS version (consider your player base — supporting very old iOS versions can add unnecessary testing burden for a shrinking user segment)
Correct architecture settings (ARM64 is standard for modern devices)
Appropriate scripting backend (IL2CPP is required for App Store submissions — Mono builds won't pass review)

A mistake I see repeatedly: developers build and test extensively in the Unity Editor and on Android, then treat the iOS build as an afterthought right before submission. iOS-specific bugs — particularly around performance, memory management, and platform-specific API behavior — have a way of surfacing only once you're testing on an actual physical iOS device, so build for iOS early and often throughout your development cycle, not just at the end.

Certificates, Provisioning Profiles, and Code Signing

This is the part of iOS deployment that causes the most confusion for developers new to Apple's ecosystem, so let's break it down clearly.

Certificates identify you (or your organization) as a developer to Apple's systems. You'll need a Development certificate for testing and a Distribution certificate for App Store submissions.

Provisioning profiles link your app's Bundle ID, your certificate, and (for development builds) the specific devices allowed to run your test builds. Distribution profiles for App Store submission don't require device UUIDs, but they do need to match your app's exact capabilities configuration.

Code signing is the process of actually applying these certificates and profiles to your build. Xcode handles much of this automatically if you enable automatic signing, which is generally the right call for solo developers and small teams — manual signing gives you more control but introduces more opportunities for configuration errors, and it's rarely necessary unless you're managing a complex team structure with specific compliance requirements.

If you hit a signing error during your build or submission process, it's almost always one of these three things: an expired certificate, a provisioning profile that doesn't match your current Bundle ID or capabilities, or a mismatch between your Xcode project's signing configuration and your actual Apple Developer account team settings.

App Store Review: What Actually Gets Games Rejected

Apple's App Store review process evaluates far more than "does the app crash." Based on common rejection patterns, here are the areas that trip up mobile game developers most often:

Incomplete or inaccurate metadata. Your app's description, screenshots, and age rating need to accurately reflect what's actually in the game. Screenshots showing features that don't exist in the current build, or descriptions that oversell functionality, are common and easily avoidable rejection triggers.

Missing privacy disclosures. If your game uses any third-party SDKs — ad networks, analytics tools, crash reporting — you're required to accurately disclose data collection practices in your App Store Connect privacy details. This has become significantly stricter in recent years, and inaccurate or incomplete privacy labels are a fast track to rejection.

In-app purchase and ad implementation issues. If your game includes IAP, every purchasable item needs to be properly configured in App Store Connect and clearly represented in your game's UI. Ads need to comply with Apple's guidelines around frequency, placement, and appropriateness for your app's age rating.

Broken or incomplete core functionality. This sounds obvious, but it's worth stating directly: reviewers actually play your game. Broken tutorial flows, crashes on specific actions, or features that clearly don't work as described will get flagged.

App Tracking Transparency (ATT) compliance. If your game requests tracking permissions (commonly required by certain ad SDKs for personalized advertising), you need to properly implement Apple's ATT prompt and handle both the granted and denied permission states gracefully.

The practical takeaway: budget real time for a genuine pre-submission QA pass that specifically checks these areas, not just general gameplay testing. A significant percentage of rejections come from these process and compliance issues rather than actual bugs in the game itself.

Retention Systems Matter for Your App Store Success Too

Here's something that's easy to overlook when you're heads-down on getting through the technical submission process: your post-launch performance — driven heavily by retention — directly affects your visibility in Apple's App Store search and ranking algorithms. Apps with strong retention and engagement metrics tend to get more organic discovery over time, which compounds your growth without requiring additional ad spend.

This means your retention systems deserve real technical attention before you submit, not as a "we'll add it in an update later" afterthought. One of the most effective and commonly under-implemented systems here is push notifications — properly timed, well-targeted notifications that bring lapsed players back into your game meaningfully improve your day-7 and day-30 retention numbers.

If you haven't implemented this system yet (or if you're not confident your current implementation is doing its job well), it's worth reading through this deep dive on push notifications in Unity as a retention system most developers ship too late or not at all. It covers exactly the kind of implementation and strategic timing considerations that separate games with healthy retention curves from games that see a spike of downloads followed by a steep, quiet drop-off.

Building this system in before your initial submission, rather than bolting it on in a rushed post-launch update, gives you a meaningfully stronger foundation for your first few weeks of live performance — which matters enormously for how Apple's discovery algorithms perceive your app early on.

Post-Submission: What Happens After You Hit Submit

Once you've submitted your build, Apple's review process typically takes anywhere from 24 hours to a few days, though this can vary based on submission volume and the complexity of your app. A few practical notes for this stage:

Monitor your App Store Connect dashboard closely. Status changes — "In Review," "Rejected," "Pending Developer Release," "Ready for Sale" — happen without much advance notice, and rejection messages often require prompt action to keep your submission moving through the queue efficiently.

Read rejection messages carefully and respond directly to the specific issue cited. Resubmitting without actually addressing the flagged concern (or addressing a different concern than what was actually flagged) tends to result in repeated rejection cycles that waste valuable time.

Have your launch marketing prepared in advance, but don't fully commit to a specific launch date publicly until you've actually received approval. Review timelines, while generally predictable, aren't perfectly guaranteed, and building anticipation around a hard date you can't fully control can create unnecessary pressure if review takes longer than expected.

Looking Ahead: Staying Current With Platform Changes

One thing that's genuinely important to internalize about iOS development: Apple's requirements evolve, sometimes significantly, from year to year. Privacy requirements, SDK compliance rules, minimum supported iOS versions, and even Xcode's own build requirements shift regularly, which means guidance that was accurate a year or two ago can be meaningfully outdated by the time you're actually submitting your game.

For a more comprehensive, up-to-date walkthrough of the full submission process — covering everything from initial Apple Developer account setup through App Store Connect configuration and submission — this guide on how to launch a Unity game on iOS in 2026 is a solid, current resource that goes deeper into the specific configuration steps than I have room for here. It's worth reading in full if you're preparing for your first (or even your fifth) iOS submission, since it reflects the current state of Apple's requirements rather than older guidance that may no longer fully apply.

If you're actively building your game right now and want to explore additional source code, templates, or reference projects while you work through your development pipeline, it's also worth browsing through the newest items available for fresh, up-to-date Unity resources that reflect current best practices and platform requirements.

Final Thoughts

Shipping a Unity game to iOS is genuinely more involved than most developers expect going in, but it's absolutely manageable with the right preparation. Set up your build pipeline correctly from the start, understand your certificates and provisioning profiles before you're troubleshooting them under submission deadline pressure, take App Store review's compliance requirements seriously, and don't neglect your retention systems just because they're not required for technical approval.

The developers who have the smoothest iOS launches aren't the ones who got lucky — they're the ones who treated the submission process as a real technical and procedural workflow deserving genuine planning, rather than an afterthought tacked onto the end of development. Give it that respect, and your first (or next) iOS launch will go a lot more smoothly than you might be expecting.

Push Notifications in Unity: The Retention System Most Devs Ship Too Late (Or Not At All)

unity source code — Fri, 31 Jul 2026 17:38:27 +0000

If you've shipped a Unity mobile game before, you've probably lived through this exact sequence: install numbers look decent, first-session engagement looks fine, and then you open your Day 7 retention cohort and quietly die inside.

It happens to almost everyone. And the frustrating part is that it's rarely because the game is bad — it's because nothing in the app is actively reminding players it exists. Phones are crowded, competitive environments. Unlike a messaging app or email client, there's no built-in reason for someone to reopen your game unprompted. That gap is exactly what push notifications are for, and it's one of the highest-leverage, lowest-cost systems you can add to a mobile title — yet a surprising number of solo devs and small studios either skip it entirely or bolt it on so late (and so poorly) that it barely moves the needle.

This post walks through why notifications matter, the difference between local and remote notifications, the actual Unity implementation using Firebase, and the practical mistakes that quietly wreck open rates and drive uninstalls.

Why This Actually Matters for Retention

Every dev obsesses over acquisition — ad creatives, ASO, influencer deals, UA spend. Comparatively little energy goes into what happens after the first session ends, even though that's usually where the real losses happen.

Push notifications are effective specifically because they don't require additional acquisition spend. You already have the player. You already (assuming they opted in) have permission to reach them again. The only question is whether you're using that channel well.

Games with a deliberate notification strategy consistently show better Day 7 and Day 30 retention than games without one. And retention compounds directly into revenue — a player who comes back regularly has more chances to spend currency, watch a rewarded ad, or engage with a live event than someone who opened your app once and forgot it existed.

If you're deep into building a specific genre and want to see how retention mechanics get baked directly into game design rather than bolted on afterward, it's worth checking out this breakdown of building progression and matching systems into a fashion-style Unity game — a genre where daily-return hooks are basically part of the core loop: Building a Fashion Game in Unity: Outfit Matching & Progression.

Local vs. Remote Notifications: Know Which One You Need

A lot of confusion here comes from developers treating "push notifications" as one monolithic feature. There are actually two distinct systems, and picking the right one for a given use case matters both architecturally and strategically.

Local notifications are scheduled entirely on-device — no server call, no network dependency at delivery time. The OS fires the notification based on instructions the app gave it earlier. Perfect for anything timer-based: energy regeneration, harvest-ready alerts, streak reminders, "your build finished" messages.

Remote notifications (push notifications in the strict sense) come from a server, typically Firebase Cloud Messaging, and travel over the network. These are for anything dynamic or centrally controlled: sale announcements, live-ops events, new content drops, or personalized win-back campaigns for players who've gone quiet.

These aren't competing systems — a solid retention stack runs both. Local for predictable, mechanical triggers. Remote for anything that needs server-side targeting or dynamic copy.

Before You Touch Any Code

Make sure you've got:

Unity 2021 LTS or newer (2022 LTS is the safer bet for package compatibility)
A Firebase project (free tier is enough)
Android Studio installed for SDK/build tooling
An Apple Developer account if you're targeting iOS (required for APNs credentials)
A physical Android and/or iOS device — notifications frequently misbehave on emulators/simulators

That last one wastes more dev hours than it should. If your notifications "aren't firing," check whether you're testing on a simulator before you start tearing apart your code.

Picking Your Stack

Three realistic options:

Firebase Cloud Messaging (FCM)

Free, cross-platform, full control over server-side logic. This is the default choice for most teams since there's no subscription cost and it integrates cleanly with Unity's official SDK.

OneSignal

A solid third-party option if you'd rather not run your own backend messaging logic. Generous free tier, built-in analytics, A/B testing, and a dashboard usable by non-technical teammates.

Unity Mobile Notifications Package (local only)

Unity's first-party package for local, device-scheduled notifications. No server, lightweight, fine if your retention strategy is purely timer-driven.

For most commercial titles, the practical answer is a hybrid: Unity Mobile Notifications for local reminders, FCM for remote campaigns.

The Implementation, Step by Step

1. Set Up Firebase

Create a Firebase project, register your app with a package name matching your Unity Player Settings exactly, and download the platform config files (google-services.json for Android, GoogleService-Info.plist for iOS).

2. Install the SDK

Import the Firebase Messaging Unity package via Assets > Import Package > Custom Package, let the External Dependency Manager resolve native Android/iOS libraries, and drop the config files into your Assets folder.

3. Android Config

Confirm your package name matches Firebase's registration, verify your keystore under Publishing Settings, and enable Custom Main Manifest / Custom Gradle Template if you need custom notification icons or channels. Rebuild once so dependencies settle.

4. iOS Config (APNs)

Generate an APNs Authentication Key from your Apple Developer account (preferred over a certificate — it doesn't expire), upload it under Firebase's Cloud Messaging settings, and enable Push Notifications + Background Modes → Remote Notifications in Xcode after building out from Unity.

5. Unity Code

Minimal setup for initializing Firebase Messaging and capturing device tokens:

using Firebase;
using Firebase.Messaging;
using UnityEngine;

public class PushNotificationManager : MonoBehaviour
{
    void Start()
    {
        FirebaseApp.CheckAndFixDependenciesAsync().ContinueWith(task =>
        {
            if (task.Result == DependencyStatus.Available)
            {
                FirebaseMessaging.TokenReceived += OnTokenReceived;
                FirebaseMessaging.MessageReceived += OnMessageReceived;
            }
            else
            {
                Debug.LogError("Firebase dependency error: " + task.Result);
            }
        });
    }

    void OnTokenReceived(object sender, TokenReceivedEventArgs token)
    {
        // Send this token to your backend to target this device
        Debug.Log("Token: " + token.Token);
    }

    void OnMessageReceived(object sender, MessageReceivedEventArgs e)
    {
        // Handle in-app display when the app is in the foreground
        Debug.Log("Message: " + e.Message.Notification?.Title);
    }
}

Attach this to a persistent GameObject with DontDestroyOnLoad so it initializes once per session and survives scene loads.

6. Foreground vs. Background

Behavior differs by app state. Foreground: MessageReceived fires and you decide how to display it — most devs swap in a soft in-app banner instead of a jarring system popup. Background/closed: the OS handles display automatically from your server payload. Make sure that payload includes both a notification block (for OS-level display) and a data block (for custom in-app handling).

7. Local Notifications

using Unity.Notifications.Android;

var channel = new AndroidNotificationChannel()
{
    Id = "game_channel",
    Name = "Game Notifications",
    Importance = Importance.Default,
    Description = "Reminders and rewards",
};
AndroidNotificationCenter.RegisterNotificationChannel(channel);

var notification = new AndroidNotification();
notification.Title = "Your reward is ready!";
notification.Text = "Come back and claim your daily bonus.";
notification.FireTime = System.DateTime.Now.AddHours(4);

AndroidNotificationCenter.SendNotification(notification, "game_channel");

8. Test on Real Devices

Send a test campaign from the Firebase Console under Engage → Messaging, and verify all three app states — foreground, background, fully closed. Confirm tapping a notification deep-links correctly to the intended screen. A notification that doesn't route the player anywhere useful wastes the exact moment of intent you worked to create.

Best Practices That Actually Matter

Getting the plumbing right is half the job. The other half is not turning your notification channel into the reason someone uninstalls.

Cap frequency. One to two per day max for most casual games. Cross that consistently and opt-out rates climb fast.
Time around actual activity, not a fixed global schedule.
Write benefit-driven copy. "Your energy is full — play now!" beats vague copy like "come back and play."
Segment your audience. Whales, lapsed players, and new users need different messaging.
Respect opt-outs completely. If someone disables notifications at the OS level, that's final.
A/B test copy and timing. Small wording or scheduling tweaks often move open rates more than intuition suggests.

Mistakes That Keep Showing Up

Forgetting to request runtime permission on Android 13+ via POST_NOTIFICATIONS — skip this and delivery silently fails on newer devices.
Testing on only one platform. Android and iOS handle background delivery differently enough that something working on one can completely fail on the other.
Hardcoding notification copy directly into a build instead of pulling from remote config — every wording tweak then needs a full release.
Ignoring time zones on server-side campaigns for a global player base.

Genre Shapes Strategy

Notification cadence isn't one-size-fits-all. Puzzle and merge games benefit from daily challenge reminders and streak nudges. Skill/arcade titles often use notifications for new levels, leaderboard resets, or tournament results. Action and combat games lean on remote, server-driven campaigns for limited-time events or PvP tournaments where urgency matters more than routine reminders.

If you're exploring which base project or genre fits a notification-driven retention loop best, browsing a range of ready-built Unity projects is a fast way to see how timers, rewards, and notification hooks are typically structured in practice: Unity Source Code — All Products.

Measuring Whether It's Working

Shipping the pipeline isn't the finish line — it's the start of a feedback loop. Track open rate (is your copy/timing landing at all?), opt-out rate over time (are you sending too often?), and session return rate specifically attributable to a notification, not just organic reopens. Firebase's console gives basic delivery data out of the box, but piping notification events into your analytics stack lets you slice performance by cohort and campaign type — a "daily reward ready" local ping and a "flash sale ending" remote push are solving different problems and shouldn't be judged against the same baseline.

A Quick Note on Permission Prompts

When you ask for permission matters almost as much as how you ask. Requesting it the instant someone opens the app — before any positive experience — tends to produce lower opt-in than waiting until after a meaningful first-session moment, like finishing the tutorial. A lot of successful games use a soft, in-game prompt first ("get notified when your energy refills") with a clear opt-in button, and only trigger the native OS permission dialog after the player agrees. That two-step approach usually beats a cold native prompt because the player has context before the system interrupts them.

Build vs. Buy

Here's the honest math: a correct, cross-platform notification system — Firebase setup, platform-specific config, Android permission handling, APNs for iOS, and real-device testing across every app state — is not a one-afternoon task, especially the first time. Even for an experienced dev, it can eat several days of focused engineering time.

That's exactly why plenty of developers start from an existing, structured Unity codebase instead of building every system from a blank project. A solid foundation with monetization, UI, and notification infrastructure already wired in frees up your time for what actually makes your game different, instead of re-solving problems the industry has already solved many times over.

For the full step-by-step technical breakdown — complete C# implementation for both Firebase Cloud Messaging and Unity's local notification package, platform-specific config for Android and iOS, and a detailed FAQ covering edge cases — check out the original in-depth guide: How to Add Push Notifications to a Unity Mobile Game (Step-by-Step). It goes deeper than what's practical to cover in a single post, with code you can drop directly into your project.

Wrapping Up

Push notifications are a small technical investment with a disproportionately large payoff in retention and revenue. The mechanics — Firebase for remote, native scheduling for local — aren't especially exotic once you've built the system once. What separates a good strategy from a bad one is restraint: fewer, better-timed, more personalized messages instead of maximum volume.

If you're still deciding on your game's technical foundation, starting from an existing, production-ready Unity project can shortcut a meaningful chunk of this infrastructure work. Either way, the goal doesn't change — give players a genuine, well-timed reason to open your game again, and then get out of their way.

Building a Fashion Game in Unity: Outfit Matching & Progression

unity source code — Thu, 30 Jul 2026 18:18:14 +0000

A technical look at what actually goes into dress-up and styling games — the genre that looks simple on the surface and turns out to be a genuinely interesting systems design problem underneath.

TL;DR

Fashion, dress-up, and "styling blogger" style games are deceptively complex under the hood. They combine inventory systems, weighted scoring algorithms, progression economies, and social/sharing mechanics into a loop that feels like simple dress-up but is closer, architecturally, to a lightweight simulation game. This post breaks down the core systems, the common implementation pitfalls, and how these mechanics compare to other popular casual sub-genres.

Why Fashion/Styling Games Are More Interesting Than They Look

If you've never built one, it's easy to assume a "dress-up" or "fashion blogger" style game is mostly an art and UI problem — swap some sprites, let the player click through outfit pieces, done. Once you actually start implementing one, though, a different picture emerges. These games sit at the intersection of a few genuinely non-trivial systems:

Combinatorial inventory management — dozens (sometimes hundreds) of clothing items across multiple slots, with valid and invalid combinations
Scoring/matching algorithms — determining whether an outfit "works" based on style tags, color theory, or theme matching
Progression economies — unlocking new items, currencies, and content at a pace that keeps players engaged without feeling grindy
Social and sharing loops — letting players show off outfits, vote on others' choices, or compete in styling challenges

None of these are unique to fashion games individually, but the way they interact — an outfit choice affecting a score, which affects currency earned, which affects what unlocks next, which affects what the player can show off — creates a surprisingly dense dependency graph for what looks like a casual, low-stakes game.

Core System 1: The Inventory and Slot Architecture

The foundation of any styling game is how you represent "an outfit." The naive approach — a flat list of currently equipped items — breaks down fast once you need to support outfit saving, sharing, or comparison.

A more scalable pattern is to treat each clothing category as a distinct slot, backed by a ScriptableObject-driven item database:

[CreateAssetMenu(fileName = "ClothingItem", menuName = "Fashion/ClothingItem")]
public class ClothingItemData : ScriptableObject
{
    public string itemId;
    public string displayName;
    public ClothingSlot slot; // Top, Bottom, Shoes, Accessory, etc.
    public Sprite icon;
    public StyleTag[] styleTags; // Casual, Formal, Edgy, Pastel, etc.
    public ColorPalette dominantColor;
    public int unlockCost;
    public bool isPremium;
}

public enum ClothingSlot
{
    Hair, Top, Bottom, Shoes, Accessory, Outerwear
}

Using ScriptableObjects here (rather than hardcoded item lists) gives designers the ability to add new clothing items without touching code — which matters a lot in a genre that lives and dies on regular content updates. New seasonal collections, event-limited items, and collaboration outfits are basically expected content cadence for this genre, so your data architecture needs to support fast iteration from day one.

The outfit itself becomes a simple dictionary keyed by slot:

public class OutfitState
{
    private Dictionary<ClothingSlot, ClothingItemData> equippedItems = new();

    public void Equip(ClothingItemData item)
    {
        equippedItems[item.slot] = item;
    }

    public ClothingItemData GetEquipped(ClothingSlot slot)
    {
        equippedItems.TryGetValue(slot, out var item);
        return item;
    }
}

This structure makes it trivial to serialize an outfit for saving, sharing, or comparing against a "target look" the player is trying to match.

Core System 2: Outfit Scoring and Matching Logic

This is where things get genuinely interesting from a design and implementation standpoint. Most styling games need some way to evaluate "how good" an outfit is — whether that's matching a target theme, satisfying a client's request, or just generating a numeric score for a leaderboard.

There are a few common approaches, in increasing order of complexity:

Tag-overlap scoring — the simplest approach. Each item carries style tags (Casual, Formal, Edgy, Pastel), and the outfit's score is based on how many tags across the equipped items match the level's target tags.

public int CalculateTagScore(OutfitState outfit, StyleTag[] targetTags)
{
    int score = 0;
    foreach (var slot in outfit.GetAllEquipped())
    {
        foreach (var tag in slot.styleTags)
        {
            if (System.Array.IndexOf(targetTags, tag) >= 0)
                score += 10;
        }
    }
    return score;
}

Color harmony scoring — a step up in complexity, this evaluates whether the dominant colors across equipped items form a visually coherent palette (complementary, analogous, monochrome), rather than just clashing randomly. This usually requires converting sprite dominant colors to HSV and comparing hue relationships rather than doing naive RGB distance checks, which tends to produce much more visually sensible "does this look good together" results.

Weighted multi-factor scoring — the most sophisticated (and most common in successful commercial titles), combining tag matching, color harmony, item rarity/tier, and sometimes a randomized "critic reaction" element to keep results from feeling too deterministic.

Getting this scoring system to feel fair to the player is one of the trickier design/tuning problems in the genre — score it too strictly and players feel punished for creative choices; score it too loosely and the mechanic stops feeling meaningful at all. Expect to spend real playtesting time tuning weight values here.

Core System 3: Progression and Unlock Economy

Once the core outfit-scoring loop works, the next system is what keeps players coming back: progression. This typically layers a few interlocking mechanics:

Soft currency earned through gameplay (completing looks, winning styling challenges)
Hard/premium currency available through purchase or rare rewards
Unlockable item tiers, often gated by both currency and player level
Seasonal/limited-time content to create urgency and recurring engagement

A clean way to structure this in Unity is to keep the economy logic entirely separate from the UI and gameplay logic, using an event-driven approach:

public class CurrencyManager : MonoBehaviour
{
    public static event System.Action<int> OnCurrencyChanged;
    private int softCurrency;

    public bool TrySpend(int amount)
    {
        if (softCurrency < amount) return false;
        softCurrency -= amount;
        OnCurrencyChanged?.Invoke(softCurrency);
        return true;
    }

    public void AddCurrency(int amount)
    {
        softCurrency += amount;
        OnCurrencyChanged?.Invoke(softCurrency);
    }
}

Keeping currency and unlock logic decoupled from any specific UI screen means you can reuse the same economy backbone across a shop screen, a reward popup, and a progression map without duplicating logic — a pattern that pays off significantly as the game's content grows.

Core System 4: Social and Sharing Mechanics

The "blogger" framing in this genre usually implies some kind of social loop layered on top of the core styling gameplay — sharing an outfit for likes/votes, competing in styling challenges against other players, or building a follower count that gates new content.

Technically, this typically requires:

A backend (Firebase, PlayFab, or custom) to store and retrieve shared outfit data
A voting/rating system with basic anti-abuse protections (rate limiting, duplicate-vote prevention)
A feed or gallery UI capable of loading and displaying a paginated list of community content efficiently, without loading everything into memory at once

This is genuinely one of the more backend-heavy corners of casual mobile game development, and it's worth scoping carefully — a full social sharing system is a meaningfully larger engineering investment than the core dress-up loop itself, and it's worth prototyping the core styling mechanic first before committing to the social layer.

Comparing This to Other Systems-Heavy Casual Genres

It's worth noting that fashion/styling games aren't the only casual genre where the "looks simple, is actually a systems design problem" pattern shows up. Parking and spatial-puzzle games are another good example — mechanically about as far from fashion games as you can get, but architecturally similar in that a simple-looking core interaction hides a fair amount of underlying complexity.

There's a solid technical breakdown of exactly this in a systems-level write-up of a park-and-match mechanic: Building a Parking Puzzle in Unity: A Systems Breakdown of the Park & Match Mechanic. It's a genuinely different genre, but the underlying lesson is the same one that applies here — "simple to play" and "simple to build" are two very different claims, and a lot of the genre's real engineering complexity lives in state management and scoring logic that never shows up on screen.

Common Implementation Pitfalls

A few mistakes tend to show up repeatedly in styling/dress-up game codebases:

Coupling scoring logic directly to UI code, making it impossible to unit test or reuse the scoring algorithm elsewhere (like an AI-suggested outfit feature)
Hardcoding item data instead of using a data-driven asset pipeline, which turns every content update into a code change
No pooling for gallery/feed UI elements, causing frame drops when scrolling through community outfit feeds with dozens of entries
Overly strict scoring thresholds discovered only after launch, frustrating players who feel like their creative outfit choices are being "wrong" answers
Underestimating backend scope for the social/sharing layer, treating it as an afterthought rather than a real infrastructure investment

Most of these are avoidable with early architectural decisions — particularly keeping data, logic, and presentation cleanly separated from the start, which matters more in this genre than it might initially seem given how content-heavy and frequently updated these games tend to be.

Studying a Working Implementation

Reading about these systems in the abstract only gets you so far — at some point, it's worth looking at a fully built, working implementation to see how the inventory, scoring, and progression systems actually fit together in a shipped project. There's a working example of exactly this kind of styling/dress-up mechanic available here: Fashion Blogger Game in Unity, built out with the slot-based inventory, outfit scoring, and progression systems described above already implemented and functioning end to end. It's a useful reference point if you're trying to see how these pieces connect in practice rather than just in isolated code snippets.

If you're exploring this genre more broadly, or comparing it against other casual mechanics before deciding what to build, it's also worth browsing a wider set of ready-made Android-focused casual titles for a sense of how different genres solve similar retention and progression problems: Best Ready-Made Unity Games for Android.

Wrapping Up

Fashion and styling games are a great example of a genre where the player-facing simplicity is doing a lot of work to hide real systems complexity underneath. Slot-based inventory, weighted scoring algorithms, layered progression economies, and social sharing mechanics all need to work together cleanly — and the genre's expectation of frequent content updates means your architecture needs to be data-driven from day one, not bolted on after the fact.

If you're building something in this space, the advice that seems to hold up consistently is: get your data layer (ScriptableObject-driven items, decoupled scoring logic, event-driven currency systems) right early. Content will keep growing for as long as the game is live, and a clean architecture is what determines whether that growth stays manageable or turns into a maintenance burden six months in.

Building a Parking Puzzle in Unity: A Systems Breakdown of the Park Match Mechanic

unity source code — Tue, 28 Jul 2026 18:35:22 +0000

Parking and matching puzzles look almost insultingly simple from the outside. A few cars, a cramped lot, tap or drag to move them out. But if you've actually tried to build one that feels tight — no janky collision resolution, no ambiguous "why didn't that move register" moments, no lag once the board gets crowded — you know there's a real systems design problem hiding underneath what looks like a weekend project.

I recently went through the architecture of a parking/matching hybrid template built in Unity and wanted to break down the core systems the way I'd want them explained if I were reskinning or extending one myself. This isn't a marketing post — it's a walkthrough of the actual mechanics: how vehicle movement and collision resolution work, how the match/clear pipeline is structured, how level data is separated from movement logic so hundreds of levels don't require touching code, and how monetization hooks slot into natural break points without polluting gameplay scripts.

If you want to see the finished product this breakdown is loosely based on, there's a working template here: Park Match Unity Game Template. Everything below applies whether you're building something similar from scratch or extending an existing base.

Why Parking Puzzles Are Harder Than They Look

The core loop — tap or drag a vehicle, it exits along a valid path, the lot clears one piece at a time — is trivial to describe and genuinely fiddly to implement well. Four problems show up almost immediately once you move past a static mockup:

Valid-move detection: how do you know, at any given moment, which vehicles can actually move given their orientation and the current board state?
Path resolution: once a vehicle starts moving, how does it navigate around other vehicles and obstacles without clipping through them or getting stuck mid-animation?
Match/clear logic: when does a vehicle actually "clear" the board — on reaching an exit, on matching color/type with another vehicle, or both — and how do you avoid double-triggering a clear when two systems could plausibly fire at once?
Level authoring at scale: since this genre lives or dies on having dozens or hundreds of well-tuned layouts, how do you avoid a level being a hardcoded scene that takes as long to build as a whole new feature?

Get any of these wrong and the game either feels unresponsive (taps that don't register because the valid-move check was too conservative), visually broken (vehicles overlapping mid-animation), or becomes a nightmare to scale past a dozen hand-built levels — all of which show up fast in churn and review scores for casual mobile puzzles.

System 1: Valid-Move Detection

Before a vehicle can move, the game needs to know whether a clear path exists in the direction that vehicle is oriented. The cleanest way to handle this is to keep the board as a simple 2D grid of cell occupancy, independent of the visual transform positions of the vehicles themselves.

public class ParkingGrid
{
    private readonly int[,] occupancy; // -1 = empty, otherwise vehicleId
    private readonly int width, height;

    public ParkingGrid(int w, int h)
    {
        width = w;
        height = h;
        occupancy = new int[w, h];
        for (int x = 0; x < w; x++)
            for (int y = 0; y < h; y++)
                occupancy[x, y] = -1;
    }

    public bool IsPathClear(Vector2Int start, Vector2Int direction, int length)
    {
        for (int i = 1; i <= length; i++)
        {
            var check = start + direction * i;
            if (!InBounds(check) || occupancy[check.x, check.y] != -1)
                return false;
        }
        return true;
    }

    private bool InBounds(Vector2Int p) =>
        p.x >= 0 && p.x < width && p.y >= 0 && p.y < height;
}

Notice the grid knows nothing about sprites, animation curves, or input — it's pure occupancy state. That separation matters enormously once you get to system 2, because path resolution and visual movement are genuinely different concerns that get tangled constantly in naive implementations.

System 2: Path Resolution Without Fighting Physics

A tempting shortcut is to drive vehicle movement through Unity's physics engine directly — Rigidbody2D with collisions, let the physics solver figure out contact resolution. This works for about the first five vehicles you test and then falls apart the moment two vehicles are released to move in the same frame and their colliders briefly overlap during the transition, producing a visible stutter or an unintended nudge.

A more predictable approach separates grid-state movement (instant, logical, resolved before any animation plays) from presentation movement (purely visual, tweened, guaranteed not to fight with physics):

public class VehicleController : MonoBehaviour
{
    public Vector2Int gridPosition;
    public Vector2Int facingDirection;
    private ParkingGrid grid;

    public void TryMove(Action onArrived)
    {
        int length = ComputeExitDistance();
        if (!grid.IsPathClear(gridPosition, facingDirection, length))
        {
            onArrived?.Invoke(); // move rejected, no animation plays
            return;
        }

        grid.ClearCell(gridPosition);
        var targetWorldPos = GridToWorld(gridPosition + facingDirection * length);
        StartCoroutine(AnimateMove(targetWorldPos, onArrived));
    }

    private IEnumerator AnimateMove(Vector3 target, Action onComplete)
    {
        float duration = 0.35f;
        float t = 0f;
        Vector3 start = transform.position;
        while (t < duration)
        {
            t += Time.deltaTime;
            transform.position = Vector3.Lerp(start, target, t / duration);
            yield return null;
        }
        transform.position = target;
        onComplete?.Invoke();
    }
}

The key decision here is that the grid state resolves before any animation starts, not during it. By the time the player sees a vehicle sliding out, the logical outcome of that move has already been decided and committed. This eliminates an entire category of race-condition bugs where two vehicles both start animating toward positions that briefly conflict, because the grid never allows that state to exist in the first place — a move that isn't valid never starts animating at all.

System 3: Match and Clear Logic Without Double-Triggers

Depending on the specific variant, a vehicle might clear the board by reaching a designated exit, by matching color or type with another vehicle in an adjacent clear zone, or both. The failure mode to watch for here is a clear event firing twice — once from an exit-reached check and once from a match check that both happened to resolve on the same frame.

The fix is to route every possible clear condition through a single authority rather than letting each system independently decide a vehicle is "done":

public class ClearAuthority : MonoBehaviour
{
    private readonly HashSet<int> clearedThisFrame = new HashSet<int>();

    public void RequestClear(int vehicleId, ClearReason reason)
    {
        if (clearedThisFrame.Contains(vehicleId)) return; // already handled
        clearedThisFrame.Add(vehicleId);

        BoardStateManager.Instance.RemoveVehicle(vehicleId);
        ScoreManager.Instance.RegisterClear(vehicleId, reason);
        LevelWinChecker.Instance.CheckWinCondition();
    }

    private void LateUpdate() => clearedThisFrame.Clear();
}

public enum ClearReason { ReachedExit, MatchedPair }

Both the exit-detection script and the match-detection script call ClearAuthority.RequestClear, and neither one needs to know or care whether the other system might also be trying to clear the same vehicle on the same frame. This is the same defensive pattern that shows up anywhere multiple systems can plausibly trigger the same terminal state — better to have one gatekeeper than to have every caller individually try to guard against a race condition it can only partially see.

System 4: Level Data as Content, Not Code

This is the part that determines whether a parking puzzle game can scale to a real level count or stalls out around level fifteen because every new layout means opening a scene and hand-placing vehicles. The fix is the same one that shows up in basically every casual-genre systems breakdown worth reading: pull layout data out into ScriptableObject assets that the runtime scene reads, rather than baking layouts directly into hand-built scenes.

[CreateAssetMenu(fileName = "LevelLayout", menuName = "Game/Level Layout")]
public class LevelLayout : ScriptableObject
{
    [Serializable]
    public class VehiclePlacement
    {
        public Vector2Int gridPosition;
        public Vector2Int facingDirection;
        public VehicleType type;
        public int colorIndex;
    }

    public int gridWidth;
    public int gridHeight;
    public List<VehiclePlacement> placements;
    public int moveLimit;
}

A single generic level-loader scene reads whichever LevelLayout asset is active, spawns vehicles at the specified grid positions, and wires them into the same ParkingGrid and ClearAuthority systems described above — no per-level code, no per-level scene. Building a new level becomes a data-authoring task (arranging placements in an Inspector or an external level editor tool that exports to this same format), not an engineering task. This is what actually lets a template like this scale to hundreds of levels without a proportional increase in developer time per level.

System 5: Monetization Hooks at Natural Break Points

Parking and matching puzzles have unusually clean break points for monetization compared to genres with more continuous action — a level either ends in a win or a stall (no more valid moves, move limit reached), and both of those moments are natural, non-disruptive places to offer a rewarded video for an extra move or a hint, rather than interrupting the player mid-action.

The mistake to avoid is wiring ad calls directly into the win/loss detection logic itself. Keeping monetization behind the same kind of interface-driven boundary used for the clear authority avoids polluting the core game logic with third-party SDK concerns:

public interface IRewardService
{
    void OfferExtraMove(Action onGranted, Action onDeclinedOrFailed);
}

public class LevelStallHandler : MonoBehaviour
{
    private IRewardService rewardService;

    public void OnNoValidMovesRemaining()
    {
        rewardService.OfferExtraMove(
            onGranted: () => MoveLimitManager.Instance.GrantExtraMove(),
            onDeclinedOrFailed: () => LevelWinChecker.Instance.TriggerLevelFailed()
        );
    }
}

LevelStallHandler doesn't know or care whether IRewardService is backed by AdMob, Unity LevelPlay, or a mock implementation used in editor testing. That separation is exactly what let earlier systems in this breakdown — grid state, path resolution, clear authority — stay entirely free of any monetization-specific logic, which matters a lot the first time you need to swap ad networks or A/B test reward placement without touching gameplay code at all.

Extending the Core Loop

Once movement, matching, level-data separation, and monetization hooks are solid, most of the "make it feel like a full game" work is additive rather than architectural:

New vehicle types: trucks that need two grid cells instead of one, or vehicles that can only exit in specific directions, both slot into the existing ParkingGrid/VehicleController split without new core systems
Hint systems: a lightweight solver that scans current grid occupancy for any valid move and highlights it, built entirely on top of the same IsPathClear check the core loop already uses
Daily challenges: a rotating LevelLayout reference swapped based on system date, using the exact same data-driven loader described in System 4
Leaderboards and star ratings: meta-progression layered on top of ScoreManager, decoupled from the movement and clear systems entirely

None of these require touching the grid, movement, or clear-authority core — which is really the entire point of building the foundation this way. A parking puzzle with this kind of separation can absorb months of new level content and feature additions without ever needing a rewrite of the underlying mechanics.

If you're evaluating whether to build this kind of system from scratch or start from an existing, already-architected base, it's worth browsing what's already out there before committing to either path — a broader look at Unity Source Code's full product catalog is a reasonable place to compare feature sets and architecture quality across templates before deciding where to spend your own engineering time. I went through a similarly detailed systems breakdown for a completely different casual mechanic — fill-based coloring gameplay rather than movement-based puzzle gameplay — in an earlier piece on building a relaxing coloring game in Unity, and a lot of the same underlying principles show up there too: decoupled input handling, ScriptableObject-driven content, and a save/state layer that doesn't know or care about presentation. The specific mechanic changes; the architectural discipline that makes a casual game scale past a dozen hand-built levels doesn't.

Wrapping Up

Parking and matching puzzles earn their "casual" label by hiding complexity, not by lacking it. The systems that make this genre feel tight — grid-based occupancy state decoupled from visual animation, a single clear authority that prevents double-trigger bugs, level layouts as data rather than hardcoded scenes, and monetization wired behind an interface instead of tangled into win/loss logic — are the same categories of systems you'll run into building almost any casual mobile puzzle game. Get those right and the rest — new vehicle types, hint systems, daily challenges, leaderboards — is just content and feature work layered on top of a foundation that doesn't need to change.

If you're prototyping something in this space, start with the grid-state/animation separation first. Every other system in this breakdown — path resolution, clear detection, even how cleanly monetization hooks slot in — depends on getting that one decision right before anything else gets built on top of it.

Building a Relaxing Coloring Game in Unity: A Systems Breakdown of Mandala Fill Mechanics

unity source code — Mon, 27 Jul 2026 17:48:39 +0000

Coloring games look simple from the outside. Tap a shape, it fills with a color, move to the next shape. But if you've ever tried to build one that feels good — smooth fills, no flood-fill lag, palettes that update instantly, and progress that survives an app restart — you know there's a surprising amount of systems design hiding behind that simplicity.

I recently went through the architecture of a mandala-style coloring template built in Unity, and wanted to break down the core systems the way I'd want them explained if I were reskinning or extending one myself. This isn't a marketing post — it's a walkthrough of the actual mechanics: how region detection works, how the palette and fill pipeline talk to each other, how zoom/pan is handled without killing frame rate on low-end Android devices, and how the save system persists a half-finished mandala across sessions.

If you want to see the finished product this breakdown is based on, there's a working template here: Mandala Coloring Unity Template. Everything below applies whether you're building from scratch or extending an existing base.

Why Coloring Games Are Harder Than They Look

The core loop of a coloring game — tap, fill, repeat — is trivial to describe and non-trivial to implement well. Three problems show up almost immediately:

Region detection: how do you know which "cell" of the mandala the player just tapped?
Fill rendering: how do you change that region's color without repainting the whole texture or triggering a garbage collection spike?
State persistence: how do you remember which regions are colored, in what color, across app restarts, without bloating save file size?

Get any of these wrong and the game either lags on mid-range phones, looks visually broken (color bleeding past region borders), or loses player progress — all of which tank retention numbers fast in casual mobile games.

System 1: Region Detection (Sprite Segmentation vs. Mesh Segmentation)

There are two common approaches to segmenting a mandala into fillable regions:

Sprite-based segmentation treats each closed shape in the mandala as its own separate sprite object, layered with a shared outline sprite on top. Each sprite has its own SpriteRenderer and a PolygonCollider2D (or PolygonCollider2D auto-generated from the sprite's physics shape) so taps can be captured via standard OnMouseDown or a raycast against 2D colliders.

public class MandalaRegion : MonoBehaviour
{
    public int regionId;
    public SpriteRenderer regionRenderer;

    public void Fill(Color color)
    {
        regionRenderer.color = color;
        SaveSystem.Instance.RecordFill(regionId, color);
    }

    private void OnMouseDown()
    {
        Fill(PaletteManager.Instance.CurrentColor);
    }
}

This is the approach most reskinnable coloring templates use, because it keeps each region as a discrete, inspectable GameObject — artists can drop in a new mandala design just by swapping sprites and re-generating colliders, without touching code.

Mesh/texture-based segmentation instead bakes the entire mandala into a single texture with a region ID encoded per pixel (often in an unused color channel or a separate lookup texture). A tap does a pixel read at the touch coordinate to determine the region ID, then a shader recolors just that region using a color-replace pass. This scales better for extremely dense mandalas (hundreds of tiny regions) since you avoid the overhead of hundreds of individual GameObjects and colliders, but it's harder for non-programmers to reskin since new art requires regenerating the ID lookup texture.

For most mobile coloring games — including mandala templates where region counts are usually in the 40–150 range — sprite-based segmentation is the more sustainable choice. It trades a small amount of raw performance for a huge gain in reskin speed, which matters more when the business model is "sell the template and let studios re-skin it fast."

System 2: The Palette-to-Fill Pipeline

The palette bar is deceptively important. Players expect:

Instant visual feedback when they select a color (no delay before the next tap fills correctly)
The currently selected color to be visually indicated (usually a border/highlight state)
Colors to persist correctly if the player switches palettes mid-design

A clean way to handle this is a singleton PaletteManager that other systems subscribe to via events rather than polling every frame:

public class PaletteManager : MonoBehaviour
{
    public static PaletteManager Instance;
    public Color CurrentColor { get; private set; }
    public event Action<Color> OnColorChanged;

    private void Awake() => Instance = this;

    public void SelectColor(Color color)
    {
        CurrentColor = color;
        OnColorChanged?.Invoke(color);
    }
}

Region components then just read PaletteManager.Instance.CurrentColor at the moment of the tap, rather than caching a stale value. This avoids a subtle bug that shows up in a lot of hobby coloring-game code: the player selects a new color, taps a region, but it fills with the previous color because the region component cached the color reference on Start() instead of reading it live.

System 3: Zoom and Pan Without Killing Frame Rate

Mandalas have fine detail, so zoom is not optional — it's core to the game feel. The naive implementation (scaling a Canvas or parent Transform directly in response to pinch input) works but tends to produce jittery, low-frame-rate zooming on budget Android devices because every frame recalculates layout for potentially dozens of UI-driven region objects.

A more robust approach separates the camera from the canvas:

Keep the mandala on a World Space canvas (or plain sprites, not UI at all)
Drive zoom via Camera.main.orthographicSize, clamped to a min/max range
Drive pan via camera position, clamped to keep the mandala roughly centered in view
Use Cinemachine (or a lightweight custom camera rig) so zoom/pan momentum feels natural instead of snapping

public class MandalaCameraRig : MonoBehaviour
{
    public float minZoom = 2f;
    public float maxZoom = 8f;
    private Camera cam;

    private void Awake() => cam = Camera.main;

    public void Zoom(float delta)
    {
        cam.orthographicSize = Mathf.Clamp(
            cam.orthographicSize - delta,
            minZoom,
            maxZoom
        );
    }
}

Driving zoom through the camera instead of scaling individual objects means the fill/tap logic never has to know or care about the current zoom level — a tap is still a tap, region colliders don't need re-scaling, and performance stays flat regardless of zoom depth. This is the same principle that shows up in a lot of casual mobile games: keep gameplay logic decoupled from camera/viewport state so one system's changes don't cascade into another.

System 4: Save System — Persisting Partial Progress

Coloring games are rarely finished in one sitting. A player might color 12 of 60 regions, close the app, and come back three days later expecting exactly where they left off. That means the save system needs to track, per mandala design:

Which regions have been filled
What color each filled region currently holds
Which mandala/level the player was last working on

A lightweight approach avoids saving a full serialized scene and instead stores a compact dictionary keyed by region ID:

[Serializable]
public class MandalaSaveData
{
    public string mandalaId;
    public List<int> filledRegionIds = new List<int>();
    public List<string> hexColors = new List<string>(); // parallel array
}

public class SaveSystem : MonoBehaviour
{
    public static SaveSystem Instance;
    private MandalaSaveData current;

    public void RecordFill(int regionId, Color color)
    {
        int idx = current.filledRegionIds.IndexOf(regionId);
        string hex = ColorUtility.ToHtmlStringRGB(color);

        if (idx >= 0) current.hexColors[idx] = hex;
        else
        {
            current.filledRegionIds.Add(regionId);
            current.hexColors.Add(hex);
        }

        PlayerPrefs.SetString(current.mandalaId, JsonUtility.ToJson(current));
    }
}

PlayerPrefs is fine for a coloring game since save payloads are small (a mandala with 150 regions is still a tiny JSON blob), but if you're extending this into something with dozens of unlockable designs, cloud sync, or account-based progress, it's worth migrating to a proper local file store or a lightweight backend fairly early — retrofitting a save system after players already have progress on-device is a much more painful migration than building it in from day one.

System 5: Reskin Architecture — Why This Matters for the Business Model

A lot of coloring, puzzle, and casual mobile templates are sold specifically because they're fast to reskin — a studio buys the base mechanic once and reskins it repeatedly for different markets or ad campaigns. That only works if the codebase separates content from logic cleanly:

All mandala designs live as prefab variants referencing the same base MandalaController script
Palette color sets are ScriptableObject assets, not hardcoded arrays, so a new palette is a new asset, not a new build
UI theme (background, buttons, fonts) is decoupled from gameplay scripts entirely

This pattern isn't unique to coloring games — it's the same architectural discipline you'd want in any casual game meant to support multiple SKUs from one codebase. I covered a related angle of this — building systems that are meant to be extended and reskinned rather than rebuilt from scratch — in a previous breakdown of adding leaderboards and achievements to a Unity puzzle game, which walks through wiring meta-progression systems into an existing puzzle loop without touching core gameplay code. The same separation-of-concerns logic applies whether you're adding a leaderboard to a match-3 game or adding a new mandala pack to a coloring game — the content layer and the systems layer should never know too much about each other.

Extending the Core Loop

Once the fill, palette, zoom, and save systems are solid, most of the "make it feel like a full game" work is additive rather than architectural:

Daily challenges: a ScriptableObject-driven rotation that swaps which mandala is "featured" based on the system date
Gradient/texture fills: swap the flat SpriteRenderer.color assignment for a material property block driving a gradient shader
Ambient audio: a simple AudioSource crossfade system tied to scene load, decoupled from gameplay entirely
Monetization hooks: reward-based unlocks (watch an ad to unlock a premium palette or design) plumbed through the same PaletteManager/save system rather than as a bolted-on separate system

None of these require touching the region-fill or save-system core — which is exactly the point of building the foundation this way. A coloring game with a well-separated fill/palette/save architecture can absorb months of content updates (new mandala packs, new palettes, seasonal designs) without ever needing a rewrite of the underlying mechanics.

If you're building something adjacent — say, a physics-based puzzle rather than a fill-based one — a lot of the same principles (decoupled input handling, ScriptableObject-driven content, lightweight per-object save state) carry over directly. There's a similar mechanically-distinct but architecturally-related template worth looking at if nuts-and-bolts style puzzle mechanics are more your speed: Wood Nuts & Bolts Screw Unity Template, which deals with a different core loop (screw/unscrew physics puzzles) but faces a lot of the same reskin and save-state design questions.

Wrapping Up

Coloring games earn their "casual" label by hiding complexity, not by lacking it. The systems that make a mandala coloring game feel smooth — clean region segmentation, an event-driven palette pipeline, camera-decoupled zoom, compact save state, and a content/logic split that supports fast reskinning — are the same categories of systems you'll run into building almost any casual mobile game. Get those five things right and the rest (new designs, new palettes, new monetization hooks) is just content work layered on top of a foundation that doesn't need to change.

If you're prototyping something similar, start with the region-detection decision first — sprite-based vs. texture-based segmentation shapes almost every downstream decision about performance, reskin speed, and how your save system needs to be structured. Everything else in this breakdown follows from getting that one choice right for your specific mandala density and target device range.

Adding Leaderboards and Achievements to a Unity Puzzle Game: A Systems Breakdown

unity source code — Sun, 26 Jul 2026 18:42:42 +0000

In my last post, I walked through the tile-collection match mechanic slot-based matching, win/loss detection, level data structures, the works. A few people asked a reasonable follow-up question: okay, the core loop works, now what? What actually turns a finished prototype into something players open more than once?

The honest answer is retention systems, and the two cheapest, most reliable ones you can add are leaderboards and achievements. Neither is glamorous. Neither will fix a weak core loop. But bolted onto a mechanic that already works, they're some of the highest return-on-effort systems you can build, and they're a genuinely good exercise in state management, event-driven architecture, and separating your game logic from your presentation layer — skills that transfer to basically every other system you'll build afterward.

This post walks through the actual architecture: how I'd structure the data models, where the hooks into your core loop should live, and the mistakes that turn a simple feature into a tangled mess if you don't think about them up front.

Why This Matters More Than It Sounds Like It Should

If you've shipped a game before, you already know that getting someone to open your app a second time is often harder than getting the first download. A tile-matching puzzle with no reason to return is a game people finish (or abandon) once and delete. The same game with a persistent leaderboard and a handful of well-designed achievements gives players an external reason to come back — competing with a friend's score, chasing the next unlock, closing out a completion percentage.

None of that changes your core mechanic. It changes the meta-layer wrapped around it, and that meta-layer is disproportionately responsible for Day 7 and Day 30 retention numbers compared to how much development time it actually costs.

Designing the Data Model First

Before writing a single line of UI code, decide what you're actually tracking. For a tile-matching puzzle like the one from my last post, a reasonable starting model looks like this:

[System.Serializable]
public class PlayerStats
{
    public int highScore;
    public int totalMatchesCleared;
    public int totalLevelsCompleted;
    public int currentWinStreak;
    public int bestWinStreak;
    public List<string> unlockedAchievementIds = new List<string>();
}

Enter fullscreen mode

Exit fullscreen mode

Keep this separate from your gameplay state entirely. PlayerStats shouldn't know anything about tiles, slots, or match logic — it just accumulates numbers over time. This separation is what saves you from a tangled mess later: your gameplay code fires events, and something else entirely is responsible for listening to those events and updating stats.

Event-Driven Hooks Instead of Direct Calls

The mistake I see most often — and one I made myself the first time I built this — is calling stat-tracking code directly from inside gameplay logic:

// Don't do this
void ClearMatch(List<Tile> matchedTiles)
{
    // ... match clearing logic ...
    PlayerStats.Instance.totalMatchesCleared++;
    CheckAchievements(); // gameplay code shouldn't know achievements exist
}

Enter fullscreen mode

Exit fullscreen mode

This works fine for a five-minute prototype and becomes a nightmare the moment you want to add a new achievement, change how streaks are calculated, or reuse the same gameplay code in a different game mode. Instead, fire an event and let a dedicated manager listen for it:

public static class GameEvents
{
    public static event Action<int> OnMatchCleared;
    public static event Action<int> OnLevelCompleted;
    public static event Action OnLevelFailed;

    public static void MatchCleared(int tileCount) => OnMatchCleared?.Invoke(tileCount);
    public static void LevelCompleted(int score) => OnLevelCompleted?.Invoke(score);
    public static void LevelFailed() => OnLevelFailed?.Invoke();
}

Enter fullscreen mode

Exit fullscreen mode

Your gameplay code now just fires the event and moves on:

void ClearMatch(List<Tile> matchedTiles)
{
    // ... match clearing logic ...
    GameEvents.MatchCleared(matchedTiles.Count);
}

Enter fullscreen mode

Exit fullscreen mode

And a separate StatsManager subscribes and owns all the bookkeeping:

public class StatsManager : MonoBehaviour
{
    void OnEnable()
    {
        GameEvents.OnMatchCleared += HandleMatchCleared;
        GameEvents.OnLevelCompleted += HandleLevelCompleted;
        GameEvents.OnLevelFailed += HandleLevelFailed;
    }

    void OnDisable()
    {
        GameEvents.OnMatchCleared -= HandleMatchCleared;
        GameEvents.OnLevelCompleted -= HandleLevelCompleted;
        GameEvents.OnLevelFailed -= HandleLevelFailed;
    }

    void HandleMatchCleared(int tileCount)
    {
        PlayerStats.Instance.totalMatchesCleared++;
        AchievementManager.Instance.CheckMatchAchievements();
    }

    void HandleLevelCompleted(int score)
    {
        PlayerStats.Instance.totalLevelsCompleted++;
        PlayerStats.Instance.currentWinStreak++;
        PlayerStats.Instance.bestWinStreak = Mathf.Max(
            PlayerStats.Instance.bestWinStreak,
            PlayerStats.Instance.currentWinStreak
        );

        if (score > PlayerStats.Instance.highScore)
        {
            PlayerStats.Instance.highScore = score;
            LeaderboardManager.Instance.SubmitScore(score);
        }

        AchievementManager.Instance.CheckLevelAchievements();
    }

    void HandleLevelFailed()
    {
        PlayerStats.Instance.currentWinStreak = 0;
    }
}

Enter fullscreen mode

Exit fullscreen mode

Now your gameplay code has zero knowledge of achievements, leaderboards, or streak logic. You can gut and rebuild the entire retention system without touching a single line of match-clearing logic, and vice versa — you can rework your tile-matching mechanic without worrying about breaking stat tracking.

Structuring Achievements So They Scale

The other common mistake is hardcoding achievement conditions directly in code — an if statement per achievement, scattered across your codebase. It works for three achievements. It falls apart at twenty. Define achievements as data instead:

[CreateAssetMenu(fileName = "Achievement", menuName = "Game/Achievement")]
public class AchievementData : ScriptableObject
{
    public string achievementId;
    public string displayName;
    public string description;
    public AchievementType type;
    public int targetValue;
}

public enum AchievementType
{
    TotalMatches,
    TotalLevelsCompleted,
    WinStreak,
    HighScore
}

Enter fullscreen mode

Exit fullscreen mode

Then your AchievementManager just iterates over a list of these ScriptableObjects and checks the relevant stat against each one's targetValue, instead of hardcoding a check per achievement:

public class AchievementManager : MonoBehaviour
{
    public static AchievementManager Instance { get; private set; }
    [SerializeField] private List<AchievementData> allAchievements;

    void Awake() => Instance = this;

    public void CheckMatchAchievements() => EvaluateType(AchievementType.TotalMatches, PlayerStats.Instance.totalMatchesCleared);
    public void CheckLevelAchievements()
    {
        EvaluateType(AchievementType.TotalLevelsCompleted, PlayerStats.Instance.totalLevelsCompleted);
        EvaluateType(AchievementType.WinStreak, PlayerStats.Instance.currentWinStreak);
        EvaluateType(AchievementType.HighScore, PlayerStats.Instance.highScore);
    }

    void EvaluateType(AchievementType type, int currentValue)
    {
        foreach (var achievement in allAchievements)
        {
            if (achievement.type != type) continue;
            if (PlayerStats.Instance.unlockedAchievementIds.Contains(achievement.achievementId)) continue;

            if (currentValue >= achievement.targetValue)
            {
                UnlockAchievement(achievement);
            }
        }
    }

    void UnlockAchievement(AchievementData achievement)
    {
        PlayerStats.Instance.unlockedAchievementIds.Add(achievement.achievementId);
        GameEvents.AchievementUnlocked(achievement); // fire an event for UI to react to
    }
}

Enter fullscreen mode

Exit fullscreen mode

Designing a new achievement is now a data task, not a code task — create a new AchievementData asset in the editor, set its type and target value, done. No recompiling, no new if statement buried somewhere in your stats manager.

Local Leaderboards vs. Platform Leaderboards

There are really two tiers here, and it's worth building them as separate concerns rather than assuming you'll only ever need one.

Local leaderboards are just a sorted list of scores stored on-device — useful for single-player high score tracking even before you've integrated any platform services. A simple approach using PlayerPrefs for a lightweight top-10 list works fine early on:

public class LeaderboardManager : MonoBehaviour
{
    public static LeaderboardManager Instance { get; private set; }
    const string LeaderboardKey = "local_leaderboard";
    const int MaxEntries = 10;

    void Awake() => Instance = this;

    public void SubmitScore(int score)
    {
        List<int> scores = LoadScores();
        scores.Add(score);
        scores.Sort((a, b) => b.CompareTo(a));
        if (scores.Count > MaxEntries) scores = scores.GetRange(0, MaxEntries);
        SaveScores(scores);
    }

    List<int> LoadScores()
    {
        string raw = PlayerPrefs.GetString(LeaderboardKey, "");
        if (string.IsNullOrEmpty(raw)) return new List<int>();
        var parts = raw.Split(',');
        var result = new List<int>();
        foreach (var p in parts) if (int.TryParse(p, out int val)) result.Add(val);
        return result;
    }

    void SaveScores(List<int> scores)
    {
        PlayerPrefs.SetString(LeaderboardKey, string.Join(",", scores));
    }
}

Enter fullscreen mode

Exit fullscreen mode

Platform leaderboards — Google Play Games Services on Android, Game Center on iOS — are what actually give you cross-device, social, competitive leaderboards, and they're what most players mean when they think "leaderboard." These require SDK integration rather than a homegrown system, and the implementation details (authentication flow, submitting scores through the platform API, showing the native UI) differ meaningfully between platforms and are honestly enough to warrant their own dedicated walkthrough rather than trying to cram it into this post.

If you're at the point of wiring in the real platform SDKs — Play Games Services setup, Game Center authentication, achievement syncing across both platforms — I'd point you to this full walkthrough on adding leaderboards and achievements to a Unity game, which goes through the platform-specific setup in more depth than makes sense to duplicate here. The architecture in this post (event-driven stats, data-driven achievements) is exactly what you'd plug that platform integration into — the LeaderboardManager.SubmitScore() method above is where you'd eventually call PlayGamesPlatform.Instance.SubmitScore() or the iOS equivalent instead of (or alongside) the local implementation.

The UI Layer: React to Events, Don't Poll

The last piece worth getting right is how your UI finds out an achievement unlocked. Polling PlayerStats every frame to check for changes is wasteful and awkward. Instead, subscribe to the event you already defined:

public class AchievementToastUI : MonoBehaviour
{
    [SerializeField] private GameObject toastPrefab;
    [SerializeField] private Transform toastParent;

    void OnEnable() => GameEvents.OnAchievementUnlocked += ShowToast;
    void OnDisable() => GameEvents.OnAchievementUnlocked -= ShowToast;

    void ShowToast(AchievementData achievement)
    {
        var toast = Instantiate(toastPrefab, toastParent);
        toast.GetComponent<ToastDisplay>().Setup(achievement.displayName, achievement.description);
    }
}

Enter fullscreen mode

Exit fullscreen mode

This is the same pattern as your StatsManager — the UI layer knows nothing about how achievements are evaluated, it just reacts to an event firing. If you later change how achievements are unlocked (server-side validation, for instance), the UI code doesn't need to change at all.

Where This Fits Into the Bigger Picture

If you worked through the tile-collection matcher from my previous post, everything above bolts directly onto that project without touching the core match-detection logic — that's the whole point of keeping gameplay and meta-systems decoupled through events. GameEvents.MatchCleared() and GameEvents.LevelCompleted() just need to be called from the same places your slot-matching and win/loss logic already lives.

The broader lesson generalizes past this one genre, too. Any Unity project — puzzle, runner, idle, arcade — benefits from the same separation: gameplay systems fire events, a stats layer listens and accumulates, an achievement layer evaluates data-driven conditions, and a UI layer reacts to whatever the stats and achievement layers decide happened. Once you've built this pattern once, adding it to your next project is mostly copy-and-adapt rather than starting from zero.

If you're building this into an existing project and want the deeper platform-integration details — actual Play Games Services and Game Center setup, achievement syncing, and the edge cases around offline score submission — the full leaderboards and achievements guide is the better resource for that layer specifically. Everything in this post is the architecture you'd want in place before you get there.

Breaking Down the Tile-Collection Match Mechanic (and Why It's a Great Second Project for New Unity Devs)

unity source code — Sat, 25 Jul 2026 17:42:33 +0000

f you've built a Unity project or two already and you're looking for the next thing to tackle, tile-matching puzzle games are one of the most underrated genres to study. They look simple on the surface — tap a tile, match three, clear the board — but the systems underneath (state management, win/loss detection, level data structures, UI feedback) hit almost every fundamental a new Unity developer needs to practice before jumping into something more ambitious.

I want to walk through the core mechanics of a tile-collection match puzzle — the "tap to collect, manage limited slots" variant rather than the classic swap-three-in-a-row format — and talk about why this genre is such a good learning ground, what systems you'd need to build one from scratch, and where a ready-made source code base fits into that picture if you'd rather study a working implementation than start from a blank scene.

Two Different Match-3 Philosophies

Most people picture "match 3" as the classic swap mechanic — think Candy Crush, where you swap two adjacent tiles to form a line of three or more. That's one valid design, but it's not the only one, and honestly it's not always the friendliest one to prototype as a beginner because the swap-and-cascade logic (checking for matches after every swap, handling chain reactions, animating multiple simultaneous clears) gets complicated fast.

The tile-collection variant works differently, and it's a genuinely good place to start if you're newer to gameplay systems programming:

Tiles sit on the board in a static grid (or scattered layout)
Tapping a tile moves it into a limited-capacity "collection slot" row
When three identical tiles land in the slot row, they auto-match and clear
If your slots fill up before you can complete a match, it's game over

Notice what's different here: there's no swap logic, no gravity/cascade system, and no complex line-detection algorithm. The state machine is much simpler — you're tracking a slot array, checking for three-of-a-kind whenever a new tile enters it, and handling an overflow condition. That's a far more approachable systems-programming exercise than a cascading swap-3 clone, while still teaching you the same underlying skills: grid-based data structures, win/loss state detection, and UI that reflects game state in real time.

The Systems You'd Actually Need to Build

If you set out to build something like this from scratch, here's roughly what you're looking at, broken into the pieces that actually matter for learning:

1. Board and tile data model

You need a clean separation between the visual tile GameObjects and the underlying data representing what's on the board. A common approach:

public class TileData
{
    public int tileTypeId;
    public Vector2Int gridPosition;
    public bool isCollected;
}

Keeping your data model separate from your visuals (rather than reading tile type directly off a sprite or GameObject name) is one of the biggest habits worth building early — it pays off the moment you want to add save/load, level editors, or analytics.

2. Slot management and match detection

Your collection row is really just a fixed-size array (commonly six or seven slots) that you push tiles into. Every time a tile enters, you check whether three of the same type are now present:

void CheckForMatch()
{
    var groups = slotTiles.GroupBy(t => t.tileTypeId);
    foreach (var group in groups)
    {
        if (group.Count() >= 3)
        {
            ClearTiles(group.Take(3));
        }
    }
}

This is a great exercise in LINQ and collection manipulation if you're still getting comfortable with C#, and it maps directly onto win/loss detection: if the slot array is full and no group has reached the match threshold, the run ends.

3. Level data and progression

Rather than hardcoding tile layouts in the scene, most production-quality implementations load level data from ScriptableObjects or JSON, which lets designers (or you, later) iterate on difficulty without touching code:

[CreateAssetMenu(fileName = "Level", menuName = "Puzzle/LevelData")]
public class LevelData : ScriptableObject
{
    public int levelNumber;
    public TileLayoutEntry[] tileLayout;
    public int slotCapacity;
    public int targetMoves;
}

This is also where you'd start thinking about difficulty curves — slot capacity, tile variety count, and layout density are your main levers for tuning how forgiving or punishing a given level feels.

4. UI feedback loop

Tile games live or die on juiciness — the little animations and feedback cues that make a match feel satisfying. Scale punches on match, a brief particle burst, a slot-row shake on overflow warning. None of this is complicated individually, but it's often the part beginners skip, and it's the part that actually determines whether a prototype feels like a real game or a spreadsheet with sprites.

5. Monetization and retention hooks

Once the core loop works, the systems that actually make a mobile puzzle game commercially viable are the ones layered on top: booster items, daily challenges, ad-based continues, and basic progression tracking (stars, level unlocks). These aren't complicated individually, but wiring all of them together cleanly — without turning your codebase into spaghetti — is genuinely one of the harder parts of finishing a mobile game, as opposed to just prototyping one.

Why This Genre Is a Smart Second (or Third) Project

If you're a newer Unity developer trying to figure out what to build next, tile-matching puzzles hit a sweet spot: complex enough to teach real systems-design lessons, simple enough that you can actually finish it instead of abandoning it three weeks in. That "actually finish it" part matters more than people give it credit for — a completed simple project teaches you more than an abandoned ambitious one.

If you're looking for a broader list of project ideas at a similar difficulty level — genres and mechanics that are approachable enough to complete but substantial enough to actually teach you something — this roundup of best Unity projects for new developers is worth a look. It's a good way to figure out what to build next once you've got the fundamentals from a project like this one down.

Studying a Finished Implementation vs. Building From Zero

There's real value in building this kind of system from scratch once, purely for the learning experience. But there's also real value in reading a finished, production-tested implementation to see how the pieces actually fit together in a shipped project — how the slot logic handles edge cases you might not think of, how the level data is structured for a real content pipeline, how the monetization and progression systems are wired in without becoming a tangled mess.

The Tile World Match 3 Unity source code is a working example of exactly this genre — tap-to-collect tile matching with limited slot management, a modular C# structure, and hooks already in place for boosters, daily challenges, leaderboards, and AdMob integration. Whether you're using it as a reference to compare against your own from-scratch build, or as a foundation to reskin and extend into your own release, it's a useful case study in how a genuinely simple core mechanic gets turned into a complete, monetizable mobile product.

Where to Go From Here

If tile-matching isn't quite the genre you want to specialize in, it's worth browsing more broadly to see what other mechanics and systems are out there. Puzzle, arcade, idle, and casual mobile genres all share a lot of the same underlying skills — grid systems, state machines, UI feedback, monetization hooks — even when the surface-level gameplay looks completely different. The Games category on Unity Source Code is a good place to browse a wide range of genres and mechanics side by side if you want to compare a few different approaches before committing to your next project.

Whichever direction you go, the underlying lesson holds: the genres that look "too simple to be interesting" are usually the ones with the best learning-to-effort ratio. Tile matching is a perfect example — a mechanic simple enough to build in a weekend, but deep enough in its data structures and state management to teach you patterns you'll reuse in every mobile game you build after it.

Monetization Almost Killed My Unity Puzzle Game (Here's What I'd Do Differently)

unity source code — Fri, 24 Jul 2026 17:58:35 +0000

I shipped my first puzzle game with a monetization plan that was basically "add AdMob, figure it out later." That decision cost me about three weeks of post-launch scrambling, a retention curve that looked like a cliff, and a very humbling lesson about how much design work "add ads" actually hides.

This post is the practical, slightly embarrassing version of what I learned — not the polished "10 monetization tips" listicle version. If you're earlier in your Unity mobile journey, hopefully this saves you the detour.

TL;DR

Monetization isn't a checkbox you tick at the end — it's a design decision that changes your retry flow, your failure states, and your session pacing.
Ads-first, IAP-first, and hybrid aren't interchangeable defaults; they map to specific genres and session lengths, and picking the wrong one for your game shape will hurt retention.
Reusing systems (yours or someone else's) that already have monetization scaffolding wired in correctly saves you from re-learning these lessons the hard way.
None of this is about clever code — it's about testing your assumptions against real player behavior early.

Where I went wrong

My prototype was a straightforward match-based puzzle game. Core loop felt good in about two weeks. I spent the next six weeks on levels, polish, and juice — tweening, particles, the fun stuff — and left monetization for "later," treating it as a plumbing task I'd bolt on right before submission.

Later arrived. I dropped in an interstitial after every level completion because that was the fastest thing to implement, and I didn't think hard about it beyond "does the SDK call fire." First week of soft launch, Day 1 retention was noticeably worse than my internal playtests had suggested it should be. Session length was short. Players were bailing right around level 4 or 5 — right where the ad frequency started to feel punishing rather than incidental.

The code was fine. The ad SDK integration worked exactly as intended. The problem was that I'd treated a design decision as an implementation detail.

The actual lesson: ad placement is part of game feel

This sounds obvious written down, but it wasn't obvious to me mid-project: for a puzzle game, session feel is the product. A rewarded ad a player opts into for an extra move feels like generosity. An interstitial that yanks them out of flow right after a level they were enjoying feels like punishment — even though, from a code perspective, both are just an SDK call with a callback.

Once I rebuilt my ad placement around this — rewarded ads for hints and continues, interstitials capped and only shown at natural break points rather than every single level — retention recovered noticeably. Nothing about the underlying tech changed. Only the design thinking behind where and when those calls fired.

If you want the deeper technical and business breakdown of this tradeoff — IAP vs. ad revenue, hybrid models, genre-specific benchmarks, and how session length should actually inform which model you lean into — there's a genuinely thorough guide on this here: In-App Purchases vs. Ad Revenue for Unity Games. It covers the numbers side of this decision in more depth than I'm going to here, including conversion benchmarks and how to read your own retention curve to decide which model fits.

What I'd do differently: design monetization alongside the core loop

If I were starting over, I'd sketch out ad and IAP touchpoints at the same time I'm sketching the core loop and failure states — not after. Concretely, that means answering these questions before writing a single line of monetization code:

Where does a player naturally want a boost? (a failed level, a near-miss, low currency) — that's your rewarded ad opportunity.
Where would an interruption feel least disruptive? (between distinct sessions, not mid-flow) — that's where interstitials belong, if at all.
What's actually worth paying for in this game? (remove ads, hint packs, cosmetic skins, level skips) — this shapes your IAP catalog, and it should map to what players are actually frustrated by or excited about, not a generic shop template.
What's my expected session length, and does that favor ads-first, IAP-first, or hybrid? Short, snackable sessions lean ads. Deeper, progression-heavy sessions have more room for IAP. Most casual/puzzle games land somewhere in a hybrid model.

None of this requires exotic engineering. It requires treating monetization as a design surface instead of a checklist item you rush through at the end, which is exactly the mistake I made the first time.

The bigger pattern: I kept re-learning the same lessons

This wasn't actually the first time I'd relearned a version of this lesson. Save system robustness, cascade edge cases, deadlock detection — I've written before about how much of my early development time went into rediscovering the same set of problems on every new project, instead of building on what I'd already solved. I went into more of that in What Shipping a Puzzle Game in Unity Actually Taught Me About Speed vs. Perfectionism, which covers the architecture and workflow side of this same underlying problem — building the dumbest working version first, and why perfect architecture on day one is usually wasted effort.

Monetization turned out to be the same story with a different subsystem. The fix wasn't a smarter SDK integration. It was recognizing, earlier, that ad placement and IAP design are core-loop decisions, not afterthoughts — and that starting from a codebase or template where that thinking is already baked in saves you from learning it the expensive way, in production, against real retention numbers.

If you're evaluating starting points

If you're weighing whether to build your monetization layer completely from scratch or start from something with ad and IAP scaffolding already wired in sensibly, it's worth spending a little time browsing what's actually out there before committing to a from-scratch build. I've spent a fair amount of time going through the Unity games catalog on Unity Source Code just to calibrate what reasonable monetization integration looks like across different genres — even when I ended up building pieces myself, having that reference point was useful for knowing what "done" should look like before I got there.

Wrapping up

If there's one thing I'd want a newer Unity dev to take from this: monetization is not the boring part you save for last. It's as much a design decision as your level difficulty curve or your retry flow, and getting it wrong doesn't show up as a bug — it shows up as a retention curve that quietly tells you players are leaving right where you made them feel punished instead of rewarded.

Happy to talk through specifics in the comments if you're mid-build on your own monetization layer — curious what ad placement decisions other folks have landed on for puzzle or casual genres specifically.

What Shipping a Puzzle Game in Unity Actually Taught Me About Speed vs. Perfectionism

unity source code — Thu, 23 Jul 2026 17:53:37 +0000

A dev-to-dev breakdown of what actually slows puzzle game development down, and what I'd do differently if I started over.

I used to be the developer who wanted every system "done right" before moving to the next feature. Clean architecture first, then features. Sounds responsible, right? It also meant my first puzzle game prototype sat half-finished for four months while I refactored a grid system that honestly worked fine the first time.

That experience — and a few shipped titles since — changed how I think about building puzzle games in Unity. This post is a collection of the actual lessons, not the polished "10 tips" version. Some of this might be obvious to folks who've shipped a dozen titles. If you're earlier in your mobile dev journey, hopefully it saves you a few of the detours I took.

TL;DR

Puzzle game mechanics are simple, but the edge cases around them are where all your time actually goes.
Perfect architecture on day one is usually wasted effort — build for the game you have, not the game you imagine you'll have in six months.
Reusing proven systems (yours or someone else's) isn't cutting corners, it's just good time allocation.
Shipping fast and iterating on real player data beats theorizing about what players "probably" want.

The Grid System Rabbit Hole

Every puzzle game tutorial starts the same way: build a grid, populate it with tiles, detect matches. Easy enough that you can have something moving on screen within a day.

Here's where I went wrong the first time. I got the basic match detection working, and instead of moving forward, I started "future-proofing" it — building support for hexagonal grids I didn't need, an abstract tile-type system for mechanics I hadn't designed yet, and a generic event bus for interactions that didn't exist in my actual game.

None of that complexity was wrong in principle. It was wrong in timing. I was solving problems I didn't have yet, at the expense of problems I did have — like the fact that my match detection broke the moment two chain reactions happened in the same frame.

The lesson: build the dumbest version that solves your actual current problem. Generalize later, once you know what you're actually generalizing for. Abstracting early, before you have two or three real use cases to compare, almost always guesses wrong.

Cascades Will Humble You

If you've never built cascade logic (the chain-reaction effect where a match causes tiles to fall, which causes new matches, which causes more falling), it sounds like a simple loop. It is not.

The failure mode that got me was assuming cascades resolve sequentially and predictably. They don't, especially once you add special tiles, obstacles, or multiple simultaneous match groups. I had a bug where two match groups resolving in the same update cycle would sometimes double-count score, and it took an embarrassingly long time to track down because it only happened under specific board configurations that my manual testing rarely hit.

What actually fixed it wasn't cleverer code — it was better testing discipline. I built a simple in-editor tool to load specific board states directly (bypassing random generation) so I could reproduce edge cases on demand instead of playing the game repeatedly hoping to get lucky. If you're building match-based mechanics, build that tool early. It'll save you hours.

The Save System Nobody Thinks About Until It Breaks

This one's less glamorous but genuinely important: your save system needs to survive the app being killed mid-write. Players background apps constantly, phones sleep, OS updates interrupt things — and if your save file gets corrupted because you were mid-write when the process died, you get a player who loses hours of progress and immediately uninstalls.

The fix is straightforward once you know to look for it: write to a temp file, then atomically rename/replace the actual save file only after the write completes successfully. It's not hard. It's just easy to skip if you're focused on gameplay and treating "save the game" as an afterthought feature you'll polish later. Don't. Build it defensively from day one.

Ads Are Part of Your Game Feel, Not a Bolt-On

I used to treat ad integration as a checkbox task at the very end of development — plug in the SDK, place a few interstitial calls, done. That's a mistake for puzzle games specifically, because ad placement directly affects session feel in a genre where session feel is the product.

Rewarded ads that players opt into (for hints, extra moves, or a second chance) tend to feel like part of the game's generosity. Interstitials that interrupt a player mid-flow tend to feel like punishment. The difference in perceived quality between those two approaches is enormous, even though the underlying SDK integration is nearly identical from a code perspective.

If you're building a puzzle game, I'd genuinely recommend thinking about ad placement during design, not after. It changes how you structure failure states, retry flows, and reward pacing.

Why I Stopped Rebuilding the Same Systems From Scratch

After my second puzzle title, I had a realization that felt obvious in hindsight: the systems I kept rebuilding — grid management, cascade resolution, save robustness, ad mediation — were mostly the same problems with different skins on top. I was spending 60-70% of my development time re-solving problems I'd already solved before, just because each project started from an empty Unity scene.

This is roughly the same realization a lot of solo devs and small teams eventually land on, and it's why starting from a proven, already-tested codebase (whether your own internal template or a well-built third-party source code) makes so much sense once you've been burned by rebuilding core systems a few times. I wrote a longer breakdown of the different puzzle mechanic categories worth considering — match-3, merge, sorting, physics-based — along with a realistic launch timeline, in Best Puzzle Game Source Codes in Unity, if you want a more structured comparison.

The point isn't that you shouldn't understand how these systems work under the hood — you absolutely should, because you'll need to debug and extend them. The point is that re-implementing solved problems from zero, every single project, is a poor use of limited development time when your actual competitive advantage is in content, polish, and player experience, not in reinventing grid logic for the fifth time.

What I'd Actually Prioritize If Starting Over

If I were starting a new puzzle game project today, here's the order I'd tackle things in, based on what actually mattered versus what I wasted time on:

Playable core loop first — the dumbest possible version, ugly art, no polish. Get it in your hands and see if it's fun before investing further.
Deadlock detection — before you build a single extra level, make sure your board can never reach an unsolvable state.
A board-state debugging tool — the ability to load specific configurations on demand, not just random generation.
Save system robustness — atomic writes, tested against forced app kills, from the start.
Juice and feel — tweening, particles, sound feedback. This is where "functional" becomes "fun," but it's step five, not step one.
Monetization design — thought through as part of the core loop, not bolted on afterward.
Content pipeline — a way to add/edit levels without recompiling, so your last few weeks before launch are about content and balance, not code changes.

Notice what's not early on this list: generic architecture, abstract systems for features you don't have yet, and premature optimization. Those come later, once real constraints tell you what actually needs generalizing.

Speed Isn't the Enemy of Quality

There's a mindset in some corners of gamedev that shipping fast means cutting corners, and that "real" developers take their time to build things properly. I used to believe that too. What I've actually found is closer to the opposite: teams and solo devs who ship faster tend to get more real player feedback per unit of time, which means their second, third, and fourth iterations are informed by actual data instead of guesswork.

The developer who spends eight months building the "perfect" architecture before ever getting a build in front of real players is optimizing for a version of quality that doesn't actually matter yet. The developer who ships a rough-but-functional version in three weeks, watches real retention and funnel data, and iterates based on that — that's the version of "doing it properly" that actually correlates with games people want to keep playing.

If you're weighing genre options or want to see what a broader, already-built catalog of puzzle and casual mechanics looks like — useful context even if you end up building your own from scratch, just to calibrate what "done" looks like — it's worth browsing through the games catalog on Unity Source Code to get a sense of feature completeness and scope for this genre.

Wrapping Up

None of this is revolutionary advice. It's the kind of thing that's obvious in retrospect and completely invisible when you're heads-down building your first puzzle game. If there's one thing I'd want a newer dev reading this to take away, it's: the mechanic is not where your time goes. The edge cases, the robustness, the "boring" infrastructure around the fun part — that's where every puzzle game project actually lives or dies. Budget your time (and your patience) accordingly.

Happy to answer questions in the comments if you're mid-build on something similar — always curious to hear what edge cases other folks have run into with cascade logic or save systems specifically.

What a Maze-Logic Puzzle Game Taught Me About Shipping Mobile Titles Fast

unity source code — Wed, 22 Jul 2026 19:01:54 +0000

I've spent a fair amount of time lately thinking about a question that doesn't get discussed enough in dev communities: why do some small, mechanically simple mobile puzzle games quietly outperform far more ambitious projects in terms of actual revenue per hour of development time invested? The answer, once you dig into it, has less to do with luck and more to do with a set of decisions around genre selection, technical scope, and monetization strategy that a lot of solo and indie developers get wrong on their first few attempts.

I want to walk through this using a maze-navigation puzzle format as the anchor example — the kind of game where a player guides a character through an increasingly complex path structure, trying to reach an exit without getting boxed in. It's a deceptively simple mechanic, and that simplicity is exactly what makes it worth examining closely as a case study in efficient mobile game development.

The Underrated Strength of "Simple to Learn, Hard to Master" Mechanics

There's a reason path-navigation puzzles have persisted across decades of gaming, from the original arcade-era maze games through to modern mobile brain-teaser apps. The core interaction — get from point A to point B without hitting an obstacle — requires zero explanation. A player understands the objective within the first two seconds of seeing the screen, with no tutorial overlay needed, no lengthy onboarding flow, nothing standing between install and engagement.

That matters enormously for mobile retention metrics specifically. Every additional second a player spends figuring out what they're supposed to do before their first meaningful action is a second where churn risk increases. Genres that front-load complexity — deep strategy games, anything requiring resource management literacy, games with unfamiliar control schemes — pay a real cost in day-one retention that's easy to underestimate when you're deep in development and have long since forgotten what it's like to see the game for the first time.

Maze and path-logic puzzles sidestep this problem almost entirely. The learning curve is close to zero, but the skill ceiling isn't, because level design can introduce genuinely challenging spatial reasoning problems without ever needing to add a new control or a new rule. That's an efficient use of design effort: nearly all of the "content" comes from level layout rather than from new systems, which means a solo developer can generate weeks of engaging gameplay by iterating on level design rather than writing new code.

Technical Scope: Why This Genre Is Achievable for Small Teams

From an engineering standpoint, a maze-navigation puzzle game sits in a genuinely favorable spot. The core systems involved — grid or path-based movement, collision detection against maze boundaries, win-condition checking when a player reaches an exit — are well within reach of a single developer without requiring deep expertise in physics simulation, complex AI, or advanced rendering techniques.

That doesn't mean there's no craft involved in getting it right. Movement needs to feel responsive rather than sluggish, which usually means tuning input handling carefully rather than relying on default physics behavior. Maze generation and level design need enough variety that levels don't start feeling repetitive by level twenty, which is a design problem more than a technical one. And difficulty progression has to be tuned so that the jump from "easy enough to feel confident" to "hard enough to feel rewarding" happens gradually rather than in a jarring spike that causes players to quit.

But compared to genres that require solving genuinely hard technical problems — real-time multiplayer synchronization, complex physics-based combat, procedural 3D world generation — the technical risk here is low. That's a meaningful consideration for anyone deciding what to build next, particularly if the goal is validating a monetization strategy or building a portfolio of shipped titles rather than pursuing one large, technically ambitious project.

The Part Most Developers Get Wrong: Monetization Placement

Here's where I think a lot of first-time puzzle game developers leave real money on the table, and it's not because the mechanics are wrong — it's because the ad placement strategy is an afterthought bolted on right before submission rather than something designed into the game from the start.

Puzzle games are unusually well-suited to rewarded video ads specifically, more so than most other genres, because the player's motivation to watch an ad is intrinsic rather than manufactured. A player who's stuck on a maze level and offered a hint in exchange for watching a short ad is making a genuinely voluntary trade that solves an actual problem they have. Compare that to games that force interstitial ads at arbitrary intervals regardless of what the player is doing — that's friction with no corresponding value delivered, and it shows up in both review scores and uninstall rates.

The placement pattern that tends to perform best in this genre looks something like: rewarded ads offered as an optional hint or retry mechanism when a player is stuck, interstitial ads placed at natural breakpoints between levels rather than mid-puzzle, and occasional optional rewarded placements for bonus content or cosmetic unlocks. None of this is exotic advice, but the difference between implementing it thoughtfully versus implementing it as an afterthought is often the difference between a game that earns modestly and one that earns well, holding gameplay quality constant.

There's a broader point buried in here too: the revenue difference between two functionally similar puzzle games is frequently not about which one has better core mechanics. It's about which developer thought more carefully about where and how monetization touches the player experience. That's a solvable problem, but only if you treat it as a design question rather than a technical checkbox to tick off right before launch.

Reskinning as a Legitimate Content Strategy, Not a Shortcut

One thing I've come to appreciate about genres like maze-navigation puzzles is how naturally they support a reskinning-based content strategy. Because the underlying mechanic — navigate a path, avoid obstacles, reach an exit — is largely independent of visual theme, the same core system can support wildly different presentations: a neon-lit cyberpunk maze, a jungle-themed escape, a minimalist geometric puzzle aesthetic. Each of these can appeal to a meaningfully different audience segment while sharing nearly all of the same underlying code.

This is worth taking seriously as a strategy rather than dismissing it as a lesser form of development. A developer who validates a maze-puzzle mechanic once and then produces two or three thematically distinct variations is, in effect, testing multiple audience hypotheses at a fraction of the cost of building each one from scratch. If one theme resonates more strongly with a particular market or age group, that's genuinely useful signal — and it's signal you can only get by actually shipping multiple variations, which reskinning makes economically realistic in a way that full rebuilds don't.

It also compounds over time in a way that's easy to underestimate. Each subsequent reskin benefits from lessons learned on the previous one — which difficulty curve worked, which monetization placement performed best, which visual style got better store page conversion. That accumulated knowledge is worth more, in practice, than the marginal creative satisfaction of building every project's core systems from zero.

Performance Considerations That Are Easy to Overlook

Because maze-puzzle games look mechanically simple, it's tempting to assume performance optimization barely matters. In my experience that assumption causes more problems than it prevents. Puzzle games are frequently played in short bursts — a level or two while waiting in line, a few minutes before bed — and in that context, any friction between opening the app and actually playing disproportionately hurts the experience compared to genres where players are settling in for a longer session anyway.

Load times matter more than they seem like they should. Input responsiveness matters more than it seems like it should. A maze game where movement has even a slight, barely perceptible delay between input and response ends up feeling worse to play than the mechanical simplicity would suggest, precisely because there's so little else going on to distract from that friction. Getting this right requires actual device testing across a reasonable spread of hardware, not just testing in the Unity editor and assuming it'll translate cleanly to real devices — a mistake I've made myself more than once early on.

This connects to a broader point about shipping mobile games generally: the gap between "works in the editor" and "performs well on a mid-range Android device in the field" is bigger than it looks from inside a development environment, and profiling on real hardware before you consider a build ready is not optional busywork — it's where a meaningful share of post-launch review complaints get prevented before they ever happen. I've written up a more detailed, checklist-style breakdown of how I approach this step specifically, which is worth a look if you're getting close to a submission and haven't done a dedicated profiling pass yet: Profiling Your Unity Mobile Build: A Practical Checklist Before You Ship.

Putting the Pieces Together: A Realistic Case Study

To make this concrete rather than abstract, it's worth looking at how these principles show up in an actual shipped template. The Snake Escape Puzzle Unity source code is a reasonable example to point to, since it's built specifically around this maze-navigation format — guiding a snake through progressively complex paths without getting trapped, with swipe-based controls, a difficulty curve that escalates gradually across levels, and AdMob integration structured around the rewarded-hint and between-level-interstitial pattern described above.

What makes it a useful reference point isn't that it's doing anything mechanically novel — it isn't, and that's sort of the point. It's a clean execution of a genre that's proven itself repeatedly, built with the kind of modular structure that supports exactly the reskinning strategy discussed earlier: swappable maze themes, adjustable difficulty curves, and a codebase organized well enough that a developer can focus their effort on level design and visual identity rather than fighting the underlying architecture.

The Bigger Financial Question Worth Asking

All of this eventually circles back to a question that's worth being honest with yourself about before investing weeks or months into any project: what's the realistic revenue ceiling for a game in this category, and does the development effort required actually make sense against that ceiling? This is a question I see a lot of developers skip entirely, either because it feels uncomfortably commercial to ask, or because it's genuinely hard to estimate without real data.

I'd encourage anyone thinking seriously about building — or reskinning — a puzzle title like this to look at real numbers rather than guessing. There's a detailed breakdown worth reading on exactly this topic that covers what reskinned Unity games realistically earn across different genres and monetization setups: How Much Can You Earn Selling a Reskinned Unity Game. It's the kind of grounded, numbers-first perspective that's genuinely useful before committing real development time to any specific genre or strategy.

Closing Thoughts

None of what I've described here is complicated in isolation. Simple, learnable mechanics. Monetization placement designed around genuine player value rather than bolted on as an afterthought. Reskinning treated as a legitimate content and audience-testing strategy rather than a lesser form of development. Real device profiling before considering a build ship-ready. Individually these are all fairly obvious pieces of advice. Where I think a lot of developers — myself included, in earlier projects — go wrong is in treating them as optional polish rather than as the actual substance of what separates a mobile puzzle game that earns modestly from one that earns well on a comparable amount of development effort.

Maze-logic puzzle games happen to be a particularly clean genre for illustrating all of this precisely because the mechanical complexity is low enough that these other factors — monetization design, reskinning strategy, performance discipline — end up mattering more, proportionally, than they would in a more technically demanding genre where raw engineering effort dominates the outcome.