Bouncing Rabbit

About Bouncing Rabbit – Unity Asset Pack

Bouncing Rabbit Unity Asset Overview

The Bouncing Rabbit template package is structured around a decoupled, event-driven mobile gameplay loop. At its core, the architecture isolates physics calculation, input evaluation, UI rendering, visual feedback (VFX), and audio emission into dedicated module contexts. This separation prevents tight coupling between high-frequency physics tick calculations and presentation layers.

The game state logic relies on a central state machine managing states such as MainMenu, Gameplay, Paused, and GameOver. Communication between the character controller and external systems (such as score counters or particle emitters) utilizes C# Action delegates and UnityEvents rather than standard polling or high-frequency FindObjectOfType queries in Update() methods.

Event-Driven Character Controller

The character movement logic utilizes lightweight physics calculations paired with custom collision triggers. Below is a representative snippet illustrating the event delegation approach implemented for ground impact and force impulse application:

using System;
using UnityEngine;

namespace BouncingRabbit.Core
{
    [RequireComponent(typeof(Rigidbody2D))]
    public class RabbitController : MonoBehaviour
    {
        [SerializeField] private RabbitMovementData movementData;
        
        public static event Action OnRabbitJump;
        public static event Action OnRabbitLanded;

        private Rigidbody2D physicsBody;
        private bool isGrounded;

        private void Awake()
        {
            physicsBody = GetComponent();
        }

        private void OnCollisionEnter2D(Collision2D collision)
        {
            if (collision.gameObject.CompareTag("Ground"))
            {
                isGrounded = true;
                OnRabbitLanded?.Invoke();
                ApplyBounceImpulse();
            }
        }

        public void ApplyBounceImpulse()
        {
            if (!isGrounded) return;

            physicsBody.velocity = new Vector2(physicsBody.velocity.x, movementData.JumpImpulseForce);
            isGrounded = false;
            OnRabbitJump?.Invoke(movementData.JumpImpulseForce);
        }
    }
}

Inspector Configuration & Data Structures

To keep code separate from data parameters, game settings are stored in ScriptableObject data containers. This design allows game designers to adjust parameters like movement speed, bouncy curves, and score multipliers across multiple scenes without risking merge conflicts in scene files.

ScriptableObject Game Balance Architecture

Parameters such as jump velocity, ground bounce damping, squish-and-stretch parameters, and audio pitch variation curves are maintained inside localized Data Assets. Modifying these assets updates runtime settings instantly without triggering dynamic script re-compilations.

• RabbitMovementData: Stores JumpImpulseForce, HorizontalSensitivity, and MaxVelocityCap values exposed to the Unity Inspector via [Range] attributes to safeguard against improper entries.
• AudioConfigSO: Defines sound effects assignments, audio mixer routing, volume variance ranges, and pitch variation curves.
• VFXPoolData: Controls object pooling thresholds, maximum dynamic pool capacities, and particle prefab allocations.

Inspector Customization & Workflow Features

The template includes custom property drawers and Inspector organizational headers using serialization tags like [Header], [Tooltip], and [SerializeField]. This organization ensures clear visual separation between runtime status indicators and serialized configuration variables within the Inspector pane.

Performance & Memory Profiling Analysis

Evaluating the package under the Unity Profiler confirms that runtime execution is optimized for low-overhead mobile device operation (iOS/Android). Particular care has been taken to prevent runtime memory spikes and garbage collection allocations.

Garbage Collection Optimization Highlights

• Zero Allocation Update Loops: Avoids string concatenations, array allocations, and dynamic lambda instantiation within high-frequency functions like Update() or FixedUpdate().
• Pre-Allocated Object Pools: Particle effects, score floaters, and impact audio sources utilize pre-allocated dynamic pools managed by an internal PoolManager prefab to eliminate runtime calls to Instantiate() and Destroy().
• UI Canvas Isolation: Dynamic score text elements and static background panels are split onto separate Canvas components. This setup minimizes canvas dirty-flag invalidations, avoiding unnecessary batch recalculations during dynamic jumps.
• Physics Layer Matrix Settings: Collision layers are explicitly mapped within Project Settings > Physics 2D, preventing unnecessary raycasts and broadphase overlap tests between non-interactive sprites.

Quick-Start Unity Integration Guide

Setting up the Bouncing Rabbit package within a new or existing Unity project requires configuring physics collision layers, scene hierarchy references, and manager prefabs.

Step-by-Step Setup Process

1. Import Package Assets: Import the template directory into your project's Assets/ folder. Ensure your project's platform target is set to Android, iOS, or Standalone.
2. Configure Tag & Layer Assignments: Create missing tags (Ground, Obstacle, Collectable) inside the Tags and Layers manager.
3. Instantiate Core Managers: Drag the central [Core_Managers] prefab from the prefabs directory into your bootstrap scene. This prefab contains the GameManager, AudioManager, and UIManager components.
4. Assign ScriptableObject Configs: Navigate to the ScriptableObjects/ folder, create or modify the default RabbitMovementData container, and link it into the RabbitController inspector component on your player prefab.
5. Set Up Input Settings: Verify that the project uses Unity's Input System or standard Legacy Input Manager mapping for screen touches and mouse clicks, depending on your build target settings.

Related Unity Templates Assets