Hidden Object Game Template

About Hidden Object Game Template – Unity Editor Tool & Plugin

Hidden Object Game Template Unity Asset Overview

The Hidden Object Game Template employs a modular, event-driven architecture designed to decouple input handling, state tracking, and user interface updates. At its core, the system avoids tight coupling by using C# events (delegates) and ScriptableObject data containers to manage level definitions, item databases, and player progress.

Core Architectural Components

The framework operates primarily around three core structural pillars:

• Level Definition Data (ScriptableObject): Stores target item references, scene backgrounds, localizations, and hint parameters independently from scene assets.
• Item Controller (MonoBehaviour): Attached to interactable objects within the scene, implementing Unity's IPointerClickHandler interface or standard 2D/3D physics raycasting to register player interactions.
• State & Game Manager (Singleton / Service Locator): Tracks remaining hidden items, handles hint timers, manages game state transitions (e.g., Active Searching, Paused, Minigame Active, Level Complete), and invokes system-wide events.

Event-Driven Item Collection Pattern

To eliminate expensive Update() polling and prevent performance bottlenecks during rapid tap inputs, item collection uses a C# event channel pattern. Below is a structural example of the item register and interaction logic used within the template framework:

using System;
using UnityEngine;
using UnityEngine.EventSystems;

namespace HiddenObjectTemplate.Core
{
    [RequireComponent(typeof(Collider2D))]
    public class HiddenObjectItem : MonoBehaviour, IPointerClickHandler
    {
        [SerializeField] private ItemData itemData;
        
        public static event Action<HiddenObjectItem, ItemData> OnItemFound;

        public ItemData ItemData => itemData;

        public void OnPointerClick(PointerEventData eventData)
        {
            Collect();
        }

        public void Collect()
        {
            OnItemFound?.Invoke(this, itemData);
            
            // Disable colliders immediately to prevent double-tap race conditions
            if (TryGetComponent<Collider2D>(out var col))
            {
                col.enabled = false;
            }

            gameObject.SetActive(false);
        }
    }
}

By decoupling the visual feedback and score calculation from the item itself, the system maintains a lightweight runtime loop. The central GameManager listens for OnItemFound, updating the objective list UI and triggering localized audio feedback without creating garbage collector (GC) overhead.

Inspector Configuration & Workflow

The template provides custom Unity Inspector property drawers and editor windows designed to streamline the level authoring workflow. Custom GUI scripts validate target items placed in the scene against the active ItemData database to eliminate missing references prior to build execution.

Level Setup Workflow

Configuring a level involves establishing the core manager prefabs and populating scene nodes:

• Item Database Editor: Creates unique string IDs or GUIDs for each interactable object, pairing visual thumbnails with localized display names.
• Placement & Raycast Layering: Hidden items use dedicated physics layers (e.g., HiddenObject layer) to restrict raycast checks during user input processing, reducing unnecessary physics calculations against background elements.
• Hint Navigation Mesh / Spline System: Configures visual visualizers (particle paths, glowing overlays, or magnified UI indicators) when the player clicks the hint button. The hint manager pulls the transform of a random remaining active item from the manager's active tracking list.

Quick-Start Unity Integration Guide

Follow these steps to integrate and build a functional hidden object level using the template framework.

Step 1: Instantiating Core Manager Prefabs

Drag the primary engine prefabs into your scene hierarchy. The setup relies on three essential manager prefabs:

// Ensure scene hierarchy contains:
[HOG_GameManager]    // Handles game state, level timers, and completion events
[HOG_UIManager]      // Renders objective text/icons, hint buttons, and pause menus
[HOG_AudioManager]   // Coordinates audio feedback for item clicks, ambient loops, and UI

Step 2: Creating an Item Asset Database

Right-click in the Project window and navigate to Create > Hidden Object System > Item Database. Add new entries to the database and assign unique asset identifiers, thumbnail icons, and localized text strings.

Step 3: Populating the Scene

Place target hidden object prefabs into your background layout. Attach the HiddenObjectItem script to each object, assign its corresponding ItemData asset from the database, and verify that a Collider2D or Collider component is attached.

Step 4: Binding UI Objectives

Connect the target LevelData asset to the GameManager component. On level load, the UIManager automatically populates the UI list panel with the required item icons or text labels based on the active level configuration.

Engine Profiling & Performance Analysis

When deploying to mobile platforms (iOS/Android) or low-spec hardware, memory consumption and canvas rebuilds are the primary areas requiring performance monitoring.

Memory Allocation & GC Overhead

The framework keeps zero-allocation patterns during main gameplay loops. Raycast queries utilize non-allocating physics calls (such as Physics2D.RaycastNonAlloc or Unity's EventSystem event passing), preventing runtime allocations inside the frame update loop. Audio triggers pass pre-hashed string parameters or AudioClip references to prevent string-based garbage creation.

Canvas Rendering Optimizations

UI item lists undergo frequent layout updates as objects are discovered. The visual indicators utilize nested Canvas components to ensure that updating single elements (such as striking through a found item's name) dirty only the local dynamic UI sub-tree, leaving the static UI elements unrendered during rebuild cycles.

Pros & Cons Analysis

• Pros:
  • ScriptableObject-driven architecture allows quick level iteration without code modifications.
  • Zero-allocation event handling ensures stable framerates on mobile platforms.
  • Includes built-in systems for hint cooldowns, item highlight effects, and audio coordination.
  • Clean C# codebase structured with standard Unity serialization paradigms.
• Cons:
  • Requires manual setup of physics colliders for custom artwork assets.
  • Complex minigame implementations (e.g., sliding tile puzzles) require separate custom C# extensions.

Related Unity Templates Assets