🎬 Paired Animation System - Complete Manual v1.4

🌟 What's New in v1.4 Professional

Major update — AI, Cinematic tools, and much more!

🤖 AI Behavior Tree

Full BT integration! AI can execute paired animations with task nodes and decorators.

🎬 Sequencer Tracks

Use paired animations in Level Sequences for cinematics and cutscenes!

🔗 Chain Animations

Create combo systems with auto-chaining sequences.

🎯 Smart Targeting

8 target modes including health-based, threat-based, and custom!

💥 QTE System

Interactive events with branching animations.

🌍 Environment

Wall slams, prop interaction, context-sensitive kills!

📦 Installation

Get the plugin running in your project.

v1.4 is 100% backward compatible. If you're upgrading from v1.3, your existing animations will work without changes.

Copy plugin to your project

Extract the PairedAnimationSystem_UE5_6 folder into your project's Plugins/ folder. If the Plugins folder doesn't exist, create it next to your .uproject file.

YourProject/
├── Content/
├── Plugins/
│   └── PairedAnimationSystem_UE5_6/    ← put it here
│       ├── Source/
│       ├── Resources/
│       └── PairedAnimationSystem.uplugin
└── YourProject.uproject

Enable GameplayAbilities in your .uproject

Open your .uproject file in a text editor and add:

{
  "Plugins": [
    { "Name": "GameplayAbilities", "Enabled": true }
  ]
}

If you're using a Blueprint-only project and don't plan to use GAS, this step is still needed because the plugin depends on it internally. Just add it and forget about it.

Regenerate project files (C++ projects only)

Right-click your .uproject file → Generate Visual Studio project files, then open and compile.

Blueprint-only projects can skip this — just open the editor and let it compile automatically.

Verify in Editor

Open Unreal Editor → Edit → Plugins → search "Paired Animation" → make sure the checkbox is ✅ enabled. Restart the editor if prompted.

🚀 Quick Start — Your First Paired Animation

Step-by-step, from zero to a working paired animation in Blueprints. No C++ or GAS knowledge needed.

This tutorial assumes you have a project with at least 2 characters in a level (for example your player + an enemy). You also need at least 2 animation assets (any animations will work for testing).

Add PairedAnimationComponent to BOTH characters

Open your Player Character Blueprint:

Click Add Component (green button, top left)
Search for Paired Animation Component
Click to add it
In the Details panel, make sure Can Initiate Paired Animations = ✅ True

Now do the same for your Enemy Character Blueprint:

Add Paired Animation Component
Make sure Can Receive Paired Animations = ✅ True

A character can have BOTH "Can Initiate" and "Can Receive" enabled — for example if players can execute each other in PvP.

Create your Animation Montages

You need 2 Animation Montages — one for the attacker, one for the victim.

If you already have montages — skip to step 3.

If you only have animation assets (clips) — create montages from them:

In Content Browser, find your animation asset
Right-click on it → Create → Create AnimMontage
Name it clearly, for example: AM_Execution_Attacker
Repeat for the second animation: AM_Execution_Victim

An Animation Montage is a special wrapper around an animation that allows it to be played on demand from code or Blueprints. The plugin uses montages (not raw animation clips) because they support blending, notifies, and sections.

Don't have animations yet? For testing, you can use the same animation for both — e.g. the Mannequin idle animation. Once it works, swap in real animations later.

Create a PairedAnimationData asset

This is the main asset that tells the plugin which animations to play and how.

In Content Browser → Right-click → Miscellaneous → Data Asset
In the popup, pick PairedAnimationData from the list
Name it: DA_Execution_Sword (or any name you like)
Double-click to open it

Fill in these settings:

Setting	Value	What it does
`Animation Tag`	`Execution.Sword`	A unique tag to identify this animation
`Display Name`	"Sword Execution"	Human-readable name (optional)
`Duration`	2.5	How long the animation lasts in seconds

In the Actor Animations array, add 2 entries:

Entry	Role	Anim Montage
Entry 0	Initiator (Attacker)	`AM_Execution_Attacker`
Entry 1	Receiver (Victim)	`AM_Execution_Victim`

Positioning settings:

Setting	Recommended Value
`Positioning Mode`	Face To Face
`Actor Distance`	100
`Instant Snap`	✅ True

Add input to trigger the animation

Open your Player Character Blueprint → Event Graph. We'll use a simple keyboard key to trigger it.

// Press F near an enemy → play execution animation

Keyboard Event F ───→ SphereTraceByChannel
    Start: GetActorLocation
    End: GetActorLocation + (GetActorForwardVector × 300)
    Radius: 50

   ↓ (Hit?)

Branch ── True ──→ Break Hit Result → Hit Actor

   ↓

Get Paired Animation Component (from Self)

   ↓

Start Paired Animation With Data
    Anim Data: DA_Execution_Sword
    Target: Hit Actor

See Section 5: Adding Input & Triggering for a more detailed breakdown of this Blueprint, including Enhanced Input setup.

Test it!

Place your player and an enemy in the level
Press Play
Walk up to the enemy and press F
Both characters should snap into position and play the animation! ✅

That's it! The plugin automatically handles: positioning both characters, playing both animations in sync, blocking input during the animation, and cleaning up when done. All you need to provide is: (1) animation montages, (2) a Data Asset referencing them, and (3) an input event that calls StartPairedAnimationWithData.

🎞️ Preparing Animation Montages

Everything you need to know about setting up your montages for paired animations.

What is an Animation Montage?

An Animation Montage is an Unreal asset that wraps an animation so it can be played on demand. The Paired Animation System uses montages (not raw animation clips) because they support blending, notifies, sections, and runtime control.

Creating a Montage from an Animation

Find your animation in Content Browser

This can be any animation — an imported FBX, a Mixamo animation, a Marketplace animation, or a retargeted animation.

Create the Montage

Right-click on the animation asset → Create → Create AnimMontage

This creates a new montage asset next to your animation. Rename it with a clear prefix, e.g.:

AM_Execution_Sword_Attacker
AM_Execution_Sword_Victim
AM_Takedown_Front_Attacker
AM_Takedown_Front_Victim

Check the Skeleton

Open the montage and verify it's assigned to the correct Skeleton. Both montages must be compatible with the characters that will use them.

If your attacker and victim use different skeletons, that's fine! Each character plays its own montage on its own skeleton. They just need to be synchronized in time.

Tips for Good Paired Animations

Tip	Why
Make both animations the same length	They play simultaneously — different lengths cause desync
Animate both characters at origin (0,0,0)	The plugin handles positioning — don't bake world offsets into animations
Match the contact frames	If the sword hits at frame 30 in the attacker anim, the victim should react at frame 30 too
Use Root Motion if available	The Data Asset has a `bUseRootMotion` option per actor
Set the Duration in the Data Asset to match your montage length	This ensures proper cleanup timing

Adding AnimNotifies (optional but recommended)

Open the attacker's montage and add notifies for damage, effects, and sounds:

Notify Type	Where to Add	What it Does
`AnimNotify_PairedDamage`	At the impact frame	Applies damage to the receiver
`AnimNotify_PairedEffect`	At impact or any frame	Spawns particles / plays sound
`AnimNotifyState_PairedCamera`	Drag across entire animation	Camera control during animation

To add them: open your montage → right-click on the timeline → Add Notify → search for "Paired".

See Section 19: AnimNotifies for detailed configuration of each notify type.

🎮 Adding Input & Triggering Animations

How to trigger a paired animation from player input. No GAS required!

The plugin provides the system (sync, positioning, playback, cleanup). You provide the trigger (when should the animation start). This section shows you exactly how to wire that up.

Method A: Simple Keyboard Key (fastest to set up)

Open your Player Character Blueprint → Event Graph:

Add a keyboard event

Right-click in Event Graph → search for the key you want (e.g. F) → select "F" keyboard event. The "Pressed" output is your trigger.

Find a target

You need a reference to the enemy actor. The simplest method:

SphereTraceByChannel
  Start: GetActorLocation
  End: GetActorLocation + (GetActorForwardVector × 300)
  Radius: 50
  Channel: Visibility

↓

Branch (Return Value = hit?)
  True → Break Hit Result → Hit Actor → this is your target!

See Section 6: Finding a Target for all 3 methods in detail.

Call StartPairedAnimationWithData

Drag from Self → search Get Paired Animation Component. Then from the component pin, call Start Paired Animation With Data:

Get Paired Animation Component (from Self)

↓

Start Paired Animation With Data
Anim Data: DA_Execution_Sword (your data asset)
Target: Hit Actor (from the trace)

↓ Returns: Boolean (true = success, false = failed)

Complete Blueprint (copy this!)

Here is the full flow, start to finish:

Keyboard F (Pressed)
  → SphereTraceByChannel
    Start: GetActorLocation
    End: GetActorLocation + (Forward × 300)
    Radius: 50
  → Branch (hit?)
    True → Get Paired Animation Component (Self)
      → Start Paired Animation With Data
        Anim Data: DA_Execution_Sword
        Target: Hit Actor

Method B: Enhanced Input Action (recommended for production)

If your project uses Enhanced Input (UE5 default), here's how to set it up:

Create an Input Action asset

Content Browser → Right-click → Input → Input Action → name it IA_Execute

Open it → set Value Type to Digital (bool)

Add it to your Input Mapping Context

Open your Input Mapping Context (e.g. IMC_Default) → add a new mapping:

Input Action	Key
`IA_Execute`	F (or any key/button you want)

Use it in your Blueprint

In your Character Blueprint Event Graph, replace the keyboard event with:

EnhancedInputAction IA_Execute (Triggered)
→ ... same trace + StartPairedAnimationWithData as above

Method C: Using GAS Ability (for GAS projects)

If your project already uses Gameplay Ability System, see Section 9: GAS Integration. It lets you trigger paired animations as proper abilities with costs, cooldowns, and effects.

Alternative: Use the Blueprint Library (one-liner)

The plugin includes a Blueprint Function Library with shortcut functions. Instead of getting the component first, you can call a static function directly:

Start Paired Animation Between
  Initiator: Self
  Target: Hit Actor
  Anim Data: DA_Execution_Sword

This does the same thing but in one node — it finds the component internally.

🎯 Finding a Target — 3 Methods

Before you can trigger a paired animation, you need a reference to the other actor (the "target"). Here are 3 ways to get one.

Method 1: Line Trace / Sphere Trace (most common)

Fires a ray from your character forward and checks if it hits an enemy. Best for melee executions where the player is looking at the target.

SphereTraceByChannel
  Start: GetActorLocation
  End: GetActorLocation + (GetActorForwardVector × 300)
  Radius: 50 (wider = more forgiving aim)
  Channel: Visibility

↓ Branch on Return Value
True → Break Hit Result → Hit Actor = your target

Use SphereTrace instead of LineTrace for a wider detection area — the player doesn't have to aim perfectly at the enemy.

Method 2: Find Best Paired Animation Target (built-in!)

The plugin has a built-in function that automatically finds the closest valid target with a PairedAnimationComponent within a search radius:

Find Best Paired Animation Target (from PairedAnimationLibrary)
  Initiator: Self
  Search Radius: 300
  Required Tags: (leave empty or add tags)
  Ignored Actors: (leave empty)

↓ Returns: Actor or null

This is the easiest method — it automatically checks distance, tags, and whether the target has a PairedAnimationComponent. Just check if the result Is Valid before calling StartPairedAnimation.

Method 3: Sphere Overlap (area scan)

Checks for all actors in a sphere around the player, then picks the best one. Best for large-area executions or when the player doesn't need to aim.

SphereOverlapActors
Position: GetActorLocation
Radius: 250

↓ For Each Loop → filter for actors with PairedAnimationComponent
↓ pick closest one → use as Target

Which method should I use?

Method	Best For	Difficulty
Find Best Paired Animation Target	Most cases — auto-finds closest valid target	⭐ Easiest
Sphere Trace	Melee executions where player aims at enemy	⭐⭐ Easy
Sphere Overlap	Area attacks, grab all nearby, custom scoring	⭐⭐⭐ Medium

📋 Data Asset Reference — PairedAnimationData

Complete reference of every field in the PairedAnimationData asset.

Identification

Field	Type	Description
`AnimationTag`	GameplayTag	Unique tag to identify this animation (e.g. `Execution.Sword`)
`DisplayName`	Text	Human-readable name (for UI / debugging)
`Description`	Text	Optional description

Animation Data (ActorAnimations array)

An array of FPairedActorAnimData — add one entry per actor (typically 2: Initiator + Receiver).

Field	Type	Description
`AnimMontage`	AnimMontage	The montage this actor plays
`Role`	Enum	Initiator (Attacker), Receiver (Victim), or Support (3rd Actor)
`LocationOffset`	Vector	Custom position offset (only used with Custom positioning mode)
`RotationOffset`	Rotator	Custom rotation offset
`bUseRootMotion`	Bool	Use root motion from the montage?
`TagsToApply`	GameplayTagContainer	Tags applied to this actor during the animation

Positioning

Field	Default	Description
`PositioningMode`	FaceToFace	Face To Face — actors face each other Behind — initiator behind receiver Side — side by side Custom — use LocationOffset from ActorAnimations
`ActorDistance`	100	Distance between actors in cm (100–200 typical for melee)
`bInstantSnap`	True	True = characters teleport into position. False = smooth interpolation.
`SnapSpeed`	10.0	Interpolation speed (only if InstantSnap = false)
`bSwapActorRoles`	False	Swap initiator/receiver positioning

Requirements

Field	Default	Description
`RequiredInitiatorTags`	Empty	Initiator must have these tags to start
`RequiredReceiverTags`	Empty	Receiver must have these tags
`MaxActivationDistance`	200	Max distance (cm) between actors to trigger
`RequiredFacingAngle`	45°	Max angle (degrees) from facing direction (0 = any angle, 180 = must face directly)

Effects

Field	Description
`CameraShake`	Camera shake class to play on initiator at start
`CameraShakeScale`	Intensity multiplier (0.0 — 1.0)
`ImpactEffect`	Niagara particle system at sync point
`StartSound`	Sound to play when animation starts

Gameplay

Field	Default	Description
`bMakeInvulnerable`	True	Both actors invulnerable during animation
`bDisableInput`	True	Disable player input during animation
`bCanBeInterrupted`	False	Can external systems cancel this animation

Chaining

Field	Description
`bAutoChainToNext`	Enable combo chaining
`NextAnimations`	Array of follow-up PairedAnimationData assets
`ChainWindow`	Time window (seconds) to chain after completion
`bRequireInputToChain`	Must player press input to chain? (false = auto)

Camera, Audio, QTE, Environment

See dedicated sections: Camera, Audio, QTE, Environment.

📘 Blueprint Function Reference

All Blueprint-callable functions from PairedAnimationComponent and PairedAnimationLibrary.

Starting & Stopping Animations

Function	Description
`Start Paired Animation With Data`	Start animation using a Data Asset reference + Target actor. Returns bool.
`Start Paired Animation`	Start animation using a Gameplay Tag + Target actor. Looks up Data Asset via Subsystem.
`Stop Paired Animation`	Stop current animation. Optional `bInterrupted` flag.
`Start Paired Animation Between` ⭐	Library shortcut — one node, pass Initiator + Target + Data Asset. Finds component internally.
`Start Paired Animation By Tag` ⭐	Library shortcut — same but with Gameplay Tag instead of Data Asset.

Checking State

Function	Returns	Description
`Is In Paired Animation`	Bool	True if in ANY state (positioning, playing, finishing)
`Is Playing Paired Animation`	Bool	True only during actual playback (not positioning)
`Get Current Partner`	Actor	Returns the other actor, or null if not animating
`Can Start Paired Animation`	Bool	Check if animation can start (distance, tags, state)
`Can Start Paired Animation Between` ⭐	Bool	Library shortcut — validates two actors + data

Finding Targets

Function	Returns	Description
`Find Best Paired Animation Target` ⭐	Actor	Auto-find closest valid target within radius. Filters by tags.
`Find All Paired Animation Targets` ⭐	Array<Actor>	Get ALL valid targets in radius.
`Are Actors In Range And Facing` ⭐	Bool	Check distance + facing angle between two actors.
`Get Distance Between Actors` ⭐	Float	Simple distance check.
`Get Angle To Target` ⭐	Float	Angle (degrees) from actor's forward to target.

⭐ = From PairedAnimationLibrary (static functions — call from anywhere, no component reference needed)

Tag Helpers

Function	Description
`Has Tag`	Check if component has a specific Gameplay Tag
`Has All Tags`	Check if component has ALL specified tags
`Actor Has Tag` ⭐	Library version — pass actor directly
`Add Tag To Actor` ⭐	Add a tag to actor's PairedAnimationComponent at runtime
`Remove Tag From Actor` ⭐	Remove a tag at runtime

Events (bind in Blueprint)

Event	Parameters	When it fires
`On Paired Animation Started`	Initiator, Receiver, AnimData	Animation playback begins
`On Paired Animation Finished`	Initiator, Receiver, AnimData	Animation ends (completed or interrupted)
`On State Changed`	OldState, NewState	Any state transition (Idle → Positioning → Playing → Finishing → Idle)

⚡ GAS Integration

Trigger paired animations through Gameplay Ability System — with costs, cooldowns, and effects.

GAS is optional. If you don't use Gameplay Ability System, skip this section and trigger animations directly via Section 5.

Quick Setup

Create Ability Blueprint

Content Browser → Right-click → Blueprint Class → search for GA_PairedAnimation → Create. Name it GA_Execution_Sword.

Configure in Class Defaults

Setting	Value
`Animation Tag`	`Execution.Sword`
`Target Mode`	Auto Nearest (or Looking At for precision)
`Max Target Distance`	300

Grant ability to character

In your Character's BeginPlay: Ability System Component → Give Ability → pick GA_Execution_Sword.

Activate from input

Input Action → Try Activate Ability by Class
Ability Class: GA_Execution_Sword

Target Selection Modes (8 total)

Mode	Description
Manual	Target provided via TargetData (advanced)
Auto Nearest	Closest valid target within range
Auto Best Score	Scores by distance + angle, picks best
Looking At	Target inside cone in front of character
Lowest Health	Weakest target in range
Highest Health	Strongest target in range
Highest Threat	Most dangerous target in range
Random Valid	Random valid target in range
Custom	Override `CustomTargetSelection` in Blueprint

Gameplay Effects

Apply GAS effects automatically on start and on completion:

Field	Description
`Effects To Apply To Initiator`	E.g. GE_Invulnerable, GE_MovementLock
`Effects To Apply To Receiver`	E.g. GE_Stunned, GE_DefenseDown
`Effects On Completion`	E.g. GE_DamageBonus, GE_HealthRegen

Cost & Cooldown

Use standard GAS Cost/Cooldown GameplayEffects in the ability's Class Defaults — just like any other GAS ability.

The plugin works perfectly with Lyra — just add the component to Lyra characters and grant the ability in the hero data. See GAS_INTEGRATION.md in the plugin Documentation folder for the full Lyra guide.

🔗 Chain Animations

Create combo systems with auto-chaining sequences.

Set bAutoChainToNext = True in your Data Asset, then fill the NextAnimations array with follow-up Data Assets. The system will offer chaining within the ChainWindow time (default 0.5s after completion).

If bRequireInputToChain = True, the player must press the trigger key again within the window. If false, it auto-chains to the first available animation.

DA_Combo_Hit1  →  DA_Combo_Hit2  →  DA_Combo_Finisher
    Chain Window: 0.5s    Chain Window: 0.3s    (end)

🎯 Advanced Targeting

8 target selection modes via the GAS ability. See GAS Integration for the full list.

💥 QTE & Interactive Events

Quick Time Events with branching outcomes.

Add entries to the QTEEvents array in your Data Asset:

QTE Type	Description
Button Press	Single button press within time window
Button Mashing	Press button X times within window
Directional Input	Input a direction (WASD/stick)
Timing Challenge	Press at the exact right moment
Hold Button	Hold for duration

Each QTE can branch to a different animation on Success vs Fail, and apply different GameplayEffects. PerfectTimingMultiplier adds bonus damage for frame-perfect presses.

🌍 Environment Interaction

Wall slams, prop interaction, context-sensitive kills.

Set EnvironmentRequirement in your Data Asset to require specific environment conditions:

Mode	Description
Requires Wall	Must be near a wall (auto-detected)
Requires Prop	Specific actor class nearby (e.g. table, railing)
Requires Ledge	Near a ledge or edge
Requires Ground	Specific ground surface
Requires Water	In or near water

Use MaxEnvironmentDistance to control detection range. Set bSpawnPropIfMissing to auto-spawn a weapon or object for the animation.

📹 Advanced Camera

Multi-camera cuts, slow motion, and post-processing during animations.

Camera Cuts

Add entries to the CameraCuts array in your Data Asset. Each cut defines a camera position, FOV, and timing:

Field	Description
`StartTime`	When this cut starts (seconds into animation)
`Duration`	How long it lasts
`CameraTransform`	Position/rotation relative to initiator
`FOV`	Field of view (60–70 for dramatic, 90 for normal)
`BlendTime`	Transition time to this cut

Slow Motion

Set bUseSlowMotion = True → configure SlowMotionSpeed (0.3 = 30% speed), SlowMotionStartTime, and SlowMotionDuration.

AnimNotifyState (simpler method)

Alternatively, add AnimNotifyState_PairedCamera to your attacker's montage for basic camera control. See Section 19.

The player always has full mouse control during paired animations. The camera system never blocks player input.

🔊 Enhanced Audio

Dialogue, effort sounds, impacts, and ambient audio.

Field	Description
`InitiatorDialogue`	Array of dialogue sounds for the attacker
`ReceiverDialogue`	Array of dialogue sounds for the victim
`EffortSounds`	Timed audio events — grunts, screams at specific times
`ImpactSounds`	Array of hit/impact sounds
`AmbientSound`	Looping sound during animation
`bRandomizeAudioSelection`	Randomly pick from arrays for variety
`AudioAttenuation`	Sound attenuation settings for 3D audio

💪 Gameplay Effects

Buffs, debuffs, status effects, and rewards.

Field	Description
`StatusEffectsOnHit`	GAS effects applied on damage notify
`InitiatorBuffs`	Buffs for the attacker during animation
`ReceiverDebuffs`	Debuffs for the victim during animation
`ResourceDrainEffect`	Drain stamina/mana from initiator
`ResourceGainEffect`	Reward resources to initiator
`XPReward`	XP awarded on completion
`CurrencyReward`	Currency awarded on completion

🤖 AI Behavior Tree Integration

AI can execute paired animations directly from Behavior Trees!

Available Nodes

BTTask_ExecutePairedAnimation

Behavior Tree task that executes a paired animation.

Setting	Description	Default
`Animation Tag`	Which animation to play	None
`Animation Data`	Direct data asset reference	None
`Target Key`	Blackboard key for target	Empty (auto-find)
`Auto Target Search Distance`	Search radius if no key	300cm
`Required Target Tags`	Target must have these	Empty
`Forbidden Target Tags`	Target must NOT have these	Empty
`Wait For Completion`	Task waits for anim finish?	True

BTDecorator_CanExecutePairedAnimation

Condition decorator — checks if AI can execute a paired animation before entering the branch.

Example: AI Takedown

Behavior Tree:
Root
└── Selector
    ├── Sequence [Try Takedown]
    │   ├── Decorator: Can Execute Paired Animation?
    │   │     Animation Tag: Ability.Combat.Takedown
    │   │     Search Distance: 200cm
    │   ├── Decorator: Enemy HP < 30%
    │   └── Task: Execute Paired Animation
    │         Animation Tag: Ability.Combat.Takedown
    │         Wait For Completion: True
    │
    └── Task: Normal Attack (fallback)

Step-by-Step Setup

Make sure AI character has PairedAnimationComponent

Same as player setup — add the component and enable Can Initiate Paired Animations.

Open your AI's Behavior Tree

Add Decorator: right-click → Add Decorator → search "Can Execute Paired Animation"

Add the Task

Add Task → search "Execute Paired Animation". Set the Animation Tag. Leave Target Key empty for auto-find.

Test!

Place AI and a target in the level. The AI should approach and execute the animation automatically.

🎬 Sequencer Integration

Use paired animations in Level Sequences for cinematics and cutscenes.

Setup

Create Level Sequence

Content Browser → Right-click → Cinematics → Level Sequence. Add both actors to the Sequencer.

Add Paired Animation Track

On the initiator's track → "+ Track" → search "Paired Animation".

Add & configure section

Right-click on track → Add Section. Set the Animation Tag, Target Binding, and Blend In/Out Time.

Example Timeline: Boss Intro

0s-2s:   Boss enters room (idle animation)
2s-4s:   [PAIRED ANIMATION] Boss grabs player
4s-6s:   Close-up of boss face (camera track)
6s-8s:   Boss dialogue
8s:      Gameplay resumes

Some features don't work in Sequencer: camera cuts from Data Asset (use Sequencer cameras), slow motion (use Sequencer time dilation), QTE events (gameplay only). Audio, VFX, and damage still work.

🔔 AnimNotifies — Damage & Effects

Add damage, particles, and sounds at exact frames in your montages.

AnimNotify_PairedDamage

Applies damage to the receiver at a specific frame.

How to add: Open attacker's montage → right-click timeline → Add Notify → search "Paired Damage".

Setting	Description
`Damage Amount`	How much damage to apply
`Damage Type`	Your damage type class (optional)

Place the notify at the exact frame where the weapon makes contact — e.g. the sword swing hits at frame 30, put the notify there.

AnimNotify_PairedEffect

Spawns particles and plays sounds at specific frames.

Setting	Description
`Effect Target`	Spawn on Initiator or Receiver?
`Particle System`	Niagara or Cascade particle effect
`Sound`	Sound to play
`Attach to Socket`	Optional socket name (e.g. "hand_r")

AnimNotifyState_PairedCamera

Camera control during the animation. Drag it to cover a range of frames (it's a notify state, not a single-frame notify).

Setting	Description
`bOverrideFOV`	False = normal camera. True = custom FOV.
`CustomFOV`	50–70 for dramatic zoom, 90 for normal
`FOVTransitionSpeed`	How fast to blend to custom FOV

📢 Events & Callbacks

React to paired animation lifecycle in your game logic.

Binding Events in Blueprint

Select the PairedAnimationComponent on your character → scroll to Events in Details panel → click the + next to:

Event	When it fires	Use case
`On Paired Animation Started`	Animation begins playing	Play sound, show UI, start slow-mo
`On Paired Animation Finished`	Animation ends	Award XP, spawn loot, update counters
`On State Changed`	Any state transition	Update UI, trigger effects per-phase

Animation States

State	Description
Idle	Not in any paired animation
Positioning	Characters are moving into position
Playing	Montages are playing
Finishing	Animation ending, cleanup in progress

🌐 Multiplayer

Full replication is built-in. No extra setup needed.

The plugin automatically handles:

Server authority — animations validated on server
Multicast to all clients — everyone sees the animation
Synchronized playback — same timing everywhere
Spectator support — spectators see animations correctly

Just call StartPairedAnimationWithData from any client or the server — replication is automatic.

Make sure animation montages are identical on all clients. Different montage lengths will cause desync. Also ensure bReplicateAnimation = True in the Data Asset (it's True by default).

🔧 Troubleshooting

Common problems and solutions.

Animation Issues

❌ Animation doesn't play when I press the trigger key

Both characters have PairedAnimationComponent?
Attacker has Can Initiate Paired Animations = True?
Victim has Can Receive Paired Animations = True?
Data Asset has both montages configured (Initiator + Receiver)?
Characters are within MaxActivationDistance?
Are you actually hitting the target with your trace? Enable bShowDebugInfo on the component.
Is the target actor being passed correctly? Add a Print String after the trace to verify.

❌ StartPairedAnimationWithData returns False

Call Can Start Paired Animation first to check what fails
Enable bShowDebugInfo = True on the component — check Output Log for details
Verify the target has a PairedAnimationComponent
Check you're not already in a paired animation (Is In Paired Animation == True)

❌ Characters don't line up correctly

Check PositioningMode — try Face To Face first
Adjust ActorDistance (try 100–200)
Make sure animations were authored at origin (0,0,0)
Try bInstantSnap = True for reliable positioning

❌ Camera goes black during animation

Update to v1.2+ (this bug was fixed)
Check that your character has a valid Camera Component
Enable debug logging to diagnose

Setup Issues

❌ "Component not found" error

Make sure PairedAnimationComponent is added to the character Blueprint
Verify the character is properly spawned in the level (not just placed as a static mesh)
Check the component is not disabled

❌ Compilation errors after installing plugin

Delete Intermediate and Binaries folders from your project
Right-click .uproject → Generate Visual Studio project files
Rebuild project
Make sure GameplayAbilities plugin is enabled in .uproject

AI Issues

❌ BTTask not appearing in Behavior Tree

Recompile the plugin
Restart Unreal Editor
Check AIModule is in dependencies

❌ AI not finding targets

Increase Auto Target Search Distance
Check target has PairedAnimationComponent with Can Receive = True
Verify tag filters (Required / Forbidden)
Use BT debugger to see which node fails

Multiplayer Issues

❌ Animations are out of sync

Ensure montages are identical on all clients
Check bReplicateAnimation = True in Data Asset
Very high ping (200ms+) can cause minor desync

For all issues: enable bShowDebugInfo = True on the PairedAnimationComponent and check the Output Log — look for lines starting with 🎭 (component) or 📷 (camera).