Hide Find Seek

About Hide Find Seek – Unity Asset Pack

Hide Find Seek Unity Asset Overview

The Hide Find Seek template is engineered around a centralized state machine that dictates game loop progression, switching between discrete phases such as Hiding Phase, Seeking Phase, Match Over, and Reset. Architecturally, the toolkit separates core player control logic, artificial intelligence pathfinding, and HUD status updating to ensure a decoupled runtime execution model.

At the center of the asset lies a event-driven control flow. Instead of continuously polling game state variables in active Update() loops, the core manager relies on C# C# Actions and delegates to inform subscribers when state updates occur (e.g., player discovered, time expired, role assigned). This eliminates redundant checks and minimizes CPU branch mispredictions across high frame rates.

Vision Detection & Stealth Algorithms

Determining visibility between Seekers and Hiders is executed through field-of-view (FOV) raycasting algorithms. Rather than relying on heavyweight trigger colliders that invoke expensive physics broadphase updates, vision scanning is controlled via scheduled raycasts using Physics.OverlapSphereNonAlloc combined with direct angular vision calculations.

using UnityEngine;

public class VisionDetector : MonoBehaviour
{
    [SerializeField] private float viewRadius = 12f;
    [SerializeField] private float viewAngle = 90f;
    [SerializeField] private LayerMask targetMask;
    [SerializeField] private LayerMask obstacleMask;

    private readonly Collider[] targetBuffer = new Collider[16];

    public bool ScanForHiders(out Transform detectedTarget)
    {
        detectedTarget = null;
        int hitCount = Physics.OverlapSphereNonAlloc(transform.position, viewRadius, targetBuffer, targetMask);

        for (int i = 0; i < hitCount; i++)
        {
            Transform targetTransform = targetBuffer[i].transform;
            Vector3 directionToTarget = (targetTransform.position - transform.position).normalized;

            if (Vector3.Angle(transform.forward, directionToTarget) < viewAngle / 2f)
            {
                float distanceToTarget = Vector3.Distance(transform.position, targetTransform.position);
                
                // Validate visual line of sight against environmental occlusion
                if (!Physics.Raycast(transform.position, directionToTarget, distanceToTarget, obstacleMask))
                {
                    detectedTarget = targetTransform;
                    return true;
                }
            }
        }
        return false;
    }
}

Architectural Highlights

• State Machine Management: Enforces clean transitions between game states, preventing invalid actions like seekers moving during the hiding window.
• Zero-Allocation Physics Sweeps: Utilizes non-allocating physics spatial queries (OverlapSphereNonAlloc, RaycastNonAlloc) to limit GC pressure during AI logic sweeps.
• Decoupled UI Binding: Visual elements update via direct event invocation, preventing unnecessary UI redraws every frame.

Inspector Configuration & Workflow

The template provides tailored Inspector interfaces and scriptable configuration setups to simplify game balance adjustments without modifying hardcoded runtime values. Game settings—such as match durations, visual search distances, AI detection delays, and player speeds—are centralized inside dedicated ScriptableObject assets.

Manager Prefabs & Layer Configuration

Deploying the template requires instantiating the core manager prefabs into your main scene. These managers coordinate player spawning, match timers, sound effects, and UI synchronization.

• GameManager: Central driver controlling state transitions, player role registration, and match outcome evaluations.
• UIManager: Listens to game state events and updates overlay elements, state banners, and remaining hider counts.
• NavMeshManager: Oversees baking static environments and updating dynamic runtime obstacles used by AI hiders and seekers.

To ensure line-of-sight checks run efficiently, proper setting of Unity's LayerMask properties is required. Standard configurations establish explicit layers for Hiders, Seekers, and EnvironmentOcclusion. Assigning these masks correctly prevents vision logic from performing unnecessary occlusion tests on ground terrain or decorative props.

Quick-Start Unity Integration Guide

Integrating the Hide Find Seek asset into a project involves a structured setup process. Follow these steps to prepare your level architecture, setup player roles, and validate runtime performance.

Step 1: Environment & NavMesh Generation

Ensure your 3D level geometry is tagged as static for pathfinding navigation. Open the AI > Navigation window (or use the NavMeshSurface component in newer Unity versions) and bake the navigation mesh. Verify that walkable zones are properly contiguous to prevent AI pathing failures.

Step 2: Manager Deployment

Drag the [Game_Manager] and [UI_Canvas] prefabs from the asset directory into the hierarchy. Verify that the GameManager component links to the corresponding MatchSettings ScriptableObject.

Step 3: Character Setup & Target Grouping

Assign player and AI controller prefabs to the spawner lists on the SpawnManager component:

// Scriptable configuration assignment pattern
[CreateAssetMenu(fileName = "MatchConfig", menuName = "Game/Match Settings")]
public class MatchSettings : ScriptableObject
{
    [Header("Phase Durations")]
    public float hidingPhaseDuration = 15f;
    public float seekingPhaseDuration = 90f;

    [Header("Role Ratios")]
    public int totalSeekers = 1;
    public int totalHiders = 4;
}

Step 4: Runtime Verification

Enter Play Mode and use the Unity Profiler (Ctrl+7 / Cmd+7) to observe the CPU Usage and Memory modules. Verify that GC Allocations stay near zero during ongoing vision scans and active pathfinding operations.

Profiling, Performance & Memory Footprint

Maintaining high framerates on lower-end mobile hardware or standalone VR head-mounted displays requires careful management of physics and AI allocations. The Hide Find Seek template mitigates common engine overhead through optimized data handling and reference caching.

GC Allocation Profiling

A primary bottleneck in stealth templates stems from continuous string manipulation in timer displays and frequent array allocations inside spatial physics checks. This asset mitigates string-based Garbage Collection overhead by utilizing cached text buffers or Unity's SetTextDirect / TextMeshPro numeric parameters where applicable.

Mono vs. IL2CPP Build Characteristics

When compiling under the IL2CPP scripting backend, generic collections used within the FSM and event systems generate lightweight C++ code representations. Memory layout structures remain packed, significantly reducing execution overhead in intensive AI calculations compared to Mono runtime interpretation.

Technical Pros & Cons Analysis

• Pros:
  • Highly optimized vision-scanning logic utilizing non-allocating physics routines.
  • Clean architecture separating state logic, UI updating, and AI navigation.
  • ScriptableObject-driven workflow simplifies gameplay parameter iteration.
• Cons:
  • Complex multi-floor environments require manual setup of NavMesh links for vertical spatial AI navigation.
  • Advanced visual occlusion techniques (like visual FOV mesh projection) require custom shader adjustments for non-standard pipelines (URP/HDRP).

Developers Who Downloaded This Also Downloaded

Related Unity Templates Assets