Dorothy’s Job

To create a seamless, input-agnostic menu experience, I bypassed Unreal Engine's native SetUserFocus limitations. I engineered a dynamic input detection system and a custom focus router that maps flat arrays of widgets into irregular 2D grids.

• Hardware Polling: The ABasePlayerController acts as the single source of truth, dynamically switching between FOCUS (Gamepad) and FREE (Mouse) states the moment hardware intent is detected.
• Menu Stack & Grid Calculation: The UGeneralFocusManager routes inputs exclusively to the top of the menu stack, while the USpecificFocusManager handles complex, irregular grid navigation.
• Interface Interception: Widgets inheriting IAxisNavigable intercept directional inputs to adjust internal values (like a volume slider) without forcing the system to move focus to a different widget.

Hardcoding text or image references into C++ or UMG directly creates a massive bottleneck for narrative designers and artists. To solve this, production layouts are strictly data-driven, utilizing Unreal Engine's UDataTable and custom structs.

• Dynamic Content Fetching: The UTipManager caches all available row names and dynamically extracts FTipData structs. It explicitly removes used rows from the active pool to guarantee non-repeating content until the pool is exhausted.
• Narrative State Machines: Rather than UMG widgets driving logic, the UDialogsManager controls the narrative flow. It broadcasts multicast delegates (OnDialogLineReceived), ensuring total separation of concerns between game state and visual presentation.

To prevent the common performance bottleneck of UI elements ticking every frame, the visual HUD strictly adheres to the Observer Pattern. It binds to player pawn delegates and only executes visual updates when explicitly notified of a state change.

• Reactive Material Instances: The UHUDDorothy widget recalculates scalar parameters for Dynamic Material Instances to achieve complex, non-linear fill effects and "Doom-style" reactive facial damage responses.
• Memory-Safe Timer Visuals: Transitory UI states are handled via asynchronous timers utilizing TWeakObjectPtr, ensuring UI deletion mid-animation never causes a fatal engine crash.
• Custom Rich Text Parsing: Hiding characters during a typewriter effect breaks native Unreal Rich Text formatting tags. I wrote a custom parser that evaluates strings character-by-character, automatically closing any active tags before pushing the sub-string to the UI.

To prevent gameplay classes from becoming tightly coupled to audio APIs, I developed a centralized Audio Manager alongside an event-driven component structure to handle FMOD integration.

• Low-Level Middleware Integration: The UAudioManager acts as a UGameInstanceSubsystem. By directly retrieving the FMOD::Studio::System, the manager can instantiate events and apply dynamic parameters, bypassing standard Unreal Audio Component overhead.
• The Auto-Destroyer: To automate garbage collection and prevent memory leaks, dynamic audio components are passed to a UFMODAutoDestroyer wrapper. It binds to OnEventStopped, calling ConditionalBeginDestroy() the exact frame the sound finishes.
• Event-Driven Audio Components: Gameplay actors have zero awareness of FMOD. Instead, the UBaseWeaponAudioComponent acts as a bridge, retrieving data assets and translating gameplay logic into middleware parameters.

A common anti-pattern in inventory systems is representing held items as physical AActor instances, bloating memory. To ensure maximum scalability, the consumable framework is strictly UObject-based, separating abstract logic from physical instantiation.

• Logic over Actors: Consumables only exist as lightweight data containers until used. Timer-driven durables delegate duration tracking entirely to the World's FTimerManager instead of ticking.
• Safe NavMesh Spawning: USpawnableConsumable generates radial vectors, queries the NavMesh, and performs an FPathFindingQuery to ensure items never spawn out of bounds or inside walls.
• Filtered Spatial Queries: Physical deployables (like bombs) bypass collision spheres, utilizing highly optimized SphereOverlapActors with specific EObjectTypeQuery channels to selectively damage targets via IDamageable interfaces.

To handle progression tracking, I built a persistent UGameInstanceSubsystem that manages synchronization between local save data and the Steamworks API, while preventing race conditions during asynchronous platform initialization.

• Data-Driven Initialization: To avoid hardcoding achievement IDs, the manager dynamically reads the DefaultEngine.ini utilizing Unreal's GConfig parser to construct its internal map of structs.
• Asynchronous Queuing: Connecting to Steam is asynchronous. If a player unlocks an achievement before the API is ready, the system pushes it to an internal m_lPendingUnlocks queue, which is flushed upon successful initialization callbacks.
• Bi-Directional Synchronization: The manager compares local save data against Steam's cloud records. If the local save is ahead (e.g., the player played offline), it aggressively pushes the data up to force a cloud synchronization.