Aard and Wyzz: The rise of minions

Aard and Wyzz: The Rise of Minions is a 3D local co-op action-adventure game developed in Unreal Engine 5 and C++. Players must cooperate as two specialized wizards—one focused on melee combat, the other on ranged projectiles—who can fuse into a powerful single entity to conquer a magical tower filled with puzzles and enemies.

This project is developed by Curious Imp, a multidisciplinary team of 20, simulating a professional studio environment and providing invaluable experience in cross-departmental collaboration. A trailer and playable demo are available here.

I currently serve as the Lead Programmer, where I manage a team of three programmers while continuing to work as a hands-on generalist. My leadership and personal development work are both centered on gameplay and AI, and I have made key contributions across multiple domains:

Gameplay & AI Systems

Architected and implemented core gameplay mechanics for both player characters and enemies, including movement, combat skills, attack patterns, and lifecycle events, utilizing Unreal's Enhanced Input system for player controls.
Engineered the AI for ranged enemies, programming complex behaviors like teleportation and projectile attacks. I also contributed directly to the final boss fight logic.

Tools, Pipeline & UI

Established a CI/CD pipeline using Jenkins to automate game builds and instantly notify team members of the build status, significantly improving team workflow and efficiency.
Developed custom editor tools using the Slate UI framework to streamline the development process for the team.
Built and refined the game's UI/HUD using Unreal Widgets, with a specific focus on creating intuitive gamepad navigation and improving overall usability.
Managed the project's version control workflow, which initially utilized Perforce before I led the migration to Git with Azure. I also provided training and ongoing support to non-technical team members to ensure effective collaboration.

Animation, Graphics & Audio

Developed dynamic visual feedback for the combat system by creating and programmatically modifying materials and shaders in C++.
Contributed to the animation pipeline, using Animation Notifies to trigger gameplay events and VFX at precise moments.
Integrated sound effects using Fmod to enhance player and enemy actions.

Quality Assurance & Collaboration

Conducted rigorous testing and debugging across all game systems (gameplay, AI, UI, VFX/SFX) to identify and resolve bugs, crashes, and performance issues.
Maintained high code quality standards through consistent peer code reviews.
Collaborated closely with art, design, and production teams, using HacknPlan for agile task estimation and tracking to ensure project goals were met.

Highlighted Technical Challenge: Solving Local Co-op Input

During development, we encountered a critical engine bug in Unreal Engine 5.2 where both the keyboard and a gamepad would incorrectly control a single player (player controller) in local co-op.

To resolve this, I extended Unreal's native GameViewportClient class and engineered a custom input routing system. This solution correctly assigned controllers to each player, enabling seamless keyboard-and-gamepad co-op gameplay as designed and overcoming a significant engine limitation.

The videos below highlight some of the key systems I was directly involved in developing.

One of the most complex mechanics I engineered was a fluid character dash that functions reliably on uneven terrain.

The primary technical hurdle was enabling the player to dash smoothly up and down stairs without getting stuck, floating, or snapping between steps. The dash distance also needed to remain consistent, regardless of the character's speed.

I implemented the dash using a linear interpolation to ensure a fixed travel distance. To solve the stair-climbing issue, I developed a system that projects a continuous raycast from the player towards the ground along the dash path. By capturing the impact point's Z-axis position, I could dynamically interpolate the character's height to match the surface of the stairs perfectly, resulting in a seamless and fluid movement.

This video demonstrates the dynamic AI system I developed with my coworkers, which governs all enemy behaviors from movement and combat to sophisticated group tactics. The entire logic is architected using Behavior Trees, allowing for complex, state-driven actions.

Key features of this system include:

Three Distinct Enemy Archetypes: There is unique combat logic for Shield, Melee, and Ranged enemies, each with their own attack patterns and behaviors.
Coordinated Group Tactics: A flocking algorithm was implemented to enable believable group movement, allowing squads of enemies to position themselves and attack in a coordinated manner.
Dynamic Co-op Threat Management: To ensure a balanced co-op experience, we designed a custom aggro system. Each enemy type is assigned a different "threat value," which the system uses to intelligently distribute attackers between the two players. This prevents one player from being overwhelmed and encourages strategic teamwork.

This video highlights the comprehensive feedback system I developed to create a clear and satisfying combat experience, as well as the logic that handles the game-over state.

To ensure every action has a clear reaction, I engineered a multi-layered visual feedback system:

For Players: Upon taking damage, both the player character and their corresponding UI hearts flash white. This provides immediate, unambiguous feedback that a hit was registered.
For Enemies: Inspired by the satisfying feedback in Death's Door, I developed a two-stage system. Enemies flash purple instantly upon being hit for immediate confirmation. Concurrently, a custom shader effect progressively spreads across their model to visually represent their remaining health, giving players crucial strategic information.

I architected the complete game-over sequence. When players are defeated, a death screen is triggered, which immediately halts all enemy AI and game logic to ensure a clean state transition. The system then seamlessly restarts the current level, allowing players to jump right back into the action.

This video demonstrates the final boss encounter, which I designed around a multi-phase attack pattern. The boss's logic is driven by a State Machine, where each state corresponds to a unique attack. These attacks include homing energy rays, targeted falling projectiles (parchments), and an environmental attack that tilts the entire arena. The AI transitions between these states based on timed intervals and key gameplay events, creating a dynamic and challenging fight.

Technical Challenge: Frame-Rate Dependent Collision Failure

During testing, we discovered a critical physics bug: at low frame rates, the falling parchment projectiles would fail their collision detection and clip through the floor, breaking the mechanic.
Instead of relying on the standard physics engine which was proving unreliable at low FPS, I engineered a custom solution. I implemented the falling motion using a linear interpolation (lerp). This approach calculates the parchment's position based on elapsed time rather than per-frame updates, guaranteeing a smooth and predictable trajectory that is completely independent of the game's performance. This ensured the attack worked reliably on all hardware.

This video demonstrates a core pillar of our game's design: the ability for two players to merge into and co-pilot a single, powerful character, Ardwiz.

I architected this entire system using Unreal Engine 5's new Enhanced Input System, which allows for dynamic context-switching. When players merge:

Player 1's Input Mapping Context is swapped to control Ardwiz's movement and defensive abilities.
Player 2's Input Mapping Context is swapped to control Ardwiz's attacks and offensive skills.

The primary obstacle was a fundamental engine limitation: a single character can only be "possessed" and receive input from one player controller at a time. This made a true two-player control scheme for one entity seem impossible.

To solve this, I developed a novel approach. While Player 1's controller directly possesses the Ardwiz character, Player 2's controller possesses a lightweight, empty actor that is programmatically attached to Ardwiz.

I then engineered Ardwiz's code to listen for and process input from two sources simultaneously: its own possessed controller (Player 1) and the attached empty actor (Player 2). This innovative design successfully simulates dual-possession, allowing two players to intuitively and seamlessly control a single character.