I have started remaking Dragon's Dogma: Dark Arisen in Unreal Engine 5.8, written in C++. It is a hobby project with no deadline, and this devlog is where I write down everything as it happens: what works, what broke, and what I learned fixing it.

The plan is simple to say and long to do. First rebuild the game faithfully, then grow it: law and wanted levels, honor, bounties, swimming, sailing, mounts, taming, deeper AI, more skills and more bosses. Every phase has to end with something playable, not just more code.

What Exists After The First Sessions

  • A clean Unreal Engine 5.8 C++ project in Git with LFS, backed up to a private GitHub repository.
  • The Gameplay Ability System wired in, with health, stagnant health (the grey part of the bar that rest restores) and stamina attributes that replicate, because co-op is planned from day one.
  • The Arisen: camera, jogging, sprinting and Dragon's Dogma style stamina rules.
  • Fighter combat: a three hit light combo, heavy attack, charged heavy on hold, plus Blink Strike and Burst Strike on the skill button.
  • Damage, stagger, knockdown and death, tested against a training dummy.
  • A first HUD: health bar that turns red below a third, stamina, and a round minimap with a north marker.

Getting Stamina To Feel Like Dragon's Dogma

Stamina is one of the pillars of the original, so it had to feel right before anything else. The rules I settled on:

  • Below 25% stamina the Arisen slows to a tired jog.
  • At 0 you are exhausted and stop completely until stamina climbs back to 50%.
  • Basic light, heavy and charged attacks cost nothing and still work while exhausted.
  • Skills can be used with any stamina left. If a skill drains you to zero, exhaustion waits until the attack ends, so a dash like Blink Strike is never cancelled mid lunge.

That last rule is the one that took a fix. Here is the check as it runs now:

C++
// Running out during a skill doesn't interrupt it: exhaustion starts once the attack ends
// (otherwise the stop would cancel dashes like Blink Strike mid-lunge).
const bool bAttacking = AbilitySystemComponent->HasMatchingGameplayTag(DDGameplayTags::State_Attacking);

if (!bExhausted && Stamina <= 0.0f && !bAttacking)
{
	SetExhausted(true);
}
else if (bExhausted && Stamina >= MaxStamina * ExhaustionRecoveryFraction)
{
	SetExhausted(false);
}

SetLowStamina(Stamina < MaxStamina * LowStaminaFraction);

Movement speed then picks from a simple priority list, exhausted beats sprinting beats tired beats normal:

C++
float Speed = JogSpeed;
if (bExhausted)
{
	Speed = 0.0f;
}
else if (bSprinting)
{
	Speed = SprintSpeed;
}
else if (bLowStamina)
{
	Speed = TiredJogSpeed;
}

GetCharacterMovement()->MaxWalkSpeed = Speed;

Matching The Feel

The reference for all of this is the game itself. I have played Dragon's Dogma for thousands of hours, so most rules start as something I already know by feel and then get written down as a number that can be tuned: how low stamina has to be before the tired jog kicks in, how much has to come back before you can move again, how long a combo window stays open.

  • Write the rule down before writing the code. It is much easier to tune a number than to argue with a feeling.
  • Test every rule in play, not just in code. The exhaustion fix above only showed up once Blink Strike got cancelled mid lunge.
  • Keep the build playable after every change, even when a system is half done.

What Is Next

  • Test the combat inputs and animations in play.
  • Shield guard for the Fighter on Left Alt.
  • Lock on with the middle mouse button.
  • Enemy health bars above their heads.
  • Replacing the placeholder body with my own character model.

If you want to follow along, join the email list and I will send an update when there is something worth showing.