Introduction

Odysslime was engineered as the final project for a fast-paced game development course at Arizona State University. Leading a 5-person multidisciplinary team (2 programmers, 2 level designers, and 1 artist), we designed, implemented, and polished a complete puzzle-exploration game within a strict five-week development window. The core architectural challenge was creating a highly flexible, decoupled gameplay framework that allowed players to seamlessly transition control between various specialized actor entities to solve environmental puzzles.

---

Contributions

Entity Possession & Decoupled State Systems

I architected the core character controller and input pipelines, focusing on the system-critical possession mechanic that anchors the entire gameplay loop.

• State Transition & Visual Feedback Pipelines: Designed an event-driven possession mode that abstracts user input away from the primary player entity. I programmed a contextual world-space targeting UI indicator that filters and validates potential target entities and notifies the user when they are highlighting a possessable entity.

• Dynamic Control Handshakes: To create a polished transition matrix when switching actors, I engineered a state-machine override that temporarily suspends user input, spawns a interpolated blue orb to visually map the transition path to the new target, and rebinds the character controller and camera matrices to the newly possessed entity.

Optimized Dynamic Navigation & AI Pathfinding

To handle the AI logic for a crowd of rescued follower entities traversing a highly volatile and changing 3D environment, I extended Unity’s native NavMesh infrastructure.

• Low-Overhead Dynamic Surfaces: Rather than triggering expensive full-mesh NavMesh regenerations at runtime, which introduces severe CPU frame-rate stutters, I engineered a modular pathfinding system. I bounded localized, smaller NavMesh surfaces to independent moving actors (like elevators and bridges) and connected them dynamically via runtime NavMeshLink nodes, allowing the AI agents to seamlessly calculate jump arcs between detached, moving coordinate systems.

Procedural World Tools & Physics Management

To empower our level designers to build unique spatial puzzles quickly, I developed a suite of highly flexible, reusable world-interaction components.

• Procedural Bridge Creation Tool: Designed a modular bridge-generation utility for designers. By defining arbitrary start and end Vector3 anchors in the editor, the script automatically recalculated the transform hierarchy, scale matrices, and boundary rotations of the structural mesh at initialization, completely removing manual placement bottlenecking.

• Kinematic Velocity & Agent Overrides: To handle complex physics interactions when a bridge retracted or extended, I authored a system that overrode the active AI agents’ pathfinding vectors, forcing an immediate exit velocity toward safe ground. I also applied calculated structural velocity vectors to any actor currently standing on transforming geometry, ensuring the AI agents moved synchronously with the moving platforms.

Event-Driven UI Infrastructure & Architecture

I engineered the application’s global UI framework, managing loading pipelines, configuration menus, and HUD data synchronization.

• Asynchronous Loading Operations: Programmed an asynchronous scene-loading architecture that cached and updated asset streams in the background. To decouple the user interface from tightly bound gameplay code, I integrated Unity Events in the project. This publisher-subscriber pattern allowed separate subsystems (like pausing, unpausing, and finishing a level) to broadcast updates independently, making the codebase highly maintainable, extensible, and free of rigid dependencies.

Engineering Management & Agile Scope Control

In addition to full-stack programming, I stepped into the role of producer to manage velocity under a compressed timeline.

• Milestone Planning & Scope Auditing: Organized the core technical design documentation, mapped weekly velocity metrics, and distributed engineering tasks across the development staff. By maintaining an open feedback loop between the art asset pipeline and programming constraints, I successfully managed the feature roadmap, ensuring all core architectural dependencies were integrated and fully optimized ahead of our absolute deployment deadline.

---

What I Learned

Odysslime was a foundational exercise in rapid software prototyping, codebase co-authorship, and engineering leadership. From a systems perspective, implementing an event-driven, decoupled architecture using Unity Events completely transformed my approach to software design, establishing clean code habits regarding modularity and the separation of concerns that I carry into all my current projects.

Furthermore, optimizing runtime pathfinding pipelines without relying on expensive CPU-re-baking operations sharpened my algorithmic problem-solving skills. On a structural level, leading a multidisciplinary team within a 5-week crunch window proved that clear communication, shared architectural goals, and strict scope management are just as vital to shipping optimized, functional software as raw technical execution.