Divine Agent: Meet the Gonjis
A narrative strategy game exploring labor exploitation through resource scarcity mechanics.
Role: Solo Developer (Narrative, System, Level Design)
Tools: Unreal Engine 5, Blueprints, Aseprite.
Timeline: July 2025 - Dec 2025
Narrative Content Design
From Inspiration to Story
Growing up in Shenyang, an industrial city in the Northeast of China, I always dreamed of transforming the solemn, harsh steel of countless construction sites into something playful and warm. Inspired by the spontaneous biology and how humans cope with strange creatures in Scavengers Reign, I decided to create the world of Divine Agent, where spirits of human desire and humans live side by side.
In this world, Gonjis are spirits of imagination. They build and construct for humans. However, after long-term labor exploitation, they have lost control and begun to tear apart cityscapes. Instead of treating them as enemies of the government agent Benoit (Player) to eliminate, Player’s mission is to calm these spirits, help them recover, and guide them back toward their imaginative wonder-world.
The core mechanic isn't combat; it's Critical Care.
→
Gonji
〰️
Gonji 〰️
Benoit
〰️
Benoit 〰️
Destructible Zone’s BP: Procedural Destruction & State Management
When Gonji hits the destructible zone, the zone calculates its own size, hides the art, deletes the floor, and saves the data.
The Destruction System is an event-driven architecture to decouple the AI logic (BP_Gonji) from the environmental state logic (BP_DestructibleZone). The AI handles target acquisition, while the Zone handles its own physical state transitions. This prevents dependencies and allows for easier debugging.
Gonji’s BP: Stochastic (Random) AI Behavior Tree
AI BEHAVIOR: STOCHASTIC DECAY
This BP checks if Gonji is busy, telegraphs an attack, picks a random target from the environment, and executes the destruction event.
Locates the specific Grid Coordinates of the actor relative to the TileMap. Caches the visual tile data into an array for future restoration.
Procedurally removes physical collision and visual tiles from the level map to create empty gaps that Benoit and Gonji may fall into.
Unhides the 'Damage' flipbook to visually bridge the gap between the TileMap modification and the empty space.
Prevents logic overlaps by checking the current AI State. Drops the command if the AI is already performing an action.
Pauses AI navigation physics and syncs the attack logic to the exact length of the animation frame data, ensuring readability for the player.
Scans local physics volume for valid actors, filtering for class type. Uses a random integer array retrieval to select a stochastic target from the valid list.
Calls the Destruction Event on the external actor and restores AI movement physics (Patrol State).
Gonji’s Destruction Logic
Benoit’s BP: Player Interaction & Economy Validation Logic
Benoit/Player’s Repair Logic
Scarcity System
This is the brain of the player interaction. It handles targeting, resource checking, and execution of patching damaged blocks.
Destructible Zone’s BP: Restoration Input Handshake
It receives the signal from Benoit and prepares the actor to "Rewind."
Summary: The Repair System separates the Economic Decision (Benoit's BP) from the Physical Execution (Destructible Zone's BP), keeping the code modular.
Scans world for 'Destructible Zones', filters out healthy zones, and utilizes vector math to identify the nearest relevant target.
Queries the specific data of the target zone to calculate 'Zone Repair Cost'. Validates player resources (Ammo) before allowing action.
Aligns player rotation, triggers wind-up animation delay for 'weight', and calls the Interface Event on the target actor.
Updates global resource variables, recalculates total repair percentage, and evaluates Win/Loss states against the 35% threshold.
Wakes the actor's Tick logic from sleep mode and triggers the visual 'Time Rewind' animation. Does not instantly fix physics (that is handled by Tick logic to ensure sync).
Destructible Zone’s BP: Lifecycle Optimization & Logic
Optimization and System Initialization
This set up watches the animation. If it's breaking, it waits. If it finishes breaking, it sleeps. If it rewinds to 0, it fixes the map.
Summary: This part is an event-driven architecture that balances scalable system initialization with rigorous runtime performance optimization. By dynamically calculating the economy targets at start-up, the system allows for procedural changes to the level without requiring logic rewrites. Furthermore, the object lifecycle is optimized for high density; actors programmatically disable their own CPU update loops (Ticks) during idle states, waking only during critical state transitions like destruction or repair. This ensures resources are reserved strictly for active narrative beats.
Benoit’s BP: Dynamic System Initialization
At runtime, this logic executes a dynamic system initialization rather than relying on hard-coded values. By iterating through all actor instances in the level to aggregate their surface area, the code automatically scales the Win Condition to fit any map layout, effectively decoupling the game rules from the level design. This chain also handles dependency injection by creating the HUD and registering the Enhanced Input Mapping Contexts, ensuring a stable control state before the player can act.
Performance Optimization: Once visual destruction is complete, the Actor disables its own Tick function to save CPU cycles.
Syncs the return of physical collision with the exact frame the visual animation completes. Iterates through the cached data array to restore the TileMap visuals.
At runtime, the System loops through all level instances to calculate the maximum possible score (TotalLevelArea). This decouples the Code from the Content, allowing Level Designers to build maps of any size without manually hard-coding the Win Threshold variables.
Initializes the Heads-Up Display and injects the dependency (HUD Reference) back into the Player Blueprint. This caches the pointer early to prevent expensive lookups (like casting) during the gameplay loop, optimizing the repair mechanic performance.
Dynamically binds the 'Platforming Context' to the Local Player Subsystem upon possession. This keeps the input logic modular, allowing controls to be swapped easily for Menu States or Cutscenes.
Level Design
The level geometry was designed to enforce a constant economic trade-off between survival and scoring. Small, low-cost blocks act as essential connective tissue, allowing the player to bridge gaps and maintain the critical path toward the exit without falling. In contrast, large blocks serve as high-yield scoring targets; they offer the greatest percentage increase for the quota but demand nearly 30% of the player's total resource cap to repair. This layout forces the player to make minute-to-minute decisions: spending ammo efficiently to maximize score, or spending it inefficiently to ensure safe traversal to the Win Zone.
large block
Fall Zone
small block
Win Zone
Role: Level Artist
Tools: Unity
Timeline: Dec 2023
Hand Beneath the Floating Coffin
Environmental Storytelling
An experiment in atmospheric design. I utilized dynamic lighting and fluid simulation to establish a narrative tone of isolation without using dialogue. My goal was to create an environment that tells a story through mood and physics alone.
When A Dream comes True (Animation) & Wizards (Short Film)
Role: Solo Director & Animator
Tools: Procreate Dreams
Timeline: Dec 2023
LINEAR NARRATIVE & PACING (Film & Animation)
Role: Director, Camera Assistant, Co-Editor & Co-Producer
Tools: Adobe Premiere Pro, Blackmagic Camera, Procreate Dreams
Timeline: Dec 2023