# Animation Integration

> Author combat timing on the animation for enemies and the player alike: one Animation Blueprint family, state tag windows mirrored into bools, frame events, effects each character answers, attacks that steer to their target and stop short of it, and a pose that holds on a hit.

Markdown version of https://rigbak.com/docs/universal-combat-framework/animation-integration, a page of the Universal Combat Framework documentation. Link that page when citing it.

> Timing that belongs to the animation, authored on the animation. Enemies and the player run one Animation Blueprint family and read the same montage windows: a window holds a gameplay tag while it runs, steers an attack, or asks the character for a footstep, and the rest of the game reads the result.

## Set it up (2 minutes)

1. **Put a state tag window on the dodge**

   Open the dodge montage, right-click a notify track, **Add Notify State**, **UCF State Tag Window**. Drag it across the frames the dodge should pass through blows, and put `UCF.State.Intangible` in **Tags**.

   In **AM_MyDodge**, under State Tags, set:

   | Property | Value |
   | --- | --- |
   | Tags | UCF.State.Intangible |

   *The track reads State Tag [UCF.State.Intangible], so the window says what it holds.*
2. **Check the Animation Blueprint**

   The demo's enemies and its player run the same Animation Blueprint, `ABP_UCF_MannequinBase`, built on **UCF Anim Instance Base**. For an Animation Blueprint of your own, open **Class Settings** and set **Parent Class** to **UCF Anim Instance Base**.
3. **Map the tag to a bool**

   Add a bool variable, `IsDodging`. In **Class Defaults**, add a row to **Gameplay Tag Property Map**, pick the tag in **Tag to Map** and the variable in **Property to Edit**.

   **Details panel: ABP_MyHero** (Blueprint, in Class Defaults)

   **Category: UCF > Gameplay Tags**

   | Property | Value |
   | --- | --- |
   | Gameplay Tag Property Map > Property Mappings | 1 Array element |
   | Gameplay Tag Property Map > Property Mappings > Index [0] > Tag to Map | UCF.State.Intangible |
   | Gameplay Tag Property Map > Property Mappings > Index [0] > Property to Edit | IsDodging |

   *Each row keeps one bool variable in step with one tag on the character, whatever put the tag there.*
4. **Press Play and dodge through a swing**

   The bool is true for the window and false after it, with no event graph nodes. A sweep crossing those frames lands nothing and keeps traveling, since an enemy's melee trace and the player's both pass through `UCF.State.Intangible` by default. The demo enemy's dodge, `AM_UCF_EnemyDodgeBack`, carries the same window.

> **Warning**
>
> The tags live on the character's ability system. **Enemy Character Base** and the UCF character base each create one; a pawn of your own needs one, or the window holds nothing and the bool stays false. Give the window a length too, since a window of no length opens and closes on the same frame.

---

## One Animation Blueprint family

`ABP_UCF_MannequinBase` animates the demo's enemy, `BP_UCF_EnemyCharacter`, the Blueprints built on it, and the player, `BP_UCF_Character`. It is built on **UCF Anim Instance Base**, holds a **UCF Hit Stop** node after its montage slot, and reads `UCF.State.PairedAction` and `UCF.State.Aiming`.

A weapon's idles and locomotion come from an animation layer the weapon brings, linked into that Blueprint through the layer interface `ALI_UCF_ItemAnimLayers`. The demo builds each layer as a child of `ABP_UCF_ItemAnimLayersBase`, which reads `UCF.State.Blocking` for a raised guard: `ABP_UCF_SwordAnimLayer` for the sword and the shield, `ABP_UCF_TwoHandedAnimLayer` for the two-handed baton, and `ABP_UCF_UnarmedAnimLayers` for bare hands.

An item names its layer in **Anim Layer Class** on its [Equippable fragment](https://rigbak.com/docs/universal-combat-framework/player/items#equippable-drawing-it). Drawing the item links the layer onto the character's mesh, and putting it away unlinks it, in an enemy's hand and the player's alike: `Item_UCF_TwoHandedBaton` links `ABP_UCF_TwoHandedAnimLayer` on the demo player and on every demo enemy holding the baton.

Duplicating a demo layer is the quickest start for another weapon on a character whose Animation Blueprint is `ABP_UCF_MannequinBase` or a child of it. Any other Animation Blueprint needs a **Linked Anim Layer** node for each of the interface's layers to land in, as `ABP_UCF_MannequinBase` has.

### Tell the framework which mesh does what

Three component tags on a character's skeletal meshes say which mesh does what. A tag counts when it equals the name below or starts with it and a dot, so `UCF.Attachment.Body` counts as an attachment mesh.

| Tag | Marks a mesh that |
| --- | --- |
| `UCF.Montage` | Plays the character's montages. The main mesh plays them untagged; tag it anyway so item layers can fall back to it, and tag each extra mesh that should play them too. |
| `UCF.AnimLayer` | Takes the drawn item's animation layer. With no mesh tagged, the layer goes to the montage meshes. |
| `UCF.Attachment` | Holds drawn items. The full tag tells several attachment meshes apart, such as `UCF.Attachment.Body`. |

The **UCF Anim Manager** reads all three tags as the character is created, before anything draws an item. The UCF character base creates it as `AnimManagerComponent`, and `BP_UCF_Character` tags its mesh `UCF.Montage` and `UCF.Attachment.Body`, which is all a one-mesh character needs. Select a mesh, find **Component Tags** in its Details panel and add the tags there. A character that draws items needs the Anim Manager: without it, a draw warns once and names the component to add.

**Details panel: AnimManagerComponent** (component, in BP_UCF_Character)

**Category: UCF > Mesh Registry**

| Property | Value |
| --- | --- |
| Montage Mesh Tag Prefix | UCF.Montage |
| Anim Layer Mesh Tag Prefix | UCF.AnimLayer |
| Attachment Mesh Tag Prefix | UCF.Attachment |
| Default Attachment Tag | None |

**Category: UCF > Hit Stop**

| Property | Value |
| --- | --- |
| Hit Stop Enabled | true |

**Category: UCF > Anim > Debug**

| Property | Value |
| --- | --- |
| Debug Overlay Anim | false |

**Category: UCF > Designer Tools**

| Property | Value |
| --- | --- |
|  | buttons: Preview Mesh Discovery |

*Preview Mesh Discovery lists which meshes the tags would register, and in which roles, without registering anything.*

Press **Preview Mesh Discovery** to see which meshes the tags would register, and in which role, before pressing Play. A mesh added while the game runs, such as a mount or a swapped outfit part, joins through **Register Mesh**, where you tick its roles yourself and name its **Attachment Tag** when items should hang on it. Left at None, a mesh that carries a `UCF.Attachment` component tag keeps the slot that tag gives it, so removing the tag is how a mesh stops holding items. **Unregister Mesh** takes a mesh out again, and **Rediscover Meshes** scans the tags again.

**UCF Enemy Character Base** creates the Anim Manager as `AnimManagerComponent` and tags its body mesh `UCF.Montage` and `UCF.Attachment.Body` itself, so an enemy built on it draws its items onto its body with nothing set. An enemy built straight on **Enemy Character Base** carries no Anim Manager, so the tags change nothing on it until one is added; [Enemy Weapons](https://rigbak.com/docs/universal-combat-framework/enemy-weapons) lists what such an enemy needs.

---

## Hold a tag for part of an animation

**UCF State Tag Window** has one field: **Tags**, what the character holds while the window runs. Empty holds nothing.

Because the timing lives on the montage, retiming the animation moves the window with it. An interrupted montage releases its tags too, so a canceled dodge drops its i-frames rather than stranding them. Two windows holding the same tag keep it until the second one closes.

These tags are ready to hold, on an enemy or on the player. A tag means whatever the code reading it says, so author your own for anything else.

| Tag | Hold it over | Read by |
| --- | --- | --- |
| `UCF.State.Intangible` | The i-frames of a dodge or a roll. | A melee trace, which passes through the character. |
| `UCF.State.HyperArmor` | A heavy swing that light hits must not cancel. | A Scale Damage response that lets less poise damage through, or a hit reaction that lists it in **Activation Blocked Tags**. See [Hit Reactions](https://rigbak.com/docs/universal-combat-framework/player/hit-reactions#hyper-armor). |
| `UCF.State.Parrying` | The active frames of a parry. | A defense rule or a reaction you gate on it. |
| `UCF.State.Blocking` | A raised guard. | The demo's item layers, which map it to a bool, and a **UCF Speed Modifier** row for the slow walk a guard costs. |
| `UCF.State.Dodging` | The whole roll. | A **UCF Speed Modifier** row, [below](https://rigbak.com/docs/universal-combat-framework/animation-integration#scale-movement-speed-while-a-tag-is-held). |
| `UCF.State.Staggered` | The reaction montage after a hit lands. | An enemy action or a player transition you gate on it. |
| `UCF.State.Recovering` | The recovery after an attack. | An enemy action's **Requires Tags** and **Block Tags**, or a player transition you gate on it. |

In the demo, `AM_UCF_Sword_Parry` holds Parrying from 0.025 to 0.269 seconds, and `AM_UCF_Unarmed_Combo` holds HyperArmor over the swing that keeps going. The enemies parry on a copy, `AM_UCF_Sword_EnemyParry`, whose Parrying runs to 0.53 seconds, since an enemy raises its parry as a swing is announced and the blow lands about 0.4 seconds later.

A **UCF Telegraph Window** holds tags the same way and also announces the attack to the enemies and players in its reach. Reach for it on an attack's windup; for a stretch nobody needs warning about, the state tag window is the smaller tool. See [Telegraphs](https://rigbak.com/docs/universal-combat-framework/telegraphs).

> **Note**
>
> For the attack itself to deal damage, the montage also needs a **UCF Melee Trace Window** over the swing frames. See [Melee Trace and Damage](https://rigbak.com/docs/universal-combat-framework/melee-trace-and-damage).

### Invulnerability frames

A window holding `UCF.State.Intangible` is the whole setup. A sweep reaching a target that holds it drops the contact: no damage, no impact effect, and the swing is not spent, so it carries on to whatever stands behind and can land on the same target once the window closes.

Nothing needs setting on the attacker: a melee trace ships with that tag in **Pass Through Tags**, on an enemy and on the player alike. For a hit that lands and takes nothing, such as a boss in an immune phase, hold `UCF.State.Invulnerable` instead and answer it with a **UCF Invulnerable** defense rule; see [Defense](https://rigbak.com/docs/universal-combat-framework/defense).

---

## Mirror a tag into an animation bool

**UCF Anim Instance Base** keeps a Blueprint bool in step with a gameplay tag. Add one row to **Gameplay Tag Property Map** per pair, then read the bool in a state machine, a blend or an animation layer. A tag from a montage window and a tag from a gameplay effect both drive it.

The Animation Blueprint finds the character's ability system on its own, an enemy's and the player's alike, including one that appears later, such as one on a Player State, which binds on the frame it reaches that machine. Call **Initialize with Ability System** only to point the map at an ability system the character does not carry. **Get Owned Tags** returns the character's tags as of this frame, safe to read from a thread-safe animation function.

---

## Fire a one-off signal from a frame

Some moments need no window and no state: a prop spawning, a camera cue, an interaction committing. Add **Notify**, **UCF Gameplay Event** at the frame and set **Event Tag**. An ability or a Blueprint waiting on that exact tag with **Wait Gameplay Event** hears it once; a listener that starts waiting after the frame hears nothing. The track shows the tag's last segment, so several events stay readable side by side.

The event names the character as both its instigator and its target, and carries the animation as **Optional Object**, so one handler serving several montages can tell them apart. A character with no ability system names itself once in the Output Log and nothing is sent.

The player's chest, door and pickup montages send `UCF.Event.Interaction.Commit` this way.

---

## Ask the character for its own effect

A footstep sounds different under a barefoot rogue and a plated knight. Two notifies ask the character, which answers with its own sounds and particles, so one animation serves both.

| Notify | Use it for |
| --- | --- |
| **UCF Anim Effect** | A single frame: a footstep, a landing, a grunt. |
| **UCF Anim Effect Window** | A stretch: a weapon trail, a charge glow, a slide. It opens on its first frame and closes on its last. |

Both carry **Effect Tags**, what the frame asks for, and **Socket Name**, where on the body it belongs; None puts it at the mesh's own position. The tags ship under `UCF.AnimEffect`: `Footstep` with `.Left`, `.Right` and `.Land`, `Land`, `Jump`, `Roll`, `Slide`, `Foley`, `Vocal`, `Whoosh`, `BodyFall`, `Weapon` with `.Draw`, `.Sheathe`, `.Hit`, `.Trail` and `.Glow`, `WeaponTrail`, and `Blood`. A handler asking for a parent tag catches the tags beneath it.

A character answers in one of two ways, or both:

- **A Blueprint handler.** Add the **UCF Anim Effect Handler** interface to the character or any of its components and implement **Handle Anim Effect**, **Handle Anim Effect Begin** and **Handle Anim Effect End**. Each handler on the character is asked once. The **UCF Equipment Manager** answers too, passing each request on to the items the character holds.
- **An Anim Effect Bank.** Each row names an **Effect Tag** and plays its **Sounds** and **Particles** at the socket. A request matches the deepest row it sits under, so one `Footstep` row covers every footstep until a `Footstep.Left` row is added beside it.

Create the asset: right-click in the Content Browser, choose **UCF > Presentation > Anim Effect Bank**, and name it **AnimEffectBank_MyHero**.

*Right-click in the Content Browser, UCF, Presentation, Anim Effect Bank.*

**Details panel: AnimEffectBank_MyHero** (data asset, in Content Browser)

**Category: Anim Effects**

| Property | Value |
| --- | --- |
| Rows | 1 Array element |
| Rows > UCF.AnimEffect.Footstep > Effect Tag | UCF.AnimEffect.Footstep |
| Rows > UCF.AnimEffect.Footstep > Sounds | 1 Array element |
| Rows > UCF.AnimEffect.Footstep > Sounds > Index [0] | SC_UCF_Footstep |
| Rows > UCF.AnimEffect.Footstep > Particles | 0 Array elements |
| Rows > UCF.AnimEffect.Footstep > Attach to Socket | true |
| Rows > UCF.AnimEffect.Footstep > Forward Axis | (1, 0, 0) |
| Rows > UCF.AnimEffect.Footstep > Volume Multiplier | 1 |
| Rows > UCF.AnimEffect.Footstep > Pitch Multiplier | 1 |
| Rows > UCF.AnimEffect.Footstep > Particle Scale | 1 |
| Surface Set | None |

*A Footstep row answers Footstep.Left, Footstep.Right and Footstep.Land alike, until a deeper row is added beside it.*

| Row setting | Does |
| --- | --- |
| **Attach to Socket** | Follow the socket as the body moves. Off leaves the effect where the frame fired, which dust on the ground wants. |
| **Forward Axis** | Which axis of the socket the particles face along: X faces the socket's forward; Y suits a bone whose Y axis points out of the body, as the mannequin spine's does. |
| **Volume Multiplier**, **Pitch Multiplier**, **Particle Scale** | Scale the sounds and particles. 1 plays them as authored. |

A bank plays through a **UCF Anim Effects** component. The UCF character base and **UCF Enemy Character Base** each create one as `AnimEffectComponent`, and the demo player and the demo enemies play `AnimEffectBank_UCF_Default`. Add the component to an enemy built straight on **Enemy Character Base** to give it a bank as well.

**Details panel: AnimEffectComponent** (component, in BP_MyHero)

**Category: Anim Effects**

| Property | Value |
| --- | --- |
| Bank | AnimEffectBank_MyHero |
| Surface Trace Channel | Visibility |
| Surface Trace Distance | 50 |

*With no bank the component plays nothing, and a Blueprint answering the effects itself keeps working beside it.*

| Component setting | Does |
| --- | --- |
| **Bank** | The character's own effects. |
| **Surface Trace Channel**, **Surface Trace Distance** | The ground trace under the socket, run only for an effect that has surface rows in a bank in use, so a footstep on a material mapped to `Stone` tries `Footstep.Stone` before `Footstep`. The channel starts at Visibility and the distance at 50 cm. |

**Add Bank** layers another bank on top at a **Priority**, for a wet-ground set while it rains or a costume with its own foley, and **Remove Bank** takes it off. A layer needs only the rows it changes; anything it lacks falls through to the layers below and the character's own bank. **Set Bank** replaces the character's own.

### Weapon trails: two tags

Two trail tags ship, one with each layer.

- `UCF.AnimEffect.Weapon.Trail` is what the demo's attack montages carry, such as `AM_UCF_TwoHanded_SingleAttack` and `AM_UCF_Sword_Combo`, the enemies' swings included. An item with a [Swing Trail fragment](https://rigbak.com/docs/universal-combat-framework/player/items#guard-swing-trail-and-camera) draws its ribbon while a window carrying it runs, whoever holds the item.
- `UCF.AnimEffect.WeaponTrail` is the enemy layer's tag. No demo montage carries it.

An item's Swing Trail fragment answers the tags its **Trail Tags** list; left empty, that list answers `UCF.AnimEffect.Weapon.Trail` alone. List both tags to have the trail run on montages carrying either.

---

## Steer an attack toward its target

An attack animated on the spot whiffs the moment its target steps aside. A **UCF Approach Window** over the wind-up turns the character toward what it is fighting and glides it into range, then stops a set distance short so the swing lands; a target already in range only turns it.

Add **Notify State**, **UCF Approach Window** across the wind-up, up to where the swing's **UCF Melee Trace Window** starts.

**Timeline: AM_MyAttack** (1.2 s long). Tracks:

- **Notifies**: UCF Approach Window (0.1 s to 0.45 s); UCF Melee Trace Window (0.45 s to 0.7 s)

*The approach window covers the wind-up, so the character arrives as the swing begins.*

The window steers at whatever the character's approach component stores under its **Approach Target Name**, `Target` by default. Both character bases create that component as `ApproachComponent`: **UCF Approach** on an enemy, and **UCF Attack Approach**, which builds on it, on the player. A character carries one approach component.

**Details panel: UCF Approach Window** (anim notify, in AM_UCF_TwoHanded_SingleAttack)

**Category: Approach**

| Property | Value |
| --- | --- |
| Move by Offset | false |
| Offset Direction | (-1, 0, 0) (greyed out) |
| Offset Distance | 50 (greyed out) |
| Approach Target Name | Target |
| Mode | Move and Face |
| Stop Distance Override | -1 (advanced) |
| Max Approach Distance Override | -1 (advanced) |
| Facing Interp Speed Override | -1 (advanced) |
| Facing Speed by Angle Override | None (advanced) |
| Override Speed Limit | false (advanced) |
| Speed Limit Override | Unlimited (advanced, greyed out) |
| Max Approach Speed Override | 600 (advanced, greyed out) |
| Override Block Movement Input | false (advanced) |
| Block Movement Input Override | false (advanced, greyed out) |
| Override Moving Target | false (advanced) |
| Moving Target Override | Lead (advanced, greyed out) |
| Lead Strength Override | -1 (advanced) |
| Time Mapping Curve Override | Curve_UCF_EaseInOut (advanced) |

*The two-handed attack's window, which eases its glide in and out, in an enemy's hand and the player's. Every override left at -1 or unset takes the stored target's value, then the matching Default on the character's approach component: UCF Approach on an enemy, UCF Attack Approach on the player, where Stop Distance Override falls to the drawn weapon's Attack Stop Distance first.*

**Mode** picks which half runs.

| Mode | What it does |
| --- | --- |
| **Move and Face** | Glides toward the target and turns to face it. The gap-close for an in-place attack. |
| **Face Only** | Turns to face without moving, for an attack that aims and stays put. |
| **Move Only** | Glides without turning, for a lunge that keeps the direction the animation gives it. |

**Move by Offset** replaces the target. Tick it and the window steps the character a set distance along a direction of its own: **Offset Direction** `(-1, 0, 0)` with **Offset Distance** 50 is a step straight back, whatever way the character faces. Nothing has to be stored for it, and the target fields gray out. It suits a hit reaction or a block that should knock the character back over the animation's own frames.

The distance and facing overrides on the window can be left at -1, which hands the choice to the stored target, then to the matching **Default** on the approach component: **Default Stop Distance** 150 cm, **Default Max Approach Distance** 750 cm, **Default Facing Interp Speed** 12. Past the max approach distance the window turns the character toward its target without closing on it. On the player, the combat style's **Approach** fragment writes those defaults, and a drawn weapon's **Attack Stop Distance** comes before **Default Stop Distance**.

> **Warning**
>
> **Speed Limit** on the approach component is **Unlimited**, so a window covers whatever distance separates the two in the span it was given, which can cross a room in a fraction of a second. Set it to **Character's Max Speed** for a gap-close that reads like running, or to **Fixed Speed** with a **Max Approach Speed** in cm/s.

### What stores the target

The window decides when the steering happens; something else stores what it steers at.

| On | What stores the target | Under |
| --- | --- | --- |
| An enemy, in an ability built on **Gameplay Ability Base** | The ability, as it activates: the enemy's focus target. | Its **Motion Warping Target Name**, `Target` to start. |
| An enemy, in an attack played from an action graph node | **UCF Enemy Attack Steering**, as the node starts: the enemy's focus target, or the target an **Action Graph Combo** with **Lock Target** holds. | Its **Approach Target Name**, `Target` to start. |
| The player, in an attack played from an action graph node | **UCF Attack Approach**, as the node starts: the target the Targeting component picked, or the lock. | Its **Approach Target Name**, `Target` to start. |
| Any character, from a Blueprint graph | **Set Approach Target to Actor** stores an actor, **Set Approach Target to Location** a spot, and **Set Approach Target** the whole struct with per-target distances; **Remove Approach Target** clears one. | The name you pass. |

A window whose name holds nothing plays the attack where the character stands. The window follows its name for as long as it runs: a target stored under it partway through takes over from where the character stands, and clearing the name stops the steering.

### Swings with root motion: the UCF Skew Warp

An attack whose animation already carries root motion travels on its own, and a window on it makes up only the distance it falls short by. **Motion Warping** bends the authored motion instead of adding to it, and on a character a player controls it is the better tool, since it predicts through the ability playing the montage. It needs a **Motion Warping** component on the character; `BP_UCF_EnemyCharacter` and `BP_UCF_Character` both carry one.

On the montage, add the engine's **Motion Warping** notify state across the stretch that travels, set its **Root Motion Modifier** to **UCF Skew Warp**, and set its **Warp Target Name** to the name the character writes:

- **An enemy's ability** writes `Target`, its **Motion Warping Target Name**, and places the warp target **Motion Warping Offset** (100 cm) from its focus, center to center.
- **The player's UCF Attack Approach** writes `UCFTarget`, its **Warp Target Name**. The sword combo, `AM_UCF_Sword_Combo`, warps on it.

The UCF Skew Warp keeps its goal between the character and the target, so the character lands facing what it attacks and holds there once it arrives. Its **Stop Distance Override** sets how far short of the target this window lands, between the two capsules; -1 lands where the warp target was placed, and under Keep Distance (below) keeps the stop distance in force. The engine's own Skew Warp turns the character right around once it is inside its stop distance, so use the UCF one for an attack. **Min Lead**, an advanced setting on the UCF Skew Warp, is deprecated: the goal stays on the standoff, so leave it at its default of 1.

The player's layer adds two more ways to close a gap, a step forward at nothing (**UCF Approach Or Move Window**) and a dash that lands in front of the target (**UCF Gap Closer Warp**); [Attack Steering](https://rigbak.com/docs/universal-combat-framework/player/attack-steering) covers both.

### Steering without a montage

The same steering runs from Blueprint with no montage or notify involved, for a chase, a scripted reposition, or a boss beat you drive yourself. Get the character's approach component and call:

- **Approach Actor**: turn the character toward an actor for a number of seconds, gliding it into range when the mode asks for it.
- **Approach Location**: turn it toward a spot and glide it there over a number of seconds. The spot is exact, so no stop distance comes off it.
- **Approach Offset**: move it a set distance along a direction of its own, for a step back or a sidestep with nothing to aim at. The direction is in the character's own space, and it defaults to Move Only so a knockback does not turn the character.

These start at once rather than waiting on an animation. Seconds is how long the glide takes as well as how long the call runs, so at or below zero the character turns without gliding and keeps turning until **Stop Approach** stops it.

### Keep Distance

An attack's own root motion, a warp or a glide can carry a character into the body it is hitting. **Keep Distance** on the approach component stops the attack short.

- **What counts as an attack.** A montage carrying a **UCF Melee Trace Window**, an Approach Window that steers at a stored target, or a **UCF Skew Warp** window, from that montage's start to its end. A dodge, a hit reaction or a stagger plays as authored.
- **The distance.** The **Stop Distance Override** of the approach window or UCF Skew Warp window playing at that moment, else the fallback stop distance below, measured between the two capsules. A window whose override is 0 lets that part of the attack reach contact.
- **What it holds back.** The animation's own root motion, a warp and a window's glide alike. A move toward the target from inside the distance is held where it is, not pushed back, and a move away or past the target's side goes through whole.

The two approach components start from different settings:

|  | **UCF Approach**, on an enemy | **UCF Attack Approach**, on the player |
| --- | --- | --- |
| Keep Distance | **Off** until set **On** in the class defaults. `BP_UCF_EnemyCharacter` has it on, and the demo Blueprints built on it inherit it. | **On**. |
| Stops short of | The actor the attack stored, as long as its capsule blocks the attacker's. | The attack's target, and any targetable enemy whose capsule the path would run into. With **Steering Mode** on **Off**, nothing. |
| Fallback stop distance | **Default Stop Distance**, whatever item the enemy holds. `BP_UCF_EnemyCharacter` sets 50 cm. | The drawn weapon's **Attack Stop Distance**, else **Default Stop Distance**. |

In **UCF Approach**, under UCF > Approach > Keep Distance, set:

| Property | Value |
| --- | --- |
| Keep Distance | On (replaces Off) |

*On an enemy Blueprint's class defaults. On holds an attack the stop distance short of its target; Off lets an attack travel as far as its motion carries it.*

---

## Hold the pose on a hit

A hit stop freezes what a player sees for a moment as a blow lands, so a heavy swing reads as heavy. Only the picture holds: the montage, its windows and the character's movement run on underneath, so nothing in the fight shifts.

A character holds when three things are in place:

1. **A UCF Anim Manager on the character.** The UCF character base and **UCF Enemy Character Base** each create one as `AnimManagerComponent`. **Enemy Character Base** creates none, so add one to an enemy built straight on it that should hold.
2. **A UCF Hit Stop node in the mesh's Animation Blueprint,** after the montage slot, with an **Inertialization** node after it to blend the pose back. `ABP_UCF_MannequinBase` has it.
3. **A UCF Hit Stop hit effect on the swing's damage config,** which asks for the hold when the swing lands. See [Melee Trace and Damage](https://rigbak.com/docs/universal-combat-framework/melee-trace-and-damage).

Blueprint graph, nodes in reading order:

- **Comment box: ABP_MyHero · AnimGraph**

  - **Slot 'DefaultSlot'** (anim; Group 'DefaultGroup'); inputs: Source
  - **UCF Hit Stop** (anim); inputs: Source
  - **Inertialization** (anim); inputs: Source
  - **Output Pose** (anim); inputs: Result

The node's two settings sit in its Details panel:

| Setting | Does |
| --- | --- |
| **Release Blend Time** | Seconds the held pose takes to blend back into the live one, 0.1 to start. A hold lengthens it by half the time held, up to twice this and at most **Max Hit Stop Seconds**. 0 snaps back. Needs the Inertialization node after it. |
| **Hold Placement** | Keep the held body where it stood while the character moves on, so root motion or a glide does not slide the frozen pose; it catches up as the hold releases. Turn it off on a mesh attached to the camera, such as first-person arms. |

**Hit Stop Enabled** on the Anim Manager turns holds off for that character alone. **Max Hit Stop Seconds**, in Project Settings, Plugins, Universal Combat Framework, caps a hold at 0.3 seconds to start, and 0 turns hit stop off for the whole project. A hold ends early when its montage ends or changes, the action graph moves on, the character enters or leaves a paired action, the body goes to ragdoll, or **Release Hit Stop** is called, which suits a death that plays no montage.

---

## Scale movement speed while a tag is held

A character holding full walk speed through a dodge slides out of its own animation. **UCF Speed Modifier** scales walk speed while a tag is held, so the slowdown begins and ends with the animation. Neither character base creates one.

1. Add **UCF Speed Modifier** to the character.
2. Add a row to **Speed Scale by Tag**: the tag, and the multiplier it applies. `UCF.State.Dodging` at `0.2` leaves a fifth of the normal speed, enough to steer a roll without walking out of it.
3. Put a **UCF State Tag Window** across the dodge frames with that same tag in **Tags**.

**Details panel: UCF Speed Modifier** (component, in Character)

**Category: UCF > Movement**

| Property | Value |
| --- | --- |
| Speed Scale by Tag | 1 Map element |
| Speed Scale by Tag > key UCF.State.Dodging | 0.2 |

*Scales walk speed while a tag sits on the character. Each entry pairs a tag with the multiplier it applies: a dodge at 0.2 keeps a fifth of the speed.*

Tags held at the same time multiply, so a 0.5 slow alongside a 0.2 dodge leaves a tenth of the speed. A parent tag in the table matches the tags beneath it, so one row covers a branch. A multiplier above 1 speeds the character up. With no tag held, the character walks at its own speed: the table scales the character's own **Max Walk Speed**, along with anything else that sets its walk speed, such as the player's sprint. `BP_UCF_Character` carries one with rows for `UCF.State.Staggered` and `UCF.State.Blocking`; [Sprint and Speed](https://rigbak.com/docs/universal-combat-framework/player/sprint-and-speed#how-speed-changes-stack) shows how its changes stack with the sprint's.

---

## One montage on several meshes

A character can show one montage on more than one mesh, such as first-person arms beside the body. Each notify on that montage then runs once per mesh, so on its own a trace window would sweep twice and a state tag window would add its tag twice.

Which mesh counts follows whether the character carries a **UCF Anim Manager**:

- **With one**, only the mesh the ability system plays montages on does the notifies' work. Action graph moves, equipment changes and paired actions also play their montage on the extra meshes tagged `UCF.Montage`, as a copy for show. Each notify the framework ships asks which mesh counts before its gameplay side: the state tag, melee trace, telegraph, gameplay event, anim effect, approach, action and equipment windows.
- **Without one**, as on an enemy built straight on **Enemy Character Base**, nothing plays the montage on a second mesh, and each mesh that plays one counts. Add an Anim Manager before playing such an enemy's montages on extra meshes.

A notify you write yourself for gameplay follows the same rule; see the C++ drawer.

---

## On an enemy: targets, warps and demo content

**Enemy Character Base** creates the ability system, the **UCF Approach** component as `ApproachComponent`, and on a dedicated server sets its mesh to **Always Tick Pose and Refresh Bones**. **UCF Enemy Character Base** adds the player layer's pieces: a **UCF Anim Manager**, so the enemy holds a hit stop and links its item's layer, and a **UCF Anim Effects** component for a bank. An enemy built straight on Enemy Character Base carries neither, so it holds no hit stop and answers effect notifies only from a handler or a component you add.

- **It walks with its locomotion.** **UCF Enemy Character Base** turns on **Use Acceleration For Paths** on its Character Movement. Path following otherwise moves a character with no acceleration, and an Animation Blueprint that reads acceleration, as `ABP_UCF_MannequinBase` does, holds its idle pose while the body slides along the path. On an enemy built straight on Enemy Character Base, tick it under **Nav Movement** on its Character Movement.
- **Its abilities store the target.** An ability built on **Gameplay Ability Base** stores the enemy's focus target under its **Motion Warping Target Name** as it activates, on the approach component for an Approach Window and on the **Motion Warping** component for a warp window, and clears it as the ability ends. **Lock AIRotation**, on by default, stops the controller aiming during the ability; while a window holds the facing, the controller stops writing the facing as well.
- **Motion Warping needs its component.** Enemy Character Base does not add one; `BP_UCF_EnemyCharacter` does. On a pawn without one, a montage's warp window does nothing, and an ability built on Gameplay Ability Base warns once per pawn class in the log. See [Motion warping](https://rigbak.com/docs/universal-combat-framework/enemy/action-system#motion-warping-steering-an-attack-toward-the-target).
- **Moves from an action graph aim at the AI's target.** **UCF Enemy Character Base** carries **UCF Enemy Attack Steering**, which stores the target its AI fights on the approach component as each move an [action graph](https://rigbak.com/docs/universal-combat-framework/action-graphs-in-action-sets) plays starts, under its **Approach Target Name** (`Target`), and clears it as the move ends. An Approach Window in the move turns the enemy toward that target and closes the distance, as in its ability attacks. An enemy on Enemy Character Base gets the same by adding the component; without it, an Approach Window steers at whatever its name already holds, and plays where the enemy stands when the name holds nothing. UCF Enemy Attack Steering writes no warp target, so a warp window on `UCFTarget` plays the montage's own motion on an enemy.
- **Demo content.** The enemies swing the player's montages: an enemy holding the baton plays `AM_UCF_TwoHanded_SingleAttack`, `_DoubleAttack` and `_TripleAttack`, and blocks with `AM_UCF_TwoHanded_Block`, the player's own, so the opening frames of its block parry and its hits drain the player's poise as a player's would. A montage of the enemy layer's own carries `Enemy` after the prefix where its name meets one of the player's, such as `AM_UCF_EnemyDodgeBack`.

> **Warning**
>
> A **UCF Skew Warp** window that names no **Stop Distance Override** keeps **Default Stop Distance** under Keep Distance, rather than landing where its warp target was placed. An enemy's ability places the warp target **Motion Warping Offset** from the target, center to center, so set **Default Stop Distance** to the gap that leaves between the two capsules, or give each UCF Skew Warp window its own override.

---

## On the player: steering, layers and effects

The UCF character base creates the ability system, the **UCF Anim Manager** (`AnimManagerComponent`), the **UCF Anim Effects** component (`AnimEffectComponent`) and **UCF Attack Approach** (`ApproachComponent`), so a character built on it holds hit stops, plays a bank's effects and steers its attacks with nothing added.

- **Attacks steer from the action graph.** UCF Attack Approach stores an attack's target as its node starts, under `Target` for an Approach Window and `UCFTarget` for a warp window. Its **Steering Mode**, set by the combat style, picks how attacks use the target, and its **Attack Facing** turns the body as an attack starts. [Attack Steering](https://rigbak.com/docs/universal-combat-framework/player/attack-steering) covers both, with the order the stop distance is chosen in.
- **Keep Distance is on**, and while attacks steer it keeps them off any targetable enemy in the path, the target included.
- **Layers follow the item driving combat.** A shield drawn beside a sword animates through the sword's layer, and takes over with its own once it drives. [Equipment](https://rigbak.com/docs/universal-combat-framework/player/equipment) covers which item drives.
- **Effects.** `BP_UCF_Character` gives its Anim Effects component `AnimEffectBank_UCF_Default`, and an item's Swing Trail fragment draws the swing trail.

---

## One animation family, both layers

Enemies and the player run one set of notifies on one Animation Blueprint family, so a window authored once means the same on either. Where they differ is in what feeds the windows.

- **One item serves both.** An enemy and the player hold the same items, so `Item_UCF_TwoHandedBaton`'s **Anim Layer Class**, `ABP_UCF_TwoHandedAnimLayer`, links into the same `ABP_UCF_MannequinBase` on either, and the baton plays the same montages in either hand.
- **One i-frame tag.** `UCF.State.Intangible` on the player's dodge makes an enemy's swing pass through, and on an enemy's dodge makes the player's swing pass through, since both melee traces carry it in **Pass Through Tags**.
- **One approach slot name, two warp names.** An Approach Window on `Target` steers on an enemy and on the player alike. A warp window has to name the side's own warp target: `Target` for an enemy's ability, `UCFTarget` for the player's UCF Attack Approach.
- **Two trail tags.** An item's Swing Trail fragment answers `UCF.AnimEffect.Weapon.Trail`, which the demo's attack montages carry; the enemy layer's `UCF.AnimEffect.WeaponTrail` reaches it only when its **Trail Tags** list it.
- **An enemy playing the player's montages.** Every demo enemy plays the player's montages, as ability attacks or, on `BP_UCF_ComboEnemy`, through its item's action graph. Their state tag and melee trace windows run on it as on the player, its item's Swing Trail fragment answers their trail windows, and its Anim Manager lets it hold a hit stop. Their Approach Windows steer at the target its AI fights, which its **UCF Enemy Attack Steering** stores in the `Target` slot as each move from a graph starts.
- **A hit stop holds where an Anim Manager is.** A hit stop that names both sides holds the player's pose and every demo enemy's, since each carries one; an enemy built straight on **Enemy Character Base** keeps moving until it gets one.

---

## Debug it

```
UCF.Debug.Approach 1            // What each approach window decides, and a block above each character
UCF.Debug.Steering.Draw 1       // Orange is an approach window, green is a motion warp
UCF.Debug.Warp 1                // What an enemy ability's motion warping reach check decides
UCF.Debug.Anim 1                // Above each character with an Anim Manager: its montage mesh, its layer mesh when that differs, and any hit stop
UCF.Debug.Melee.DrawTracing 1   // The sweeps a melee trace window runs
```

`ShowDebug AbilitySystem` lists the tags a character holds at that moment, which is how you check that a state tag window opened and closed. **Debug Overlay Approach** on an approach component and **Debug Overlay Anim** on an Anim Manager turn the same views on for that one character with no console. The approach view also logs what each window decides, and `Log LogUCFApproach Verbose` raises the rest of the approach log.

The steering draw shows the same arrangement for both systems, so its color tells which one moves the character: a line runs from the character to where the motion is taking it with a sphere at that spot, a ring around the target shows how far short the motion stops, and a silver line joins the goal to the target. White is the way the character points, magenta the way the motion wants it to point.

Animation logs under `LogUCFAnim` and warns once about each setup that cannot work:

| Warning says | Fix |
| --- | --- |
| ...takes anim layers but runs no Animation Blueprint... | Give the mesh an Animation Blueprint, or take the `UCF.AnimLayer` tag off it. |
| Hit stop on ... shows nothing: its Animation Blueprint ... has no UCF Hit Stop node... | Add the node after the montage slot, with an Inertialization node after it. A mesh copying its pose from another shows that mesh's hold already: register it with **Register Mesh** and **Include in Hit Stop** unticked. |
| ...plays a montage sending ... but has no Ability System Component to send it to... | Give the character an ability system, or take the UCF Gameplay Event off the montage. |
| Montage mesh ... ticks its pose only when rendered... | See the Multiplayer drawer below. |

<details>
<summary>Nothing happens (Advanced)</summary>

| Problem | Likely cause | Fix |
| --- | --- | --- |
| Tag does not appear | The pawn has no ability system, or **Tags** is empty on the notify | Add an ability system, or build on a character base; fill **Tags**. |
| Tag sticks after the montage | Animation Blueprint recompiled mid-window in Play In Editor | Restart Play In Editor. Unreal skips notify ends while reinstancing Blueprints. |
| Bool stays false | The variable is not mapped, or the row names another tag | Check the row in **Gameplay Tag Property Map**. |
| i-frames ignored on the server | **Trigger on Dedicated Server** cleared on the placed notify, or the mesh ticks its pose only when rendered | Re-enable the notify setting; set **Visibility Based Anim Tick Option** to **Always Tick Pose**. |
| Damage lands during i-frames | The window holds a tag the melee trace does not read | Use `UCF.State.Intangible`, or add your tag to the attacker's **Pass Through Tags**. |
| Nothing answers an effect notify | No handler on the character or its components, and no Anim Effects component with a bank | Add the **UCF Anim Effect Handler** interface, or a **UCF Anim Effects** component with a bank. |
| No trail on a swing | The weapon answers the other trail tag | Match the montage's tag, or list both in the Swing Trail fragment's **Trail Tags**. |
| Attack neither turns nor closes | Nothing stored under the window's **Approach Target Name**, or no approach component on the character | Store the target, from an enemy ability or with **Set Approach Target to Actor**. `UCF.Debug.Approach 1` names which one is missing. |
| An enemy's action graph attack plays in place | No action graph move stores a target on UCF Approach | Store one under the window's name from a Blueprint. |
| Attack steers at the wrong thing | The window's **Approach Target Name** and the name the ability or component writes disagree | Match the two. |
| A root motion attack runs past its target or spins around it | The warp window's modifier is the engine's Skew Warp, its **Warp Target Name** is not the side's own, or the character has no Motion Warping component | Pick **UCF Skew Warp**, name `Target` on an enemy or `UCFTarget` on the player, add the component. |
| Attack turns but stays put | The target is past **Max Approach Distance Override**, or already inside the stop distance | Raise the limit, or lower **Stop Distance Override**. |
| Attack crosses a large gap in a fraction of a second | **Speed Limit** is **Unlimited** | Set **Character's Max Speed**, or **Fixed Speed** with a **Max Approach Speed**. |
| An enemy's attack slides into the player | Keep Distance is Off on its UCF Approach | Set it **On** in the class defaults. |
| No hit stop on an enemy | The enemy carries no UCF Anim Manager | Add one. |
| The server sees the attack facing the wrong way | The montage plays from a Blueprint, so it does not play on the server | Play the attack through an ability, or play the montage on the server as well. |

</details>

<details>
<summary>The whole request: Begin Approach (Advanced)</summary>

**Begin Approach** takes a whole **UCF Approach Request**, for a move that needs a setting the three calls above leave out. **Window Duration** is how long it lasts in seconds, and 0 turns the character without gliding until **Stop Approach**.

Tick **Until Arrival** for a walk to a spot that lasts as long as it takes rather than a set time. It needs **Use Fixed Destination**, and walks the character onto **Fixed Destination** with its own movement, so it plays its walk. It ends **Completed** once the character stands within **Arrival Radius** and **Arrival Angle** of the spot, and **Unreachable** after **Give Up Seconds**, or after **Stall Seconds** without getting closer; either at 0 does not give up. **On Approach Ended** reports which.

**Montage**, **Window Start**, **Window End** and **Effective Rate** on the request are deprecated. Put a **UCF Approach Window** on the montage instead, or set **Window Duration** for a move with no montage behind it.

</details>

<details>
<summary>Chasing a target that keeps moving (Advanced)</summary>

**Moving Target** on the approach component decides where a glide aims while the target moves, and a window can override it per attack.

| Setting | Aims at |
| --- | --- |
| **Lead** | Where the target is heading. The default, and the smoothest against a target that keeps moving, since it covers a dodge without lurching. |
| **Chase** | Where the target stands at that moment. Follows each step, which bunches up whenever the target changes direction. |
| **Committed** | Where the target stood when the window opened. For an attack that commits, so a target that got out of the way is missed. |

**Lead Strength** is how much of the target's own motion a leading glide steers ahead of, from 0 for none to 1 for all of it (the default). Lower it to aim nearer where the target stands, so a target sprinting away is followed rather than cut off.

</details>

<details>
<summary>When the glide stays home (Advanced)</summary>

The turn runs whenever the window does. The glide is the part with conditions on it, and each one leaves the attack playing in place rather than sliding it somewhere wrong.

- The target sits past **Max Approach Distance Override**, so a swing thrown across the arena does not turn into a charge.
- The character is already inside the stop distance, measured between the two capsules rather than the two origins, so a wide character stops with room for its own body.
- A speed bound is in force and the target is further than it reaches in the window's span. The character approaches as far as it can and the attack lands short.
- The target is destroyed mid-window. The glide stops rather than traveling to the spot it left behind.
- The montage stops, blends out or is replaced. The window ends with it and hands the facing back.

A window glides across the ground and leaves height to gravity, so a taller target or one standing higher is closed on sideways; an attack that should leap is authored as root motion or warped.

**Time Mapping Curve Override** eases the travel: X is the window's time from 0 to 1, Y the fraction of the distance covered by then. Unset takes the curve on the stored target, then the approach component's **Default Time Mapping Curve**, and glides at a constant rate when none is set. The demo's two-handed attacks ease in and out with `Curve_UCF_EaseInOut`.

</details>

<details>
<summary>Who owns the character's facing (Advanced)</summary>

While the window runs, whatever else turns the character stands down, and gets its settings back when the window closes. Several things can hold the facing at once and release in any order, so a window inside a paired animation composes instead of fighting.

A second window opening on a character that is already being steered takes over, so the window that opened last is the one steering. A move already given a spot to land on is the exception: it keeps the character until it gets there.

**Acquire Facing Control** and **Release Facing Control** take the facing for anything else that needs it, and **On Facing Control Changed** fires on both. Bind it from code that writes the character's rotation settings, so it stands down for the window and re-resolves once the facing comes back. **Ease Facing Back** turns a body that follows the camera back to it over time once the last hold ends, at **Facing Hand Back Rate**.

</details>

<details>
<summary>Overlapping windows and restarts (Advanced)</summary>

Unreal treats one notify object on one mesh as a single window. A window that begins again with no end between, as a jump back to an earlier section can do, releases its earlier record before adding again, and a window ending twice removes its tags once. A window survives a mid-window change to the character's ability system, since the tags come off whichever one they went onto. A pose holds per mesh: a mesh registered with **Include in Hit Stop** off keeps moving through each hold.

</details>

<details>
<summary>Footsteps on a whole folder of animations (Advanced)</summary>

The **UCF Footsteps** animation modifier finds the frames each foot lands on and writes a **UCF Anim Effect** there: `Footstep.Left` at `foot_l` and `Footstep.Right` at `foot_r`, on a track named Footsteps that it rebuilds on each apply. Apply it from an animation's **Animation Data Modifiers** window. **Ground Tolerance** (3 cm) is how far above the lowest point a foot still counts as planted, and **Lift Height** (5 cm) how high it has to rise before its next landing counts. **Notifies to Remove** clears older footstep notifies first.

For a whole folder, type `UCF.AnimEffects.PlantFootsteps /Game/MyCharacter/Animations save` in the console. Leave off `save` to leave the animations unsaved for a Save All. A turn in place can miss one step, and a jump or fall clip can gain a false one.

</details>

<details>
<summary>Changing movement from your own Blueprint (Advanced)</summary>

**Add Speed Modifier** applies a multiplier under an id you pick and holds it until **Remove Speed Modifier** drops that id, for a slow that belongs to a projectile or a pickup rather than a montage. It needs no ability system. **Has Speed Modifier** reports what is held, **Clear Speed Modifiers** drops all ids and leaves the tag table alone, and **Set Speed Scale for Tag** and **Remove Speed Scale for Tag** edit the table while play runs. A negative or non-finite multiplier is refused wherever it enters.

The character's **UCF Movement Modifiers** hold the changes to its walk speed, acceleration, braking, ground friction, turn rate and turning flags; the speed modifier, the approach and the player's sprint go through them, so your changes combine with theirs. Call **Get Movement Modifiers** on the character, which adds the component the first time, then **Override Value**, **Scale Value** or **Override Flag** under a **Source** that stands for your change, and **Remove Modifiers** with the same Source when it ends. For an upgrade that raises the character's own walk speed, call **Set Base Value** with **Max Walk Speed**. A value written straight onto the **Character Movement Component** while something modifies it lasts only until the next change.

**Get Base Max Walk Speed** and **Set Base Max Walk Speed** on the speed modifier are deprecated and keep working; call **Set Base Value** on the Movement Modifiers instead.

A Blueprint child of the speed modifier can override **Combine Speed Scales** to stack the multipliers another way, and **Apply Speed Scale** to scale acceleration or turn rate as well. **On Speed Scale Changed** fires with the combined multiplier for a dust effect, a camera change or a HUD hint.

</details>

<details>
<summary>Windows, effects and holds in multiplayer (Multiplayer)</summary>

- **Windows run on each machine playing the montage**, the server included, and add their tags on that machine; nothing replicates. The server plays the montage too, so its own window is what its damage checks read, and a dodge's i-frames hold there.
- **On a dedicated server** a window runs while the mesh ticks its pose. A character's mesh does so by default (**Visibility Based Anim Tick Option** at **Always Tick Pose**); **Only Tick Pose when Rendered** stops it there, a montage with root motion aside, since a dedicated server draws nothing. **Enemy Character Base** sets **Always Tick Pose and Refresh Bones** on a dedicated server, which also keeps sockets read outside a swing where the animation puts them, and a **UCF Melee Trace Window** keeps the meshes it sweeps refreshing while it runs. The Anim Manager warns once about a montage mesh that ticks only when rendered. Keep **Trigger on Dedicated Server** ticked on each placed notify.
- **Effects** play on each machine that draws the character, and not on a dedicated server. An animation cut short mid-window can leave the close uncalled, so stop anything expensive on the character's own teardown as well.
- **Hit stop** holds on each machine for itself. A dedicated server holds nothing, and a listen server holds only the character its own player controls, since the server judges the other characters' hits from the pose it holds.
- **Item layers** link on each machine as the drawn item reaches it.
- **Walk speed** does not replicate, so each machine works it out from the tags it can see. A montage window adds its tag on each machine playing the montage, so a window-driven slow agrees everywhere; add any other driving tag through a gameplay effect, or **Add Loose Gameplay Tags** with **Should Replicate** ticked.

</details>

<details>
<summary>Which machines steer (Multiplayer)</summary>

The turn runs on the server and on a player's own machine, and does nothing on a copy of someone else's character, which receives the motion already resolved.

**The travel has one rule: play the montage on each machine that steers.** Each machine running the window works out its own glide toward the same target, and character movement settles the difference. An enemy's attack meets this on its own, since its montage plays on the server. A montage played on one machine alone is the failure case: that machine glides, the server does not, and the server hauls the character back each frame.

Prediction removes the tug a moving target causes, and prediction means an ability: the character carries an ability system, the ability's **Net Execution Policy** is **Local Predicted**, the montage plays through **Play Montage and Wait**, and section changes go through the ability's **Montage Jump to Section**. A player character gliding with no ability behind it names itself once in the Output Log.

An ability's graph runs on the server and on the player's own machine, so a target the ability stores steers both, and the server's answer is the one that lasts. **Replicate**, an advanced pin on **Set Approach Target**, **Set Approach Target to Actor** and **Set Approach Target to Location**, is deprecated and still has the server send the target to the player's own machine; leave it off and store the target from the ability.

</details>

<details>
<summary>Keep Distance on other machines (Multiplayer)</summary>

Keep Distance runs inside the movement update on the server, on a player's own machine and on the copies other machines show, and the server sends the copies the target while the attack plays, so against a target standing still the machines all stop the attacker in the same place. Against a target moving along the attack line, a watching player's machine runs ahead of the server's view of it, and the stops can differ by its speed over a round trip. Set Keep Distance in the class defaults: a change made at runtime on one machine reaches no other.

</details>

<details>
<summary>C++</summary>

- A gameplay notify of your own asks `UCFMontageWindow::IsGameplayMesh(MeshComp)` before its gameplay side and returns early when it answers false, as the framework's notifies do. The framework sets the rule at startup to `UUCFAnimManagerComponent::ShouldMeshRunMontageNotify`: a character with no Anim Manager counts each mesh, one with an Anim Manager only `GetGASAvatarMesh`. `UCFMontageWindow::SetGameplayMeshRule` replaces it, and an unbound function clears it.
- `UUCFAnimManagerComponent` holds the mesh registry, links item layers (`LinkAnimationLayer`, counted per class), runs hit stop (`HoldPose`) and plays a montage on the extra montage meshes (`MirrorMontagePlayAt`, which returns a ticket for `MirrorMontageStopFor`). `UUCFAnimInstanceBase` carries the tag to bool map.
- `IUCFAnimEffectHandler` is the interface effect requests reach. `FUCFAnimNode_HitStop` is the runtime node behind **UCF Hit Stop**; its editor node lives in an uncooked-only module, which a packaged game does not load.
- A subclass of `UUCFApproachComponent` answers `GetFallbackStopDistance` to stop at something other than **Default Stop Distance**, and `GatherKeepDistanceBodies` to keep an attack off other characters besides its target; `UUCFAttackApproachComponent` answers both, with the drawn weapon's reach and the Targeting component's candidates. `GetAttackStopDistance` reads the distance in force, and `UCFApproachMath::TravelBeforeReach` measures how far a move travels before it comes within reach of a point.
- A subclass of `UUCFApproachWindowNotifyState` answers `GetMoveWithoutTarget` to step the character a set distance when the window finds no target, as the UCF Approach Or Move Window does.

</details>

---

Previous page: [Telegraphs](https://rigbak.com/docs/universal-combat-framework/telegraphs). Next page: [Physical Reactions](https://rigbak.com/docs/universal-combat-framework/physical-reactions)
