Back to Projects

VFX Manager & Interactables System

Game - Project Promotion ↗ (2025)

Unity C# State Machines Gameplay Systems & Managers
Overview

Manage all the VFX in the game, all logic was implemented using a singleton script and event-driven state changes, ensuring modularity and clean architecture.

This system manages all the interactable objects within the world — Interaction → Do Something → Update Other Systems — and integrates with the larger game systems.

VFX Manager

I designed and implemented a centralized VFX Manager system responsible for spawning and managing all visual effects triggered by combat, abilities, and in-world interactions. Instead of gameplay systems instantiating effects directly, all VFX requests are routed through this manager, ensuring consistency, maintainability, and scalability as the project grows.

The manager uses a Singleton pattern, allowing it to be accessed globally from any gameplay system while guaranteeing that only a single instance exists at runtime. This avoids duplicate spawns, conflicting logic, and fragmented VFX handling across the codebase.

VFX Prefab Management

To decouple gameplay logic from visual assets, I implemented a dictionary-based lookup system that maps string identifiers to their corresponding VFX prefabs. Gameplay systems can request visual effects by name, without holding direct references to prefab assets.

This design keeps gameplay code clean and modular, simplifies iteration on visual assets, and reduces technical debt by centralizing VFX ownership within a single system.

VFX Spawning, Scale & Lifetime Handling

When a visual effect is requested, the VFX Manager spawns the appropriate prefab at the provided position and rotation, and optionally applies a custom scale parameter passed in by the caller. This allows the same effect asset to be reused across different abilities, characters, or impact strengths without duplicating prefabs.

Each VFX is primarily responsible for managing its own lifetime, such as destroying itself once a particle system has finished playing. As a safety measure, the manager also enforces a fallback cleanup mechanism that automatically destroys any effect that exceeds a maximum lifespan, preventing unintended resource leaks.

Designer Tools

To support rapid iteration and empower non-programmers, I exposed editable offset values for individual VFX assets that designers can adjust directly in the editor. This enables precise placement of visual effects relative to characters, weapons, or environmental interactions without requiring code changes.

Combined with runtime scale control, these tools give designers flexible control over the appearance and feel of effects while maintaining a clean and reusable asset pipeline.

Why This System Matters

This VFX Manager provides a robust and extensible foundation for the game’s visual effects pipeline. By centralizing effect spawning, supporting scalable reuse through parameterization, and incorporating safety-focused lifetime management, the system improves reliability, maintainability, and cross-disciplinary collaboration. 


[System.Serializable]
public class VFXEntry
{
    public string key;           // Name of the vfx
    public GameObject vfxPrefab; // Prefab of the VFX
    public Vector3 offset; // offset in the y-direction
}

[Header("Registered VFX Assets")]  // list of vfx assets with a name to be invoked by
[SerializeField] private List vfxAssets = new List();

vfxTable = new Dictionary();
foreach (var entry in vfxAssets)
{
    if (!vfxTable.ContainsKey(entry.key))
        vfxTable.Add(entry.key, entry.vfxPrefab);
}
Figure 1: Building the VFX Asset Dictionary
Diagram showing the loop of Thought, Action, and Observation in the ReAct pattern.
Figure 2: Spawning the Electric Cannon VFX multiple times with random scale and position
Diagram showing the loop of Thought, Action, and Observation in the ReAct pattern.
Figure 3: Spawning Healing VFX with accurate position and scale

protected override void doInteraction()
{
        base.doInteraction();
    
        var tilesAffected = aoePattern.GetAffectedTilesInDirection(MapManager.Instance.GetTileAtPosition(pos2), CastDirection.North);

        foreach (var tile in tilesAffected)
        {
            CharacterData characterOnTile = TurnManager.Instance.GetUnitFromTile(tile);
            if (characterOnTile)
            {
                damage = (int)Math.Round(characterOnTile.GetCurrentStats().MaxHP * 0.1);
                characterOnTile.HP.TakeDamage(damage, currentUnit);
            }
        }
}
Figure 2: Example of an interactable object.

Interactable System

Any interaction with static objects, environments and/or sometimes players are processed here.

All interactions are triggered through interact button in the action box. Game data is captured and relevant interaction script is called to perform interaction.

Integration with other systems

All Interactables are calling multiple other systems to process the input from the player and execute the action based on the interactable.

Tools

Took feedback from designers to expose the relevant parameters in the inspector (GUI) with helpful tooltips and headers. Designers do not need to write code or modify scripts to modify values like range and damage

Results and Impact

* The modular VFX system significantly improved the clarity and responsiveness of player feedback by providing immediate, context-aware visual responses to combat, abilities, and interactions.

* By centralizing VFX handling and supporting parameterized spawning (offsets, scale, and lifetime safety), the system ensured consistent visual quality while remaining flexible enough for rapid iteration. Designers were able to quickly swap, tune, and prototype visual effects without engineering intervention, accelerating development and reducing iteration

* The Interactable System broadened player engagement by enabling meaningful interactions with environmental objects, NPCs, and world elements beyond direct combat.

* Centralized interaction handling and clean integration with other gameplay systems allowed interactions to feel reliable and intentional, reinforcing player agency and immersion. From a production perspective, the system reduced duplicated logic, simplified the addition of new interactables, and empowered designers to independently tune interaction parameters.

* Together, these systems contributed to a more polished and scalable gameplay experience. By emphasizing modular architecture, safety mechanisms, and designer friendly tooling, the project achieved faster iteration cycles, clearer gameplay feedback, and a stronger collaboration pipeline between engineering and design.