Punk Deliveries

Role: Generalist Programmer

Contributions:

• Built a modular dialogue system supporting both dynamic in-world triggers and hub-based branching conversations with NPCs; implemented using ScriptableObjects, event channels, and serialized quest nodes for state persistence.

• Developed patrol drone behaviors with waypoint based pathing and alert zones 

• Programmed AI vehicle controllers using Navmesh, finite state machines, and custom waypoint logic, simulating ambient city traffic with randomized pathing speed variation and collision avoidance. 

• Engineered player and hoverboard camera systems using Cinemachine, including dynamic follow cams, procedural shake, FOV adjustments based on speed, and smooth transitions between gameplay and cinematic moments ​

Project Information:

Released: May 2025

Duration: 4 Months

Engine: Unity

Platforms: Windows

Language: C#

Tools: Obsidian, HacknPlan

Team Size:  17

Dialogue

Built a reusable narrative dialogue system that handles voiced dialogue playback, subtitle sequencing, branching player responses, and interaction state management. Designed the framework around ScriptableObject-driven content pipelines, FMOD audio events, and dynamic UI generation to create scalable, designer-friendly narrative workflows in Unity.

Core Functionality

• Stores dialogue as reusable ScriptableObject sequences

• Supports character name + subtitle text + voice clip pairing per dialogue line

• Integrates FMOD voice events for audio playback timing and voice-over triggering

• Allows branching player choices that dynamically route to new dialogue sequences

• Maintains dialogue history log UI for subtitle review / accessibility

• Locks player interaction during conversations and restores control after completion

• Supports skip / interrupt voice playback for responsive pacing

Breakdown

• Built a reusable dialogue content pipeline by structuring conversations into modular ScriptableObject dialogue sequences using Unity ScriptableObjects, serializable classes, and custom editor data containers

• Implemented branching conversation logic by linking player dialogue choices to chained dialogue assets using serialized DialogueChoice references and runtime sequence swapping

• Integrated voiced dialogue playback by triggering event-based audio clips and managing playback timing using FMOD EventReference, EventInstance, and coroutine timing systems

• Created interactive dialogue UI systems by dynamically updating subtitles, speaker names, history logs, and choice buttons using TextMeshPro, Unity UI Buttons, ScrollRects, and prefab instantiation

• Improved player interaction flow by pausing movement, handling dialogue progression input, and restoring gameplay state using state management hooks and interaction flags

Drones

Engineered a configurable drone AI framework in Unity that separates movement, detection, and combat tuning from gameplay logic through ScriptableObject-driven behavior profiles. Built reusable configuration pipelines for patrol movement, player detection thresholds, and projectile behavior, enabling rapid iteration on enemy archetypes without modifying code. 

Core Functionality

• Stores drone behavior in reusable ScriptableObject presets

• Supports multiple attack types (projectile / grenade) through enum-driven configuration

• Exposes patrol speed, chase speed, stop timing, and waypoint thresholds as editable data

• Separates detection radius, chase radius, and vertical tolerance for spatial tuning

• Defines projectile prefabs, speed, and fire cadence through shared config assets

• Enables multiple drone variants using one shared controller script

Breakdown

• Built reusable enemy behavior profiles by separating drone movement, detection, and combat tuning into configurable data assets using Unity ScriptableObjects, serialized fields, and custom inspector organization

• Implemented modular patrol AI systems by combining waypoint traversal, timed idle states, and directional interpolation using Transform arrays, coroutines, Vector3 movement, and Quaternion rotation smoothing

• Designed configurable combat behaviors by supporting multiple firing archetypes with editable projectile logic using enum-based behavior switching, prefab references, Rigidbody physics, and exposed fire-rate tuning

• Improved designer iteration workflows by exposing movement, detection, and attack parameters through inspector-editable data profiles using ScriptableObject assets and data-driven configuration pipelines

Post-Mordem:

Working on the dialogue and drone systems changed the way I approach gameplay engineering. Before this project, I primarily thought about programming in terms of building isolated features, getting mechanics functional and solving the immediate technical problem in front of me. Through developing these systems, I began thinking more in terms of reusable architecture, designer-facing tooling, and long-term flexibility.

The dialogue system was my strongest lesson in data-driven design. Building it around ScriptableObjects forced me to think beyond implementation and focus on creating a workflow that designers could use independently. Supporting branching dialogue, speaker transitions, audio integration, and dynamic sequence flow required building a system that was flexible without becoming difficult to maintain. Through that process, I learned that strong engineering is often less about complexity and more about creating tools that are intuitive, scalable, and easy for others to work with.

The drone system taught me a different lesson: systems should be adaptable. What started as a full combat AI with detection, chase behavior, and multiple attack types eventually no longer matched the tone of the game. Instead of throwing away that work, I restructured it into a more modular system that supported patrol behavior while preserving its combat functionality for future use. That experience reinforced the importance of writing systems that can evolve with changing design goals rather than locking development into a single implementation.

From a technical perspective, this project strengthened my skills in ScriptableObject architecture, coroutine-driven behavior, AI movement systems, spatial detection logic, runtime UI generation, and FMOD integration. More importantly, it taught me to think of gameplay systems as flexible frameworks rather than fixed features, systems that should be built with iteration, reuse, and change in mind.