Pocket Mini Games
Casual Pack

🏠 Overview

Ten polished casual games, all built on a single contract so you can drop, replace, or extend them as you wish.

Shared Capabilities

⚙ How It Works & Customizing

Read this first — it explains what kind of asset this is and the right way to customize it.

What this means for you

• You customize through data, not by hand-editing the scene. Hand-moving a generated UI object won't persist — the game regenerates it on Play. Customize via the settings assets, theme, and reskins described below — those are read by the build, so your changes persist and the game stays fully playable.
• The included demo scenes (PocketMiniGames_Dashboard, PocketMiniGames_Casual) are real, fully-built scenes you can open and inspect. On Play the dashboard regenerates the UI live from current code.

The Toolset — your customization hub

Open Tools → Pocket MiniGames → Toolset. It has a tab per category, and inside, a panel for every game exposing all of its tunable settings — board size, colours, speed, time limits, AI difficulty, win conditions, and more.

Customization at a glance

⚡ Quick Start

Get the demo running and your first game on screen in under 2 minutes.

🛠 Architecture

A small, predictable contract; every game follows the same shape.

The IMiniGame contract

Every game is a plain C# class implementing this interface. The dashboard (or your own host) hands the game a RectTransform to build inside and an IMiniGameContext for audio, theme, events, and settings.

C#public interface IMiniGame
{
    string Id { get; }                // stable snake_case id
    string DisplayName { get; }
    string Category { get; }          // "Casual" for this pack
    string ShortDescription { get; }

    void Mount(RectTransform host, IMiniGameContext ctx);
    void Unmount();
    void NewRound();

    IEnumerable<CheatAction> GetCheatActions();
}

Auto-discovery

Four reflection-based registries scan every loaded assembly at startup — you never edit a central registration list:

Per-game folder layout

Every game lives in its own folder under Runtime/Casual/<GameName>/ with exactly five companion files:

FolderAssets/PocketMiniGames/Runtime/Casual/Match3/
│
└─ Match3Game.cs              // IMiniGame   — gameplay + visuals
└─ Match3Settings.cs          // ScriptableObject defaults
└─ Match3BoosterSpec.cs       // IBoosterSpec
└─ Match3AchievementSpec.cs   // IAchievementSpec
└─ Match3ReskinSpec.cs        // IReskinSpec  — per-slot sprite slots
└─ Match3TutorialSpec.cs      // ITutorialSpec

Runtime flow

Match-3

Candy-style swap-to-match-three with cascades, specials, and combo chains.

Gameplay

Swipe or tap-tap an adjacent pair of gems to swap them. Three-in-a-row pops with score and audio, cascades resolve until the board is stable, and longer matches promote special candies that detonate rows, columns, 3×3 areas, or whole colours.

Specials

Controls

• Drag from a gem onto an adjacent gem — instant swap
• Tap, then tap an adjacent gem — same result, two-step fallback

Boosters

Configurable Settings

Edit Match3Settings.cs or override the default at runtime:

Bubble Shooter

Aim, fire, and pop clusters of three or more matching bubbles before the ceiling overflows.

Gameplay

Mouse / touch to aim, click to fire. Bubbles bounce off side walls and stick on contact. Clusters of MinPopChain+ same-coloured bubbles pop and grant score. Disconnected "floaters" drop and pay double. A combo streak rewards back-to-back successful shots.

Special Bubbles

Boosters

Win / Lose Conditions

• Win: board cleared of all coloured bubbles (+250 bonus)
• Lose: any bubble reaches the configured danger row

Brick Balls

A salvo-launching arkanoid hybrid — aim once, watch your whole ball stack bounce, then survive a descending row of bricks.

Gameplay

Each turn the player aims and fires a salvo of balls. Balls bounce off walls and bricks, draining brick HP. After the salvo ends, the bricks descend one row and a new row spawns at the top. Survive long enough and you win the level.

Tile Types

Boosters

2048

The classic slide-and-merge puzzle — reach 2048, but no further moves loses.

Gameplay

Swipe / arrow keys to slide every tile in that direction. Identical adjacent tiles merge into double-value tiles. After every move a new 2 (or occasional 4) spawns. Reach the configured WinTile to win; lose when the board is full with no merges available.

Boosters

Settings

Snake

The classic, with smooth interpolation, walls / wrap modes, two visual styles, and three boosters.

Gameplay

Steer with arrow keys, WASD, or the on-screen D-pad. Eat the apple to grow and score; crash into a wall (when wrap is off) or your own body and lose. Filling the entire grid wins the round.

Modes

• Snappy — one cell per tick, no interpolation (true classic)
• Smooth — segments lerp between cells; mid-tick steering is allowed
• Wrap on/off — toroidal edges or hard walls (with visible boundary)
• Modern / Classic visual styles, toggleable from the top-right pills

Boosters

Maze

Recursive-backtracker maze with breadcrumb trail, decision arrows, and three navigation boosters.

Gameplay

Move with arrow keys / WASD / on-screen D-pad / on-board direction arrows. At every junction the available exits are highlighted. A yellow trail tracks the path you've walked; backtracking erases it. Reach the goal in the bottom-right to win.

Boosters

Settings

Memory Match

Pair-flipping memory game with streak bonuses and three helper boosters.

Gameplay

Tap two cards to flip them. If their icons match, they stay face-up and the streak counter increments. If not, both flip back. Clear the whole board to win; fewer moves means a higher score. A "Perfect Recall" achievement fires when you clear with zero mismatches.

Boosters

Scoring

Formulascore = max(0, _pairs × 50 − _moves × 5)

Whack-a-Mole

Timed mole-tapping arcade. Spawn interval ramps from StartSpawnInterval to EndSpawnInterval as the round clock drains.

Gameplay

Moles pop out of holes at quickening intervals. Tap them while they're up for points; let one disappear or tap an empty hole and you lose points. ~12% of spawns are golden moles — 3× score and a brief stay window.

Boosters

Settings

Cups and Balls

The shell game — remember which cup hides the ball, then pick after the shuffle.

Gameplay

Peek which cup holds the ball, watch a sequence of swap animations, then tap the cup you think still hides it. Correct picks build a streak that multiplies score; wrong picks reset the streak.

Boosters

Settings

Tic Tac Toe

3×3 versus AI — pick your difficulty.

Gameplay

You play X, the AI plays O. Three in a row (horizontal, vertical, or diagonal) wins. Win streaks are tracked across rounds.

AI Difficulty

Boosters

💥 Boosters

2–4 per-game power-ups with persistent counts, refund safety, and auto-discovery.

Defining a booster

Every game owns a <Game>BoosterSpec.cs implementing IBoosterSpec. The spec is auto-discovered by BoosterSpecRegistry:

C#public sealed class Match3BoosterSpec : IBoosterSpec
{
    public string GameId => "casual_match3";
    public IReadOnlyList<BoosterDef> Boosters { get; }
    public Match3BoosterSpec()
    {
        Boosters = new[]
        {
            new BoosterDef("hammer", "Hammer", BoosterIconFactory.Hammer,
                Color.white, new Color(0.95f, 0.55f, 0.30f),
                description: "Tap any single gem to smash it."),
            // ...
        };
    }
}

Activating a booster

The shared BoosterBar component renders the strip and calls back into the game's handler. Each game routes the key through its own switch:

C#bool OnBoosterActivated(string key)
{
    if (_ended || _busy) return false;   // false = refund
    switch (key)
    {
        case "hammer": /* ... */ return true;
        case "shuffle": /* ... */ return true;
    }
    return false;   // unknown key, refund the booster charge
}

Full booster catalogue

🏆 Achievements

3–5 progression goals per game. Tracked persistently via AchievementManager with toast notifications on unlock.

Defining achievements

Every game owns a <Game>AchievementSpec.cs:

C#public sealed class Match3AchievementSpec : IAchievementSpec
{
    public string GameId => "casual_match3";
    public IReadOnlyList<AchievementDef> Achievements { get; } = new[]
    {
        new AchievementDef("cascade_5", "Sweet Cascade",
            "Reach a 5+ cascade depth", target: 5),
        // ...
    };
}

Raising progress

Two helper calls from inside the game:

C#// Set the progress to a value if it's higher than the current.
AchievementManager.RaiseProgress(Id, "cascade_5", chain);

// Increment cumulative counters (eg. total apples eaten).
AchievementManager.IncrementProgress(Id, "apple_picker", 1);

Stored data

Progress is persisted via HCE's save system. Each achievement remembers its current value and unlock state; toast notifications fire automatically when the target is reached.

🎨 Reskins

Drop in your own art per slot, per game — no code required.

The Reskin Editor

Open Tools → Pocket MiniGames → Reskin Editor. Pick a game on the left, then for each slot browse or drag in your own image. The art is copied into Resources/Reskin/<gameId>/<slot>.png, auto-imported as a Sprite, and a per-slot transform (scale / offset / rotation) is saved alongside it as .json. Both ship in builds — no addressables setup.

Per-game slot list

Each game owns a <Game>ReskinSpec.cs declaring its sprite slots. Every slot below is read and applied by the game — drop in art and it shows up. Any slot left empty falls back to the built-in procedural look.

Applying a custom sprite

Every game reads its reskin via ReskinManager.GetSprite(gameId, slotKey, fallback). Once a game has custom art in any slot it uses that art by default — no toggle needed. The Skin Toggle Pill in each game's top-left still lets the player flip between custom and default art at runtime, and any explicit choice they make is persisted (PlayerPrefs) across relaunches.

C#// Inside a game's spawn / styling code
var custom = ReskinManager.GetSprite(Id, "bubble", null);
var sprite = custom != null ? custom : SpriteFactory.Circle;

🎯 Tutorials

First-run overlay walkthroughs — defined declaratively per game.

Defining a tutorial

Each game owns a <Game>TutorialSpec.cs with an ordered list of steps. The overlay appears once on the player's first session per game and can be replayed from the cheat panel.

C#public sealed class SnakeTutorialSpec : ITutorialSpec
{
    public string GameId => "casual_snake";
    public IReadOnlyList<TutorialStep> Steps { get; } = new[]
    {
        new TutorialStep("Use arrow keys or the D-pad to steer."),
        new TutorialStep("Eat the red apple to grow."),
        new TutorialStep("Don't crash into yourself!"),
    };
}

📈 Level Scaling

Per-game difficulty progression — auto-generated, fully editable in the Toolset.

How it works

LevelManager.GetDifficultyForCurrent(gameId) returns a bag of scaling multipliers indexed by key. Games read e.g. diff.Get("difficulty", 1f) and use it to ramp score targets, time budgets, AI depth, etc.

C#var diff = LevelManager.GetDifficultyForCurrent(Id);
float k = Mathf.Max(0.5f, diff.Get("difficulty", 1f));
_scoreTargetForRound = Mathf.RoundToInt(_settings.ScoreTarget * k);
_timeLeft = Mathf.Max(20f, _settings.RoundSeconds / Mathf.Sqrt(k));

Level state is persisted, so LevelManager.GetCurrent(gameId) remembers where the player left off across sessions. Use LevelManager.Advance(gameId) on win, LevelManager.Reset(gameId) on loss (or never, depending on your design).

Editing levels in the Toolset

Out of the box every game gets a 30-level curve from a built-in formula (difficulty ramps gently from level 1). You don't have to leave it at that — each game's Toolset tab now has a Levels editor under its Level / authoring tools section, where you can:

• Regenerate the whole curve — set a level count, a start and end difficulty, and an optional random jitter, then hit Regenerate levels.
• Hand-edit any level — rename it and set its exact difficulty multiplier in the scrollable per-level list.

The first time you open a game's Levels editor it creates a LevelSet asset at Resources/Config/Levels/<gameId>.asset. When that asset exists it overrides the built-in formula — LevelSpecRegistry resolves levels in the order: explicitly-coded ILevelSpec → LevelSet asset → the default formula. Because the asset lives under Resources/, your edited curve is loaded by the game at runtime, in both the editor and a built game.

🌙 Light & Dark Mode

One toggle re-themes the whole scene — chrome and all ten games — between a dark and a light palette.

How it works

Every game reads its colours from _ctx.Theme, a MiniGameTheme asset. The theme now carries two full palettes and a switch:

C#// Swap every colour field between the dark and light palettes.
theme.ApplyMode(bool light);

// True while the light palette is active — games can branch on it.
bool isLight = theme.IsLightMode;

The dashboard header has a DARK / LIGHT pill. Tapping it flips the palette, persists the choice (pmg_light_mode), and rebuilds the scene — chrome plus the active game — so every element repaints. The default is dark.

Both palettes stay readable

The light palette is contrast-checked: light scene + white panels, dark text, medium-blue accents. The well-defined pairings — PanelBackground/TextPrimary, TileFilled/TextOnTile, Accent/TextOnAccent — keep high contrast in both modes, so text never washes out.

Per-game adaptation

Each game's internal surfaces (boards, grids, walls, holes, cells) adapt too. Vivid gameplay-identity colours — gem palette, snake green, 2048 number tiles, brick colours, mole brown/gold — stay vivid in both modes. A few elements flip by necessity: the maze walls are drawn light-on-dark in dark mode and must become dark-on-light in light mode, and Brick Balls' white balls / aim dots tint dark so they read against the light board.

➕ Add to Your Project

Two paths: the bundled dashboard, or a single game inside your own UI.

Path A — use the bundled dashboard

The fastest way: drop Assets/PocketMiniGames/Demo/PocketMiniGamesDashboard.unity into your build settings. It auto-loads every IMiniGame in the project and lets the player switch between them. Skin it via the included theme system.

Path B — embed a single game

If you want exactly one game inside your own scene / UI:

C#using PocketMiniGames.Core;
using PocketMiniGames.Casual.Match3;

public class MyGameHost : MonoBehaviour
{
    [SerializeField] RectTransform _host;   // where the game builds its UI
    IMiniGame _game;

    void Start()
    {
        _game = new Match3Game();
        _game.Mount(_host, MiniGameContext.Default);
        // NewRound() is called by Mount() automatically; call it again to restart.
    }

    void OnDestroy() => _game?.Unmount();
}

Listening to events

C#ctx.Events.Subscribe<int>(GameEvents.RoundWon, score => {
    Debug.Log($"Player scored {score}");
});
ctx.Events.Subscribe<int>(GameEvents.RoundLost, score => { /* ... */ });
ctx.Events.Subscribe<int>(GameEvents.ScoreChanged, score => { /* HUD update */ });

⚙ Customizing

Tune defaults, swap art, rewire boosters — everything is configurable.

Override default settings

Each game uses a ScriptableObject for its defaults (e.g. Match3Settings.asset). Create a new Match3Settings via Create → Pocket MiniGames → Casual menus, edit fields in the inspector, and assign it via ctx.Settings.Get<Match3Settings>() — or just mutate the fields on Match3Settings.Default at runtime.

Theme colours

Each game pulls colours from ctx.Theme — Accent, TextPrimary, PanelBackground, TileFilled, Success, etc. Swap themes globally and every game re-skins instantly.

Boosters: add / remove / rebalance

• To remove a booster from a game, delete its BoosterDef from the spec.
• To add a booster, append a new BoosterDef AND handle the key inside the game's OnBoosterActivated.
• To change starting counts, pass defaultCount: N to the BoosterDef constructor.
• To award boosters from your meta-game, call BoosterManager.Add(gameId, key, count).

Audio

Every game uses ctx.Audio.Play(SfxKind.<...>) — piping into HCE's AudioService. Configure the sound bank via Tools → HCE → Toolset → Audio to override which clip plays for which kind.

🎁 HCE Bundled

HyperCasual Essentials is included in this pack as the backend — full version, no stripping.

The bundled HCE is the full version — identical to the standalone Asset Store SKU. It has its own deep documentation:

PathAssets/HyperCasualEssentials/Documentation/HCE-Documentation.html

🧰 Adding New Games

Mirror the per-game folder shape and the dashboard picks up your game automatically.

💡 Troubleshooting

The most common issues, with answers.

📝 Release Notes

What changed since the first release.

v1.1.0

New — Light & Dark Mode

• A DARK / LIGHT toggle in the dashboard header re-themes the whole scene — chrome plus all ten games. See Light & Dark Mode.
• MiniGameTheme gained a full light palette, ApplyMode(bool light), and an IsLightMode flag. The choice is persisted; default is dark.
• Every game's internal surfaces (boards, grids, walls, holes, cells) adapt to the active palette while keeping vivid gameplay colours fixed.

Booster reworks

• Bubble Shooter — Auto-Aim (was Long Aim): traces every shot angle and auto-fires at the largest poppable cluster.
• Brick Balls — Long Aim is now a true auto-shot: it simulates the full bouncing flight for every angle and fires the salvo at the most damaging shot.
• Brick Balls — Bomb Shot always activates now; bomb charges carry across salvos instead of being gated by ball count.
• Whack-a-Mole — Auto-Whack (was Multi-Hit): auto-whacks the next 3 moles that pop up. All three boosters now show live status chips in the header.
• Snake — Apple Magnet now reels the apple toward the head with an accelerating gravity-pull, red trail and spark particles, instead of teleporting it.
• Maze — Reveal Path draws a BFS dot trail to the goal; Dash and Break Wall show a coloured aura around the player.
• Match-3 — More play (the clock booster) adds +5 moves in move-limited mode where a timer doesn't exist.
• Slow-down boosters now use an hourglass icon; Brick Balls' Hold The Line uses a snowflake; new icons for Extra Balls and the dashboard shop button.

Polish & fixes

• Timed games (Match-3, Whack-a-Mole, Maze) now pop-animate the timer, redden it, and play a tick each second in the final 5 seconds.
• Snake: rapid 180° turns can no longer cause an instant self-collision; filling the grid now counts as a win.
• Match-3: fixed the score-target scaling; a held tile darkens while dragged.
• Whack-a-Mole: difficulty ramp now actually accelerates; tapping a just-hit mole no longer applies a miss penalty.
• Tic Tac Toe: light-mode grid cells are light-gray rather than blue.
• Hardened game teardown across the pack — coroutines, boosters and round state are cancelled / reset cleanly on Unmount and New Round.

v1.0.0

• Initial release — ten casual games with boosters, achievements, reskins, tutorials and difficulty scaling.

📬 Support & Review

We'd love to hear from you — bug reports, feature requests, or a quick review.