Building a Multiplayer Combo System in Unreal Engine 5 (and Why I Abandoned Montage Sections)

One thing I wanted for my survival game was a simple fist-fighting system.

Not because melee combat will become the focus of the game — but because in an apocalypse… sometimes you may need to solve problems with your hands.

From the beginning, I wanted to keep the system extensible.

If one day I decide to add more punch variations or different fighting styles, I didn’t want to rebuild everything.

So I started with a DataAsset to define combo possibilities.

Image 1 — PDA_CombosAsset

My First Attempt (That Failed)

Initially, I tried creating a single animation montage containing the entire combo sequence.

The idea was to split the combo into Montage Sections and jump between them.

It sounded simple.

It wasn’t.

Very quickly I started running into questions:

• When should the next punch become available?
• How should combo timing be validated?
• How do I keep server and clients synchronized?
• How do I recover if timing is lost?

Maybe there’s a clean way to solve this with montage sections.

But for this project, complexity started growing faster than value.

So I changed direction.

The New Approach

Instead of one large montage, each combo step became an individual montage.

Now the combo system simply:

• Stores animation sequences in a DataAsset
• Advances an index on each valid punch
• Resets if the timing window is missed
• Replicates state changes to clients

That gave me a system that is easier to reason about and expand.

Image 2 — This is DA_PunchVariation_1 that appears on PDA_CombosAssets from image 1

Input Flow

When the player enters combat posture and presses attack:

void UPlayerCombatComponent::OnPunchAction(bool bIsStarting)

The client sends the request to the server.

void UPlayerCombatComponent::Server_Punch_Implementation(bool bIsStarting)

The server validates and executes the punch.

This keeps combat server authoritative.

Executing the Combo

Inside Punch():

• Combo index advances
• Current montage validity is checked
• Combo chain resets if timing is lost
• Stamina gets consumed
• Replication notifies clients

One small trick I ended up using:

PunchCounter++;

The punch counter is replicated:

UPROPERTY(ReplicatedUsing = OnRep_OnJabPerformed)
uint8 PunchCounter;

Whenever it changes:

void UPlayerCombatComponent::OnRep_OnJabPerformed()
{
    PlayJabAnim();
}

That became my trigger for synchronizing combo playback.

Playing Animations

This is probably the roughest part of the implementation.

Currently:

• Third-person mesh plays animations for other players
• First-person mesh plays separate local animations
• Stamina influences animation speed
• Cooldowns adjust dynamically

It’s not perfect.

But I think it’s currently in a reasonable place.

High level Architecture

One thing I’ve been trying to improve throughout the project is responsibility separation.

PlayerCharacter owns gameplay components.

Examples:

• CombatComponent
• StaminaComponent
• HealthComponent
• InventoryComponent
• HungerComponent
• ThirstComponent

This lets systems communicate without tightly coupling behavior.

For example:

Combat asks:

“Do we have enough stamina?”

Player forwards the request.

Stamina answers.

Simple.

No component needs to know internal implementation details.

That keeps changes isolated.

What I Learned

This system will probably evolve later.

There’s no prediction yet. There’s room to improve synchronization. There’s room to clean animation handling.

But for now:

It works.

And more importantly —

it supports the current goal:

making the core gameplay loop fun before adding complexity.

Thanks for reading.

I’m building this game alone, experimenting, learning, refactoring, and trying to stay focused on the foundations before opening the idea box.

See you in the next challenge.