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:

Project Structure

Understanding the directory layout is crucial for extending the engine.

Global Core (/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 (/Games)

Each game folder is self-contained, including its own Scripts, Editor, Prefabs, and Levels.

#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

How to use:

  1. Open via Window > Hypercasual > Arrows Level Editor.
  2. Set the Grid Size (e.g., 9x11).
  3. Click on grid cells to place arrow segments.
  4. Use the Direction Toggle to set where the arrow will fly.
  5. Click Export Level to save as a .json file in the Levels folder.

#2 Block Associations

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

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

  • ApplyGraphics.cs: Select multiple item prefabs and use this tool to batch-assign sprites from a folder.
    Usage: Select prefabs in Project window, right-click -> Hypercasual > Apply Graphics.
  • LevelPreview.cs: Allows you to select a Level.json and see a ghost-preview of the layout in the Scene view.
    Usage: 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.
    Usage: Select sprites, right-click -> Hypercasual > Setup Drag Sprites.
  • FixMatchedRowBg.cs: A utility to align the background graphics with the generated grid size.
  • ImportSprites.cs / ImportClearedSprite.cs: Automates the import settings for new icons to ensure they are correctly formatted for the UI.

#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:
    Usage: Select a Texture, open Window > Hypercasual > Jigsaw Creator. Set Rows/Cols and click Generate.
  • 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.

#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:
    Usage: A grid-painting tool. Open Window > Hypercasual > Hole Level Editor. Select a block type and click on the grid to paint your level.
  • HoleMenu.cs:
    Usage: Adds right-click menu items to the Hierarchy for quickly creating Hole-related objects.

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.

Development Guide

Creating a New Game Module:

  1. Folder Setup: Create 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 { ... }.
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.

Version History

v1.0 - Initial Release (Current)

The first release of the Hypercasual Game Engine includes 5 fully functional game modules:

Current Price: $29.99

Coming Soon: The next major update (v2.0) will introduce 5 brand new game modules. Upon release of v2.0, the toolkit price will increase to $34.99. Get it now to lock in the current price and receive all future updates for free!