Hidden Object Template

About Hidden Object Template – Unity Editor Tool & Plugin

Hidden Object Template Unity Asset Overview

The Hidden Object Template relies on a decoupled, data-driven architecture optimized for linear and branching search-and-find mechanics. The core gameplay loop isolates click detection, puzzle validation, and UI list updates using C# Action delegates and ScriptableObject definitions. This prevents rigid dependencies between scene-rendered colliders and Canvas UI elements.

Central to the framework is a data abstraction tier. Interactive objects are defined via HiddenItemData ScriptableObjects, which act as single sources of truth for item identifiers, UI icons, target localized strings, and audio clip assignments. Scene-placed items bind to these assets through a lightweight HiddenObjectInteractable component, minimizing scene file size and streamlining batch edits.

Event-Driven Input and Collectible Pipeline

To eliminate expensive continuous polling in Update() cycles, interaction processing operates entirely on event streams. When a player taps or clicks an item in the viewport, an input handler emits an interaction payload. The system validates whether the clicked entity belongs to the current target search array, fires localized collection effects, and updates the search inventory panel without triggering layout recalculations across unrelated Canvas components.

using System;
using UnityEngine;

namespace HiddenObjectTemplate.Core
{
    public class HiddenObjectInteractable : MonoBehaviour
    {
        [SerializeField] private HiddenItemData itemData;
        
        public static event Action<HiddenItemData, Vector3> OnItemFound;
        
        public HiddenItemData ItemData => itemData;

        public bool TryCollect()
        {
            if (itemData == null) return false;

            OnItemFound?.Invoke(itemData, transform.position);
            gameObject.SetActive(false);
            return true;
        }
    }
}

Inspector Configuration & Workflow

The system features streamlined inspector drawers and custom editor scripts that automate level layout and list assignment. Creating a level layout requires tagging target interactive game objects and configuring scene-wide level data parameters.

Key Architectural Components

• HiddenObjectManager Prefab: The central orchestrator handling level initialization, game state management (Search, Paused, Completed), active target item tracking, and scoring timers.
• LevelData ScriptableObjects: Containers defining search constraints, such as mandatory items, optional side items, randomized list pools, available hints, and target time limits.
• UIManager Engine: Manages dynamic instantiation and updating of item target UI slots (text labels, silhouette icons, or visual thumbnails) using pooled UI elements.
• HintController: Executes visual guidance routines, spawning particle indicators or camera pan-and-zoom sequences targeted at undiscovered HiddenObjectInteractable transforms.

Designers configure levels by dropping static visual assets into the hierarchy, attaching a Collider2D or Collider, and assigning the corresponding HiddenItemData. Editor scripts feature automated level verification utilities that highlight duplicate object IDs or missing collider references prior to build compilation.

Quick-Start Unity Integration Guide

Integrating the template into an existing or new Unity project involves a standardized setup sequence that establishes manager prefabs and initial level data.

Step 1: Core System Deployment

Drag the [HiddenObjectCore] prefab into your active scene hierarchy. This prefab encapsulates the HiddenObjectManager, InputHandler, HintController, and the base UI Canvas structures.

Step 2: Level Data Definition

Create a new Level Data asset via Assets > Create > Hidden Object System > Level Data. Populate the target item array with pre-configured HiddenItemData ScriptableObjects.

Step 3: Raycasting & Non-Allocating Input Setup

Assign the HiddenObjectInputHandler to your main camera or system root. The input handler utilizes non-allocating physics raycasts to evaluate user input against 2D or 3D physics layers, preventing garbage collection allocations during user interaction.

using UnityEngine;

namespace HiddenObjectTemplate.Input
{
    public class HiddenObjectInputHandler : MonoBehaviour
    {
        [SerializeField] private Camera targetCamera;
        [SerializeField] private LayerMask interactableLayer;
        
        private readonly RaycastHit2D[] hitBuffer = new RaycastHit2D[4];

        private void Update()
        {
            if (!UnityEngine.Input.GetMouseButtonDown(0)) return;

            Ray ray = targetCamera.ScreenPointToRay(UnityEngine.Input.mousePosition);
            int count = Physics2D.GetRayIntersectionNonAlloc(ray, hitBuffer, float.MaxValue, interactableLayer);

            for (int i = 0; i < count; i++)
            {
                if (hitBuffer[i].collider.TryGetComponent<Core.HiddenObjectInteractable>(out var interactable))
                {
                    if (interactable.TryCollect()) break;
                }
            }
        }
    }
}

Performance & Runtime Overhead Analysis

The framework maintains low memory overhead and steady frame times across mobile, web, and desktop target platforms. Execution profiling highlights several performance optimization strategies inherent in the C# source design.

Technical Performance Highlights

• Zero-Allocation Raycast Input: Utilizing Physics2D.GetRayIntersectionNonAlloc avoids array generation on every user click, preventing garbage collector spikes on touch-driven mobile devices.
• UI Canvas Batching: Item labels and progress meters reside on isolated nested Canvases. Modifying a text string or hiding an icon slot isolates canvas dirtying to that specific sub-canvas, maintaining static draw-call batching for background graphics.
• IL2CPP Build Efficiency: Generic collection usage is constrained to basic List<T> and fixed arrays. This minimizes C++ code expansion when compiling under IL2CPP across iOS and Android platforms.
• Object Pooling Strategy: UI list cards and hint particle indicators are instantiated during level load and managed via a lightweight pooling component, eliminating runtime Instantiate() overhead during active gameplay.

Developers Who Downloaded This Also Downloaded

Related Unity Templates Assets