top of page
Abstract White Texture
DMC CLone Cover_edited.jpg

UE5 Devil May Cry Clone

3D Action Game | Unreal Engine 5 | C++ & Blueprint

A DMC-inspired action game focused on combat feel — full combo system with mixed LMB/RMB inputs, soft lock-on, parry, finisher, and rage mode. Built entirely in C++ with a data-driven architecture.

Tech Stack: Unreal Engine 5 | C++17 | Behavior Trees | Enhanced Input | Animation Blueprints | Data Assets

​

Development Approach

The player is split into focused components — each owns one thing. They talk to each other through IDMC_CombatInterface, which both the player and all enemy types implement. This means every AnimNotify is written once and just works across all characters.

Arch.png
Key Technical Systems
  • Combo System & State Management
    • Combo state is tracked with three indices — LightIndex, HeavyIndex, ExtenderIndex. Mixed combos work in two phases: a starter based on how many heavies landed, then an extender on the next heavy press. Resets are selective — starting a heavy clears the light index and vice versa.

    • Inputs during an active attack get buffered (EBI_LightAttack, EBI_HeavyAttack, EBI_Dodge) and consumed when a save window opens. Save windows are AnimNotifyState tracks placed directly on each montage timeline.

Light Attack.png
​
  • Component-Based Architecture
    • Instead of putting everything in one giant character class, I split the player into focused components — each owns exactly one responsibility. CombatComponent handles combo logic, TargetingComponent handles soft lock-on, RageComponent manages rage mode and its VFX sequence, FinisherComponent handles execution logic, and CombatBufferComponent manages both input buffering and movement lunges.

    • The immediate payoff was in debugging. When combo chaining broke, I only opened CombatComponent. When rotation felt wrong mid-attack, I only looked at TargetingComponent.

    • It also made the enemy side clean — EnemyCharacterBase only carries what every enemy needs. Melee-specific weapon logic lives in EnemyMelee, ranged firing in EnemyRanged. Each subclass is small and focused.

Heavy Attack.png
​
  • Animation Graph & Locomotion​
    • Locomotion and airborne states (Idle, Walk/Run, Jump, DoubleJump) live in the Katana anim layer, driven by bIsFalling, bDoubleJump, and speed from NativeUpdateAnimation. When a soft target is active, movement switches to controller-rotation yaw and blends through BS_DirectionalWalk for 8-directional strafing.​

Screenshot 2026-03-02 004130.png
Screenshot 2026-03-02 004257.png
Screenshot 2026-03-02 004228.png
​​
  • ​Enemy AI — Behavior Tree​
    • All enemies share one BT_MeleeEnemy tree. BTS_UpdateBehavior runs every 0.2–0.4s and sets a Blackboard state enum based on distance — Chase, Strafe, or Attack. Thresholds are set per enemy in C++, so the tree has no hardcoded values. BTT_Attack stays InProgress until the montage ends, so the tree can't interrupt mid-swing.​

​
  • Interface system​
    • IDMC_CombatInterface is the contract every combatant implements. When I added a ranged enemy, I didn't touch a single notify — it just overrode the relevant methods and left the rest as no-ops. Kept the animation layer completely decoupled from gameplay classes.​

  • Data-driven design​
    • All combat data lives in DMC_ComboDataAsset: montage references, special attack flags, damage multipliers, rage settings, hit reactions. No hardcoded values in code. Tweaking feel or adding a new combo was editor-only, no recompile needed.​

​

Technical Challenges
  • Combo chaining and mixed inputs: My first attempt used a single index, which broke the moment I added mixed LMB/RMB combos — I had no way to know what came before. Splitting into three indices (LightIndex, HeavyIndex, ExtenderIndex) and treating mixed combos as two phases fixed the logic. Resetting was the other headache — switching attack types mid-chain would resume from the wrong position. Calling the appropriate reset at the start of each opposite input, and firing Notify_ResetState at montage end, sorted it out.

  • Too many states, too many edge cases: With attacking, dodging, parrying, jumping, finisher, and rage all running at the same time, I kept getting bugs like attacking mid-air or chaining into a finisher during a dodge. The checks were scattered across every function. Centralizing everything into EDMC_PlayerState and checking it at the entry point of each action cleaned it up completely.

  • Player drifting past enemies in combos: Root motion from each montage would push the player forward slightly, and after a few hits they'd walked completely through the enemy. Locking movement felt too stiff. Calling SnapToTarget() at the start of every ExecuteAttack() re-locks yaw each hit, so the player naturally stays in front of the enemy through the whole combo.

​

What I Learned

State management is the backbone of any action game — I learned that the hard way. Once EDMC_PlayerState was centralized, most of my edge case bugs just disappeared. The component split also made debugging significantly faster; I always knew exactly where to look. And the interface pattern was something I'll carry into every project — writing a system once and having it work everywhere is genuinely satisfying.

Screenshot 2026-03-02 004342.png
bottom of page