EMMANUEL OYEBAMIJI

Developed a recursive backtracker algorithm for perfect maze generation across configurable grid sizes up to 30x30, sustaining 80-100 FPS in Unity Editor and standalone builds.

Engineered an object pool to manage runtime instantiation of dynamic game objects (ghosts, keys, pickups), eliminating per-frame allocation and maintaining a stable frame rate.

Designed and implemented a custom A* pathfinder with dynamic wall data and h-based tie-breaking, ensuring accurate, real-time enemy navigation on a grid graph.

Authored a robust grid/cell data structure supporting wall removal and neighbor querying, serving as the foundational backbone for pathfinding, spawning, and maze generation systems.

Developed a quadrant-aware spawning framework utilizing abstract base classes and overrides, enabling deterministic yet randomized placement of pickups and AI agents while adhering to SOLID principles.

Optimized enemy movement systems using object-pooled instances, path caching, and ~0.5s target re-evaluation, achieving predictable and fluid AI behavior through smooth cell-center interpolation.

Constructed a game state and UI synchronization layer using the Singleton pattern, ensuring clean separation between gameplay logic and interface feedback through direct references.

Developed a Unity C# maze generator using recursive depth-first search with coroutine-based step visualization, enabling real-time algorithm demonstration for configurable grid sizes.

Applied an event-driven design pattern to fully decouple rendering logic from generation logic, achieving clean single-responsibility separation between systems.

Built interactive UI controls supporting real-time parameter adjustment (grid size, speed), providing immediate visual feedback on generation output.

Implemented an interface-driven interaction system (IInteractable, IKitchenObjectParent), fully decoupling player actions from game objects to enable extensible item behavior with zero coupling.

Developed data-driven item and recipe definitions utilizing Scriptable Objects, enabling seamless content iteration without requiring code changes, exemplifying the SOLID open/closed principle.

Architected an event-based state management system using C# events for UI updates, order queue transitions, and win/lose conditions, significantly reducing inter-system dependencies.

Implemented player input abstraction via Unity Input System, providing platform-agnostic, modular control handling that supports remappable actions.

Designed a modular object parenting system to enable seamless item transfer between player, counters, and processing stations, managed within a finite state gameplay loop.

Bound UI components directly to gameplay events, achieving real-time order queue rendering and countdown timer feedback with zero polling overhead.

Developed a physics-based movement system using Unity Rigidbody and C#, producing responsive, momentum-driven player controls with realistic inertia.

Engineered a modular collision detection system handling obstacle interactions, Game Over state triggers, and level boundary enforcement via event dispatch.

Implemented a dynamic real-time scoring system tracking spatial displacement and survival time, rendered live via TextMeshPro UI binding.

Constructed a centralized Game Manager handling the core gameplay loop, including scene transitions, state persistence, and automatic level restarts.