HyperCasual Games Bundle #1

Games #1 through #10 — 10 fully functional mobile puzzle game templates with level editors, core systems, and ad monetization.

This bundle is part of the HyperCasual Game Engine – Mobile Puzzle Templates.

The full engine includes this and other bundles, with more game templates and level editors.

View the Full Engine on the Asset Store

Technical Overview

Toolkit The Hypercasual Game Engine is a modular framework designed for rapid development of puzzle and arcade mechanics. It provides a standardized architecture where game-specific logic is decoupled from core engine systems.

Architecture Philosophy: Every game is treated as a "Module". The Core provides the services (Audio, UI, Camera, Persistence), and the Games folder contains the implementation of specific mechanics.

Core Design Patterns:

Getting Started

Opening the Main Scene

The primary game scene is located at:

Assets/Hypercasual Game Engine/Core/Scenes/Games-Bundle-1.unity

Open this scene to access all game modules included in this bundle.

Where to Find Level Editors

All level editor tools are located under the Unity Tools menu in the top menu bar. There is no separate "Hypercasual" tab. To open any level editor, go to:

Tools > #{number} {Game Name} Level Editor

For example: Tools > #1 Arrows Level Editor, etc.

Important - Resizing Level Editor Windows: When you first open any level editor tool, the popup window may appear very small by default. You will need to manually resize the window by dragging its right edge and bottom edge to expand it until you can see the full tool layout (typically a left-side control panel and a right-side grid/preview area). This applies to all level editors in the toolkit.

Project Structure

Understanding the directory layout is crucial for extending the engine.

Global Core (Assets/Hypercasual Game Engine/Core)

SoundManager.cs Handles global SFX and Music. Supports muting and volume scaling.
LevelManager.cs Base class for all game managers. Handles Win/Loss logic and UI triggers.
ColorManager.cs Centralized color palette management for blocks and UI.
AnimationPlayer.cs A helper to trigger common animations (Scale, Rotate, Move) via code.

Game Modules (Assets/Hypercasual Game Engine/Games)

Each game folder is self-contained, including its own Scripts, Editor, Prefabs, and Levels. The folder naming convention is #{number}_{GameName}, for example: #1_Arrows, #7_ConveyorSort.

Scenes (Assets/Hypercasual Game Engine/Core/Scenes)

The current main scene is Games-Bundle-1. This is the scene you should open to play or test any of the game modules in this bundle.

#1 Arrow Escape

A logic puzzle where players must clear a grid of arrows. Arrows can only move in their pointed direction and are blocked by others.

Main Scripts:

ArrowsGameManager.cs Orchestrates the game loop, move counting, and level loading.
ArrowController.cs Handles the movement logic, collision detection, and "exit" animations.
ArrowSegment.cs Defines the visual and physical body of an arrow.
ArrowsLevelManager.cs Manages the specific level state and win conditions.

Arrow Escape Level Editor

Script: ArrowsLevelEditorWindow.cs

Open via: Tools > #1 Arrows Level Editor

Window Size: When you first open this editor, the window may appear small. Drag the right edge and bottom edge of the window to expand it so you can see both the left control panel and the right grid panel side by side.

How to use:

  1. Open the editor via Tools > #1 Arrows Level Editor.
  2. Set the Grid Size (e.g., 9x11) under "Grid Settings".
  3. Set Max Moves to define how many moves the player gets.
  4. Click Add Arrow in the left panel to create a new arrow. This creates an arrow with a single segment at position (0,0).
  5. With the arrow selected, set its Color and Direction (Up, Down, Left, Right) — this is where the arrow will fly when tapped.
  6. Click Edit Segments to enter segment editing mode (button turns green).
  7. Left-click on grid cells to add segments. Right-click to remove the last segment (undo).
  8. When done placing segments, click Stop Editing Segments.
  9. Repeat steps 4-8 for each additional arrow.

How Arrow Placement Works (Important!)

Each arrow is a separate entity made up of connected segments on the grid. Here's how to properly place multiple arrows so they each occupy different grid cells:

  1. Click "Add Arrow" to create Arrow 1. Select it, click "Edit Segments", and left-click on grid cells to place its body segments. Each new segment must be adjacent (directly up/down/left/right) to the current head. Segments are placed tail-first — the first cell you click becomes the tail (circle), and subsequent cells extend toward the head (arrowhead).
  2. Click "Stop Editing Segments" when Arrow 1 is done.
  3. Click "Add Arrow" again to create Arrow 2. This is a completely new, separate arrow.
  4. Select Arrow 2, set its color/direction, click "Edit Segments", and click on different grid cells that are not occupied by Arrow 1. The editor prevents you from placing segments on cells already used by another arrow.
  5. Repeat for Arrow 3 and beyond. Each arrow must occupy its own unique cells on the grid.

Common mistake: If you add 3 arrows but never deselect the first arrow and switch to editing the others, all segments will be added to the same arrow. Make sure to stop editing the current arrow, add a new arrow, select the new arrow, and then start editing segments for it.

Valid Arrow Pattern Rules:
  • Each arrow is a chain of adjacent grid cells (connected horizontally or vertically, no diagonals).
  • An arrow needs at least 1 segment, but typically has 2-5+ segments to form a snake-like body.
  • The Direction setting determines which way the arrow flies when the player taps it — it does NOT need to match the shape of the arrow body.
  • Arrows cannot overlap — each grid cell can only belong to one arrow.
  • For a solvable puzzle, make sure arrows can reach the grid edge in their facing direction. An arrow blocked by others requires the player to clear a path first.
  • The Legend in the editor shows you: the arrowhead triangle = Head (the front/tip), the circle = Tail (the back end).

Saving & Loading Levels

  • Save: Click "Save JSON". A file dialog opens. The default save location is Assets/Games/Arrows/Resources/Levels/. Enter a filename and click Save. The level is saved as a .json file.
  • Load: Click "Load JSON". A file dialog opens to the same default folder. Select a .json level file to load it into the editor for viewing or editing.
  • New: Click "New" to reset the editor to a blank state.
  • The Level Name field at the top of the left panel sets the default filename when saving.

#2 Block Associations

A drag-and-drop matching game. Players must organize items into sets to clear the board.

Standalone Version

This game is also available as a dedicated standalone package with 5 fully designed levels, extended level editors, and additional customization options.

Main Scripts:

GridManager.cs Manages the logical grid and item placement.
DragController.cs Handles the input logic for picking up and moving items.
HintManager.cs Calculates possible moves and provides visual cues to the player.
ItemView.cs Controls the visual state of individual items (icons, animations).

Block Associations Editor Tools

These tools are all accessible from the Tools menu in the Unity menu bar:

  • ApplyGraphics.cs: Select multiple item prefabs and use this tool to batch-assign sprites from a folder.
    Access: Tools > #2 ColorBlockJam Apply Graphics.
  • LevelPreview.cs: Allows you to select a Level.json and see a ghost-preview of the layout in the Scene view.
    Access: Tools > #2 ColorBlockJam Preview Level. Select a Level JSON, the preview will appear in the Scene view if the GridManager is active.
  • SetupDragSprites.cs: Automatically adds BoxCollider2D and Draggable components to a selection of sprites.
    Access: Tools > #2 ColorBlockJam Setup Drag Sprites.
  • FixMatchedRowBg.cs: A utility to align the background graphics with the generated grid size.
    Access: Tools > #2 ColorBlockJam Fix Matched Row Bg.
  • ImportSprites.cs / ImportClearedSprite.cs: Automates the import settings for new icons to ensure they are correctly formatted for the UI.
    Access: Tools > #2 ColorBlockJam Import Sprites and Tools > #2 ColorBlockJam Import Cleared Sprite.

#3 Color Block Jam

A spatial puzzle where players move groups of blocks to clear paths. Blocks are constrained by their color-coded groups.

Main Scripts:

ColorBlockJamLevelManager.cs Tracks the number of blocks remaining and handles the "Jam" logic.
DraggableBlockGroup.cs The core interaction script. It calculates if a whole group of blocks can move in a specific direction.
ColorBlock.cs Individual block component that registers with the group and handles color-specific visuals.
ColorWall.cs Defines "Goal" areas or "Blocked" areas that only interact with specific colors.

Setup Guide:

Levels are built using Prefabs. To create a new level:

  1. Place GroundTile prefabs to form your floor.
  2. Add ColorBlock prefabs and group them under an empty GameObject with DraggableBlockGroup.
  3. Assign a Color to the group; all children will automatically inherit it.

#4 Jigsaw Puzzle

A classic jigsaw mechanic. It uses a custom masking system to allow any image to be turned into a puzzle piece.

Main Scripts:

PuzzleLayoutManager.cs Manages the "Snap" logic and tracks completed pieces.
PuzzlePiece.cs Handles the individual piece state (Correct Position, Current Position, IsSnapped).
PuzzlePieceMover.cs Specialized drag logic that includes "Snap-to-Target" functionality.
PuzzleLayout.cs A ScriptableObject that stores the correct coordinates for every piece in a level.

Jigsaw Editor Tools

  • JigsawLevelCreator.cs:
    Open via: Tools > #4 Jigsaw Level Creator. Select a Texture, set Rows/Cols and click Generate.
    Window Size: When you first open this tool, the window may appear small. Drag the right edge and bottom edge to expand it and see the full interface.
  • PuzzleLayoutEditor.cs:
    Usage: Custom inspector for PuzzleLayout assets. Allows manual adjustment of piece targets.
  • PuzzleDebugInspector.cs:
    Usage: Provides a debug overlay in the Scene view to see piece IDs and snap zones. Also available via Window > #4 Jigsaw Puzzle Grid Debug.

#5 Drop the Dog Jam

A physics-and-timing game. Players must navigate dogs into holes by removing blocks in the correct order.

Main Scripts:

DogJamLevelManager.cs Manages the "Collection" count and level progression.
HoleGenerator.cs The technical core. It uses SDF (Signed Distance Fields) to render a hole that looks like it's actually "in" the ground.
HoleCollector.cs A trigger-based script that detects when a dog has successfully entered a hole.
DogHolderCube.cs Handles the "Falling" animation and logic when a dog loses its ground support.

Drop the Dog Jam Editor Tools

  • HoleEditor.cs:
    Usage: Select a DogHolePrefab. Adjust Radius and Depth in the inspector. Click Regenerate to bake the SDF texture.
  • HoleLevelEditor.cs:
    Open via: Tools > #5 Hole Level Editor. A grid-painting tool. Select a block type and click on the grid to paint your level.
    Window Size: When you first open this tool, the window may appear small. Drag the right edge and bottom edge to expand it and see the full grid painting area.
  • HoleMenu.cs:
    Usage: Adds right-click menu items to the Hierarchy for quickly creating Hole-related objects.

#6 Pixel Shooter 3D

A color-matching puzzle-shooter. Players manage a conveyor belt of "pigs" that automatically shoot colored bullets at same-colored blocks on a grid. The challenge lies in strategic pig selection and resource management.

Standalone Version

This game is also available as a dedicated standalone package with 5 fully designed levels, extended level editors, and additional customization options.

Main Scripts:

GameManager.cs Orchestrates the game loop: level loading from JSON, tray/trace management, pig activation, win/lose conditions, and ability usage.
PigController.cs State machine for pigs (Deck, Jumping, OnBelt, Returning, Holding). Handles belt path movement, auto-targeting of same-color blocks, and shooting logic.
BlockController.cs Individual block entity with a color code. Plays a pop-and-shrink destruction animation when hit by a matching bullet.
BulletController.cs Projectile that travels toward a target block at constant speed. Triggers block destruction on impact.

Key Mechanics:

Pixel Shooter 3D Editor Tools

Additional debug tools are available via Tools > Pixel Shooter 3D > Reset Level Progress and Tools > Pixel Shooter 3D > Show Current Level.

  • LevelEditorManager.cs:
    Usage: A complete level editor with a 12x12 grid UI. Provides tools for color picking, pig placement, and save/load of JSON level files with unique filename generation.
    Window Size: When you first open this tool, the window may appear small. Drag the right edge and bottom edge to expand it and see the full 12x12 grid.

    Save/Load: Levels are saved as .json files to Assets/Pixel Shooter 3D/Resources/Levels/. At runtime, levels are loaded from this same Resources/Levels folder using Resources.LoadAll.
  • BlockContainerEdit.cs:
    Usage: Custom inspector sliders for rows (1-10), columns (1-10), and block scale (0.5-2.0). Dynamically spawns/destroys blocks in the editor.
  • DeckContainerEdit.cs:
    Usage: Custom inspector for pig deck columns (1-5) and per-column pig count (1-9). Positions pig visual prefabs automatically.
  • HoldingContainerEdit.cs:
    Usage: Custom inspector for holding slot count (1-5) and spacing (2.0-3.0). Shows/hides holding cube visuals.
  • PlayerSetupManager.cs:
    Usage: Analyzes blocks to determine available colors, then randomly assigns colors and distributes ammo to pigs. Validates minimum blocks (5) and colors (2).
  • BlockColorizer.cs:
    Usage: Samples colors from a source image using K-Means clustering to quantize to N colors, then maps them to grid positions for image-based level creation.

#7 Topic Stack

A sorting puzzle where players move themed items between conveyor columns. Items must be grouped by category to lock in columns and clear the board.

Main Scripts:

InputController.cs Handles column selection via raycasting, manages the select-move-deselect flow, validates moves, triggers lock-in checks, and evaluates the win condition.
ConveyorColumn.cs Stack-based column manager. Tracks items bottom-to-top, handles capacity, slot positioning, and item parenting.
SortItem.cs Individual item with rich animations: levitation with bobbing, Perlin-noise wobble rotation, color pulsing when selected, and arc-trajectory movement to targets.
ColumnLockInController.cs Triggers when a column is full with a single category. Plays a squash animation, darkens colors, and spawns a color-coded highlight with a category label.

Key Mechanics:

Topic Stack Level Editor

Script: TopicStackLevelEditor.cs

Open via: Tools > #7 Topic Stack Level Editor

Window Size: When you first open this editor, the window may appear small. Drag the right edge and bottom edge of the window to expand it and see the full tool layout.

How to use:

  1. Open via Tools > #7 Topic Stack Level Editor.
  2. Set the Grid Layout (e.g., 4x1 for 4 columns), Empty Columns, and Items Per Column.
  3. Toggle desired Themes (Kitchen, Ice-Cream, Winter, School).
  4. Adjust Advanced Settings: global scale factor, center-based spawning, column spacing, and material references.
  5. Click Create Level to generate the level hierarchy with randomized item distribution.

Note: This editor generates the level directly as scene objects (GameObjects with components) rather than saving to JSON. The generated hierarchy appears under the active scene and can be saved as part of the scene or converted to a prefab.

#8 Solitaire Associations

A card-based puzzle combining solitaire mechanics with category matching. Players drag cards from the tableau and draw pile onto foundation slots to complete category sets within a limited number of moves.

Main Scripts:

GameManager.cs Manages level loading from JSON, card creation, move tracking, undo stack, hint system (3 hints per level), and win/lose evaluation.
Card.cs Card entity with drag-and-drop support. Handles face-up/face-down states, category card visuals (crown icon, count text), multi-card drag in tableau, and highlight/shake feedback.
DropZone.cs Drop target validation. Foundation zones accept only matching-category cards up to a capacity limit. Tableau zones accept any card on empty columns or same-category cards on occupied ones.
DrawPileLayout.cs Displays up to 3 cards in an overlapping fan. Only the newest card is draggable; older visible cards are locked.

Key Mechanics:

Solitaire Associations Editor Tools

  • LevelEditorWindow.cs:
    Open via: Tools > #8 Solitaire Associations Level Editor. A full-featured editor with a level browser, category manager, foundation/tableau/deck editors, visual preview, and validation checks (duplicate cards, capacity mismatches).
    Window Size: When you first open this tool, the window may appear small. Drag the right edge and bottom edge to expand it and see the full editor layout with the level browser on the left and the editor panels on the right.

    Save/Load: Levels are saved as .json files to Assets/Hypercasual Game Engine/Games/#8_SolitaireAssociations/Resources/Levels/SolitaireAssociations/. The editor includes a level browser panel that lists all existing levels. Use Save to overwrite the current level, or Save As to create a new file. Level files must be inside the Resources/Levels/SolitaireAssociations/ folder to be loaded at runtime.
  • UpdateCardPrefabVisualsFinal.cs:
    Usage: Editor utility that updates the CardPrefab with all required visual elements (border, count text, crown icon, category header) at correct positions.
  • UpdateTableauPrefab.cs:
    Usage: Sets up tableau column prefabs with Image, DropZone, VerticalLayoutGroup (overlapping card spacing), and LayoutElement components.

#9 Coffee Go

A conveyor-based sorting puzzle. Players tap trays to eject mismatched coffee cups onto a conveyor belt, which automatically routes them to the correct color-matched tray.

Main Scripts:

Convenyor.cs Main conveyor manager. Handles path-based movement, coffee stacking, tray-completion tracking, win condition (all trays full), and lose condition (conveyor at max capacity for too long).
Tray.cs Tray interaction controller. On click, ejects all mismatched coffees onto the conveyor with arc trajectories. Receives incoming coffees, checks for completion, and plays a shrink-and-particle effect when full.
Coffee.cs Coffee cup entity with a color enum (Red, Green, Blue, Yellow). Uses dual sprite renderers for normal and masked display modes.
ConvenyorSlot.cs Individual conveyor position that moves along the path. Detects coffee pickups via triggers and auto-delivers to the closest matching-color tray when within range.

Key Mechanics:

Coffee Go Level Editor

Script: CoffeeGoLevelEditor.cs

Open via: Tools > #9 CoffeeGo Level Editor

Window Size: When you first open this editor, the window may appear small. Drag the right edge and bottom edge of the window to expand it and see the full tool layout with the level browser and preview panels.

How to use:

  1. Open via Tools > #9 CoffeeGo Level Editor. Browse, load, or create levels from the Level Browser panel.
  2. Configure Conveyor Settings: max slots, height per coffee, move speed, and lose countdown timer.
  3. Add trays and set their Color, Slot Count, and Initial Coffees using color swatches. Use Fill to auto-populate or Randomize All Coffees for quick setup.
  4. Use Capture From Scene to read current scene data, or Apply To Scene to write editor data back.
  5. A visual preview shows tray layouts with mismatched coffees marked. Validation prevents saving impossible levels.

Saving & Loading Levels

  • Save: Click Save in the editor. Levels are saved as .json files to Assets/Hypercasual Game Engine/Games/#9_CoffeeGo/Levels/.
  • Load: Use the Level Browser panel to see all existing levels and click one to load it. You can also use the Load button for a file dialog.
  • At runtime, the game loads level files from this same Levels folder.

#10 Bricky Bounce

A 3D brick-breaking puzzle. Players select colored boxes from a board to launch balls through a conveyor system at a multi-layered brick grid. Balls seek out same-colored bricks and destroy them with physics-based break effects.

Main Scripts:

GameLevel.cs Level coordinator that integrates BoardManager and GridGame. Subscribes to win/lose events and triggers the LoseWinPanelManager.
GridGame.cs Manages a 3D layered brick grid (List<List<List<Brick>>>). Handles brick instantiation, layer spacing, collision plane generation, and win-condition tracking.
Brick.cs Individual brick with physics-based destruction: hides mesh, spawns break pieces with randomized explosion forces, applies torque, and scales down debris over 2.5 seconds.
Box.cs Conveyor box logic. Validates exit paths using BFS, moves to dock slots, launches balls through the conveyor, and routes them to matching bricks via grid pathfinding.

Key Mechanics:

Bricky Bounce Level Editor

Script: BrickyBounceLevelEditorWindow.cs

Open via: Tools > #10 Bricky Bounce Level Editor

Window Size: When you first open this editor, the window may appear small. Drag the right edge and bottom edge of the window to expand it and see the full board and grid editing panels.

How to use:

  1. Open the editor via Tools > #10 Bricky Bounce Level Editor.
  2. Edit the Board: left-click to toggle empty/filled boxes, right-click for a context menu to set color, ball count, hidden state, and exit permissions. Adjust rows and columns dynamically.
  3. Edit the Grid: left-click to toggle bricks on/off. Configure layer count, row count, and column count. Use a color selector per layer and Fill/Clear Layer buttons for quick editing.
  4. A color legend and real-time grid rendering provide visual feedback during editing.

Saving & Loading Levels

  • Save as JSON: Click Save. A file dialog opens with the default location Assets/Hypercasual Game Engine/Games/#10_BrickyBounce/Levels/. The level is saved as a .json file.
  • Save as ScriptableObject: You can also save the level as a GameData ScriptableObject to Assets/Hypercasual Game Engine/Games/#10_BrickyBounce/Datas/.
  • Load: Click Load to browse and open an existing .json level file from the same folder.

Core Systems & Utilities

Core Editor Tools

These tools are available globally to assist with general project development:

  • DragSnapWithoutPlaymodeEditor.cs:
    Usage: Attach the DragSnapWithoutPlaymode component to any GameObject. In the Scene view, a custom handle will appear. Moving this handle will snap the object to the grid defined in the inspector. It also draws a visual grid around the object for reference.
  • ImportAudioIcon.cs:
    Usage: Automatically assigns a custom icon to audio files in the Project window, making them easier to distinguish from other assets.

LoseWinPanelManager

A global UI controller. It listens for events from any LevelManager and triggers the appropriate overlay. It is designed to be "Plug and Play" — just drop the prefab into your scene's Canvas.

Animation System

The engine includes a lightweight animation system (PositionAnimation.cs, ScaleAnimation.cs, RotationAnimation.cs) that allows for tween-like behavior without external dependencies.

Ads Monetization

The Hypercasual Game Engine ships with a complete ad monetization system powered by RagendomAds. It supports Banner, Interstitial, Rewarded Video, and App Open Ad formats out of the box, with Google AdMob integration ready to go.

Documentation

Full setup instructions, API reference, and configuration guides are available in the dedicated RagendomAds documentation:

Assets/RagendomAds/Documentation/Documentation.html

Quick Start: Open the RagendomAds documentation for step-by-step instructions on configuring ad providers, setting up AdMob IDs, testing with dummy ads in the editor, and integrating ad calls into your game scripts.

Video Tutorial

Watch our setup walkthrough to get ads running in your project:

Watch on YouTube

Key Features:

Development Guide

Creating a New Game Module:

  1. Folder Setup: Create Assets/Hypercasual Game Engine/Games/#X_Name.
  2. Manager: Create a script inheriting from LevelManager. 
    public class MyGameManager : LevelManager { ... }
  3. UI Integration: Ensure your scene has an EventSystem and a Canvas with the LoseWinPanel prefab.
  4. Namespace: Wrap all code in namespace HypercasualGameEngine.YourGameName { ... } or a dedicated namespace like namespace YourGameName { ... }.
Important: When moving assets, always use the AssetDatabase API or the Unity Project window to preserve .meta files and references.

Support

Need help with the engine? Have questions about a specific mechanic or want to report a bug?

Contact Email: ragendom@gmail.com

We aim to respond to all support inquiries within 24-48 hours. Please include your order number and a detailed description of your issue for faster assistance.