SoulSync

Set in a dystopian sci-fi world where a sinister corporate curse tethers your squad's lifeforce together, SoulSync is a high-stakes, PvE co-op action roguelike where players must win, or die, as one. 

Game Title

SoulSync

Role

Quick Stats

• Genre: Dystopian Sci-Fi / Cyberpunk Co-Op Action Roguelike

• Engine & Tech Stack: Unity 6, C#, Photon Fusion (Networked Co-Op), Wwise, Universal Render Pipeline (URP), DirectX 11

• Team Size: 17 Team Members across 4 Sub-Teams 

  • 5 Engineers

  • 6 Technical Artists/Designers

  • 3 Writers

  • 7 Audio Engineers/Voice Actors

• Development Cycle: 2 Academic Semesters (Sept 2025 – May 2026) | 8 Agile Sprints

• Player Count / Modes: 1–4 Players (Server-Authoritative Shared-Life Co-Op)

• Core Systems Built:

  • Networked Shared-Life System & Server-Authoritative Wallets/Inventories (Photon Fusion)

  • Polymorphic Ability Architecture using ScriptableObjects across 5 playable classes

  • Custom In-Editor JSON-to-ScriptableObject Pipeline

  • Dynamic Wwise Dialogue & Combat Aggro Audio Routing

• Key Technical Wins & Performance Fixes:

  • Memory Leak Elimination: Identified and resolved a 1.7 GB/min Unity DX12 memory leak by forcing a DX11 fallback, stabilizing memory growth.

  • Network Migration: Successfully migrated core architecture from Netcode for GameObjects (NGO) to Photon Fusion to eliminate connection limits and lower overhead costs.

  • Rendering & Shader Optimization: Refactored URP cel-shaders to streamline multi-light models, implemented static Occlusion Culling, and used object pooling for high-frequency entities to maintain high draw-call/spawn efficiency.

The Vision

"SoulSync is a high-stakes, PvE co-op action roguelike set in a dystopian sci-fi fantasy world where a sinister corporate curse binds your squad's lifeforce together. Players must coordinate distinct character abilities, manage a shared life pool, and build stackable item synergies to survive treacherous dungeons and overthrow a ruthless corporate monolith."

Key Features

• Shared-Life Co-Op Mechanics: Play together with a tethered shared-life pool where individual player deaths drain the squad's total lives, demanding tight team coordination and revival strategy.

• Distinct Class Roster & Flexible Abilities: Choose from 5 character classes (such as Percival, ASTR-1D, and Tyr) featuring primary, secondary, mobility, and special abilities tailored for both solo survival and team synergy.

• Dynamic Item Pool & Synergy Economy: Power up through chests and shop purchases using individual player wallets, applying stackable passive effects, status modifiers, and stat boosts.

• Cel-Shaded Cyberpunk Fantasy World: Battle through corporate-ravaged environments—from cybernetic forests to ancient active forges—rendered in a 3D cel-shaded aesthetic with custom Wwise spatial audio.

• Scaling Difficulty & Extraction Looping: Fight against dynamically scaling enemy waves and bosses, with the option to escape with your loot after World 3 or loop for higher-difficulty runs.

Key Features: Engineering the Mechanics

1. Shared-Life Co-Op Mechanics

• Implementation: Built a networked shared health system with a server-authoritative LivesTracker network behavior.

• Death & Respawning: When a player's health drops to 0, an RPC request (RPC_RespawnPlayerRequest) is sent to the server. The server decrements the shared lifePool integer variable and respawns the player in the stage.

• Game Over Condition: If the networked lifePool reaches 0 when a player dies, the server triggers RPC_ToggleGameOver(), ending the session for all connected clients and returning them to the main menu.

• AI & Physics Handling: On player death, an event notifies aggroed enemy AI state machines to drop their current target and return to the IDLE state. The local player model disables animator components and turns off root kinematic settings to activate ragdoll physics through joint rigidbodies.

2. Distinct Class Roster & Flexible Abilities

• ScriptableObject Architecture: Engineered a modular combat system where all player and enemy actions derive from a base Ability ScriptableObject.

• Class Decoupling: Combat controllers execute actions polymorphically, allowing any character class (Percival, ASTR-1D, Tyr, Ronan, Felix) to equip and execute any ability from their loadout without hardcoded dependencies.

• Animation Masking & Speed Splicing: Used animation masking on lower-body rigs so characters can move without sliding while casting upper-body abilities. Long wind-up animations were programmatically spliced or scaled to match instantaneous hit-detection timings.

3. Dynamic Item Pool & Synergy Economy

• JSON to ScriptableObject Pipeline: Created an in-editor Database Tool that parses custom JSON item entries directly into Unity ScriptableObjects.

• Dual Pool System: Divided item distribution into two distinct pools: an Unlocked Items pool (used by chests based on individual player save data) and an All Items pool (used by shop vendors). Purchasing a new item in the shop permanently registers it into the player's unlocked chest pool.

• Dual-Dictionary Inventory System: Managed local inventory via two runtime C# dictionaries: one tracking item IDs and stack quantities, and another aggregating active status effect modifiers (e.g., hp_multiply, cooldown_reduction, crit_chance) applied directly to the character’s Stats component.

• Server-Authoritative Wallets: Player wallets are individual networked variables updated when enemies die (OnDeath()), allowing isolated spending at shopkeeper vendors without affecting squadmates.

4. Audio Integration

• Wwise Audio & Dynamic Routing: Routed all dynamic spatial audio, footsteps, and ability callouts through Audiokinetic Wwise.

• Dynamic Enemy Aggro Music System: Implemented dynamic combat music scaling by tracking the exact number of active enemies aggroed on the local player (NumAggroedLocal) via RPC updates.

• Refactored Dynamic Dialogue Engine: Replaced a brittle 7-parameter dialogue system with a streamlined Wwise Dynamic Sequence queue. Dialogue calls resolve audio events using JSON mappings driven by scene level, character class switches, and context IDs (e.g., friendly fire, proximity banter).

5. Scaling Difficulty & Extraction Looping

• Dynamic Difficulty Manager: Tied an automated scaling engine into EnemySpawnManager that adjusts spawn rates, enemy caps, and elite pool access based on session duration and player counts (scaling difficulty by +0.1 per additional player).

• Looping & Session State Machine: Session flow is dictated by a global GameManager state machine (Gameplay, Bossfight, Shop, PostBoss). Upon beating World 3, players can choose to extract with current spoils or trigger a run loop to re-enter early levels with amplified enemy stat multipliers.

Performance Optimization

• DirectX 11 Fallback for Memory Leaks: Discovered a critical issue in Unity where any unlit shader under DirectX 12 caused an untracked memory leak of approximately 1.7 GB/min. Forced the engine build to DirectX 11, reducing untracked memory growth down to a stable baseline.

• Occlusion Culling & Material Baking: Baked static Occlusion Culling across dense dungeon levels to prevent rendering non-visible geometry. Solved custom URP shader incompatibilities by programmatically swapping mesh materials to standard baking shaders during occlusion map generation.

• Particle System & Sprite Sheet Efficiency: Engineered a centralized VFX particle system utilizing packed sprite sheets and custom emission shaders to minimize draw calls during multi-ability combat encounters.

• Tick-Aligned Input Processing: Smooth camera rotation and player movement under varying frame rates were achieved using a Vector2Accumulator look-rotation buffer, consuming input aligned to Photon Fusion network ticks.

• Object Pooling: Implemented aggressive object pooling for recurring high-frequency entities—such as enemy wave spawns, projectile bullets, particle systems, and drop loot—minimizing garbage collection (GC) spikes and runtime instantiation overhead.

• Batching & Shaders: Leveraged static and dynamic batching alongside optimized custom cel-shaders to minimize draw calls across complex 3D environments.

• Network & Data Payload Optimization: Optimized RPC frequency by serializing essential dynamic state variables (position, health updates, ability triggers) and compressing network tick updates for smooth multiplayer co-op sync.

Key Development Setbacks & Solutions

1. Networking Framework Migration

   • Issue: Early builds relied on Unity Netcode for GameObjects (NGO) and Relay, which suffered from strict free-tier connection limits.

   • Solution: Migrated the networking architecture to Photon Fusion, prioritizing direct peer-to-peer connectivity.

2. Multi-Light Cel Shader GPU Spikes

   • Issue: Expanding the custom URP cel shader to calculate dynamic specular, diffuse, and Fresnel lighting across multiple light sources caused extreme RAM/GPU memory spikes and crashes in dense rooms.

   • Solution: Refactored lighting calculations back to an optimized single-main-light model with custom screen-space geometry outlines, eliminating performance drops while preserving the target comic-book aesthetic.

3. Wwise Dynamic Sequence Path Failures

   • Issue: Initial dialogue scripts required complex manual argument chains (7 parameters) to play character interaction lines, leading to frequent invalid node path resolutions and dropped audio.

   • Solution: Refactored the DialogueManager to dynamically infer speaking characters and active scene levels automatically, reducing calls to 3–4 parameters and enqueuing dynamic sequences cleanly via AkUnitySoundEngine.ResolveDialogueEvent.

Team Architecture

As Producer/Project Manager, I provided leadership across 4 cross-functional sub-teams:

• Development Team (5 Engineers): Network architecture (Photon), state machines, AI behavior, player movement, combat controllers, inventory JSON systems, and memory optimization.

• Design & Technical Art Team (6 Designers/Artists): 3D modeling, rigging (UEFY 2/Blender), texturing (Substance Painter), URP custom cel-shaders, VFX particle systems, UI/UX design, and level grayboxing/population.

• Narrative Team (3 Writers): Lore, dialogue systems, character arcs, cutscene scripting, and worldbuilding.

• Audio Team (7 Audio Engineers/Voice Actors): Dynamic Wwise soundscapes, spatial audio, adaptive combat audio triggers, custom character dialogue routing, and full voice acting.

Key Pivots, Technical Challenges & Scope Adjustments

A core responsibility in project management is mitigating bottlenecks, managing risk, and making hard scope adjustments when production hits friction.

1. Cutscene Production Pipeline Pivot (Sprint 5–6)

• Initial Workflow: Physical sketch -> Digital upscale -> Detailed annotations -> Storyboard.

• The Bottleneck: Storyboarding created a massive production bottleneck that halted narrative and art integration.

• The Producer Decision: Eliminated the multi-step storyboarding process entirely. Shifted to direct 3D animation in Blender by a dedicated animator, utilizing a master file with a single rendering pipeline into Unity via custom FBX exports.

2. Narrative & Character Tone Refactor (Sprint 3–5)

• Tone Adjustment: The original narrative focused heavily on slapstick, "Hanna-Barbera" style comedy. Following team and playtester feedback, comedy elements were stripped back in favor of high-stakes corporate dystopian drama, deepening character backstories and bonds.

• Character Redesigns:

  • Felix: Originally designed as a cat-eared, moody "joke" character. Redesigned into a street-smart blue-mage summoner burdened by black-market debt.

  • Ronan: Shifted from an arrogant assassin wanting fame to a vengeful hitman trapped by the company after an attempted corporate assassination.

3. Critical Technical Bottlenecks & Engine Fixes (Sprint 4–8)

• DirectX 12 Memory Leak Emergency: During Unity 6 development, an untracked memory leak was identified in DirectX 12, causing memory bloat of 1.7 GB/min when using unlit URP shaders. Evaluated two solutions (engine upgrade vs. DX11 downgrade). Selected forcing DirectX 11 for stability and reduced risks associated with upgrading project versions.

• Network Framework Migration: Shifted from Unity Netcode for GameObjects (NGO) to Photon. This cut reliance on 20-user capped Relay limits, eliminating overage charges while optimizing peer-to-peer room discovery.

• Animation Masking & Physics Bug Fixes: Fixed lower-body sliding during ability usage by implementing lower-body animation masks. Replaced static player death models with dynamic ragdoll physics linked to networked authority states.

4. System & Architecture Modularization (Sprint 6)

• Game Manager Architecture Split: Decoupled global session state management (matchmaking, character persistence, scene GUID tracking) from scene-specific level logic (enemy spawners, runtime tracking) by introducing a dedicated LevelManager.

• Dialogue System Simplification: Refactored a cumbersome 7-parameter Wwise dialogue call down to a clean 3-to-4 parameter dynamic lookup system reading straight from scene contexts and JSON tables.

• Outcome: Released on Itch.io with over 500 downloads.

• Play Game