Motion 2.0

Motion 2.0 is a full architectural rewrite of Motion for Unreal Engine 5.6, 5.7, and 5.8. It replaces the Motion-specific character inheritance stack from Motion 1.x with standard Unreal Engine character, movement, GAS, Enhanced Input, animation, and content workflows.

The result is a component-based first-person controller that can be added to your own characters, PlayerStates, AttributeSets, input bindings, animation blueprints, and first-person item systems.

Breaking release

Motion 2.0 is not an in-place upgrade from Motion 1.x.

Treat Motion 2.0 as a fresh integration: remove Motion 1.x classes and Blueprint components, add the Motion 2.0 components to your own character, wire your project GAS and input setup, and migrate tuning into component profile assets.

Highlights

• Unlike Motion 1.x, Motion 2.0 does not require AMotionCharacter, a Motion-specific movement component, a Motion-specific PlayerState, or a Motion-specific AbilitySystemComponent.
• Motion components work with any ACharacter-based pawn when the surrounding project supplies the expected Unreal Engine systems.
• GAS integration uses interface-first UAbilitySystemComponent discovery plus documented component lookup fallbacks.
• GAS is required for the supported Motion 2.0 component path; Motion does not provide a second CharacterMovement-only architecture.
• Motion 2.0 movement tuning lives in versioned component profile DataAssets.
• Walk, sprint, crouch, jump, breathing, camera, movement sound, animation, and first-person item visuals are implemented as C++ components and runtime systems.
• Multiplayer behavior has been rebuilt around server-owned state, local prediction, GameplayEffect-backed state, validation, and rate limiting.
• Motion 2.0 supports first-person held-item presentation through native item configs, carry postures, hand IK, linked animation layers, and an upper-body overlay animation node.

Breaking changes

Motion-specific base classes removed

Motion 2.0 replaces Motion 1.x's inheritance-first architecture. Projects should own their gameplay framework classes and add Motion as components.

Removed or replaced	Use in Motion 2.0
AMotionCharacter	Your own ACharacter subclass with Motion components added
UMotionCharacterMovementComponent	Standard UCharacterMovementComponent
UMotionAbilitySystemComponent	Standard UAbilitySystemComponent or your own subclass
AMotionPlayerController	Your own APlayerController
AMotionGameMode C++ class	Your own GameMode
AMotionPlayerState C++ class	Your own PlayerState implementing IAbilitySystemInterface
UMotionInputComponent / UMotionInputConfig	Project-owned Enhanced Input bindings
UMotionCurveManager	UMotionCameraComponent integrated curve evaluation
MotionComponentFunctionLibrary	Direct component APIs and supported helper APIs
MotionGameplayEffectData	Profile and GameplayEffect asset configuration

Motion 1.x Blueprint movement components such as BPC_BreathComponent, BPC_CrouchComponent, BPC_JumpComponent, BPC_MovementSoundComponent, BPC_SprintComponent, and BPC_WalkComponent are replaced by C++ components and profile-driven setup.

PlayerState and ASC discovery changed

Motion 1.x AMotionPlayerState is not part of Motion 2.0. Motion discovers the Ability System Component through IAbilitySystemInterface first, then supported actor and PlayerState component lookup fallbacks.

Projects should provide their own GAS-enabled PlayerState, implement IAbilitySystemInterface, and configure the project GameMode to use that PlayerState class.

Motion components use event-driven ASC initialization through APawn::ReceiveControllerChangedDelegate, with fallback retry timers for multiplayer cases where Controller or PlayerState replication is delayed.

Attribute discovery changed

Unlike Motion 1.x, Motion 2.0 does not require projects to use UMotionAttributeSet; the class is available as a reference implementation.

Motion discovers expected attributes by name. The Motion 2.0 movement contracts are:

Component	Expected attributes
UMotionWalkComponent	WalkSpeed
UMotionSprintingComponent	WalkSpeed, Stamina, MaxStamina, StaminaRegenRate, StaminaDrainRate

If an expected attribute is missing, the affected feature fails closed and reports the missing contract. Other correctly configured Motion features can continue to operate.

At runtime, Motion components seed UMotionAttributeSet on authority when it is absent. Projects that route movement through same-named attributes on another set must retarget the relevant GameplayEffects and provide equivalent CharacterMovementComponent synchronization.

Motion 1.x SprintSpeed is not part of the Motion 2.0 attribute surface. Sprinting uses the walk-speed contract, sprint effects, and component/profile configuration.

Input ownership changed

Motion 2.0 does not provide a shared Motion input-binding layer.

Bind input in your Character or PlayerController using Enhanced Input, then call the relevant Motion component input handlers directly.

Motion 1.x tag groups not included in Motion 2.0 are:

• Motion.Input.*
• Motion.Control.*
• Motion.Camera.DisableCollision

Define your own tags in DefaultGameplayTags.ini if your game needs equivalent tags.

Component tuning moved to profiles

Motion 2.0 walk, sprint, crouch, jump, breathing, movement sound, and camera defaults live in versioned component profile DataAssets.

Default Motion profiles ship under:

/MotionCore/Motion/Profiles/v2_0_0

Included defaults:

• DA_MotionWalkProfile_Default_v2_0_0
• DA_MotionSprintProfile_Default_v2_0_0
• DA_MotionCrouchProfile_Default_v2_0_0
• DA_MotionJumpProfile_Default_v2_0_0
• DA_MotionBreathingProfile_Default_v2_0_0
• DA_MotionMovementSoundProfile_Default_v2_0_0
• DA_MotionCameraProfile_Default_v2_0_0

Duplicate Motion profiles into your project content before customizing them.

Profiles expose the settings projects are expected to tune, while runtime-only state stays inside the components.

Camera curve API changed

Motion 1.x UMotionCurveManager is not part of Motion 2.0. UMotionCameraComponent owns camera curve registration, evaluation, and blending.

Motion 2.0 camera effects use UCurveVector assets instead of inline FRuntimeVectorCurve data, and curve identifiers use FName rather than FString.

Motion 1.x FStructMotionCurve is FMotionCurve in Motion 2.0.

Logging macro signature changed

Motion 2.0 MOTION_LOG requires the component as the first argument.

// Motion 1.x
MOTION_LOG(LogMotionSprinting, Log, TEXT("Sprint started"));

// Motion 2.0
MOTION_LOG(this, LogMotionSprinting, Log, TEXT("Sprint started"));

Motion 2.0 logging adds network-role and component context, and it compiles out in Shipping builds.

Movement sound configuration changed

UMotionMovementSoundComponent does not use the Motion 1.x sound arrays.

Motion 2.0 movement sound setup uses a required SurfaceSoundDataTable, FMotionSurfaceSoundDataRow rows, and MetaSound assets for variation handling. Motion 1.x SurfaceSounds, FMotionSurfaceSoundData, and DefaultSurfaceSound configuration are not supported.

A single footstep path routes walk, sprint, and crouch sounds based on movement state.

Major features

Universal component architecture

Motion 2.0 is built around component composition. Add the Motion components you need to your own ACharacter subclass instead of inheriting from a Motion character class.

Core runtime types include:

• UMotionComponentBase
• UMotionWalkComponent
• UMotionSprintingComponent
• UMotionCrouchingComponent
• UMotionJumpComponent
• UMotionBreathingComponent
• UMotionMovementSoundComponent
• UMotionCameraComponent
• UMotionHeldItemComponent
• UMotionAnimInstance

UMotionComponentBase centralizes shared behavior such as character/component discovery, ASC initialization, cached-component validation, local prediction state, and debug support. Derived components own their request-specific network validation.

GAS-first movement state

Motion 2.0 uses GAS for replicated movement state, attributes, and GameplayEffect-driven modifiers.

Included GameplayEffect assets cover common movement and stamina states, including:

• GE_Motion_WalkSpeed
• GE_Motion_SprintSpeed
• GE_Motion_CrouchSpeed
• GE_Motion_JumpVelocity
• GE_Motion_Walking
• GE_Motion_Sprinting
• GE_Motion_Crouching
• GE_Motion_Jumping
• GE_Motion_WantsToSprint
• GE_Motion_WantsToCrouch
• GE_Motion_WantsToJump
• GE_Motion_BreathingActive
• GE_Motion_SprintStaminaDrain
• GE_Motion_SprintStaminaRegen
• GE_Motion_SprintStaminaRegenDelay

UMotionAttributeSet synchronizes key movement attributes to UCharacterMovementComponent properties, including WalkSpeed to MaxWalkSpeed and JumpVelocity to JumpZVelocity.

Walk

UMotionWalkComponent handles base walking behavior, directional speed handling, and walk-speed synchronization.

Walking initializes and synchronizes speed consistently with GAS attributes and directional movement, so startup speed and strafe/forward transitions stay in sync.

Sprint and stamina

UMotionSprintingComponent supports GAS-backed sprinting with stamina drain, regeneration, cooldown behavior, authority validation, local prediction, and movement-gated active sprinting.

Notable behavior:

• Sprint intent can remain held while idle.
• Active sprint state, stamina drain, and local sprint feedback start only once movement passes the configured threshold.
• Server-side decisions prevent multiplayer sprint cycling.
• Stamina comparisons use consistent raw values.
• Hysteresis prevents repeated start/stop flicker near the stamina threshold.
• Sprint/crouch conflicts are resolved through Motion state handling.

Crouch

UMotionCrouchingComponent uses native Unreal crouch behavior, server validation, and smooth first-person camera interpolation.

Important behavior:

• Crouch uses native state as the public contract.
• Capsule resizing uses Character->Crouch() and Character->UnCrouch() where appropriate.
• Client visual capsule changes and remote synchronization work in multiplayer.
• Native crouch replication plus camera height interpolation reduces crouch jitter.
• Ground-based camera positioning prevents camera jumps during capsule height changes.
• Crouch speed validation uses proportional speed handling.

Jump

UMotionJumpComponent supports multiplayer-safe jump requests, coyote time, multi-jump budgeting, server-side validation, local prediction, and jump-input release handling.

Important behavior:

• Coyote time participates correctly in the multi-jump budget.
• Server jump counts are validated to prevent infinite jump exploits.
• Client and server use synchronized landing detection.
• Air jumps use character velocity for direction.
• Native ACharacter::Jump() preserves horizontal momentum while Motion applies profile-driven jump velocity.

Breathing

UMotionBreathingComponent participates in the Motion component base initialization flow and uses Motion.Camera.BreathingActive as the public active-state contract.

The breathing path preserves camera curve recovery when a paused or resumed breathing curve is missing.

Camera

UMotionCameraComponent owns first-person camera curve evaluation, camera height interpolation, collision handling, additive camera effects, and item-facing camera/framing work.

Major capabilities include:

• Built-in location and rotation curve evaluation.
• UCurveVector camera effects.
• FName curve identifiers.
• Smooth crouch camera interpolation independent of capsule resizing.
• Ground-relative camera positioning for stable crouch transitions.
• Collision and framing support for first-person item visuals.
• Profile-driven setup with project-facing camera settings.

Movement sound

UMotionMovementSoundComponent uses DataTable-driven surface sound configuration and MetaSound-based variation.

Important behavior:

• SurfaceSoundDataTable is required.
• Movement sound data is cached for runtime lookup.
• Footstep routing handles walk, sprint, and crouch through a consolidated path.
• Landing sounds can be triggered directly from the jump component.
• Surface row contracts are validated so invalid rows fail predictably.
• Surface detection is event-based rather than tick-based.

First-person held items

Motion 2.0 adds native first-person held-item presentation.

The first-person item system includes:

• UMotionHeldItemComponent
• UMotionNativeFirstPersonItemConfig
• FAnimNode_MotionFirstPersonItemUpperBodyOverlay
• Config-driven carry postures
• Optional linked animation layers
• Native upper-body overlay blending
• Distributed pitch solve
• Hand IK
• Cross-faded automatic carry animations
• Config-authored presentation actions
• One-shot held-item visual actions with request and lifecycle-event flow

The first-person item system includes support for stable hand position, item collision/framing, custom overlay persistence across editor restarts, remote first-person aim pitch replication, and simulated proxy routing.

Animation

UMotionAnimInstance supports robust GAS discovery and first-person item overlay integration.

Motion 2.0 animation support includes:

• Generic ASC discovery through PlayerState and IAbilitySystemInterface patterns.
• Cached GroundDistance state with throttled airborne traces.
• Runtime first-person item upper-body overlay support.
• Graph-safe accessors for Motion animation state.
• Multi-threaded animation support.
• Documented first-person pitch conventions.

Debugging and validation

Motion 2.0 adds a dedicated Motion Gameplay Debugger category and expanded logging support.

Debugging support includes:

• Context-aware MOTION_LOG prefixes with network role and component name.
• Gameplay Debugger output for component state, movement speed, stamina, GameplayEffects, GameplayTags, and camera curves.
• Initialization timeout messaging for delayed ASC discovery.
• Targeted log levels for normal operation.

Improvements

Performance

• Movement sound surface detection is event-driven.
• Breathing avoids unnecessary tick fallback paths.
• Ground traces in animation are throttled.
• Runtime-cached pointers are marked Transient where appropriate.
• ASC lookup checks IAbilitySystemInterface first.
• Logged actor eviction is bounded.
• Operational logs use lower verbosity where appropriate.

Networking

• Movement actions use server validation with local prediction where appropriate.
• GameplayEffect-backed tags replicate movement state.
• Request validation is applied across networked movement paths; sprint and jump requests also have explicit rate limits.
• Local loose intent tags track crouch, sprint, and jump requests while authoritative active-state tags replicate from the server.

Documentation

Motion 2.0 documentation includes these starting points:

Important starting points:

• Quick start
• Add Motion to a character
• Verify multiplayer
• Component profiles
• Use GAS patterns
• Configure movement sounds
• Create camera curves
• Set up MotionAnimInstance
• First-person item configs
• First-person item API
• Networking commands
• MotionAbilitySystemHelper
• Known issues
• Supported versions

Migration notes

Fresh integration recommended

Do not attempt to migrate by keeping Motion 1.x classes in place.

Create a clean Motion 2.0 integration path, then move your project's behavior over deliberately.

1. Remove Motion 1.x dependencies.
2. Make your character inherit from ACharacter or your own existing character base.
3. Use the standard UCharacterMovementComponent.
4. Add the Motion components you need.
5. Provide a project PlayerState that owns or exposes the ASC and implements IAbilitySystemInterface.
6. Provide attributes named for the Motion features you want to use, or use UMotionAttributeSet as a reference implementation.
7. Wire Enhanced Input in your project code and call Motion component input handlers directly.
8. Configure GameplayEffects for the movement-state and stamina paths you use. UMotionAttributeSet also supports optional speed and jump-velocity effects.
9. Duplicate Motion profile assets into your project before customizing movement, camera, sound, or effect defaults.
10. Replace Motion 1.x movement sound arrays with SurfaceSoundDataTable rows and MetaSound assets.
11. Update camera curves to UCurveVector assets and use FName identifiers.
12. Update any MOTION_LOG calls to pass the component as the first argument.
13. Rebuild first-person item setup around UMotionHeldItemComponent, native item configs, and the upper-body overlay node if your project uses held items.
14. Validate multiplayer behavior with your project's abilities, tags, AttributeSets, input setup, animation graphs, and network settings.

Known limitations and integration responsibilities

• Full replicated behavior depends on a correctly configured project GAS setup.
• Motion does not own your PlayerState, GameMode, PlayerController, ASC subclass, or input component.
• Missing required attributes make the affected feature fail closed until its GAS contract is provided.
• Component profile migration is not automatic. Motion 1.x inline component edits are not converted into project-local profile assets.
• Movement sound requires a valid SurfaceSoundDataTable and MetaSound setup. Motion 1.x array-based sound configuration is not supported.
• Native first-person item visuals are opt-in and require compatible item configs plus valid mesh, animation, and skeleton settings for the selected presentation mode.
• Motion includes workarounds and validation for Unreal jump-count behavior in UE 5.3-5.6. Custom jump logic should preserve Motion's jump count and input-release behavior.