• Acted as sole engineer, taking full responsibility for architecture, implementation, and deployment.
• Architected and implemented all core gameplay systems from scratch.
• Collaborated deeply with a 2D artist, ensuring game logic remained strictly decoupled from visual assets.
• Prioritized technical decisions focusing heavily on system extensibility, performance, and long-term maintainability.

• Engineered a data-driven level system utilizing Unity's ScriptableObject assets.
• Strictly separated level configuration from runtime gameplay logic to prevent rigid dependencies.
• Empowered designers and non-technical collaborators to add, remove, and reorder levels directly from the Inspector.
• Centralized level metadata to actively support rapid iteration and balancing for production.

• Designed a generic IHealth interface applied universally to all damageable entities.
• Decoupled damage sources (weapons, collisions) completely from the health logic implementations.
• Enabled entity-specific health behaviors naturally without requiring complex branching logic.
• Exposed clean architectural events to trigger feedback systems like audio or camera effects.

public interface IHealth
{
    float HP { get; }

    event Action<float> OnHpPercentChanged;
    event Action<Vector2> OnHit;
    event Action OnDeath;

    void SetInitialHp(float hp);
    void TakeDamage(float damageValue, Vector2 contactPoint);
}

• Implemented an extensible weapon abstraction utilizing a strict IWeapon interface.
• Allowed for the easy addition of new weapon types without modifying pre-existing core logic.
• Decoupled targeting evaluation logic from the actual weapon firing behavior.
• Developed a Model-View-Presenter laser weapon on URP utilizing LineRenderer arrays and raycasts against the IHealth system.

public interface IWeapon
{
  float WeaponRange { get; set; }

  void Shoot(float damageMultiplier);
  void ResetState();
}

Implemented robust object pooling to explicitly minimize continuous allocations and garbage collections for high-frequency runtime entities.

Asteroid Spawning

• Spawned asteroids dynamically based on strict level-specific spawn parameters.
• Randomized spawn vectors, positions, and visual variants on initialization.
• Reused asteroid instances aggressively through object pooling to flatten runtime overhead.

Explosion Effects

• Broadcast explosion spawn requests entirely via decoupled events upon asteroid destruction.
• Reused explosion particle prefab instances efficiently using the object pooling layer.
• Eliminated noticeable garbage collection spikes safely during intense, active gameplay.

• Engineered a custom intuitive input slider extending Unity's Slider component via IDragHandler and IEndDragHandler.
• Ensured responsive multi-platform UI flow adapting smoothly across diverse device resolutions.
• Implemented an onboarding in-game tutorial seamlessly upon a user's first launch.